Branch data Line data Source code
1 : : // SPDX-License-Identifier: GPL-2.0
2 : : /*
3 : : * Performance events core code:
4 : : *
5 : : * Copyright (C) 2008 Thomas Gleixner <tglx@linutronix.de>
6 : : * Copyright (C) 2008-2011 Red Hat, Inc., Ingo Molnar
7 : : * Copyright (C) 2008-2011 Red Hat, Inc., Peter Zijlstra
8 : : * Copyright © 2009 Paul Mackerras, IBM Corp. <paulus@au1.ibm.com>
9 : : */
10 : :
11 : : #include <linux/fs.h>
12 : : #include <linux/mm.h>
13 : : #include <linux/cpu.h>
14 : : #include <linux/smp.h>
15 : : #include <linux/idr.h>
16 : : #include <linux/file.h>
17 : : #include <linux/poll.h>
18 : : #include <linux/slab.h>
19 : : #include <linux/hash.h>
20 : : #include <linux/tick.h>
21 : : #include <linux/sysfs.h>
22 : : #include <linux/dcache.h>
23 : : #include <linux/percpu.h>
24 : : #include <linux/ptrace.h>
25 : : #include <linux/reboot.h>
26 : : #include <linux/vmstat.h>
27 : : #include <linux/device.h>
28 : : #include <linux/export.h>
29 : : #include <linux/vmalloc.h>
30 : : #include <linux/hardirq.h>
31 : : #include <linux/rculist.h>
32 : : #include <linux/uaccess.h>
33 : : #include <linux/syscalls.h>
34 : : #include <linux/anon_inodes.h>
35 : : #include <linux/kernel_stat.h>
36 : : #include <linux/cgroup.h>
37 : : #include <linux/perf_event.h>
38 : : #include <linux/trace_events.h>
39 : : #include <linux/hw_breakpoint.h>
40 : : #include <linux/mm_types.h>
41 : : #include <linux/module.h>
42 : : #include <linux/mman.h>
43 : : #include <linux/compat.h>
44 : : #include <linux/bpf.h>
45 : : #include <linux/filter.h>
46 : : #include <linux/namei.h>
47 : : #include <linux/parser.h>
48 : : #include <linux/sched/clock.h>
49 : : #include <linux/sched/mm.h>
50 : : #include <linux/proc_ns.h>
51 : : #include <linux/mount.h>
52 : :
53 : : #include "internal.h"
54 : :
55 : : #include <asm/irq_regs.h>
56 : :
57 : : typedef int (*remote_function_f)(void *);
58 : :
59 : : struct remote_function_call {
60 : : struct task_struct *p;
61 : : remote_function_f func;
62 : : void *info;
63 : : int ret;
64 : : };
65 : :
66 : 0 : static void remote_function(void *data)
67 : : {
68 : : struct remote_function_call *tfc = data;
69 : 0 : struct task_struct *p = tfc->p;
70 : :
71 [ # # ]: 0 : if (p) {
72 : : /* -EAGAIN */
73 [ # # ]: 0 : if (task_cpu(p) != smp_processor_id())
74 : : return;
75 : :
76 : : /*
77 : : * Now that we're on right CPU with IRQs disabled, we can test
78 : : * if we hit the right task without races.
79 : : */
80 : :
81 : 0 : tfc->ret = -ESRCH; /* No such (running) process */
82 [ # # ]: 0 : if (p != current)
83 : : return;
84 : : }
85 : :
86 : 0 : tfc->ret = tfc->func(tfc->info);
87 : : }
88 : :
89 : : /**
90 : : * task_function_call - call a function on the cpu on which a task runs
91 : : * @p: the task to evaluate
92 : : * @func: the function to be called
93 : : * @info: the function call argument
94 : : *
95 : : * Calls the function @func when the task is currently running. This might
96 : : * be on the current CPU, which just calls the function directly. This will
97 : : * retry due to any failures in smp_call_function_single(), such as if the
98 : : * task_cpu() goes offline concurrently.
99 : : *
100 : : * returns @func return value or -ESRCH when the process isn't running
101 : : */
102 : : static int
103 : 0 : task_function_call(struct task_struct *p, remote_function_f func, void *info)
104 : : {
105 : 0 : struct remote_function_call data = {
106 : : .p = p,
107 : : .func = func,
108 : : .info = info,
109 : : .ret = -EAGAIN,
110 : : };
111 : : int ret;
112 : :
113 : : for (;;) {
114 : 0 : ret = smp_call_function_single(task_cpu(p), remote_function,
115 : : &data, 1);
116 [ # # ]: 0 : ret = !ret ? data.ret : -EAGAIN;
117 : :
118 [ # # ]: 0 : if (ret != -EAGAIN)
119 : : break;
120 : :
121 : 0 : cond_resched();
122 : 0 : }
123 : :
124 : 0 : return ret;
125 : : }
126 : :
127 : : /**
128 : : * cpu_function_call - call a function on the cpu
129 : : * @func: the function to be called
130 : : * @info: the function call argument
131 : : *
132 : : * Calls the function @func on the remote cpu.
133 : : *
134 : : * returns: @func return value or -ENXIO when the cpu is offline
135 : : */
136 : 0 : static int cpu_function_call(int cpu, remote_function_f func, void *info)
137 : : {
138 : 0 : struct remote_function_call data = {
139 : : .p = NULL,
140 : : .func = func,
141 : : .info = info,
142 : : .ret = -ENXIO, /* No such CPU */
143 : : };
144 : :
145 : 0 : smp_call_function_single(cpu, remote_function, &data, 1);
146 : :
147 : 0 : return data.ret;
148 : : }
149 : :
150 : : static inline struct perf_cpu_context *
151 : : __get_cpu_context(struct perf_event_context *ctx)
152 : : {
153 : 0 : return this_cpu_ptr(ctx->pmu->pmu_cpu_context);
154 : : }
155 : :
156 : : static void perf_ctx_lock(struct perf_cpu_context *cpuctx,
157 : : struct perf_event_context *ctx)
158 : : {
159 : 0 : raw_spin_lock(&cpuctx->ctx.lock);
160 [ # # # # : 0 : if (ctx)
# # # # #
# # # # #
# # ]
161 : 0 : raw_spin_lock(&ctx->lock);
162 : : }
163 : :
164 : 0 : static void perf_ctx_unlock(struct perf_cpu_context *cpuctx,
165 : : struct perf_event_context *ctx)
166 : : {
167 [ # # ]: 0 : if (ctx)
168 : : raw_spin_unlock(&ctx->lock);
169 : : raw_spin_unlock(&cpuctx->ctx.lock);
170 : 0 : }
171 : :
172 : : #define TASK_TOMBSTONE ((void *)-1L)
173 : :
174 : : static bool is_kernel_event(struct perf_event *event)
175 : : {
176 : 0 : return READ_ONCE(event->owner) == TASK_TOMBSTONE;
177 : : }
178 : :
179 : : /*
180 : : * On task ctx scheduling...
181 : : *
182 : : * When !ctx->nr_events a task context will not be scheduled. This means
183 : : * we can disable the scheduler hooks (for performance) without leaving
184 : : * pending task ctx state.
185 : : *
186 : : * This however results in two special cases:
187 : : *
188 : : * - removing the last event from a task ctx; this is relatively straight
189 : : * forward and is done in __perf_remove_from_context.
190 : : *
191 : : * - adding the first event to a task ctx; this is tricky because we cannot
192 : : * rely on ctx->is_active and therefore cannot use event_function_call().
193 : : * See perf_install_in_context().
194 : : *
195 : : * If ctx->nr_events, then ctx->is_active and cpuctx->task_ctx are set.
196 : : */
197 : :
198 : : typedef void (*event_f)(struct perf_event *, struct perf_cpu_context *,
199 : : struct perf_event_context *, void *);
200 : :
201 : : struct event_function_struct {
202 : : struct perf_event *event;
203 : : event_f func;
204 : : void *data;
205 : : };
206 : :
207 : 0 : static int event_function(void *info)
208 : : {
209 : : struct event_function_struct *efs = info;
210 : 0 : struct perf_event *event = efs->event;
211 : 0 : struct perf_event_context *ctx = event->ctx;
212 : : struct perf_cpu_context *cpuctx = __get_cpu_context(ctx);
213 : 0 : struct perf_event_context *task_ctx = cpuctx->task_ctx;
214 : : int ret = 0;
215 : :
216 : : lockdep_assert_irqs_disabled();
217 : :
218 : : perf_ctx_lock(cpuctx, task_ctx);
219 : : /*
220 : : * Since we do the IPI call without holding ctx->lock things can have
221 : : * changed, double check we hit the task we set out to hit.
222 : : */
223 [ # # ]: 0 : if (ctx->task) {
224 [ # # ]: 0 : if (ctx->task != current) {
225 : : ret = -ESRCH;
226 : : goto unlock;
227 : : }
228 : :
229 : : /*
230 : : * We only use event_function_call() on established contexts,
231 : : * and event_function() is only ever called when active (or
232 : : * rather, we'll have bailed in task_function_call() or the
233 : : * above ctx->task != current test), therefore we must have
234 : : * ctx->is_active here.
235 : : */
236 [ # # # # ]: 0 : WARN_ON_ONCE(!ctx->is_active);
237 : : /*
238 : : * And since we have ctx->is_active, cpuctx->task_ctx must
239 : : * match.
240 : : */
241 [ # # # # ]: 0 : WARN_ON_ONCE(task_ctx != ctx);
242 : : } else {
243 [ # # # # ]: 0 : WARN_ON_ONCE(&cpuctx->ctx != ctx);
244 : : }
245 : :
246 : 0 : efs->func(event, cpuctx, ctx, efs->data);
247 : : unlock:
248 : 0 : perf_ctx_unlock(cpuctx, task_ctx);
249 : :
250 : 0 : return ret;
251 : : }
252 : :
253 : 0 : static void event_function_call(struct perf_event *event, event_f func, void *data)
254 : : {
255 : 0 : struct perf_event_context *ctx = event->ctx;
256 : 0 : struct task_struct *task = READ_ONCE(ctx->task); /* verified in event_function */
257 : 0 : struct event_function_struct efs = {
258 : : .event = event,
259 : : .func = func,
260 : : .data = data,
261 : : };
262 : :
263 : : if (!event->parent) {
264 : : /*
265 : : * If this is a !child event, we must hold ctx::mutex to
266 : : * stabilize the the event->ctx relation. See
267 : : * perf_event_ctx_lock().
268 : : */
269 : : lockdep_assert_held(&ctx->mutex);
270 : : }
271 : :
272 [ # # ]: 0 : if (!task) {
273 : 0 : cpu_function_call(event->cpu, event_function, &efs);
274 : 0 : return;
275 : : }
276 : :
277 [ # # ]: 0 : if (task == TASK_TOMBSTONE)
278 : : return;
279 : :
280 : : again:
281 [ # # ]: 0 : if (!task_function_call(task, event_function, &efs))
282 : : return;
283 : :
284 : 0 : raw_spin_lock_irq(&ctx->lock);
285 : : /*
286 : : * Reload the task pointer, it might have been changed by
287 : : * a concurrent perf_event_context_sched_out().
288 : : */
289 : 0 : task = ctx->task;
290 [ # # ]: 0 : if (task == TASK_TOMBSTONE) {
291 : 0 : raw_spin_unlock_irq(&ctx->lock);
292 : 0 : return;
293 : : }
294 [ # # ]: 0 : if (ctx->is_active) {
295 : 0 : raw_spin_unlock_irq(&ctx->lock);
296 : 0 : goto again;
297 : : }
298 : 0 : func(event, NULL, ctx, data);
299 : 0 : raw_spin_unlock_irq(&ctx->lock);
300 : : }
301 : :
302 : : /*
303 : : * Similar to event_function_call() + event_function(), but hard assumes IRQs
304 : : * are already disabled and we're on the right CPU.
305 : : */
306 : 0 : static void event_function_local(struct perf_event *event, event_f func, void *data)
307 : : {
308 : 0 : struct perf_event_context *ctx = event->ctx;
309 : : struct perf_cpu_context *cpuctx = __get_cpu_context(ctx);
310 : 0 : struct task_struct *task = READ_ONCE(ctx->task);
311 : : struct perf_event_context *task_ctx = NULL;
312 : :
313 : : lockdep_assert_irqs_disabled();
314 : :
315 [ # # ]: 0 : if (task) {
316 [ # # ]: 0 : if (task == TASK_TOMBSTONE)
317 : 0 : return;
318 : :
319 : : task_ctx = ctx;
320 : : }
321 : :
322 : : perf_ctx_lock(cpuctx, task_ctx);
323 : :
324 : 0 : task = ctx->task;
325 [ # # ]: 0 : if (task == TASK_TOMBSTONE)
326 : : goto unlock;
327 : :
328 [ # # ]: 0 : if (task) {
329 : : /*
330 : : * We must be either inactive or active and the right task,
331 : : * otherwise we're screwed, since we cannot IPI to somewhere
332 : : * else.
333 : : */
334 [ # # ]: 0 : if (ctx->is_active) {
335 [ # # # # : 0 : if (WARN_ON_ONCE(task != current))
# # ]
336 : : goto unlock;
337 : :
338 [ # # # # : 0 : if (WARN_ON_ONCE(cpuctx->task_ctx != ctx))
# # ]
339 : : goto unlock;
340 : : }
341 : : } else {
342 [ # # # # ]: 0 : WARN_ON_ONCE(&cpuctx->ctx != ctx);
343 : : }
344 : :
345 : 0 : func(event, cpuctx, ctx, data);
346 : : unlock:
347 : 0 : perf_ctx_unlock(cpuctx, task_ctx);
348 : : }
349 : :
350 : : #define PERF_FLAG_ALL (PERF_FLAG_FD_NO_GROUP |\
351 : : PERF_FLAG_FD_OUTPUT |\
352 : : PERF_FLAG_PID_CGROUP |\
353 : : PERF_FLAG_FD_CLOEXEC)
354 : :
355 : : /*
356 : : * branch priv levels that need permission checks
357 : : */
358 : : #define PERF_SAMPLE_BRANCH_PERM_PLM \
359 : : (PERF_SAMPLE_BRANCH_KERNEL |\
360 : : PERF_SAMPLE_BRANCH_HV)
361 : :
362 : : enum event_type_t {
363 : : EVENT_FLEXIBLE = 0x1,
364 : : EVENT_PINNED = 0x2,
365 : : EVENT_TIME = 0x4,
366 : : /* see ctx_resched() for details */
367 : : EVENT_CPU = 0x8,
368 : : EVENT_ALL = EVENT_FLEXIBLE | EVENT_PINNED,
369 : : };
370 : :
371 : : /*
372 : : * perf_sched_events : >0 events exist
373 : : * perf_cgroup_events: >0 per-cpu cgroup events exist on this cpu
374 : : */
375 : :
376 : : static void perf_sched_delayed(struct work_struct *work);
377 : : DEFINE_STATIC_KEY_FALSE(perf_sched_events);
378 : : static DECLARE_DELAYED_WORK(perf_sched_work, perf_sched_delayed);
379 : : static DEFINE_MUTEX(perf_sched_mutex);
380 : : static atomic_t perf_sched_count;
381 : :
382 : : static DEFINE_PER_CPU(atomic_t, perf_cgroup_events);
383 : : static DEFINE_PER_CPU(int, perf_sched_cb_usages);
384 : : static DEFINE_PER_CPU(struct pmu_event_list, pmu_sb_events);
385 : :
386 : : static atomic_t nr_mmap_events __read_mostly;
387 : : static atomic_t nr_comm_events __read_mostly;
388 : : static atomic_t nr_namespaces_events __read_mostly;
389 : : static atomic_t nr_task_events __read_mostly;
390 : : static atomic_t nr_freq_events __read_mostly;
391 : : static atomic_t nr_switch_events __read_mostly;
392 : : static atomic_t nr_ksymbol_events __read_mostly;
393 : : static atomic_t nr_bpf_events __read_mostly;
394 : :
395 : : static LIST_HEAD(pmus);
396 : : static DEFINE_MUTEX(pmus_lock);
397 : : static struct srcu_struct pmus_srcu;
398 : : static cpumask_var_t perf_online_mask;
399 : :
400 : : /*
401 : : * perf event paranoia level:
402 : : * -1 - not paranoid at all
403 : : * 0 - disallow raw tracepoint access for unpriv
404 : : * 1 - disallow cpu events for unpriv
405 : : * 2 - disallow kernel profiling for unpriv
406 : : */
407 : : int sysctl_perf_event_paranoid __read_mostly = 2;
408 : :
409 : : /* Minimum for 512 kiB + 1 user control page */
410 : : int sysctl_perf_event_mlock __read_mostly = 512 + (PAGE_SIZE / 1024); /* 'free' kiB per user */
411 : :
412 : : /*
413 : : * max perf event sample rate
414 : : */
415 : : #define DEFAULT_MAX_SAMPLE_RATE 100000
416 : : #define DEFAULT_SAMPLE_PERIOD_NS (NSEC_PER_SEC / DEFAULT_MAX_SAMPLE_RATE)
417 : : #define DEFAULT_CPU_TIME_MAX_PERCENT 25
418 : :
419 : : int sysctl_perf_event_sample_rate __read_mostly = DEFAULT_MAX_SAMPLE_RATE;
420 : :
421 : : static int max_samples_per_tick __read_mostly = DIV_ROUND_UP(DEFAULT_MAX_SAMPLE_RATE, HZ);
422 : : static int perf_sample_period_ns __read_mostly = DEFAULT_SAMPLE_PERIOD_NS;
423 : :
424 : : static int perf_sample_allowed_ns __read_mostly =
425 : : DEFAULT_SAMPLE_PERIOD_NS * DEFAULT_CPU_TIME_MAX_PERCENT / 100;
426 : :
427 : 0 : static void update_perf_cpu_limits(void)
428 : : {
429 : 0 : u64 tmp = perf_sample_period_ns;
430 : :
431 : 0 : tmp *= sysctl_perf_cpu_time_max_percent;
432 : : tmp = div_u64(tmp, 100);
433 [ # # ]: 0 : if (!tmp)
434 : : tmp = 1;
435 : :
436 : 0 : WRITE_ONCE(perf_sample_allowed_ns, tmp);
437 : 0 : }
438 : :
439 : : static bool perf_rotate_context(struct perf_cpu_context *cpuctx);
440 : :
441 : 0 : int perf_proc_update_handler(struct ctl_table *table, int write,
442 : : void __user *buffer, size_t *lenp,
443 : : loff_t *ppos)
444 : : {
445 : : int ret;
446 : 0 : int perf_cpu = sysctl_perf_cpu_time_max_percent;
447 : : /*
448 : : * If throttling is disabled don't allow the write:
449 : : */
450 [ # # # # ]: 0 : if (write && (perf_cpu == 100 || perf_cpu == 0))
451 : : return -EINVAL;
452 : :
453 : 0 : ret = proc_dointvec_minmax(table, write, buffer, lenp, ppos);
454 [ # # ]: 0 : if (ret || !write)
455 : : return ret;
456 : :
457 : 0 : max_samples_per_tick = DIV_ROUND_UP(sysctl_perf_event_sample_rate, HZ);
458 : 0 : perf_sample_period_ns = NSEC_PER_SEC / sysctl_perf_event_sample_rate;
459 : 0 : update_perf_cpu_limits();
460 : :
461 : 0 : return 0;
462 : : }
463 : :
464 : : int sysctl_perf_cpu_time_max_percent __read_mostly = DEFAULT_CPU_TIME_MAX_PERCENT;
465 : :
466 : 0 : int perf_cpu_time_max_percent_handler(struct ctl_table *table, int write,
467 : : void __user *buffer, size_t *lenp,
468 : : loff_t *ppos)
469 : : {
470 : 0 : int ret = proc_dointvec_minmax(table, write, buffer, lenp, ppos);
471 : :
472 [ # # ]: 0 : if (ret || !write)
473 : : return ret;
474 : :
475 [ # # ]: 0 : if (sysctl_perf_cpu_time_max_percent == 100 ||
476 : : sysctl_perf_cpu_time_max_percent == 0) {
477 : 0 : printk(KERN_WARNING
478 : : "perf: Dynamic interrupt throttling disabled, can hang your system!\n");
479 : : WRITE_ONCE(perf_sample_allowed_ns, 0);
480 : : } else {
481 : 0 : update_perf_cpu_limits();
482 : : }
483 : :
484 : : return 0;
485 : : }
486 : :
487 : : /*
488 : : * perf samples are done in some very critical code paths (NMIs).
489 : : * If they take too much CPU time, the system can lock up and not
490 : : * get any real work done. This will drop the sample rate when
491 : : * we detect that events are taking too long.
492 : : */
493 : : #define NR_ACCUMULATED_SAMPLES 128
494 : : static DEFINE_PER_CPU(u64, running_sample_length);
495 : :
496 : : static u64 __report_avg;
497 : : static u64 __report_allowed;
498 : :
499 : 0 : static void perf_duration_warn(struct irq_work *w)
500 : : {
501 [ # # ]: 0 : printk_ratelimited(KERN_INFO
502 : : "perf: interrupt took too long (%lld > %lld), lowering "
503 : : "kernel.perf_event_max_sample_rate to %d\n",
504 : : __report_avg, __report_allowed,
505 : : sysctl_perf_event_sample_rate);
506 : 0 : }
507 : :
508 : : static DEFINE_IRQ_WORK(perf_duration_work, perf_duration_warn);
509 : :
510 : 0 : void perf_sample_event_took(u64 sample_len_ns)
511 : : {
512 : 0 : u64 max_len = READ_ONCE(perf_sample_allowed_ns);
513 : : u64 running_len;
514 : : u64 avg_len;
515 : : u32 max;
516 : :
517 [ # # ]: 0 : if (max_len == 0)
518 : : return;
519 : :
520 : : /* Decay the counter by 1 average sample. */
521 : 0 : running_len = __this_cpu_read(running_sample_length);
522 : 0 : running_len -= running_len/NR_ACCUMULATED_SAMPLES;
523 : 0 : running_len += sample_len_ns;
524 : 0 : __this_cpu_write(running_sample_length, running_len);
525 : :
526 : : /*
527 : : * Note: this will be biased artifically low until we have
528 : : * seen NR_ACCUMULATED_SAMPLES. Doing it this way keeps us
529 : : * from having to maintain a count.
530 : : */
531 : 0 : avg_len = running_len/NR_ACCUMULATED_SAMPLES;
532 [ # # ]: 0 : if (avg_len <= max_len)
533 : : return;
534 : :
535 : 0 : __report_avg = avg_len;
536 : 0 : __report_allowed = max_len;
537 : :
538 : : /*
539 : : * Compute a throttle threshold 25% below the current duration.
540 : : */
541 : 0 : avg_len += avg_len / 4;
542 : 0 : max = (TICK_NSEC / 100) * sysctl_perf_cpu_time_max_percent;
543 [ # # ]: 0 : if (avg_len < max)
544 : 0 : max /= (u32)avg_len;
545 : : else
546 : : max = 1;
547 : :
548 : 0 : WRITE_ONCE(perf_sample_allowed_ns, avg_len);
549 : : WRITE_ONCE(max_samples_per_tick, max);
550 : :
551 : 0 : sysctl_perf_event_sample_rate = max * HZ;
552 : 0 : perf_sample_period_ns = NSEC_PER_SEC / sysctl_perf_event_sample_rate;
553 : :
554 : 0 : if (!irq_work_queue(&perf_duration_work)) {
555 : : early_printk("perf: interrupt took too long (%lld > %lld), lowering "
556 : : "kernel.perf_event_max_sample_rate to %d\n",
557 : : __report_avg, __report_allowed,
558 : : sysctl_perf_event_sample_rate);
559 : : }
560 : : }
561 : :
562 : : static atomic64_t perf_event_id;
563 : :
564 : : static void cpu_ctx_sched_out(struct perf_cpu_context *cpuctx,
565 : : enum event_type_t event_type);
566 : :
567 : : static void cpu_ctx_sched_in(struct perf_cpu_context *cpuctx,
568 : : enum event_type_t event_type,
569 : : struct task_struct *task);
570 : :
571 : : static void update_context_time(struct perf_event_context *ctx);
572 : : static u64 perf_event_time(struct perf_event *event);
573 : :
574 : 0 : void __weak perf_event_print_debug(void) { }
575 : :
576 : 0 : extern __weak const char *perf_pmu_name(void)
577 : : {
578 : 0 : return "pmu";
579 : : }
580 : :
581 : : static inline u64 perf_clock(void)
582 : : {
583 : : return local_clock();
584 : : }
585 : :
586 : : static inline u64 perf_event_clock(struct perf_event *event)
587 : : {
588 : 0 : return event->clock();
589 : : }
590 : :
591 : : /*
592 : : * State based event timekeeping...
593 : : *
594 : : * The basic idea is to use event->state to determine which (if any) time
595 : : * fields to increment with the current delta. This means we only need to
596 : : * update timestamps when we change state or when they are explicitly requested
597 : : * (read).
598 : : *
599 : : * Event groups make things a little more complicated, but not terribly so. The
600 : : * rules for a group are that if the group leader is OFF the entire group is
601 : : * OFF, irrespecive of what the group member states are. This results in
602 : : * __perf_effective_state().
603 : : *
604 : : * A futher ramification is that when a group leader flips between OFF and
605 : : * !OFF, we need to update all group member times.
606 : : *
607 : : *
608 : : * NOTE: perf_event_time() is based on the (cgroup) context time, and thus we
609 : : * need to make sure the relevant context time is updated before we try and
610 : : * update our timestamps.
611 : : */
612 : :
613 : : static __always_inline enum perf_event_state
614 : : __perf_effective_state(struct perf_event *event)
615 : : {
616 : 0 : struct perf_event *leader = event->group_leader;
617 : :
618 [ # # # # : 0 : if (leader->state <= PERF_EVENT_STATE_OFF)
# # ]
619 : : return leader->state;
620 : :
621 : 0 : return event->state;
622 : : }
623 : :
624 : : static __always_inline void
625 : : __perf_update_times(struct perf_event *event, u64 now, u64 *enabled, u64 *running)
626 : : {
627 : : enum perf_event_state state = __perf_effective_state(event);
628 : 0 : u64 delta = now - event->tstamp;
629 : :
630 : 0 : *enabled = event->total_time_enabled;
631 [ # # # # : 0 : if (state >= PERF_EVENT_STATE_INACTIVE)
# # ]
632 : 0 : *enabled += delta;
633 : :
634 : 0 : *running = event->total_time_running;
635 [ # # # # : 0 : if (state >= PERF_EVENT_STATE_ACTIVE)
# # ]
636 : 0 : *running += delta;
637 : : }
638 : :
639 : 0 : static void perf_event_update_time(struct perf_event *event)
640 : : {
641 : : u64 now = perf_event_time(event);
642 : :
643 : : __perf_update_times(event, now, &event->total_time_enabled,
644 : : &event->total_time_running);
645 : 0 : event->tstamp = now;
646 : 0 : }
647 : :
648 : 0 : static void perf_event_update_sibling_time(struct perf_event *leader)
649 : : {
650 : : struct perf_event *sibling;
651 : :
652 [ # # # # ]: 0 : for_each_sibling_event(sibling, leader)
653 : 0 : perf_event_update_time(sibling);
654 : 0 : }
655 : :
656 : : static void
657 : 0 : perf_event_set_state(struct perf_event *event, enum perf_event_state state)
658 : : {
659 [ # # ]: 0 : if (event->state == state)
660 : 0 : return;
661 : :
662 : 0 : perf_event_update_time(event);
663 : : /*
664 : : * If a group leader gets enabled/disabled all its siblings
665 : : * are affected too.
666 : : */
667 [ # # ]: 0 : if ((event->state < 0) ^ (state < 0))
668 : 0 : perf_event_update_sibling_time(event);
669 : :
670 : : WRITE_ONCE(event->state, state);
671 : : }
672 : :
673 : : #ifdef CONFIG_CGROUP_PERF
674 : :
675 : : static inline bool
676 : 0 : perf_cgroup_match(struct perf_event *event)
677 : : {
678 : 0 : struct perf_event_context *ctx = event->ctx;
679 : : struct perf_cpu_context *cpuctx = __get_cpu_context(ctx);
680 : :
681 : : /* @event doesn't care about cgroup */
682 [ # # ]: 0 : if (!event->cgrp)
683 : : return true;
684 : :
685 : : /* wants specific cgroup scope but @cpuctx isn't associated with any */
686 [ # # ]: 0 : if (!cpuctx->cgrp)
687 : : return false;
688 : :
689 : : /*
690 : : * Cgroup scoping is recursive. An event enabled for a cgroup is
691 : : * also enabled for all its descendant cgroups. If @cpuctx's
692 : : * cgroup is a descendant of @event's (the test covers identity
693 : : * case), it's a match.
694 : : */
695 : 0 : return cgroup_is_descendant(cpuctx->cgrp->css.cgroup,
696 : : event->cgrp->css.cgroup);
697 : : }
698 : :
699 : 0 : static inline void perf_detach_cgroup(struct perf_event *event)
700 : : {
701 : 0 : css_put(&event->cgrp->css);
702 : 0 : event->cgrp = NULL;
703 : 0 : }
704 : :
705 : : static inline int is_cgroup_event(struct perf_event *event)
706 : : {
707 : 0 : return event->cgrp != NULL;
708 : : }
709 : :
710 : : static inline u64 perf_cgroup_event_time(struct perf_event *event)
711 : : {
712 : : struct perf_cgroup_info *t;
713 : :
714 : 0 : t = per_cpu_ptr(event->cgrp->info, event->cpu);
715 : 0 : return t->time;
716 : : }
717 : :
718 : 0 : static inline void __update_cgrp_time(struct perf_cgroup *cgrp)
719 : : {
720 : : struct perf_cgroup_info *info;
721 : : u64 now;
722 : :
723 : : now = perf_clock();
724 : :
725 : 0 : info = this_cpu_ptr(cgrp->info);
726 : :
727 : 0 : info->time += now - info->timestamp;
728 : 0 : info->timestamp = now;
729 : 0 : }
730 : :
731 : 0 : static inline void update_cgrp_time_from_cpuctx(struct perf_cpu_context *cpuctx)
732 : : {
733 : 0 : struct perf_cgroup *cgrp = cpuctx->cgrp;
734 : : struct cgroup_subsys_state *css;
735 : :
736 [ # # ]: 0 : if (cgrp) {
737 [ # # ]: 0 : for (css = &cgrp->css; css; css = css->parent) {
738 : : cgrp = container_of(css, struct perf_cgroup, css);
739 : 0 : __update_cgrp_time(cgrp);
740 : : }
741 : : }
742 : 0 : }
743 : :
744 : 0 : static inline void update_cgrp_time_from_event(struct perf_event *event)
745 : : {
746 : : struct perf_cgroup *cgrp;
747 : :
748 : : /*
749 : : * ensure we access cgroup data only when needed and
750 : : * when we know the cgroup is pinned (css_get)
751 : : */
752 [ # # ]: 0 : if (!is_cgroup_event(event))
753 : 0 : return;
754 : :
755 : 0 : cgrp = perf_cgroup_from_task(current, event->ctx);
756 : : /*
757 : : * Do not update time when cgroup is not active
758 : : */
759 [ # # ]: 0 : if (cgroup_is_descendant(cgrp->css.cgroup, event->cgrp->css.cgroup))
760 : 0 : __update_cgrp_time(event->cgrp);
761 : : }
762 : :
763 : : static inline void
764 : 0 : perf_cgroup_set_timestamp(struct task_struct *task,
765 : : struct perf_event_context *ctx)
766 : : {
767 : : struct perf_cgroup *cgrp;
768 : : struct perf_cgroup_info *info;
769 : : struct cgroup_subsys_state *css;
770 : :
771 : : /*
772 : : * ctx->lock held by caller
773 : : * ensure we do not access cgroup data
774 : : * unless we have the cgroup pinned (css_get)
775 : : */
776 [ # # # # ]: 0 : if (!task || !ctx->nr_cgroups)
777 : 0 : return;
778 : :
779 : : cgrp = perf_cgroup_from_task(task, ctx);
780 : :
781 [ # # ]: 0 : for (css = &cgrp->css; css; css = css->parent) {
782 : : cgrp = container_of(css, struct perf_cgroup, css);
783 : 0 : info = this_cpu_ptr(cgrp->info);
784 : 0 : info->timestamp = ctx->timestamp;
785 : : }
786 : : }
787 : :
788 : : static DEFINE_PER_CPU(struct list_head, cgrp_cpuctx_list);
789 : :
790 : : #define PERF_CGROUP_SWOUT 0x1 /* cgroup switch out every event */
791 : : #define PERF_CGROUP_SWIN 0x2 /* cgroup switch in events based on task */
792 : :
793 : : /*
794 : : * reschedule events based on the cgroup constraint of task.
795 : : *
796 : : * mode SWOUT : schedule out everything
797 : : * mode SWIN : schedule in based on cgroup for next
798 : : */
799 : 0 : static void perf_cgroup_switch(struct task_struct *task, int mode)
800 : : {
801 : : struct perf_cpu_context *cpuctx;
802 : : struct list_head *list;
803 : : unsigned long flags;
804 : :
805 : : /*
806 : : * Disable interrupts and preemption to avoid this CPU's
807 : : * cgrp_cpuctx_entry to change under us.
808 : : */
809 : 0 : local_irq_save(flags);
810 : :
811 : 0 : list = this_cpu_ptr(&cgrp_cpuctx_list);
812 [ # # ]: 0 : list_for_each_entry(cpuctx, list, cgrp_cpuctx_entry) {
813 [ # # # # ]: 0 : WARN_ON_ONCE(cpuctx->ctx.nr_cgroups == 0);
814 : :
815 : 0 : perf_ctx_lock(cpuctx, cpuctx->task_ctx);
816 : 0 : perf_pmu_disable(cpuctx->ctx.pmu);
817 : :
818 [ # # ]: 0 : if (mode & PERF_CGROUP_SWOUT) {
819 : : cpu_ctx_sched_out(cpuctx, EVENT_ALL);
820 : : /*
821 : : * must not be done before ctxswout due
822 : : * to event_filter_match() in event_sched_out()
823 : : */
824 : 0 : cpuctx->cgrp = NULL;
825 : : }
826 : :
827 [ # # ]: 0 : if (mode & PERF_CGROUP_SWIN) {
828 [ # # # # ]: 0 : WARN_ON_ONCE(cpuctx->cgrp);
829 : : /*
830 : : * set cgrp before ctxsw in to allow
831 : : * event_filter_match() to not have to pass
832 : : * task around
833 : : * we pass the cpuctx->ctx to perf_cgroup_from_task()
834 : : * because cgorup events are only per-cpu
835 : : */
836 : 0 : cpuctx->cgrp = perf_cgroup_from_task(task,
837 : : &cpuctx->ctx);
838 : : cpu_ctx_sched_in(cpuctx, EVENT_ALL, task);
839 : : }
840 : 0 : perf_pmu_enable(cpuctx->ctx.pmu);
841 : 0 : perf_ctx_unlock(cpuctx, cpuctx->task_ctx);
842 : : }
843 : :
844 [ # # ]: 0 : local_irq_restore(flags);
845 : 0 : }
846 : :
847 : 0 : static inline void perf_cgroup_sched_out(struct task_struct *task,
848 : : struct task_struct *next)
849 : : {
850 : : struct perf_cgroup *cgrp1;
851 : : struct perf_cgroup *cgrp2 = NULL;
852 : :
853 : : rcu_read_lock();
854 : : /*
855 : : * we come here when we know perf_cgroup_events > 0
856 : : * we do not need to pass the ctx here because we know
857 : : * we are holding the rcu lock
858 : : */
859 : : cgrp1 = perf_cgroup_from_task(task, NULL);
860 : : cgrp2 = perf_cgroup_from_task(next, NULL);
861 : :
862 : : /*
863 : : * only schedule out current cgroup events if we know
864 : : * that we are switching to a different cgroup. Otherwise,
865 : : * do no touch the cgroup events.
866 : : */
867 [ # # ]: 0 : if (cgrp1 != cgrp2)
868 : 0 : perf_cgroup_switch(task, PERF_CGROUP_SWOUT);
869 : :
870 : : rcu_read_unlock();
871 : 0 : }
872 : :
873 : 0 : static inline void perf_cgroup_sched_in(struct task_struct *prev,
874 : : struct task_struct *task)
875 : : {
876 : : struct perf_cgroup *cgrp1;
877 : : struct perf_cgroup *cgrp2 = NULL;
878 : :
879 : : rcu_read_lock();
880 : : /*
881 : : * we come here when we know perf_cgroup_events > 0
882 : : * we do not need to pass the ctx here because we know
883 : : * we are holding the rcu lock
884 : : */
885 : : cgrp1 = perf_cgroup_from_task(task, NULL);
886 : : cgrp2 = perf_cgroup_from_task(prev, NULL);
887 : :
888 : : /*
889 : : * only need to schedule in cgroup events if we are changing
890 : : * cgroup during ctxsw. Cgroup events were not scheduled
891 : : * out of ctxsw out if that was not the case.
892 : : */
893 [ # # ]: 0 : if (cgrp1 != cgrp2)
894 : 0 : perf_cgroup_switch(task, PERF_CGROUP_SWIN);
895 : :
896 : : rcu_read_unlock();
897 : 0 : }
898 : :
899 : 0 : static inline int perf_cgroup_connect(int fd, struct perf_event *event,
900 : : struct perf_event_attr *attr,
901 : : struct perf_event *group_leader)
902 : : {
903 : : struct perf_cgroup *cgrp;
904 : : struct cgroup_subsys_state *css;
905 : 0 : struct fd f = fdget(fd);
906 : : int ret = 0;
907 : :
908 [ # # ]: 0 : if (!f.file)
909 : : return -EBADF;
910 : :
911 : 0 : css = css_tryget_online_from_dir(f.file->f_path.dentry,
912 : : &perf_event_cgrp_subsys);
913 [ # # ]: 0 : if (IS_ERR(css)) {
914 : : ret = PTR_ERR(css);
915 : 0 : goto out;
916 : : }
917 : :
918 : : cgrp = container_of(css, struct perf_cgroup, css);
919 : 0 : event->cgrp = cgrp;
920 : :
921 : : /*
922 : : * all events in a group must monitor
923 : : * the same cgroup because a task belongs
924 : : * to only one perf cgroup at a time
925 : : */
926 [ # # # # ]: 0 : if (group_leader && group_leader->cgrp != cgrp) {
927 : 0 : perf_detach_cgroup(event);
928 : : ret = -EINVAL;
929 : : }
930 : : out:
931 : : fdput(f);
932 : 0 : return ret;
933 : : }
934 : :
935 : : static inline void
936 : : perf_cgroup_set_shadow_time(struct perf_event *event, u64 now)
937 : : {
938 : : struct perf_cgroup_info *t;
939 : 0 : t = per_cpu_ptr(event->cgrp->info, event->cpu);
940 : 0 : event->shadow_ctx_time = now - t->timestamp;
941 : : }
942 : :
943 : : /*
944 : : * Update cpuctx->cgrp so that it is set when first cgroup event is added and
945 : : * cleared when last cgroup event is removed.
946 : : */
947 : : static inline void
948 : 0 : list_update_cgroup_event(struct perf_event *event,
949 : : struct perf_event_context *ctx, bool add)
950 : : {
951 : : struct perf_cpu_context *cpuctx;
952 : : struct list_head *cpuctx_entry;
953 : :
954 [ # # ]: 0 : if (!is_cgroup_event(event))
955 : : return;
956 : :
957 : : /*
958 : : * Because cgroup events are always per-cpu events,
959 : : * this will always be called from the right CPU.
960 : : */
961 : : cpuctx = __get_cpu_context(ctx);
962 : :
963 : : /*
964 : : * Since setting cpuctx->cgrp is conditional on the current @cgrp
965 : : * matching the event's cgroup, we must do this for every new event,
966 : : * because if the first would mismatch, the second would not try again
967 : : * and we would leave cpuctx->cgrp unset.
968 : : */
969 [ # # # # ]: 0 : if (add && !cpuctx->cgrp) {
970 : 0 : struct perf_cgroup *cgrp = perf_cgroup_from_task(current, ctx);
971 : :
972 [ # # ]: 0 : if (cgroup_is_descendant(cgrp->css.cgroup, event->cgrp->css.cgroup))
973 : 0 : cpuctx->cgrp = cgrp;
974 : : }
975 : :
976 [ # # # # ]: 0 : if (add && ctx->nr_cgroups++)
977 : : return;
978 [ # # # # ]: 0 : else if (!add && --ctx->nr_cgroups)
979 : : return;
980 : :
981 : : /* no cgroup running */
982 [ # # ]: 0 : if (!add)
983 : 0 : cpuctx->cgrp = NULL;
984 : :
985 : 0 : cpuctx_entry = &cpuctx->cgrp_cpuctx_entry;
986 [ # # ]: 0 : if (add)
987 : 0 : list_add(cpuctx_entry, this_cpu_ptr(&cgrp_cpuctx_list));
988 : : else
989 : : list_del(cpuctx_entry);
990 : : }
991 : :
992 : : #else /* !CONFIG_CGROUP_PERF */
993 : :
994 : : static inline bool
995 : : perf_cgroup_match(struct perf_event *event)
996 : : {
997 : : return true;
998 : : }
999 : :
1000 : : static inline void perf_detach_cgroup(struct perf_event *event)
1001 : : {}
1002 : :
1003 : : static inline int is_cgroup_event(struct perf_event *event)
1004 : : {
1005 : : return 0;
1006 : : }
1007 : :
1008 : : static inline void update_cgrp_time_from_event(struct perf_event *event)
1009 : : {
1010 : : }
1011 : :
1012 : : static inline void update_cgrp_time_from_cpuctx(struct perf_cpu_context *cpuctx)
1013 : : {
1014 : : }
1015 : :
1016 : : static inline void perf_cgroup_sched_out(struct task_struct *task,
1017 : : struct task_struct *next)
1018 : : {
1019 : : }
1020 : :
1021 : : static inline void perf_cgroup_sched_in(struct task_struct *prev,
1022 : : struct task_struct *task)
1023 : : {
1024 : : }
1025 : :
1026 : : static inline int perf_cgroup_connect(pid_t pid, struct perf_event *event,
1027 : : struct perf_event_attr *attr,
1028 : : struct perf_event *group_leader)
1029 : : {
1030 : : return -EINVAL;
1031 : : }
1032 : :
1033 : : static inline void
1034 : : perf_cgroup_set_timestamp(struct task_struct *task,
1035 : : struct perf_event_context *ctx)
1036 : : {
1037 : : }
1038 : :
1039 : : static inline void
1040 : : perf_cgroup_switch(struct task_struct *task, struct task_struct *next)
1041 : : {
1042 : : }
1043 : :
1044 : : static inline void
1045 : : perf_cgroup_set_shadow_time(struct perf_event *event, u64 now)
1046 : : {
1047 : : }
1048 : :
1049 : : static inline u64 perf_cgroup_event_time(struct perf_event *event)
1050 : : {
1051 : : return 0;
1052 : : }
1053 : :
1054 : : static inline void
1055 : : list_update_cgroup_event(struct perf_event *event,
1056 : : struct perf_event_context *ctx, bool add)
1057 : : {
1058 : : }
1059 : :
1060 : : #endif
1061 : :
1062 : : /*
1063 : : * set default to be dependent on timer tick just
1064 : : * like original code
1065 : : */
1066 : : #define PERF_CPU_HRTIMER (1000 / HZ)
1067 : : /*
1068 : : * function must be called with interrupts disabled
1069 : : */
1070 : 0 : static enum hrtimer_restart perf_mux_hrtimer_handler(struct hrtimer *hr)
1071 : : {
1072 : : struct perf_cpu_context *cpuctx;
1073 : : bool rotations;
1074 : :
1075 : : lockdep_assert_irqs_disabled();
1076 : :
1077 : 0 : cpuctx = container_of(hr, struct perf_cpu_context, hrtimer);
1078 : 0 : rotations = perf_rotate_context(cpuctx);
1079 : :
1080 : 0 : raw_spin_lock(&cpuctx->hrtimer_lock);
1081 [ # # ]: 0 : if (rotations)
1082 : 0 : hrtimer_forward_now(hr, cpuctx->hrtimer_interval);
1083 : : else
1084 : 0 : cpuctx->hrtimer_active = 0;
1085 : : raw_spin_unlock(&cpuctx->hrtimer_lock);
1086 : :
1087 : 0 : return rotations ? HRTIMER_RESTART : HRTIMER_NORESTART;
1088 : : }
1089 : :
1090 : 1656 : static void __perf_mux_hrtimer_init(struct perf_cpu_context *cpuctx, int cpu)
1091 : : {
1092 : 1656 : struct hrtimer *timer = &cpuctx->hrtimer;
1093 : 1656 : struct pmu *pmu = cpuctx->ctx.pmu;
1094 : : u64 interval;
1095 : :
1096 : : /* no multiplexing needed for SW PMU */
1097 [ + + ]: 1656 : if (pmu->task_ctx_nr == perf_sw_context)
1098 : 1656 : return;
1099 : :
1100 : : /*
1101 : : * check default is sane, if not set then force to
1102 : : * default interval (1/tick)
1103 : : */
1104 : 828 : interval = pmu->hrtimer_interval_ms;
1105 [ + + ]: 828 : if (interval < 1)
1106 : 207 : interval = pmu->hrtimer_interval_ms = PERF_CPU_HRTIMER;
1107 : :
1108 : 1656 : cpuctx->hrtimer_interval = ns_to_ktime(NSEC_PER_MSEC * interval);
1109 : :
1110 : 828 : raw_spin_lock_init(&cpuctx->hrtimer_lock);
1111 : 828 : hrtimer_init(timer, CLOCK_MONOTONIC, HRTIMER_MODE_ABS_PINNED_HARD);
1112 : 828 : timer->function = perf_mux_hrtimer_handler;
1113 : : }
1114 : :
1115 : 0 : static int perf_mux_hrtimer_restart(struct perf_cpu_context *cpuctx)
1116 : : {
1117 : 0 : struct hrtimer *timer = &cpuctx->hrtimer;
1118 : 0 : struct pmu *pmu = cpuctx->ctx.pmu;
1119 : : unsigned long flags;
1120 : :
1121 : : /* not for SW PMU */
1122 [ # # ]: 0 : if (pmu->task_ctx_nr == perf_sw_context)
1123 : : return 0;
1124 : :
1125 : 0 : raw_spin_lock_irqsave(&cpuctx->hrtimer_lock, flags);
1126 [ # # ]: 0 : if (!cpuctx->hrtimer_active) {
1127 : 0 : cpuctx->hrtimer_active = 1;
1128 : 0 : hrtimer_forward_now(timer, cpuctx->hrtimer_interval);
1129 : 0 : hrtimer_start_expires(timer, HRTIMER_MODE_ABS_PINNED_HARD);
1130 : : }
1131 : 0 : raw_spin_unlock_irqrestore(&cpuctx->hrtimer_lock, flags);
1132 : :
1133 : 0 : return 0;
1134 : : }
1135 : :
1136 : 0 : void perf_pmu_disable(struct pmu *pmu)
1137 : : {
1138 : 0 : int *count = this_cpu_ptr(pmu->pmu_disable_count);
1139 [ # # # # : 0 : if (!(*count)++)
# # # # #
# # # # #
# # # # #
# # # # #
# # # # ]
1140 : 0 : pmu->pmu_disable(pmu);
1141 : 0 : }
1142 : :
1143 : 0 : void perf_pmu_enable(struct pmu *pmu)
1144 : : {
1145 : 0 : int *count = this_cpu_ptr(pmu->pmu_disable_count);
1146 [ # # # # : 0 : if (!--(*count))
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# ]
1147 : 0 : pmu->pmu_enable(pmu);
1148 : 0 : }
1149 : :
1150 : : static DEFINE_PER_CPU(struct list_head, active_ctx_list);
1151 : :
1152 : : /*
1153 : : * perf_event_ctx_activate(), perf_event_ctx_deactivate(), and
1154 : : * perf_event_task_tick() are fully serialized because they're strictly cpu
1155 : : * affine and perf_event_ctx{activate,deactivate} are called with IRQs
1156 : : * disabled, while perf_event_task_tick is called from IRQ context.
1157 : : */
1158 : 0 : static void perf_event_ctx_activate(struct perf_event_context *ctx)
1159 : : {
1160 : 0 : struct list_head *head = this_cpu_ptr(&active_ctx_list);
1161 : :
1162 : : lockdep_assert_irqs_disabled();
1163 : :
1164 [ # # ]: 0 : WARN_ON(!list_empty(&ctx->active_ctx_list));
1165 : :
1166 : : list_add(&ctx->active_ctx_list, head);
1167 : 0 : }
1168 : :
1169 : 0 : static void perf_event_ctx_deactivate(struct perf_event_context *ctx)
1170 : : {
1171 : : lockdep_assert_irqs_disabled();
1172 : :
1173 [ # # ]: 0 : WARN_ON(list_empty(&ctx->active_ctx_list));
1174 : :
1175 : : list_del_init(&ctx->active_ctx_list);
1176 : 0 : }
1177 : :
1178 : : static void get_ctx(struct perf_event_context *ctx)
1179 : : {
1180 : 0 : refcount_inc(&ctx->refcount);
1181 : : }
1182 : :
1183 : 0 : static void free_ctx(struct rcu_head *head)
1184 : : {
1185 : : struct perf_event_context *ctx;
1186 : :
1187 : 0 : ctx = container_of(head, struct perf_event_context, rcu_head);
1188 : 0 : kfree(ctx->task_ctx_data);
1189 : 0 : kfree(ctx);
1190 : 0 : }
1191 : :
1192 : 0 : static void put_ctx(struct perf_event_context *ctx)
1193 : : {
1194 [ # # ]: 0 : if (refcount_dec_and_test(&ctx->refcount)) {
1195 [ # # ]: 0 : if (ctx->parent_ctx)
1196 : 0 : put_ctx(ctx->parent_ctx);
1197 [ # # ]: 0 : if (ctx->task && ctx->task != TASK_TOMBSTONE)
1198 : 0 : put_task_struct(ctx->task);
1199 : 0 : call_rcu(&ctx->rcu_head, free_ctx);
1200 : : }
1201 : 0 : }
1202 : :
1203 : : /*
1204 : : * Because of perf_event::ctx migration in sys_perf_event_open::move_group and
1205 : : * perf_pmu_migrate_context() we need some magic.
1206 : : *
1207 : : * Those places that change perf_event::ctx will hold both
1208 : : * perf_event_ctx::mutex of the 'old' and 'new' ctx value.
1209 : : *
1210 : : * Lock ordering is by mutex address. There are two other sites where
1211 : : * perf_event_context::mutex nests and those are:
1212 : : *
1213 : : * - perf_event_exit_task_context() [ child , 0 ]
1214 : : * perf_event_exit_event()
1215 : : * put_event() [ parent, 1 ]
1216 : : *
1217 : : * - perf_event_init_context() [ parent, 0 ]
1218 : : * inherit_task_group()
1219 : : * inherit_group()
1220 : : * inherit_event()
1221 : : * perf_event_alloc()
1222 : : * perf_init_event()
1223 : : * perf_try_init_event() [ child , 1 ]
1224 : : *
1225 : : * While it appears there is an obvious deadlock here -- the parent and child
1226 : : * nesting levels are inverted between the two. This is in fact safe because
1227 : : * life-time rules separate them. That is an exiting task cannot fork, and a
1228 : : * spawning task cannot (yet) exit.
1229 : : *
1230 : : * But remember that that these are parent<->child context relations, and
1231 : : * migration does not affect children, therefore these two orderings should not
1232 : : * interact.
1233 : : *
1234 : : * The change in perf_event::ctx does not affect children (as claimed above)
1235 : : * because the sys_perf_event_open() case will install a new event and break
1236 : : * the ctx parent<->child relation, and perf_pmu_migrate_context() is only
1237 : : * concerned with cpuctx and that doesn't have children.
1238 : : *
1239 : : * The places that change perf_event::ctx will issue:
1240 : : *
1241 : : * perf_remove_from_context();
1242 : : * synchronize_rcu();
1243 : : * perf_install_in_context();
1244 : : *
1245 : : * to affect the change. The remove_from_context() + synchronize_rcu() should
1246 : : * quiesce the event, after which we can install it in the new location. This
1247 : : * means that only external vectors (perf_fops, prctl) can perturb the event
1248 : : * while in transit. Therefore all such accessors should also acquire
1249 : : * perf_event_context::mutex to serialize against this.
1250 : : *
1251 : : * However; because event->ctx can change while we're waiting to acquire
1252 : : * ctx->mutex we must be careful and use the below perf_event_ctx_lock()
1253 : : * function.
1254 : : *
1255 : : * Lock order:
1256 : : * cred_guard_mutex
1257 : : * task_struct::perf_event_mutex
1258 : : * perf_event_context::mutex
1259 : : * perf_event::child_mutex;
1260 : : * perf_event_context::lock
1261 : : * perf_event::mmap_mutex
1262 : : * mmap_sem
1263 : : * perf_addr_filters_head::lock
1264 : : *
1265 : : * cpu_hotplug_lock
1266 : : * pmus_lock
1267 : : * cpuctx->mutex / perf_event_context::mutex
1268 : : */
1269 : : static struct perf_event_context *
1270 : 0 : perf_event_ctx_lock_nested(struct perf_event *event, int nesting)
1271 : : {
1272 : : struct perf_event_context *ctx;
1273 : :
1274 : : again:
1275 : : rcu_read_lock();
1276 : 0 : ctx = READ_ONCE(event->ctx);
1277 [ # # ]: 0 : if (!refcount_inc_not_zero(&ctx->refcount)) {
1278 : : rcu_read_unlock();
1279 : : goto again;
1280 : : }
1281 : : rcu_read_unlock();
1282 : :
1283 : 0 : mutex_lock_nested(&ctx->mutex, nesting);
1284 [ # # ]: 0 : if (event->ctx != ctx) {
1285 : 0 : mutex_unlock(&ctx->mutex);
1286 : 0 : put_ctx(ctx);
1287 : 0 : goto again;
1288 : : }
1289 : :
1290 : 0 : return ctx;
1291 : : }
1292 : :
1293 : : static inline struct perf_event_context *
1294 : : perf_event_ctx_lock(struct perf_event *event)
1295 : : {
1296 : 0 : return perf_event_ctx_lock_nested(event, 0);
1297 : : }
1298 : :
1299 : : static void perf_event_ctx_unlock(struct perf_event *event,
1300 : : struct perf_event_context *ctx)
1301 : : {
1302 : 0 : mutex_unlock(&ctx->mutex);
1303 : 0 : put_ctx(ctx);
1304 : : }
1305 : :
1306 : : /*
1307 : : * This must be done under the ctx->lock, such as to serialize against
1308 : : * context_equiv(), therefore we cannot call put_ctx() since that might end up
1309 : : * calling scheduler related locks and ctx->lock nests inside those.
1310 : : */
1311 : : static __must_check struct perf_event_context *
1312 : : unclone_ctx(struct perf_event_context *ctx)
1313 : : {
1314 : 0 : struct perf_event_context *parent_ctx = ctx->parent_ctx;
1315 : :
1316 : : lockdep_assert_held(&ctx->lock);
1317 : :
1318 [ # # # # : 0 : if (parent_ctx)
# # ]
1319 : 0 : ctx->parent_ctx = NULL;
1320 : 0 : ctx->generation++;
1321 : :
1322 : : return parent_ctx;
1323 : : }
1324 : :
1325 : 0 : static u32 perf_event_pid_type(struct perf_event *event, struct task_struct *p,
1326 : : enum pid_type type)
1327 : : {
1328 : : u32 nr;
1329 : : /*
1330 : : * only top level events have the pid namespace they were created in
1331 : : */
1332 [ # # ]: 0 : if (event->parent)
1333 : : event = event->parent;
1334 : :
1335 : 0 : nr = __task_pid_nr_ns(p, type, event->ns);
1336 : : /* avoid -1 if it is idle thread or runs in another ns */
1337 [ # # # # ]: 0 : if (!nr && !pid_alive(p))
1338 : : nr = -1;
1339 : 0 : return nr;
1340 : : }
1341 : :
1342 : : static u32 perf_event_pid(struct perf_event *event, struct task_struct *p)
1343 : : {
1344 : 0 : return perf_event_pid_type(event, p, PIDTYPE_TGID);
1345 : : }
1346 : :
1347 : : static u32 perf_event_tid(struct perf_event *event, struct task_struct *p)
1348 : : {
1349 : 0 : return perf_event_pid_type(event, p, PIDTYPE_PID);
1350 : : }
1351 : :
1352 : : /*
1353 : : * If we inherit events we want to return the parent event id
1354 : : * to userspace.
1355 : : */
1356 : : static u64 primary_event_id(struct perf_event *event)
1357 : : {
1358 : 0 : u64 id = event->id;
1359 : :
1360 [ # # # # : 0 : if (event->parent)
# # # # #
# # # # #
# # # # ]
1361 : 0 : id = event->parent->id;
1362 : :
1363 : : return id;
1364 : : }
1365 : :
1366 : : /*
1367 : : * Get the perf_event_context for a task and lock it.
1368 : : *
1369 : : * This has to cope with with the fact that until it is locked,
1370 : : * the context could get moved to another task.
1371 : : */
1372 : : static struct perf_event_context *
1373 : 511572 : perf_lock_task_context(struct task_struct *task, int ctxn, unsigned long *flags)
1374 : : {
1375 : : struct perf_event_context *ctx;
1376 : :
1377 : : retry:
1378 : : /*
1379 : : * One of the few rules of preemptible RCU is that one cannot do
1380 : : * rcu_read_unlock() while holding a scheduler (or nested) lock when
1381 : : * part of the read side critical section was irqs-enabled -- see
1382 : : * rcu_read_unlock_special().
1383 : : *
1384 : : * Since ctx->lock nests under rq->lock we must ensure the entire read
1385 : : * side critical section has interrupts disabled.
1386 : : */
1387 : 511541 : local_irq_save(*flags);
1388 : : rcu_read_lock();
1389 : 1023230 : ctx = rcu_dereference(task->perf_event_ctxp[ctxn]);
1390 [ - + ]: 511615 : if (ctx) {
1391 : : /*
1392 : : * If this context is a clone of another, it might
1393 : : * get swapped for another underneath us by
1394 : : * perf_event_task_sched_out, though the
1395 : : * rcu_read_lock() protects us from any context
1396 : : * getting freed. Lock the context and check if it
1397 : : * got swapped before we could get the lock, and retry
1398 : : * if so. If we locked the right context, then it
1399 : : * can't get swapped on us any more.
1400 : : */
1401 : 0 : raw_spin_lock(&ctx->lock);
1402 [ # # ]: 0 : if (ctx != rcu_dereference(task->perf_event_ctxp[ctxn])) {
1403 : : raw_spin_unlock(&ctx->lock);
1404 : : rcu_read_unlock();
1405 [ # # ]: 0 : local_irq_restore(*flags);
1406 : : goto retry;
1407 : : }
1408 : :
1409 [ # # # # ]: 0 : if (ctx->task == TASK_TOMBSTONE ||
1410 : 0 : !refcount_inc_not_zero(&ctx->refcount)) {
1411 : : raw_spin_unlock(&ctx->lock);
1412 : 0 : ctx = NULL;
1413 : : } else {
1414 [ # # # # ]: 0 : WARN_ON_ONCE(ctx->task != task);
1415 : : }
1416 : : }
1417 : : rcu_read_unlock();
1418 [ + + ]: 511609 : if (!ctx)
1419 [ - + ]: 1023218 : local_irq_restore(*flags);
1420 : 511579 : return ctx;
1421 : : }
1422 : :
1423 : : /*
1424 : : * Get the context for a task and increment its pin_count so it
1425 : : * can't get swapped to another task. This also increments its
1426 : : * reference count so that the context can't get freed.
1427 : : */
1428 : : static struct perf_event_context *
1429 : 511556 : perf_pin_task_context(struct task_struct *task, int ctxn)
1430 : : {
1431 : : struct perf_event_context *ctx;
1432 : : unsigned long flags;
1433 : :
1434 : 511556 : ctx = perf_lock_task_context(task, ctxn, &flags);
1435 [ - + ]: 511616 : if (ctx) {
1436 : 0 : ++ctx->pin_count;
1437 : 0 : raw_spin_unlock_irqrestore(&ctx->lock, flags);
1438 : : }
1439 : 511616 : return ctx;
1440 : : }
1441 : :
1442 : 0 : static void perf_unpin_context(struct perf_event_context *ctx)
1443 : : {
1444 : : unsigned long flags;
1445 : :
1446 : 0 : raw_spin_lock_irqsave(&ctx->lock, flags);
1447 : 0 : --ctx->pin_count;
1448 : 0 : raw_spin_unlock_irqrestore(&ctx->lock, flags);
1449 : 0 : }
1450 : :
1451 : : /*
1452 : : * Update the record of the current time in a context.
1453 : : */
1454 : 0 : static void update_context_time(struct perf_event_context *ctx)
1455 : : {
1456 : : u64 now = perf_clock();
1457 : :
1458 : 0 : ctx->time += now - ctx->timestamp;
1459 : 0 : ctx->timestamp = now;
1460 : 0 : }
1461 : :
1462 : : static u64 perf_event_time(struct perf_event *event)
1463 : : {
1464 : 0 : struct perf_event_context *ctx = event->ctx;
1465 : :
1466 [ # # # # ]: 0 : if (is_cgroup_event(event))
1467 : : return perf_cgroup_event_time(event);
1468 : :
1469 [ # # # # ]: 0 : return ctx ? ctx->time : 0;
1470 : : }
1471 : :
1472 : : static enum event_type_t get_event_type(struct perf_event *event)
1473 : : {
1474 : 0 : struct perf_event_context *ctx = event->ctx;
1475 : : enum event_type_t event_type;
1476 : :
1477 : : lockdep_assert_held(&ctx->lock);
1478 : :
1479 : : /*
1480 : : * It's 'group type', really, because if our group leader is
1481 : : * pinned, so are we.
1482 : : */
1483 [ # # # # : 0 : if (event->group_leader != event)
# # ]
1484 : : event = event->group_leader;
1485 : :
1486 [ # # # # : 0 : event_type = event->attr.pinned ? EVENT_PINNED : EVENT_FLEXIBLE;
# # ]
1487 [ # # # # : 0 : if (!ctx->task)
# # ]
1488 : 0 : event_type |= EVENT_CPU;
1489 : :
1490 : : return event_type;
1491 : : }
1492 : :
1493 : : /*
1494 : : * Helper function to initialize event group nodes.
1495 : : */
1496 : : static void init_event_group(struct perf_event *event)
1497 : : {
1498 : 0 : RB_CLEAR_NODE(&event->group_node);
1499 : 0 : event->group_index = 0;
1500 : : }
1501 : :
1502 : : /*
1503 : : * Extract pinned or flexible groups from the context
1504 : : * based on event attrs bits.
1505 : : */
1506 : : static struct perf_event_groups *
1507 : : get_event_groups(struct perf_event *event, struct perf_event_context *ctx)
1508 : : {
1509 [ # # # # : 0 : if (event->attr.pinned)
# # ]
1510 : 0 : return &ctx->pinned_groups;
1511 : : else
1512 : 0 : return &ctx->flexible_groups;
1513 : : }
1514 : :
1515 : : /*
1516 : : * Helper function to initializes perf_event_group trees.
1517 : : */
1518 : : static void perf_event_groups_init(struct perf_event_groups *groups)
1519 : : {
1520 : 3312 : groups->tree = RB_ROOT;
1521 : 3312 : groups->index = 0;
1522 : : }
1523 : :
1524 : : /*
1525 : : * Compare function for event groups;
1526 : : *
1527 : : * Implements complex key that first sorts by CPU and then by virtual index
1528 : : * which provides ordering when rotating groups for the same CPU.
1529 : : */
1530 : : static bool
1531 : : perf_event_groups_less(struct perf_event *left, struct perf_event *right)
1532 : : {
1533 [ # # ]: 0 : if (left->cpu < right->cpu)
1534 : : return true;
1535 [ # # ]: 0 : if (left->cpu > right->cpu)
1536 : : return false;
1537 : :
1538 [ # # ]: 0 : if (left->group_index < right->group_index)
1539 : : return true;
1540 : : if (left->group_index > right->group_index)
1541 : : return false;
1542 : :
1543 : : return false;
1544 : : }
1545 : :
1546 : : /*
1547 : : * Insert @event into @groups' tree; using {@event->cpu, ++@groups->index} for
1548 : : * key (see perf_event_groups_less). This places it last inside the CPU
1549 : : * subtree.
1550 : : */
1551 : : static void
1552 : 0 : perf_event_groups_insert(struct perf_event_groups *groups,
1553 : : struct perf_event *event)
1554 : : {
1555 : : struct perf_event *node_event;
1556 : : struct rb_node *parent;
1557 : : struct rb_node **node;
1558 : :
1559 : 0 : event->group_index = ++groups->index;
1560 : :
1561 : 0 : node = &groups->tree.rb_node;
1562 : 0 : parent = *node;
1563 : :
1564 [ # # ]: 0 : while (*node) {
1565 : : parent = *node;
1566 : : node_event = container_of(*node, struct perf_event, group_node);
1567 : :
1568 [ # # ]: 0 : if (perf_event_groups_less(event, node_event))
1569 : 0 : node = &parent->rb_left;
1570 : : else
1571 : 0 : node = &parent->rb_right;
1572 : : }
1573 : :
1574 : 0 : rb_link_node(&event->group_node, parent, node);
1575 : 0 : rb_insert_color(&event->group_node, &groups->tree);
1576 : 0 : }
1577 : :
1578 : : /*
1579 : : * Helper function to insert event into the pinned or flexible groups.
1580 : : */
1581 : : static void
1582 : : add_event_to_groups(struct perf_event *event, struct perf_event_context *ctx)
1583 : : {
1584 : : struct perf_event_groups *groups;
1585 : :
1586 : : groups = get_event_groups(event, ctx);
1587 : 0 : perf_event_groups_insert(groups, event);
1588 : : }
1589 : :
1590 : : /*
1591 : : * Delete a group from a tree.
1592 : : */
1593 : : static void
1594 : 0 : perf_event_groups_delete(struct perf_event_groups *groups,
1595 : : struct perf_event *event)
1596 : : {
1597 [ # # # # : 0 : WARN_ON_ONCE(RB_EMPTY_NODE(&event->group_node) ||
# # # # ]
1598 : : RB_EMPTY_ROOT(&groups->tree));
1599 : :
1600 : 0 : rb_erase(&event->group_node, &groups->tree);
1601 : : init_event_group(event);
1602 : 0 : }
1603 : :
1604 : : /*
1605 : : * Helper function to delete event from its groups.
1606 : : */
1607 : : static void
1608 : : del_event_from_groups(struct perf_event *event, struct perf_event_context *ctx)
1609 : : {
1610 : : struct perf_event_groups *groups;
1611 : :
1612 : : groups = get_event_groups(event, ctx);
1613 : 0 : perf_event_groups_delete(groups, event);
1614 : : }
1615 : :
1616 : : /*
1617 : : * Get the leftmost event in the @cpu subtree.
1618 : : */
1619 : : static struct perf_event *
1620 : : perf_event_groups_first(struct perf_event_groups *groups, int cpu)
1621 : : {
1622 : : struct perf_event *node_event = NULL, *match = NULL;
1623 : 0 : struct rb_node *node = groups->tree.rb_node;
1624 : :
1625 [ # # # # ]: 0 : while (node) {
1626 : 0 : node_event = container_of(node, struct perf_event, group_node);
1627 : :
1628 [ # # # # ]: 0 : if (cpu < node_event->cpu) {
1629 : 0 : node = node->rb_left;
1630 [ # # # # ]: 0 : } else if (cpu > node_event->cpu) {
1631 : 0 : node = node->rb_right;
1632 : : } else {
1633 : : match = node_event;
1634 : 0 : node = node->rb_left;
1635 : : }
1636 : : }
1637 : :
1638 : 0 : return match;
1639 : : }
1640 : :
1641 : : /*
1642 : : * Like rb_entry_next_safe() for the @cpu subtree.
1643 : : */
1644 : : static struct perf_event *
1645 : 0 : perf_event_groups_next(struct perf_event *event)
1646 : : {
1647 : : struct perf_event *next;
1648 : :
1649 [ # # ]: 0 : next = rb_entry_safe(rb_next(&event->group_node), typeof(*event), group_node);
1650 [ # # # # ]: 0 : if (next && next->cpu == event->cpu)
1651 : 0 : return next;
1652 : :
1653 : : return NULL;
1654 : : }
1655 : :
1656 : : /*
1657 : : * Iterate through the whole groups tree.
1658 : : */
1659 : : #define perf_event_groups_for_each(event, groups) \
1660 : : for (event = rb_entry_safe(rb_first(&((groups)->tree)), \
1661 : : typeof(*event), group_node); event; \
1662 : : event = rb_entry_safe(rb_next(&event->group_node), \
1663 : : typeof(*event), group_node))
1664 : :
1665 : : /*
1666 : : * Add an event from the lists for its context.
1667 : : * Must be called with ctx->mutex and ctx->lock held.
1668 : : */
1669 : : static void
1670 : 0 : list_add_event(struct perf_event *event, struct perf_event_context *ctx)
1671 : : {
1672 : : lockdep_assert_held(&ctx->lock);
1673 : :
1674 [ # # # # ]: 0 : WARN_ON_ONCE(event->attach_state & PERF_ATTACH_CONTEXT);
1675 : 0 : event->attach_state |= PERF_ATTACH_CONTEXT;
1676 : :
1677 : 0 : event->tstamp = perf_event_time(event);
1678 : :
1679 : : /*
1680 : : * If we're a stand alone event or group leader, we go to the context
1681 : : * list, group events are kept attached to the group so that
1682 : : * perf_group_detach can, at all times, locate all siblings.
1683 : : */
1684 [ # # ]: 0 : if (event->group_leader == event) {
1685 : 0 : event->group_caps = event->event_caps;
1686 : : add_event_to_groups(event, ctx);
1687 : : }
1688 : :
1689 : 0 : list_update_cgroup_event(event, ctx, true);
1690 : :
1691 : 0 : list_add_rcu(&event->event_entry, &ctx->event_list);
1692 : 0 : ctx->nr_events++;
1693 [ # # ]: 0 : if (event->attr.inherit_stat)
1694 : 0 : ctx->nr_stat++;
1695 : :
1696 : 0 : ctx->generation++;
1697 : 0 : }
1698 : :
1699 : : /*
1700 : : * Initialize event state based on the perf_event_attr::disabled.
1701 : : */
1702 : : static inline void perf_event__state_init(struct perf_event *event)
1703 : : {
1704 [ # # # # : 0 : event->state = event->attr.disabled ? PERF_EVENT_STATE_OFF :
# # ]
1705 : : PERF_EVENT_STATE_INACTIVE;
1706 : : }
1707 : :
1708 : 0 : static void __perf_event_read_size(struct perf_event *event, int nr_siblings)
1709 : : {
1710 : : int entry = sizeof(u64); /* value */
1711 : : int size = 0;
1712 : : int nr = 1;
1713 : :
1714 [ # # ]: 0 : if (event->attr.read_format & PERF_FORMAT_TOTAL_TIME_ENABLED)
1715 : : size += sizeof(u64);
1716 : :
1717 [ # # ]: 0 : if (event->attr.read_format & PERF_FORMAT_TOTAL_TIME_RUNNING)
1718 : 0 : size += sizeof(u64);
1719 : :
1720 [ # # ]: 0 : if (event->attr.read_format & PERF_FORMAT_ID)
1721 : : entry += sizeof(u64);
1722 : :
1723 [ # # ]: 0 : if (event->attr.read_format & PERF_FORMAT_GROUP) {
1724 : 0 : nr += nr_siblings;
1725 : 0 : size += sizeof(u64);
1726 : : }
1727 : :
1728 : 0 : size += entry * nr;
1729 : 0 : event->read_size = size;
1730 : 0 : }
1731 : :
1732 : 0 : static void __perf_event_header_size(struct perf_event *event, u64 sample_type)
1733 : : {
1734 : : struct perf_sample_data *data;
1735 : : u16 size = 0;
1736 : :
1737 [ # # ]: 0 : if (sample_type & PERF_SAMPLE_IP)
1738 : : size += sizeof(data->ip);
1739 : :
1740 [ # # ]: 0 : if (sample_type & PERF_SAMPLE_ADDR)
1741 : 0 : size += sizeof(data->addr);
1742 : :
1743 [ # # ]: 0 : if (sample_type & PERF_SAMPLE_PERIOD)
1744 : 0 : size += sizeof(data->period);
1745 : :
1746 [ # # ]: 0 : if (sample_type & PERF_SAMPLE_WEIGHT)
1747 : 0 : size += sizeof(data->weight);
1748 : :
1749 [ # # ]: 0 : if (sample_type & PERF_SAMPLE_READ)
1750 : 0 : size += event->read_size;
1751 : :
1752 [ # # ]: 0 : if (sample_type & PERF_SAMPLE_DATA_SRC)
1753 : 0 : size += sizeof(data->data_src.val);
1754 : :
1755 [ # # ]: 0 : if (sample_type & PERF_SAMPLE_TRANSACTION)
1756 : 0 : size += sizeof(data->txn);
1757 : :
1758 [ # # ]: 0 : if (sample_type & PERF_SAMPLE_PHYS_ADDR)
1759 : 0 : size += sizeof(data->phys_addr);
1760 : :
1761 : 0 : event->header_size = size;
1762 : 0 : }
1763 : :
1764 : : /*
1765 : : * Called at perf_event creation and when events are attached/detached from a
1766 : : * group.
1767 : : */
1768 : 0 : static void perf_event__header_size(struct perf_event *event)
1769 : : {
1770 : 0 : __perf_event_read_size(event,
1771 : 0 : event->group_leader->nr_siblings);
1772 : 0 : __perf_event_header_size(event, event->attr.sample_type);
1773 : 0 : }
1774 : :
1775 : 0 : static void perf_event__id_header_size(struct perf_event *event)
1776 : : {
1777 : : struct perf_sample_data *data;
1778 : 0 : u64 sample_type = event->attr.sample_type;
1779 : : u16 size = 0;
1780 : :
1781 [ # # ]: 0 : if (sample_type & PERF_SAMPLE_TID)
1782 : : size += sizeof(data->tid_entry);
1783 : :
1784 [ # # ]: 0 : if (sample_type & PERF_SAMPLE_TIME)
1785 : 0 : size += sizeof(data->time);
1786 : :
1787 [ # # ]: 0 : if (sample_type & PERF_SAMPLE_IDENTIFIER)
1788 : 0 : size += sizeof(data->id);
1789 : :
1790 [ # # ]: 0 : if (sample_type & PERF_SAMPLE_ID)
1791 : 0 : size += sizeof(data->id);
1792 : :
1793 [ # # ]: 0 : if (sample_type & PERF_SAMPLE_STREAM_ID)
1794 : 0 : size += sizeof(data->stream_id);
1795 : :
1796 [ # # ]: 0 : if (sample_type & PERF_SAMPLE_CPU)
1797 : 0 : size += sizeof(data->cpu_entry);
1798 : :
1799 : 0 : event->id_header_size = size;
1800 : 0 : }
1801 : :
1802 : 0 : static bool perf_event_validate_size(struct perf_event *event)
1803 : : {
1804 : : /*
1805 : : * The values computed here will be over-written when we actually
1806 : : * attach the event.
1807 : : */
1808 : 0 : __perf_event_read_size(event, event->group_leader->nr_siblings + 1);
1809 : 0 : __perf_event_header_size(event, event->attr.sample_type & ~PERF_SAMPLE_READ);
1810 : 0 : perf_event__id_header_size(event);
1811 : :
1812 : : /*
1813 : : * Sum the lot; should not exceed the 64k limit we have on records.
1814 : : * Conservative limit to allow for callchains and other variable fields.
1815 : : */
1816 [ # # ]: 0 : if (event->read_size + event->header_size +
1817 : 0 : event->id_header_size + sizeof(struct perf_event_header) >= 16*1024)
1818 : : return false;
1819 : :
1820 : 0 : return true;
1821 : : }
1822 : :
1823 : 0 : static void perf_group_attach(struct perf_event *event)
1824 : : {
1825 : 0 : struct perf_event *group_leader = event->group_leader, *pos;
1826 : :
1827 : : lockdep_assert_held(&event->ctx->lock);
1828 : :
1829 : : /*
1830 : : * We can have double attach due to group movement in perf_event_open.
1831 : : */
1832 [ # # ]: 0 : if (event->attach_state & PERF_ATTACH_GROUP)
1833 : : return;
1834 : :
1835 : 0 : event->attach_state |= PERF_ATTACH_GROUP;
1836 : :
1837 [ # # ]: 0 : if (group_leader == event)
1838 : : return;
1839 : :
1840 [ # # # # ]: 0 : WARN_ON_ONCE(group_leader->ctx != event->ctx);
1841 : :
1842 : 0 : group_leader->group_caps &= event->event_caps;
1843 : :
1844 : 0 : list_add_tail(&event->sibling_list, &group_leader->sibling_list);
1845 : 0 : group_leader->nr_siblings++;
1846 : :
1847 : 0 : perf_event__header_size(group_leader);
1848 : :
1849 [ # # # # ]: 0 : for_each_sibling_event(pos, group_leader)
1850 : 0 : perf_event__header_size(pos);
1851 : : }
1852 : :
1853 : : /*
1854 : : * Remove an event from the lists for its context.
1855 : : * Must be called with ctx->mutex and ctx->lock held.
1856 : : */
1857 : : static void
1858 : 0 : list_del_event(struct perf_event *event, struct perf_event_context *ctx)
1859 : : {
1860 [ # # # # ]: 0 : WARN_ON_ONCE(event->ctx != ctx);
1861 : : lockdep_assert_held(&ctx->lock);
1862 : :
1863 : : /*
1864 : : * We can have double detach due to exit/hot-unplug + close.
1865 : : */
1866 [ # # ]: 0 : if (!(event->attach_state & PERF_ATTACH_CONTEXT))
1867 : 0 : return;
1868 : :
1869 : 0 : event->attach_state &= ~PERF_ATTACH_CONTEXT;
1870 : :
1871 : 0 : list_update_cgroup_event(event, ctx, false);
1872 : :
1873 : 0 : ctx->nr_events--;
1874 [ # # ]: 0 : if (event->attr.inherit_stat)
1875 : 0 : ctx->nr_stat--;
1876 : :
1877 : : list_del_rcu(&event->event_entry);
1878 : :
1879 [ # # ]: 0 : if (event->group_leader == event)
1880 : : del_event_from_groups(event, ctx);
1881 : :
1882 : : /*
1883 : : * If event was in error state, then keep it
1884 : : * that way, otherwise bogus counts will be
1885 : : * returned on read(). The only way to get out
1886 : : * of error state is by explicit re-enabling
1887 : : * of the event
1888 : : */
1889 [ # # ]: 0 : if (event->state > PERF_EVENT_STATE_OFF)
1890 : 0 : perf_event_set_state(event, PERF_EVENT_STATE_OFF);
1891 : :
1892 : 0 : ctx->generation++;
1893 : : }
1894 : :
1895 : : static int
1896 : : perf_aux_output_match(struct perf_event *event, struct perf_event *aux_event)
1897 : : {
1898 [ # # ]: 0 : if (!has_aux(aux_event))
1899 : : return 0;
1900 : :
1901 [ # # ]: 0 : if (!event->pmu->aux_output_match)
1902 : : return 0;
1903 : :
1904 : 0 : return event->pmu->aux_output_match(aux_event);
1905 : : }
1906 : :
1907 : : static void put_event(struct perf_event *event);
1908 : : static void event_sched_out(struct perf_event *event,
1909 : : struct perf_cpu_context *cpuctx,
1910 : : struct perf_event_context *ctx);
1911 : :
1912 : 0 : static void perf_put_aux_event(struct perf_event *event)
1913 : : {
1914 : 0 : struct perf_event_context *ctx = event->ctx;
1915 : : struct perf_cpu_context *cpuctx = __get_cpu_context(ctx);
1916 : : struct perf_event *iter;
1917 : :
1918 : : /*
1919 : : * If event uses aux_event tear down the link
1920 : : */
1921 [ # # ]: 0 : if (event->aux_event) {
1922 : : iter = event->aux_event;
1923 : 0 : event->aux_event = NULL;
1924 : 0 : put_event(iter);
1925 : 0 : return;
1926 : : }
1927 : :
1928 : : /*
1929 : : * If the event is an aux_event, tear down all links to
1930 : : * it from other events.
1931 : : */
1932 [ # # # # ]: 0 : for_each_sibling_event(iter, event->group_leader) {
1933 [ # # ]: 0 : if (iter->aux_event != event)
1934 : 0 : continue;
1935 : :
1936 : 0 : iter->aux_event = NULL;
1937 : 0 : put_event(event);
1938 : :
1939 : : /*
1940 : : * If it's ACTIVE, schedule it out and put it into ERROR
1941 : : * state so that we don't try to schedule it again. Note
1942 : : * that perf_event_enable() will clear the ERROR status.
1943 : : */
1944 : 0 : event_sched_out(iter, cpuctx, ctx);
1945 : 0 : perf_event_set_state(event, PERF_EVENT_STATE_ERROR);
1946 : : }
1947 : : }
1948 : :
1949 : 0 : static int perf_get_aux_event(struct perf_event *event,
1950 : : struct perf_event *group_leader)
1951 : : {
1952 : : /*
1953 : : * Our group leader must be an aux event if we want to be
1954 : : * an aux_output. This way, the aux event will precede its
1955 : : * aux_output events in the group, and therefore will always
1956 : : * schedule first.
1957 : : */
1958 [ # # ]: 0 : if (!group_leader)
1959 : : return 0;
1960 : :
1961 [ # # ]: 0 : if (!perf_aux_output_match(event, group_leader))
1962 : : return 0;
1963 : :
1964 [ # # ]: 0 : if (!atomic_long_inc_not_zero(&group_leader->refcount))
1965 : : return 0;
1966 : :
1967 : : /*
1968 : : * Link aux_outputs to their aux event; this is undone in
1969 : : * perf_group_detach() by perf_put_aux_event(). When the
1970 : : * group in torn down, the aux_output events loose their
1971 : : * link to the aux_event and can't schedule any more.
1972 : : */
1973 : 0 : event->aux_event = group_leader;
1974 : :
1975 : 0 : return 1;
1976 : : }
1977 : :
1978 : 0 : static void perf_group_detach(struct perf_event *event)
1979 : : {
1980 : : struct perf_event *sibling, *tmp;
1981 : 0 : struct perf_event_context *ctx = event->ctx;
1982 : :
1983 : : lockdep_assert_held(&ctx->lock);
1984 : :
1985 : : /*
1986 : : * We can have double detach due to exit/hot-unplug + close.
1987 : : */
1988 [ # # ]: 0 : if (!(event->attach_state & PERF_ATTACH_GROUP))
1989 : 0 : return;
1990 : :
1991 : 0 : event->attach_state &= ~PERF_ATTACH_GROUP;
1992 : :
1993 : 0 : perf_put_aux_event(event);
1994 : :
1995 : : /*
1996 : : * If this is a sibling, remove it from its group.
1997 : : */
1998 [ # # ]: 0 : if (event->group_leader != event) {
1999 : 0 : list_del_init(&event->sibling_list);
2000 : 0 : event->group_leader->nr_siblings--;
2001 : 0 : goto out;
2002 : : }
2003 : :
2004 : : /*
2005 : : * If this was a group event with sibling events then
2006 : : * upgrade the siblings to singleton events by adding them
2007 : : * to whatever list we are on.
2008 : : */
2009 [ # # ]: 0 : list_for_each_entry_safe(sibling, tmp, &event->sibling_list, sibling_list) {
2010 : :
2011 : 0 : sibling->group_leader = sibling;
2012 : 0 : list_del_init(&sibling->sibling_list);
2013 : :
2014 : : /* Inherit group flags from the previous leader */
2015 : 0 : sibling->group_caps = event->group_caps;
2016 : :
2017 [ # # ]: 0 : if (!RB_EMPTY_NODE(&event->group_node)) {
2018 : 0 : add_event_to_groups(sibling, event->ctx);
2019 : :
2020 [ # # ]: 0 : if (sibling->state == PERF_EVENT_STATE_ACTIVE) {
2021 : 0 : struct list_head *list = sibling->attr.pinned ?
2022 [ # # ]: 0 : &ctx->pinned_active : &ctx->flexible_active;
2023 : :
2024 : 0 : list_add_tail(&sibling->active_list, list);
2025 : : }
2026 : : }
2027 : :
2028 [ # # # # ]: 0 : WARN_ON_ONCE(sibling->ctx != event->ctx);
2029 : : }
2030 : :
2031 : : out:
2032 : 0 : perf_event__header_size(event->group_leader);
2033 : :
2034 [ # # # # ]: 0 : for_each_sibling_event(tmp, event->group_leader)
2035 : 0 : perf_event__header_size(tmp);
2036 : : }
2037 : :
2038 : : static bool is_orphaned_event(struct perf_event *event)
2039 : : {
2040 : 0 : return event->state == PERF_EVENT_STATE_DEAD;
2041 : : }
2042 : :
2043 : : static inline int __pmu_filter_match(struct perf_event *event)
2044 : : {
2045 : 0 : struct pmu *pmu = event->pmu;
2046 [ # # # # ]: 0 : return pmu->filter_match ? pmu->filter_match(event) : 1;
2047 : : }
2048 : :
2049 : : /*
2050 : : * Check whether we should attempt to schedule an event group based on
2051 : : * PMU-specific filtering. An event group can consist of HW and SW events,
2052 : : * potentially with a SW leader, so we must check all the filters, to
2053 : : * determine whether a group is schedulable:
2054 : : */
2055 : 0 : static inline int pmu_filter_match(struct perf_event *event)
2056 : : {
2057 : : struct perf_event *sibling;
2058 : :
2059 [ # # ]: 0 : if (!__pmu_filter_match(event))
2060 : : return 0;
2061 : :
2062 [ # # # # ]: 0 : for_each_sibling_event(sibling, event) {
2063 [ # # ]: 0 : if (!__pmu_filter_match(sibling))
2064 : : return 0;
2065 : : }
2066 : :
2067 : : return 1;
2068 : : }
2069 : :
2070 : : static inline int
2071 : 0 : event_filter_match(struct perf_event *event)
2072 : : {
2073 [ # # # # ]: 0 : return (event->cpu == -1 || event->cpu == smp_processor_id()) &&
2074 [ # # # # ]: 0 : perf_cgroup_match(event) && pmu_filter_match(event);
2075 : : }
2076 : :
2077 : : static void
2078 : 0 : event_sched_out(struct perf_event *event,
2079 : : struct perf_cpu_context *cpuctx,
2080 : : struct perf_event_context *ctx)
2081 : : {
2082 : : enum perf_event_state state = PERF_EVENT_STATE_INACTIVE;
2083 : :
2084 [ # # # # ]: 0 : WARN_ON_ONCE(event->ctx != ctx);
2085 : : lockdep_assert_held(&ctx->lock);
2086 : :
2087 [ # # ]: 0 : if (event->state != PERF_EVENT_STATE_ACTIVE)
2088 : 0 : return;
2089 : :
2090 : : /*
2091 : : * Asymmetry; we only schedule events _IN_ through ctx_sched_in(), but
2092 : : * we can schedule events _OUT_ individually through things like
2093 : : * __perf_remove_from_context().
2094 : : */
2095 : 0 : list_del_init(&event->active_list);
2096 : :
2097 : 0 : perf_pmu_disable(event->pmu);
2098 : :
2099 : 0 : event->pmu->del(event, 0);
2100 : 0 : event->oncpu = -1;
2101 : :
2102 [ # # ]: 0 : if (READ_ONCE(event->pending_disable) >= 0) {
2103 : : WRITE_ONCE(event->pending_disable, -1);
2104 : : state = PERF_EVENT_STATE_OFF;
2105 : : }
2106 : 0 : perf_event_set_state(event, state);
2107 : :
2108 [ # # ]: 0 : if (!is_software_event(event))
2109 : 0 : cpuctx->active_oncpu--;
2110 [ # # ]: 0 : if (!--ctx->nr_active)
2111 : 0 : perf_event_ctx_deactivate(ctx);
2112 [ # # # # ]: 0 : if (event->attr.freq && event->attr.sample_freq)
2113 : 0 : ctx->nr_freq--;
2114 [ # # # # ]: 0 : if (event->attr.exclusive || !cpuctx->active_oncpu)
2115 : 0 : cpuctx->exclusive = 0;
2116 : :
2117 : 0 : perf_pmu_enable(event->pmu);
2118 : : }
2119 : :
2120 : : static void
2121 : 0 : group_sched_out(struct perf_event *group_event,
2122 : : struct perf_cpu_context *cpuctx,
2123 : : struct perf_event_context *ctx)
2124 : : {
2125 : : struct perf_event *event;
2126 : :
2127 [ # # ]: 0 : if (group_event->state != PERF_EVENT_STATE_ACTIVE)
2128 : 0 : return;
2129 : :
2130 : 0 : perf_pmu_disable(ctx->pmu);
2131 : :
2132 : 0 : event_sched_out(group_event, cpuctx, ctx);
2133 : :
2134 : : /*
2135 : : * Schedule out siblings (if any):
2136 : : */
2137 [ # # # # ]: 0 : for_each_sibling_event(event, group_event)
2138 : 0 : event_sched_out(event, cpuctx, ctx);
2139 : :
2140 : 0 : perf_pmu_enable(ctx->pmu);
2141 : :
2142 [ # # ]: 0 : if (group_event->attr.exclusive)
2143 : 0 : cpuctx->exclusive = 0;
2144 : : }
2145 : :
2146 : : #define DETACH_GROUP 0x01UL
2147 : :
2148 : : /*
2149 : : * Cross CPU call to remove a performance event
2150 : : *
2151 : : * We disable the event on the hardware level first. After that we
2152 : : * remove it from the context list.
2153 : : */
2154 : : static void
2155 : 0 : __perf_remove_from_context(struct perf_event *event,
2156 : : struct perf_cpu_context *cpuctx,
2157 : : struct perf_event_context *ctx,
2158 : : void *info)
2159 : : {
2160 : 0 : unsigned long flags = (unsigned long)info;
2161 : :
2162 [ # # ]: 0 : if (ctx->is_active & EVENT_TIME) {
2163 : 0 : update_context_time(ctx);
2164 : 0 : update_cgrp_time_from_cpuctx(cpuctx);
2165 : : }
2166 : :
2167 : 0 : event_sched_out(event, cpuctx, ctx);
2168 [ # # ]: 0 : if (flags & DETACH_GROUP)
2169 : 0 : perf_group_detach(event);
2170 : 0 : list_del_event(event, ctx);
2171 : :
2172 [ # # # # ]: 0 : if (!ctx->nr_events && ctx->is_active) {
2173 : 0 : ctx->is_active = 0;
2174 : 0 : ctx->rotate_necessary = 0;
2175 [ # # ]: 0 : if (ctx->task) {
2176 [ # # # # ]: 0 : WARN_ON_ONCE(cpuctx->task_ctx != ctx);
2177 : 0 : cpuctx->task_ctx = NULL;
2178 : : }
2179 : : }
2180 : 0 : }
2181 : :
2182 : : /*
2183 : : * Remove the event from a task's (or a CPU's) list of events.
2184 : : *
2185 : : * If event->ctx is a cloned context, callers must make sure that
2186 : : * every task struct that event->ctx->task could possibly point to
2187 : : * remains valid. This is OK when called from perf_release since
2188 : : * that only calls us on the top-level context, which can't be a clone.
2189 : : * When called from perf_event_exit_task, it's OK because the
2190 : : * context has been detached from its task.
2191 : : */
2192 : 0 : static void perf_remove_from_context(struct perf_event *event, unsigned long flags)
2193 : : {
2194 : 0 : struct perf_event_context *ctx = event->ctx;
2195 : :
2196 : : lockdep_assert_held(&ctx->mutex);
2197 : :
2198 : 0 : event_function_call(event, __perf_remove_from_context, (void *)flags);
2199 : :
2200 : : /*
2201 : : * The above event_function_call() can NO-OP when it hits
2202 : : * TASK_TOMBSTONE. In that case we must already have been detached
2203 : : * from the context (by perf_event_exit_event()) but the grouping
2204 : : * might still be in-tact.
2205 : : */
2206 [ # # # # ]: 0 : WARN_ON_ONCE(event->attach_state & PERF_ATTACH_CONTEXT);
2207 [ # # # # ]: 0 : if ((flags & DETACH_GROUP) &&
2208 : 0 : (event->attach_state & PERF_ATTACH_GROUP)) {
2209 : : /*
2210 : : * Since in that case we cannot possibly be scheduled, simply
2211 : : * detach now.
2212 : : */
2213 : 0 : raw_spin_lock_irq(&ctx->lock);
2214 : 0 : perf_group_detach(event);
2215 : 0 : raw_spin_unlock_irq(&ctx->lock);
2216 : : }
2217 : 0 : }
2218 : :
2219 : : /*
2220 : : * Cross CPU call to disable a performance event
2221 : : */
2222 : 0 : static void __perf_event_disable(struct perf_event *event,
2223 : : struct perf_cpu_context *cpuctx,
2224 : : struct perf_event_context *ctx,
2225 : : void *info)
2226 : : {
2227 [ # # ]: 0 : if (event->state < PERF_EVENT_STATE_INACTIVE)
2228 : 0 : return;
2229 : :
2230 [ # # ]: 0 : if (ctx->is_active & EVENT_TIME) {
2231 : 0 : update_context_time(ctx);
2232 : 0 : update_cgrp_time_from_event(event);
2233 : : }
2234 : :
2235 [ # # ]: 0 : if (event == event->group_leader)
2236 : 0 : group_sched_out(event, cpuctx, ctx);
2237 : : else
2238 : 0 : event_sched_out(event, cpuctx, ctx);
2239 : :
2240 : 0 : perf_event_set_state(event, PERF_EVENT_STATE_OFF);
2241 : : }
2242 : :
2243 : : /*
2244 : : * Disable an event.
2245 : : *
2246 : : * If event->ctx is a cloned context, callers must make sure that
2247 : : * every task struct that event->ctx->task could possibly point to
2248 : : * remains valid. This condition is satisfied when called through
2249 : : * perf_event_for_each_child or perf_event_for_each because they
2250 : : * hold the top-level event's child_mutex, so any descendant that
2251 : : * goes to exit will block in perf_event_exit_event().
2252 : : *
2253 : : * When called from perf_pending_event it's OK because event->ctx
2254 : : * is the current context on this CPU and preemption is disabled,
2255 : : * hence we can't get into perf_event_task_sched_out for this context.
2256 : : */
2257 : 0 : static void _perf_event_disable(struct perf_event *event)
2258 : : {
2259 : 0 : struct perf_event_context *ctx = event->ctx;
2260 : :
2261 : 0 : raw_spin_lock_irq(&ctx->lock);
2262 [ # # ]: 0 : if (event->state <= PERF_EVENT_STATE_OFF) {
2263 : 0 : raw_spin_unlock_irq(&ctx->lock);
2264 : 0 : return;
2265 : : }
2266 : 0 : raw_spin_unlock_irq(&ctx->lock);
2267 : :
2268 : 0 : event_function_call(event, __perf_event_disable, NULL);
2269 : : }
2270 : :
2271 : 0 : void perf_event_disable_local(struct perf_event *event)
2272 : : {
2273 : 0 : event_function_local(event, __perf_event_disable, NULL);
2274 : 0 : }
2275 : :
2276 : : /*
2277 : : * Strictly speaking kernel users cannot create groups and therefore this
2278 : : * interface does not need the perf_event_ctx_lock() magic.
2279 : : */
2280 : 0 : void perf_event_disable(struct perf_event *event)
2281 : : {
2282 : : struct perf_event_context *ctx;
2283 : :
2284 : : ctx = perf_event_ctx_lock(event);
2285 : 0 : _perf_event_disable(event);
2286 : : perf_event_ctx_unlock(event, ctx);
2287 : 0 : }
2288 : : EXPORT_SYMBOL_GPL(perf_event_disable);
2289 : :
2290 : 0 : void perf_event_disable_inatomic(struct perf_event *event)
2291 : : {
2292 : 0 : WRITE_ONCE(event->pending_disable, smp_processor_id());
2293 : : /* can fail, see perf_pending_event_disable() */
2294 : 0 : irq_work_queue(&event->pending);
2295 : 0 : }
2296 : :
2297 : 0 : static void perf_set_shadow_time(struct perf_event *event,
2298 : : struct perf_event_context *ctx)
2299 : : {
2300 : : /*
2301 : : * use the correct time source for the time snapshot
2302 : : *
2303 : : * We could get by without this by leveraging the
2304 : : * fact that to get to this function, the caller
2305 : : * has most likely already called update_context_time()
2306 : : * and update_cgrp_time_xx() and thus both timestamp
2307 : : * are identical (or very close). Given that tstamp is,
2308 : : * already adjusted for cgroup, we could say that:
2309 : : * tstamp - ctx->timestamp
2310 : : * is equivalent to
2311 : : * tstamp - cgrp->timestamp.
2312 : : *
2313 : : * Then, in perf_output_read(), the calculation would
2314 : : * work with no changes because:
2315 : : * - event is guaranteed scheduled in
2316 : : * - no scheduled out in between
2317 : : * - thus the timestamp would be the same
2318 : : *
2319 : : * But this is a bit hairy.
2320 : : *
2321 : : * So instead, we have an explicit cgroup call to remain
2322 : : * within the time time source all along. We believe it
2323 : : * is cleaner and simpler to understand.
2324 : : */
2325 [ # # ]: 0 : if (is_cgroup_event(event))
2326 : 0 : perf_cgroup_set_shadow_time(event, event->tstamp);
2327 : : else
2328 : 0 : event->shadow_ctx_time = event->tstamp - ctx->timestamp;
2329 : 0 : }
2330 : :
2331 : : #define MAX_INTERRUPTS (~0ULL)
2332 : :
2333 : : static void perf_log_throttle(struct perf_event *event, int enable);
2334 : : static void perf_log_itrace_start(struct perf_event *event);
2335 : :
2336 : : static int
2337 : 0 : event_sched_in(struct perf_event *event,
2338 : : struct perf_cpu_context *cpuctx,
2339 : : struct perf_event_context *ctx)
2340 : : {
2341 : : int ret = 0;
2342 : :
2343 : : lockdep_assert_held(&ctx->lock);
2344 : :
2345 [ # # ]: 0 : if (event->state <= PERF_EVENT_STATE_OFF)
2346 : : return 0;
2347 : :
2348 : 0 : WRITE_ONCE(event->oncpu, smp_processor_id());
2349 : : /*
2350 : : * Order event::oncpu write to happen before the ACTIVE state is
2351 : : * visible. This allows perf_event_{stop,read}() to observe the correct
2352 : : * ->oncpu if it sees ACTIVE.
2353 : : */
2354 : 0 : smp_wmb();
2355 : 0 : perf_event_set_state(event, PERF_EVENT_STATE_ACTIVE);
2356 : :
2357 : : /*
2358 : : * Unthrottle events, since we scheduled we might have missed several
2359 : : * ticks already, also for a heavily scheduling task there is little
2360 : : * guarantee it'll get a tick in a timely manner.
2361 : : */
2362 [ # # ]: 0 : if (unlikely(event->hw.interrupts == MAX_INTERRUPTS)) {
2363 : 0 : perf_log_throttle(event, 1);
2364 : 0 : event->hw.interrupts = 0;
2365 : : }
2366 : :
2367 : 0 : perf_pmu_disable(event->pmu);
2368 : :
2369 : 0 : perf_set_shadow_time(event, ctx);
2370 : :
2371 : 0 : perf_log_itrace_start(event);
2372 : :
2373 [ # # ]: 0 : if (event->pmu->add(event, PERF_EF_START)) {
2374 : 0 : perf_event_set_state(event, PERF_EVENT_STATE_INACTIVE);
2375 : 0 : event->oncpu = -1;
2376 : : ret = -EAGAIN;
2377 : 0 : goto out;
2378 : : }
2379 : :
2380 [ # # ]: 0 : if (!is_software_event(event))
2381 : 0 : cpuctx->active_oncpu++;
2382 [ # # ]: 0 : if (!ctx->nr_active++)
2383 : 0 : perf_event_ctx_activate(ctx);
2384 [ # # # # ]: 0 : if (event->attr.freq && event->attr.sample_freq)
2385 : 0 : ctx->nr_freq++;
2386 : :
2387 [ # # ]: 0 : if (event->attr.exclusive)
2388 : 0 : cpuctx->exclusive = 1;
2389 : :
2390 : : out:
2391 : 0 : perf_pmu_enable(event->pmu);
2392 : :
2393 : 0 : return ret;
2394 : : }
2395 : :
2396 : : static int
2397 : 0 : group_sched_in(struct perf_event *group_event,
2398 : : struct perf_cpu_context *cpuctx,
2399 : : struct perf_event_context *ctx)
2400 : : {
2401 : : struct perf_event *event, *partial_group = NULL;
2402 : 0 : struct pmu *pmu = ctx->pmu;
2403 : :
2404 [ # # ]: 0 : if (group_event->state == PERF_EVENT_STATE_OFF)
2405 : : return 0;
2406 : :
2407 : 0 : pmu->start_txn(pmu, PERF_PMU_TXN_ADD);
2408 : :
2409 [ # # ]: 0 : if (event_sched_in(group_event, cpuctx, ctx)) {
2410 : 0 : pmu->cancel_txn(pmu);
2411 : 0 : perf_mux_hrtimer_restart(cpuctx);
2412 : 0 : return -EAGAIN;
2413 : : }
2414 : :
2415 : : /*
2416 : : * Schedule in siblings as one group (if any):
2417 : : */
2418 [ # # # # ]: 0 : for_each_sibling_event(event, group_event) {
2419 [ # # ]: 0 : if (event_sched_in(event, cpuctx, ctx)) {
2420 : 0 : partial_group = event;
2421 : 0 : goto group_error;
2422 : : }
2423 : : }
2424 : :
2425 [ # # ]: 0 : if (!pmu->commit_txn(pmu))
2426 : : return 0;
2427 : :
2428 : : group_error:
2429 : : /*
2430 : : * Groups can be scheduled in as one unit only, so undo any
2431 : : * partial group before returning:
2432 : : * The events up to the failed event are scheduled out normally.
2433 : : */
2434 [ # # # # ]: 0 : for_each_sibling_event(event, group_event) {
2435 [ # # ]: 0 : if (event == partial_group)
2436 : : break;
2437 : :
2438 : 0 : event_sched_out(event, cpuctx, ctx);
2439 : : }
2440 : 0 : event_sched_out(group_event, cpuctx, ctx);
2441 : :
2442 : 0 : pmu->cancel_txn(pmu);
2443 : :
2444 : 0 : perf_mux_hrtimer_restart(cpuctx);
2445 : :
2446 : 0 : return -EAGAIN;
2447 : : }
2448 : :
2449 : : /*
2450 : : * Work out whether we can put this event group on the CPU now.
2451 : : */
2452 : : static int group_can_go_on(struct perf_event *event,
2453 : : struct perf_cpu_context *cpuctx,
2454 : : int can_add_hw)
2455 : : {
2456 : : /*
2457 : : * Groups consisting entirely of software events can always go on.
2458 : : */
2459 [ # # # # ]: 0 : if (event->group_caps & PERF_EV_CAP_SOFTWARE)
2460 : : return 1;
2461 : : /*
2462 : : * If an exclusive group is already on, no other hardware
2463 : : * events can go on.
2464 : : */
2465 [ # # # # ]: 0 : if (cpuctx->exclusive)
2466 : : return 0;
2467 : : /*
2468 : : * If this group is exclusive and there are already
2469 : : * events on the CPU, it can't go on.
2470 : : */
2471 [ # # # # : 0 : if (event->attr.exclusive && cpuctx->active_oncpu)
# # # # ]
2472 : : return 0;
2473 : : /*
2474 : : * Otherwise, try to add it if all previous groups were able
2475 : : * to go on.
2476 : : */
2477 : : return can_add_hw;
2478 : : }
2479 : :
2480 : : static void add_event_to_ctx(struct perf_event *event,
2481 : : struct perf_event_context *ctx)
2482 : : {
2483 : 0 : list_add_event(event, ctx);
2484 : 0 : perf_group_attach(event);
2485 : : }
2486 : :
2487 : : static void ctx_sched_out(struct perf_event_context *ctx,
2488 : : struct perf_cpu_context *cpuctx,
2489 : : enum event_type_t event_type);
2490 : : static void
2491 : : ctx_sched_in(struct perf_event_context *ctx,
2492 : : struct perf_cpu_context *cpuctx,
2493 : : enum event_type_t event_type,
2494 : : struct task_struct *task);
2495 : :
2496 : 0 : static void task_ctx_sched_out(struct perf_cpu_context *cpuctx,
2497 : : struct perf_event_context *ctx,
2498 : : enum event_type_t event_type)
2499 : : {
2500 [ # # ]: 0 : if (!cpuctx->task_ctx)
2501 : : return;
2502 : :
2503 [ # # # # : 0 : if (WARN_ON_ONCE(ctx != cpuctx->task_ctx))
# # ]
2504 : : return;
2505 : :
2506 : 0 : ctx_sched_out(ctx, cpuctx, event_type);
2507 : : }
2508 : :
2509 : 0 : static void perf_event_sched_in(struct perf_cpu_context *cpuctx,
2510 : : struct perf_event_context *ctx,
2511 : : struct task_struct *task)
2512 : : {
2513 : : cpu_ctx_sched_in(cpuctx, EVENT_PINNED, task);
2514 [ # # ]: 0 : if (ctx)
2515 : 0 : ctx_sched_in(ctx, cpuctx, EVENT_PINNED, task);
2516 : : cpu_ctx_sched_in(cpuctx, EVENT_FLEXIBLE, task);
2517 [ # # ]: 0 : if (ctx)
2518 : 0 : ctx_sched_in(ctx, cpuctx, EVENT_FLEXIBLE, task);
2519 : 0 : }
2520 : :
2521 : : /*
2522 : : * We want to maintain the following priority of scheduling:
2523 : : * - CPU pinned (EVENT_CPU | EVENT_PINNED)
2524 : : * - task pinned (EVENT_PINNED)
2525 : : * - CPU flexible (EVENT_CPU | EVENT_FLEXIBLE)
2526 : : * - task flexible (EVENT_FLEXIBLE).
2527 : : *
2528 : : * In order to avoid unscheduling and scheduling back in everything every
2529 : : * time an event is added, only do it for the groups of equal priority and
2530 : : * below.
2531 : : *
2532 : : * This can be called after a batch operation on task events, in which case
2533 : : * event_type is a bit mask of the types of events involved. For CPU events,
2534 : : * event_type is only either EVENT_PINNED or EVENT_FLEXIBLE.
2535 : : */
2536 : 0 : static void ctx_resched(struct perf_cpu_context *cpuctx,
2537 : : struct perf_event_context *task_ctx,
2538 : : enum event_type_t event_type)
2539 : : {
2540 : : enum event_type_t ctx_event_type;
2541 : 0 : bool cpu_event = !!(event_type & EVENT_CPU);
2542 : :
2543 : : /*
2544 : : * If pinned groups are involved, flexible groups also need to be
2545 : : * scheduled out.
2546 : : */
2547 [ # # ]: 0 : if (event_type & EVENT_PINNED)
2548 : 0 : event_type |= EVENT_FLEXIBLE;
2549 : :
2550 : 0 : ctx_event_type = event_type & EVENT_ALL;
2551 : :
2552 : 0 : perf_pmu_disable(cpuctx->ctx.pmu);
2553 [ # # ]: 0 : if (task_ctx)
2554 : 0 : task_ctx_sched_out(cpuctx, task_ctx, event_type);
2555 : :
2556 : : /*
2557 : : * Decide which cpu ctx groups to schedule out based on the types
2558 : : * of events that caused rescheduling:
2559 : : * - EVENT_CPU: schedule out corresponding groups;
2560 : : * - EVENT_PINNED task events: schedule out EVENT_FLEXIBLE groups;
2561 : : * - otherwise, do nothing more.
2562 : : */
2563 [ # # ]: 0 : if (cpu_event)
2564 : : cpu_ctx_sched_out(cpuctx, ctx_event_type);
2565 [ # # ]: 0 : else if (ctx_event_type & EVENT_PINNED)
2566 : : cpu_ctx_sched_out(cpuctx, EVENT_FLEXIBLE);
2567 : :
2568 : 0 : perf_event_sched_in(cpuctx, task_ctx, current);
2569 : 0 : perf_pmu_enable(cpuctx->ctx.pmu);
2570 : 0 : }
2571 : :
2572 : 0 : void perf_pmu_resched(struct pmu *pmu)
2573 : : {
2574 : 0 : struct perf_cpu_context *cpuctx = this_cpu_ptr(pmu->pmu_cpu_context);
2575 : 0 : struct perf_event_context *task_ctx = cpuctx->task_ctx;
2576 : :
2577 : : perf_ctx_lock(cpuctx, task_ctx);
2578 : 0 : ctx_resched(cpuctx, task_ctx, EVENT_ALL|EVENT_CPU);
2579 : 0 : perf_ctx_unlock(cpuctx, task_ctx);
2580 : 0 : }
2581 : :
2582 : : /*
2583 : : * Cross CPU call to install and enable a performance event
2584 : : *
2585 : : * Very similar to remote_function() + event_function() but cannot assume that
2586 : : * things like ctx->is_active and cpuctx->task_ctx are set.
2587 : : */
2588 : 0 : static int __perf_install_in_context(void *info)
2589 : : {
2590 : : struct perf_event *event = info;
2591 : 0 : struct perf_event_context *ctx = event->ctx;
2592 : : struct perf_cpu_context *cpuctx = __get_cpu_context(ctx);
2593 : 0 : struct perf_event_context *task_ctx = cpuctx->task_ctx;
2594 : : bool reprogram = true;
2595 : : int ret = 0;
2596 : :
2597 : 0 : raw_spin_lock(&cpuctx->ctx.lock);
2598 [ # # ]: 0 : if (ctx->task) {
2599 : 0 : raw_spin_lock(&ctx->lock);
2600 : : task_ctx = ctx;
2601 : :
2602 : 0 : reprogram = (ctx->task == current);
2603 : :
2604 : : /*
2605 : : * If the task is running, it must be running on this CPU,
2606 : : * otherwise we cannot reprogram things.
2607 : : *
2608 : : * If its not running, we don't care, ctx->lock will
2609 : : * serialize against it becoming runnable.
2610 : : */
2611 [ # # # # ]: 0 : if (task_curr(ctx->task) && !reprogram) {
2612 : : ret = -ESRCH;
2613 : : goto unlock;
2614 : : }
2615 : :
2616 [ # # # # : 0 : WARN_ON_ONCE(reprogram && cpuctx->task_ctx && cpuctx->task_ctx != ctx);
# # # # #
# ]
2617 [ # # ]: 0 : } else if (task_ctx) {
2618 : 0 : raw_spin_lock(&task_ctx->lock);
2619 : : }
2620 : :
2621 : : #ifdef CONFIG_CGROUP_PERF
2622 [ # # ]: 0 : if (is_cgroup_event(event)) {
2623 : : /*
2624 : : * If the current cgroup doesn't match the event's
2625 : : * cgroup, we should not try to schedule it.
2626 : : */
2627 : 0 : struct perf_cgroup *cgrp = perf_cgroup_from_task(current, ctx);
2628 : 0 : reprogram = cgroup_is_descendant(cgrp->css.cgroup,
2629 : : event->cgrp->css.cgroup);
2630 : : }
2631 : : #endif
2632 : :
2633 [ # # ]: 0 : if (reprogram) {
2634 : 0 : ctx_sched_out(ctx, cpuctx, EVENT_TIME);
2635 : : add_event_to_ctx(event, ctx);
2636 : 0 : ctx_resched(cpuctx, task_ctx, get_event_type(event));
2637 : : } else {
2638 : : add_event_to_ctx(event, ctx);
2639 : : }
2640 : :
2641 : : unlock:
2642 : 0 : perf_ctx_unlock(cpuctx, task_ctx);
2643 : :
2644 : 0 : return ret;
2645 : : }
2646 : :
2647 : : static bool exclusive_event_installable(struct perf_event *event,
2648 : : struct perf_event_context *ctx);
2649 : :
2650 : : /*
2651 : : * Attach a performance event to a context.
2652 : : *
2653 : : * Very similar to event_function_call, see comment there.
2654 : : */
2655 : : static void
2656 : 0 : perf_install_in_context(struct perf_event_context *ctx,
2657 : : struct perf_event *event,
2658 : : int cpu)
2659 : : {
2660 : 0 : struct task_struct *task = READ_ONCE(ctx->task);
2661 : :
2662 : : lockdep_assert_held(&ctx->mutex);
2663 : :
2664 [ # # # # ]: 0 : WARN_ON_ONCE(!exclusive_event_installable(event, ctx));
2665 : :
2666 [ # # ]: 0 : if (event->cpu != -1)
2667 : 0 : event->cpu = cpu;
2668 : :
2669 : : /*
2670 : : * Ensures that if we can observe event->ctx, both the event and ctx
2671 : : * will be 'complete'. See perf_iterate_sb_cpu().
2672 : : */
2673 : 0 : smp_store_release(&event->ctx, ctx);
2674 : :
2675 [ # # ]: 0 : if (!task) {
2676 : 0 : cpu_function_call(cpu, __perf_install_in_context, event);
2677 : 0 : return;
2678 : : }
2679 : :
2680 : : /*
2681 : : * Should not happen, we validate the ctx is still alive before calling.
2682 : : */
2683 [ # # # # : 0 : if (WARN_ON_ONCE(task == TASK_TOMBSTONE))
# # ]
2684 : : return;
2685 : :
2686 : : /*
2687 : : * Installing events is tricky because we cannot rely on ctx->is_active
2688 : : * to be set in case this is the nr_events 0 -> 1 transition.
2689 : : *
2690 : : * Instead we use task_curr(), which tells us if the task is running.
2691 : : * However, since we use task_curr() outside of rq::lock, we can race
2692 : : * against the actual state. This means the result can be wrong.
2693 : : *
2694 : : * If we get a false positive, we retry, this is harmless.
2695 : : *
2696 : : * If we get a false negative, things are complicated. If we are after
2697 : : * perf_event_context_sched_in() ctx::lock will serialize us, and the
2698 : : * value must be correct. If we're before, it doesn't matter since
2699 : : * perf_event_context_sched_in() will program the counter.
2700 : : *
2701 : : * However, this hinges on the remote context switch having observed
2702 : : * our task->perf_event_ctxp[] store, such that it will in fact take
2703 : : * ctx::lock in perf_event_context_sched_in().
2704 : : *
2705 : : * We do this by task_function_call(), if the IPI fails to hit the task
2706 : : * we know any future context switch of task must see the
2707 : : * perf_event_ctpx[] store.
2708 : : */
2709 : :
2710 : : /*
2711 : : * This smp_mb() orders the task->perf_event_ctxp[] store with the
2712 : : * task_cpu() load, such that if the IPI then does not find the task
2713 : : * running, a future context switch of that task must observe the
2714 : : * store.
2715 : : */
2716 : 0 : smp_mb();
2717 : : again:
2718 [ # # ]: 0 : if (!task_function_call(task, __perf_install_in_context, event))
2719 : : return;
2720 : :
2721 : 0 : raw_spin_lock_irq(&ctx->lock);
2722 : 0 : task = ctx->task;
2723 [ # # # # : 0 : if (WARN_ON_ONCE(task == TASK_TOMBSTONE)) {
# # ]
2724 : : /*
2725 : : * Cannot happen because we already checked above (which also
2726 : : * cannot happen), and we hold ctx->mutex, which serializes us
2727 : : * against perf_event_exit_task_context().
2728 : : */
2729 : 0 : raw_spin_unlock_irq(&ctx->lock);
2730 : 0 : return;
2731 : : }
2732 : : /*
2733 : : * If the task is not running, ctx->lock will avoid it becoming so,
2734 : : * thus we can safely install the event.
2735 : : */
2736 [ # # ]: 0 : if (task_curr(task)) {
2737 : 0 : raw_spin_unlock_irq(&ctx->lock);
2738 : 0 : goto again;
2739 : : }
2740 : : add_event_to_ctx(event, ctx);
2741 : 0 : raw_spin_unlock_irq(&ctx->lock);
2742 : : }
2743 : :
2744 : : /*
2745 : : * Cross CPU call to enable a performance event
2746 : : */
2747 : 0 : static void __perf_event_enable(struct perf_event *event,
2748 : : struct perf_cpu_context *cpuctx,
2749 : : struct perf_event_context *ctx,
2750 : : void *info)
2751 : : {
2752 : 0 : struct perf_event *leader = event->group_leader;
2753 : : struct perf_event_context *task_ctx;
2754 : :
2755 [ # # ]: 0 : if (event->state >= PERF_EVENT_STATE_INACTIVE ||
2756 : : event->state <= PERF_EVENT_STATE_ERROR)
2757 : : return;
2758 : :
2759 [ # # ]: 0 : if (ctx->is_active)
2760 : 0 : ctx_sched_out(ctx, cpuctx, EVENT_TIME);
2761 : :
2762 : 0 : perf_event_set_state(event, PERF_EVENT_STATE_INACTIVE);
2763 : :
2764 [ # # ]: 0 : if (!ctx->is_active)
2765 : : return;
2766 : :
2767 [ # # ]: 0 : if (!event_filter_match(event)) {
2768 : 0 : ctx_sched_in(ctx, cpuctx, EVENT_TIME, current);
2769 : 0 : return;
2770 : : }
2771 : :
2772 : : /*
2773 : : * If the event is in a group and isn't the group leader,
2774 : : * then don't put it on unless the group is on.
2775 : : */
2776 [ # # # # ]: 0 : if (leader != event && leader->state != PERF_EVENT_STATE_ACTIVE) {
2777 : 0 : ctx_sched_in(ctx, cpuctx, EVENT_TIME, current);
2778 : 0 : return;
2779 : : }
2780 : :
2781 : 0 : task_ctx = cpuctx->task_ctx;
2782 [ # # ]: 0 : if (ctx->task)
2783 [ # # # # ]: 0 : WARN_ON_ONCE(task_ctx != ctx);
2784 : :
2785 : 0 : ctx_resched(cpuctx, task_ctx, get_event_type(event));
2786 : : }
2787 : :
2788 : : /*
2789 : : * Enable an event.
2790 : : *
2791 : : * If event->ctx is a cloned context, callers must make sure that
2792 : : * every task struct that event->ctx->task could possibly point to
2793 : : * remains valid. This condition is satisfied when called through
2794 : : * perf_event_for_each_child or perf_event_for_each as described
2795 : : * for perf_event_disable.
2796 : : */
2797 : 0 : static void _perf_event_enable(struct perf_event *event)
2798 : : {
2799 : 0 : struct perf_event_context *ctx = event->ctx;
2800 : :
2801 : 0 : raw_spin_lock_irq(&ctx->lock);
2802 [ # # ]: 0 : if (event->state >= PERF_EVENT_STATE_INACTIVE ||
2803 : : event->state < PERF_EVENT_STATE_ERROR) {
2804 : 0 : raw_spin_unlock_irq(&ctx->lock);
2805 : 0 : return;
2806 : : }
2807 : :
2808 : : /*
2809 : : * If the event is in error state, clear that first.
2810 : : *
2811 : : * That way, if we see the event in error state below, we know that it
2812 : : * has gone back into error state, as distinct from the task having
2813 : : * been scheduled away before the cross-call arrived.
2814 : : */
2815 [ # # ]: 0 : if (event->state == PERF_EVENT_STATE_ERROR)
2816 : 0 : event->state = PERF_EVENT_STATE_OFF;
2817 : 0 : raw_spin_unlock_irq(&ctx->lock);
2818 : :
2819 : 0 : event_function_call(event, __perf_event_enable, NULL);
2820 : : }
2821 : :
2822 : : /*
2823 : : * See perf_event_disable();
2824 : : */
2825 : 0 : void perf_event_enable(struct perf_event *event)
2826 : : {
2827 : : struct perf_event_context *ctx;
2828 : :
2829 : : ctx = perf_event_ctx_lock(event);
2830 : 0 : _perf_event_enable(event);
2831 : : perf_event_ctx_unlock(event, ctx);
2832 : 0 : }
2833 : : EXPORT_SYMBOL_GPL(perf_event_enable);
2834 : :
2835 : : struct stop_event_data {
2836 : : struct perf_event *event;
2837 : : unsigned int restart;
2838 : : };
2839 : :
2840 : 0 : static int __perf_event_stop(void *info)
2841 : : {
2842 : : struct stop_event_data *sd = info;
2843 : 0 : struct perf_event *event = sd->event;
2844 : :
2845 : : /* if it's already INACTIVE, do nothing */
2846 [ # # ]: 0 : if (READ_ONCE(event->state) != PERF_EVENT_STATE_ACTIVE)
2847 : : return 0;
2848 : :
2849 : : /* matches smp_wmb() in event_sched_in() */
2850 : 0 : smp_rmb();
2851 : :
2852 : : /*
2853 : : * There is a window with interrupts enabled before we get here,
2854 : : * so we need to check again lest we try to stop another CPU's event.
2855 : : */
2856 [ # # ]: 0 : if (READ_ONCE(event->oncpu) != smp_processor_id())
2857 : : return -EAGAIN;
2858 : :
2859 : 0 : event->pmu->stop(event, PERF_EF_UPDATE);
2860 : :
2861 : : /*
2862 : : * May race with the actual stop (through perf_pmu_output_stop()),
2863 : : * but it is only used for events with AUX ring buffer, and such
2864 : : * events will refuse to restart because of rb::aux_mmap_count==0,
2865 : : * see comments in perf_aux_output_begin().
2866 : : *
2867 : : * Since this is happening on an event-local CPU, no trace is lost
2868 : : * while restarting.
2869 : : */
2870 [ # # ]: 0 : if (sd->restart)
2871 : 0 : event->pmu->start(event, 0);
2872 : :
2873 : : return 0;
2874 : : }
2875 : :
2876 : 0 : static int perf_event_stop(struct perf_event *event, int restart)
2877 : : {
2878 : 0 : struct stop_event_data sd = {
2879 : : .event = event,
2880 : : .restart = restart,
2881 : : };
2882 : : int ret = 0;
2883 : :
2884 : : do {
2885 [ # # ]: 0 : if (READ_ONCE(event->state) != PERF_EVENT_STATE_ACTIVE)
2886 : : return 0;
2887 : :
2888 : : /* matches smp_wmb() in event_sched_in() */
2889 : 0 : smp_rmb();
2890 : :
2891 : : /*
2892 : : * We only want to restart ACTIVE events, so if the event goes
2893 : : * inactive here (event->oncpu==-1), there's nothing more to do;
2894 : : * fall through with ret==-ENXIO.
2895 : : */
2896 : 0 : ret = cpu_function_call(READ_ONCE(event->oncpu),
2897 : : __perf_event_stop, &sd);
2898 [ # # ]: 0 : } while (ret == -EAGAIN);
2899 : :
2900 : 0 : return ret;
2901 : : }
2902 : :
2903 : : /*
2904 : : * In order to contain the amount of racy and tricky in the address filter
2905 : : * configuration management, it is a two part process:
2906 : : *
2907 : : * (p1) when userspace mappings change as a result of (1) or (2) or (3) below,
2908 : : * we update the addresses of corresponding vmas in
2909 : : * event::addr_filter_ranges array and bump the event::addr_filters_gen;
2910 : : * (p2) when an event is scheduled in (pmu::add), it calls
2911 : : * perf_event_addr_filters_sync() which calls pmu::addr_filters_sync()
2912 : : * if the generation has changed since the previous call.
2913 : : *
2914 : : * If (p1) happens while the event is active, we restart it to force (p2).
2915 : : *
2916 : : * (1) perf_addr_filters_apply(): adjusting filters' offsets based on
2917 : : * pre-existing mappings, called once when new filters arrive via SET_FILTER
2918 : : * ioctl;
2919 : : * (2) perf_addr_filters_adjust(): adjusting filters' offsets based on newly
2920 : : * registered mapping, called for every new mmap(), with mm::mmap_sem down
2921 : : * for reading;
2922 : : * (3) perf_event_addr_filters_exec(): clearing filters' offsets in the process
2923 : : * of exec.
2924 : : */
2925 : 0 : void perf_event_addr_filters_sync(struct perf_event *event)
2926 : : {
2927 : : struct perf_addr_filters_head *ifh = perf_event_addr_filters(event);
2928 : :
2929 [ # # ]: 0 : if (!has_addr_filter(event))
2930 : 0 : return;
2931 : :
2932 : 0 : raw_spin_lock(&ifh->lock);
2933 [ # # ]: 0 : if (event->addr_filters_gen != event->hw.addr_filters_gen) {
2934 : 0 : event->pmu->addr_filters_sync(event);
2935 : 0 : event->hw.addr_filters_gen = event->addr_filters_gen;
2936 : : }
2937 : : raw_spin_unlock(&ifh->lock);
2938 : : }
2939 : : EXPORT_SYMBOL_GPL(perf_event_addr_filters_sync);
2940 : :
2941 : 0 : static int _perf_event_refresh(struct perf_event *event, int refresh)
2942 : : {
2943 : : /*
2944 : : * not supported on inherited events
2945 : : */
2946 [ # # # # ]: 0 : if (event->attr.inherit || !is_sampling_event(event))
2947 : : return -EINVAL;
2948 : :
2949 : 0 : atomic_add(refresh, &event->event_limit);
2950 : 0 : _perf_event_enable(event);
2951 : :
2952 : 0 : return 0;
2953 : : }
2954 : :
2955 : : /*
2956 : : * See perf_event_disable()
2957 : : */
2958 : 0 : int perf_event_refresh(struct perf_event *event, int refresh)
2959 : : {
2960 : : struct perf_event_context *ctx;
2961 : : int ret;
2962 : :
2963 : : ctx = perf_event_ctx_lock(event);
2964 : 0 : ret = _perf_event_refresh(event, refresh);
2965 : : perf_event_ctx_unlock(event, ctx);
2966 : :
2967 : 0 : return ret;
2968 : : }
2969 : : EXPORT_SYMBOL_GPL(perf_event_refresh);
2970 : :
2971 : 0 : static int perf_event_modify_breakpoint(struct perf_event *bp,
2972 : : struct perf_event_attr *attr)
2973 : : {
2974 : : int err;
2975 : :
2976 : 0 : _perf_event_disable(bp);
2977 : :
2978 : 0 : err = modify_user_hw_breakpoint_check(bp, attr, true);
2979 : :
2980 [ # # ]: 0 : if (!bp->attr.disabled)
2981 : 0 : _perf_event_enable(bp);
2982 : :
2983 : 0 : return err;
2984 : : }
2985 : :
2986 : 0 : static int perf_event_modify_attr(struct perf_event *event,
2987 : : struct perf_event_attr *attr)
2988 : : {
2989 [ # # ]: 0 : if (event->attr.type != attr->type)
2990 : : return -EINVAL;
2991 : :
2992 [ # # ]: 0 : switch (event->attr.type) {
2993 : : case PERF_TYPE_BREAKPOINT:
2994 : 0 : return perf_event_modify_breakpoint(event, attr);
2995 : : default:
2996 : : /* Place holder for future additions. */
2997 : : return -EOPNOTSUPP;
2998 : : }
2999 : : }
3000 : :
3001 : 0 : static void ctx_sched_out(struct perf_event_context *ctx,
3002 : : struct perf_cpu_context *cpuctx,
3003 : : enum event_type_t event_type)
3004 : : {
3005 : : struct perf_event *event, *tmp;
3006 : 0 : int is_active = ctx->is_active;
3007 : :
3008 : : lockdep_assert_held(&ctx->lock);
3009 : :
3010 [ # # ]: 0 : if (likely(!ctx->nr_events)) {
3011 : : /*
3012 : : * See __perf_remove_from_context().
3013 : : */
3014 [ # # # # ]: 0 : WARN_ON_ONCE(ctx->is_active);
3015 [ # # ]: 0 : if (ctx->task)
3016 [ # # # # ]: 0 : WARN_ON_ONCE(cpuctx->task_ctx);
3017 : : return;
3018 : : }
3019 : :
3020 : 0 : ctx->is_active &= ~event_type;
3021 [ # # ]: 0 : if (!(ctx->is_active & EVENT_ALL))
3022 : 0 : ctx->is_active = 0;
3023 : :
3024 [ # # ]: 0 : if (ctx->task) {
3025 [ # # # # ]: 0 : WARN_ON_ONCE(cpuctx->task_ctx != ctx);
3026 [ # # ]: 0 : if (!ctx->is_active)
3027 : 0 : cpuctx->task_ctx = NULL;
3028 : : }
3029 : :
3030 : : /*
3031 : : * Always update time if it was set; not only when it changes.
3032 : : * Otherwise we can 'forget' to update time for any but the last
3033 : : * context we sched out. For example:
3034 : : *
3035 : : * ctx_sched_out(.event_type = EVENT_FLEXIBLE)
3036 : : * ctx_sched_out(.event_type = EVENT_PINNED)
3037 : : *
3038 : : * would only update time for the pinned events.
3039 : : */
3040 [ # # ]: 0 : if (is_active & EVENT_TIME) {
3041 : : /* update (and stop) ctx time */
3042 : 0 : update_context_time(ctx);
3043 : 0 : update_cgrp_time_from_cpuctx(cpuctx);
3044 : : }
3045 : :
3046 : 0 : is_active ^= ctx->is_active; /* changed bits */
3047 : :
3048 [ # # # # ]: 0 : if (!ctx->nr_active || !(is_active & EVENT_ALL))
3049 : : return;
3050 : :
3051 : 0 : perf_pmu_disable(ctx->pmu);
3052 [ # # ]: 0 : if (is_active & EVENT_PINNED) {
3053 [ # # ]: 0 : list_for_each_entry_safe(event, tmp, &ctx->pinned_active, active_list)
3054 : 0 : group_sched_out(event, cpuctx, ctx);
3055 : : }
3056 : :
3057 [ # # ]: 0 : if (is_active & EVENT_FLEXIBLE) {
3058 [ # # ]: 0 : list_for_each_entry_safe(event, tmp, &ctx->flexible_active, active_list)
3059 : 0 : group_sched_out(event, cpuctx, ctx);
3060 : :
3061 : : /*
3062 : : * Since we cleared EVENT_FLEXIBLE, also clear
3063 : : * rotate_necessary, is will be reset by
3064 : : * ctx_flexible_sched_in() when needed.
3065 : : */
3066 : 0 : ctx->rotate_necessary = 0;
3067 : : }
3068 : 0 : perf_pmu_enable(ctx->pmu);
3069 : : }
3070 : :
3071 : : /*
3072 : : * Test whether two contexts are equivalent, i.e. whether they have both been
3073 : : * cloned from the same version of the same context.
3074 : : *
3075 : : * Equivalence is measured using a generation number in the context that is
3076 : : * incremented on each modification to it; see unclone_ctx(), list_add_event()
3077 : : * and list_del_event().
3078 : : */
3079 : 0 : static int context_equiv(struct perf_event_context *ctx1,
3080 : : struct perf_event_context *ctx2)
3081 : : {
3082 : : lockdep_assert_held(&ctx1->lock);
3083 : : lockdep_assert_held(&ctx2->lock);
3084 : :
3085 : : /* Pinning disables the swap optimization */
3086 [ # # # # ]: 0 : if (ctx1->pin_count || ctx2->pin_count)
3087 : : return 0;
3088 : :
3089 : : /* If ctx1 is the parent of ctx2 */
3090 [ # # # # ]: 0 : if (ctx1 == ctx2->parent_ctx && ctx1->generation == ctx2->parent_gen)
3091 : : return 1;
3092 : :
3093 : : /* If ctx2 is the parent of ctx1 */
3094 [ # # # # ]: 0 : if (ctx1->parent_ctx == ctx2 && ctx1->parent_gen == ctx2->generation)
3095 : : return 1;
3096 : :
3097 : : /*
3098 : : * If ctx1 and ctx2 have the same parent; we flatten the parent
3099 : : * hierarchy, see perf_event_init_context().
3100 : : */
3101 [ # # # # : 0 : if (ctx1->parent_ctx && ctx1->parent_ctx == ctx2->parent_ctx &&
# # ]
3102 : 0 : ctx1->parent_gen == ctx2->parent_gen)
3103 : : return 1;
3104 : :
3105 : : /* Unmatched */
3106 : 0 : return 0;
3107 : : }
3108 : :
3109 : 0 : static void __perf_event_sync_stat(struct perf_event *event,
3110 : : struct perf_event *next_event)
3111 : : {
3112 : : u64 value;
3113 : :
3114 [ # # ]: 0 : if (!event->attr.inherit_stat)
3115 : 0 : return;
3116 : :
3117 : : /*
3118 : : * Update the event value, we cannot use perf_event_read()
3119 : : * because we're in the middle of a context switch and have IRQs
3120 : : * disabled, which upsets smp_call_function_single(), however
3121 : : * we know the event must be on the current CPU, therefore we
3122 : : * don't need to use it.
3123 : : */
3124 [ # # ]: 0 : if (event->state == PERF_EVENT_STATE_ACTIVE)
3125 : 0 : event->pmu->read(event);
3126 : :
3127 : 0 : perf_event_update_time(event);
3128 : :
3129 : : /*
3130 : : * In order to keep per-task stats reliable we need to flip the event
3131 : : * values when we flip the contexts.
3132 : : */
3133 : 0 : value = local64_read(&next_event->count);
3134 : 0 : value = local64_xchg(&event->count, value);
3135 : : local64_set(&next_event->count, value);
3136 : :
3137 : 0 : swap(event->total_time_enabled, next_event->total_time_enabled);
3138 : 0 : swap(event->total_time_running, next_event->total_time_running);
3139 : :
3140 : : /*
3141 : : * Since we swizzled the values, update the user visible data too.
3142 : : */
3143 : 0 : perf_event_update_userpage(event);
3144 : 0 : perf_event_update_userpage(next_event);
3145 : : }
3146 : :
3147 : 0 : static void perf_event_sync_stat(struct perf_event_context *ctx,
3148 : : struct perf_event_context *next_ctx)
3149 : : {
3150 : : struct perf_event *event, *next_event;
3151 : :
3152 [ # # ]: 0 : if (!ctx->nr_stat)
3153 : 0 : return;
3154 : :
3155 : 0 : update_context_time(ctx);
3156 : :
3157 : 0 : event = list_first_entry(&ctx->event_list,
3158 : : struct perf_event, event_entry);
3159 : :
3160 : 0 : next_event = list_first_entry(&next_ctx->event_list,
3161 : : struct perf_event, event_entry);
3162 : :
3163 [ # # # # ]: 0 : while (&event->event_entry != &ctx->event_list &&
3164 : 0 : &next_event->event_entry != &next_ctx->event_list) {
3165 : :
3166 : 0 : __perf_event_sync_stat(event, next_event);
3167 : :
3168 : 0 : event = list_next_entry(event, event_entry);
3169 : 0 : next_event = list_next_entry(next_event, event_entry);
3170 : : }
3171 : : }
3172 : :
3173 : 0 : static void perf_event_context_sched_out(struct task_struct *task, int ctxn,
3174 : : struct task_struct *next)
3175 : : {
3176 : 0 : struct perf_event_context *ctx = task->perf_event_ctxp[ctxn];
3177 : : struct perf_event_context *next_ctx;
3178 : : struct perf_event_context *parent, *next_parent;
3179 : : struct perf_cpu_context *cpuctx;
3180 : : int do_switch = 1;
3181 : :
3182 [ # # ]: 0 : if (likely(!ctx))
3183 : : return;
3184 : :
3185 : : cpuctx = __get_cpu_context(ctx);
3186 [ # # ]: 0 : if (!cpuctx->task_ctx)
3187 : : return;
3188 : :
3189 : : rcu_read_lock();
3190 : 0 : next_ctx = next->perf_event_ctxp[ctxn];
3191 [ # # ]: 0 : if (!next_ctx)
3192 : : goto unlock;
3193 : :
3194 : 0 : parent = rcu_dereference(ctx->parent_ctx);
3195 : 0 : next_parent = rcu_dereference(next_ctx->parent_ctx);
3196 : :
3197 : : /* If neither context have a parent context; they cannot be clones. */
3198 [ # # ]: 0 : if (!parent && !next_parent)
3199 : : goto unlock;
3200 : :
3201 [ # # # # ]: 0 : if (next_parent == ctx || next_ctx == parent || next_parent == parent) {
3202 : : /*
3203 : : * Looks like the two contexts are clones, so we might be
3204 : : * able to optimize the context switch. We lock both
3205 : : * contexts and check that they are clones under the
3206 : : * lock (including re-checking that neither has been
3207 : : * uncloned in the meantime). It doesn't matter which
3208 : : * order we take the locks because no other cpu could
3209 : : * be trying to lock both of these tasks.
3210 : : */
3211 : 0 : raw_spin_lock(&ctx->lock);
3212 : 0 : raw_spin_lock_nested(&next_ctx->lock, SINGLE_DEPTH_NESTING);
3213 [ # # ]: 0 : if (context_equiv(ctx, next_ctx)) {
3214 : 0 : WRITE_ONCE(ctx->task, next);
3215 : 0 : WRITE_ONCE(next_ctx->task, task);
3216 : :
3217 : 0 : swap(ctx->task_ctx_data, next_ctx->task_ctx_data);
3218 : :
3219 : : /*
3220 : : * RCU_INIT_POINTER here is safe because we've not
3221 : : * modified the ctx and the above modification of
3222 : : * ctx->task and ctx->task_ctx_data are immaterial
3223 : : * since those values are always verified under
3224 : : * ctx->lock which we're now holding.
3225 : : */
3226 : 0 : RCU_INIT_POINTER(task->perf_event_ctxp[ctxn], next_ctx);
3227 : 0 : RCU_INIT_POINTER(next->perf_event_ctxp[ctxn], ctx);
3228 : :
3229 : : do_switch = 0;
3230 : :
3231 : 0 : perf_event_sync_stat(ctx, next_ctx);
3232 : : }
3233 : : raw_spin_unlock(&next_ctx->lock);
3234 : : raw_spin_unlock(&ctx->lock);
3235 : : }
3236 : : unlock:
3237 : : rcu_read_unlock();
3238 : :
3239 [ # # ]: 0 : if (do_switch) {
3240 : 0 : raw_spin_lock(&ctx->lock);
3241 : 0 : task_ctx_sched_out(cpuctx, ctx, EVENT_ALL);
3242 : : raw_spin_unlock(&ctx->lock);
3243 : : }
3244 : : }
3245 : :
3246 : : static DEFINE_PER_CPU(struct list_head, sched_cb_list);
3247 : :
3248 : 0 : void perf_sched_cb_dec(struct pmu *pmu)
3249 : : {
3250 : 0 : struct perf_cpu_context *cpuctx = this_cpu_ptr(pmu->pmu_cpu_context);
3251 : :
3252 : 0 : this_cpu_dec(perf_sched_cb_usages);
3253 : :
3254 [ # # ]: 0 : if (!--cpuctx->sched_cb_usage)
3255 : : list_del(&cpuctx->sched_cb_entry);
3256 : 0 : }
3257 : :
3258 : :
3259 : 0 : void perf_sched_cb_inc(struct pmu *pmu)
3260 : : {
3261 : 0 : struct perf_cpu_context *cpuctx = this_cpu_ptr(pmu->pmu_cpu_context);
3262 : :
3263 [ # # ]: 0 : if (!cpuctx->sched_cb_usage++)
3264 : 0 : list_add(&cpuctx->sched_cb_entry, this_cpu_ptr(&sched_cb_list));
3265 : :
3266 : 0 : this_cpu_inc(perf_sched_cb_usages);
3267 : 0 : }
3268 : :
3269 : : /*
3270 : : * This function provides the context switch callback to the lower code
3271 : : * layer. It is invoked ONLY when the context switch callback is enabled.
3272 : : *
3273 : : * This callback is relevant even to per-cpu events; for example multi event
3274 : : * PEBS requires this to provide PID/TID information. This requires we flush
3275 : : * all queued PEBS records before we context switch to a new task.
3276 : : */
3277 : 0 : static void perf_pmu_sched_task(struct task_struct *prev,
3278 : : struct task_struct *next,
3279 : : bool sched_in)
3280 : : {
3281 : : struct perf_cpu_context *cpuctx;
3282 : : struct pmu *pmu;
3283 : :
3284 [ # # ]: 0 : if (prev == next)
3285 : 0 : return;
3286 : :
3287 [ # # ]: 0 : list_for_each_entry(cpuctx, this_cpu_ptr(&sched_cb_list), sched_cb_entry) {
3288 : 0 : pmu = cpuctx->ctx.pmu; /* software PMUs will not have sched_task */
3289 : :
3290 [ # # # # : 0 : if (WARN_ON_ONCE(!pmu->sched_task))
# # ]
3291 : 0 : continue;
3292 : :
3293 : 0 : perf_ctx_lock(cpuctx, cpuctx->task_ctx);
3294 : : perf_pmu_disable(pmu);
3295 : :
3296 : 0 : pmu->sched_task(cpuctx->task_ctx, sched_in);
3297 : :
3298 : : perf_pmu_enable(pmu);
3299 : 0 : perf_ctx_unlock(cpuctx, cpuctx->task_ctx);
3300 : : }
3301 : : }
3302 : :
3303 : : static void perf_event_switch(struct task_struct *task,
3304 : : struct task_struct *next_prev, bool sched_in);
3305 : :
3306 : : #define for_each_task_context_nr(ctxn) \
3307 : : for ((ctxn) = 0; (ctxn) < perf_nr_task_contexts; (ctxn)++)
3308 : :
3309 : : /*
3310 : : * Called from scheduler to remove the events of the current task,
3311 : : * with interrupts disabled.
3312 : : *
3313 : : * We stop each event and update the event value in event->count.
3314 : : *
3315 : : * This does not protect us against NMI, but disable()
3316 : : * sets the disabled bit in the control field of event _before_
3317 : : * accessing the event control register. If a NMI hits, then it will
3318 : : * not restart the event.
3319 : : */
3320 : 0 : void __perf_event_task_sched_out(struct task_struct *task,
3321 : : struct task_struct *next)
3322 : : {
3323 : : int ctxn;
3324 : :
3325 [ # # ]: 0 : if (__this_cpu_read(perf_sched_cb_usages))
3326 : 0 : perf_pmu_sched_task(task, next, false);
3327 : :
3328 [ # # ]: 0 : if (atomic_read(&nr_switch_events))
3329 : 0 : perf_event_switch(task, next, false);
3330 : :
3331 [ # # ]: 0 : for_each_task_context_nr(ctxn)
3332 : 0 : perf_event_context_sched_out(task, ctxn, next);
3333 : :
3334 : : /*
3335 : : * if cgroup events exist on this CPU, then we need
3336 : : * to check if we have to switch out PMU state.
3337 : : * cgroup event are system-wide mode only
3338 : : */
3339 [ # # ]: 0 : if (atomic_read(this_cpu_ptr(&perf_cgroup_events)))
3340 : 0 : perf_cgroup_sched_out(task, next);
3341 : 0 : }
3342 : :
3343 : : /*
3344 : : * Called with IRQs disabled
3345 : : */
3346 : : static void cpu_ctx_sched_out(struct perf_cpu_context *cpuctx,
3347 : : enum event_type_t event_type)
3348 : : {
3349 : 0 : ctx_sched_out(&cpuctx->ctx, cpuctx, event_type);
3350 : : }
3351 : :
3352 : 0 : static int visit_groups_merge(struct perf_event_groups *groups, int cpu,
3353 : : int (*func)(struct perf_event *, void *), void *data)
3354 : : {
3355 : : struct perf_event **evt, *evt1, *evt2;
3356 : : int ret;
3357 : :
3358 : 0 : evt1 = perf_event_groups_first(groups, -1);
3359 : 0 : evt2 = perf_event_groups_first(groups, cpu);
3360 : :
3361 [ # # ]: 0 : while (evt1 || evt2) {
3362 [ # # ]: 0 : if (evt1 && evt2) {
3363 [ # # ]: 0 : if (evt1->group_index < evt2->group_index)
3364 : : evt = &evt1;
3365 : : else
3366 : : evt = &evt2;
3367 [ # # ]: 0 : } else if (evt1) {
3368 : : evt = &evt1;
3369 : : } else {
3370 : : evt = &evt2;
3371 : : }
3372 : :
3373 : 0 : ret = func(*evt, data);
3374 [ # # ]: 0 : if (ret)
3375 : 0 : return ret;
3376 : :
3377 : 0 : *evt = perf_event_groups_next(*evt);
3378 : : }
3379 : :
3380 : : return 0;
3381 : : }
3382 : :
3383 : : struct sched_in_data {
3384 : : struct perf_event_context *ctx;
3385 : : struct perf_cpu_context *cpuctx;
3386 : : int can_add_hw;
3387 : : };
3388 : :
3389 : 0 : static int pinned_sched_in(struct perf_event *event, void *data)
3390 : : {
3391 : : struct sched_in_data *sid = data;
3392 : :
3393 [ # # ]: 0 : if (event->state <= PERF_EVENT_STATE_OFF)
3394 : : return 0;
3395 : :
3396 [ # # ]: 0 : if (!event_filter_match(event))
3397 : : return 0;
3398 : :
3399 [ # # ]: 0 : if (group_can_go_on(event, sid->cpuctx, sid->can_add_hw)) {
3400 [ # # ]: 0 : if (!group_sched_in(event, sid->cpuctx, sid->ctx))
3401 : 0 : list_add_tail(&event->active_list, &sid->ctx->pinned_active);
3402 : : }
3403 : :
3404 : : /*
3405 : : * If this pinned group hasn't been scheduled,
3406 : : * put it in error state.
3407 : : */
3408 [ # # ]: 0 : if (event->state == PERF_EVENT_STATE_INACTIVE)
3409 : 0 : perf_event_set_state(event, PERF_EVENT_STATE_ERROR);
3410 : :
3411 : : return 0;
3412 : : }
3413 : :
3414 : 0 : static int flexible_sched_in(struct perf_event *event, void *data)
3415 : : {
3416 : : struct sched_in_data *sid = data;
3417 : :
3418 [ # # ]: 0 : if (event->state <= PERF_EVENT_STATE_OFF)
3419 : : return 0;
3420 : :
3421 [ # # ]: 0 : if (!event_filter_match(event))
3422 : : return 0;
3423 : :
3424 [ # # ]: 0 : if (group_can_go_on(event, sid->cpuctx, sid->can_add_hw)) {
3425 : 0 : int ret = group_sched_in(event, sid->cpuctx, sid->ctx);
3426 [ # # ]: 0 : if (ret) {
3427 : 0 : sid->can_add_hw = 0;
3428 : 0 : sid->ctx->rotate_necessary = 1;
3429 : 0 : return 0;
3430 : : }
3431 : 0 : list_add_tail(&event->active_list, &sid->ctx->flexible_active);
3432 : : }
3433 : :
3434 : : return 0;
3435 : : }
3436 : :
3437 : : static void
3438 : 0 : ctx_pinned_sched_in(struct perf_event_context *ctx,
3439 : : struct perf_cpu_context *cpuctx)
3440 : : {
3441 : 0 : struct sched_in_data sid = {
3442 : : .ctx = ctx,
3443 : : .cpuctx = cpuctx,
3444 : : .can_add_hw = 1,
3445 : : };
3446 : :
3447 : 0 : visit_groups_merge(&ctx->pinned_groups,
3448 : 0 : smp_processor_id(),
3449 : : pinned_sched_in, &sid);
3450 : 0 : }
3451 : :
3452 : : static void
3453 : 0 : ctx_flexible_sched_in(struct perf_event_context *ctx,
3454 : : struct perf_cpu_context *cpuctx)
3455 : : {
3456 : 0 : struct sched_in_data sid = {
3457 : : .ctx = ctx,
3458 : : .cpuctx = cpuctx,
3459 : : .can_add_hw = 1,
3460 : : };
3461 : :
3462 : 0 : visit_groups_merge(&ctx->flexible_groups,
3463 : 0 : smp_processor_id(),
3464 : : flexible_sched_in, &sid);
3465 : 0 : }
3466 : :
3467 : : static void
3468 : 0 : ctx_sched_in(struct perf_event_context *ctx,
3469 : : struct perf_cpu_context *cpuctx,
3470 : : enum event_type_t event_type,
3471 : : struct task_struct *task)
3472 : : {
3473 : 0 : int is_active = ctx->is_active;
3474 : : u64 now;
3475 : :
3476 : : lockdep_assert_held(&ctx->lock);
3477 : :
3478 [ # # ]: 0 : if (likely(!ctx->nr_events))
3479 : 0 : return;
3480 : :
3481 : 0 : ctx->is_active |= (event_type | EVENT_TIME);
3482 [ # # ]: 0 : if (ctx->task) {
3483 [ # # ]: 0 : if (!is_active)
3484 : 0 : cpuctx->task_ctx = ctx;
3485 : : else
3486 [ # # # # ]: 0 : WARN_ON_ONCE(cpuctx->task_ctx != ctx);
3487 : : }
3488 : :
3489 : 0 : is_active ^= ctx->is_active; /* changed bits */
3490 : :
3491 [ # # ]: 0 : if (is_active & EVENT_TIME) {
3492 : : /* start ctx time */
3493 : : now = perf_clock();
3494 : 0 : ctx->timestamp = now;
3495 : 0 : perf_cgroup_set_timestamp(task, ctx);
3496 : : }
3497 : :
3498 : : /*
3499 : : * First go through the list and put on any pinned groups
3500 : : * in order to give them the best chance of going on.
3501 : : */
3502 [ # # ]: 0 : if (is_active & EVENT_PINNED)
3503 : 0 : ctx_pinned_sched_in(ctx, cpuctx);
3504 : :
3505 : : /* Then walk through the lower prio flexible groups */
3506 [ # # ]: 0 : if (is_active & EVENT_FLEXIBLE)
3507 : 0 : ctx_flexible_sched_in(ctx, cpuctx);
3508 : : }
3509 : :
3510 : : static void cpu_ctx_sched_in(struct perf_cpu_context *cpuctx,
3511 : : enum event_type_t event_type,
3512 : : struct task_struct *task)
3513 : : {
3514 : 0 : struct perf_event_context *ctx = &cpuctx->ctx;
3515 : :
3516 : 0 : ctx_sched_in(ctx, cpuctx, event_type, task);
3517 : : }
3518 : :
3519 : 0 : static void perf_event_context_sched_in(struct perf_event_context *ctx,
3520 : : struct task_struct *task)
3521 : : {
3522 : : struct perf_cpu_context *cpuctx;
3523 : :
3524 : : cpuctx = __get_cpu_context(ctx);
3525 [ # # ]: 0 : if (cpuctx->task_ctx == ctx)
3526 : 0 : return;
3527 : :
3528 : : perf_ctx_lock(cpuctx, ctx);
3529 : : /*
3530 : : * We must check ctx->nr_events while holding ctx->lock, such
3531 : : * that we serialize against perf_install_in_context().
3532 : : */
3533 [ # # ]: 0 : if (!ctx->nr_events)
3534 : : goto unlock;
3535 : :
3536 : 0 : perf_pmu_disable(ctx->pmu);
3537 : : /*
3538 : : * We want to keep the following priority order:
3539 : : * cpu pinned (that don't need to move), task pinned,
3540 : : * cpu flexible, task flexible.
3541 : : *
3542 : : * However, if task's ctx is not carrying any pinned
3543 : : * events, no need to flip the cpuctx's events around.
3544 : : */
3545 [ # # ]: 0 : if (!RB_EMPTY_ROOT(&ctx->pinned_groups.tree))
3546 : : cpu_ctx_sched_out(cpuctx, EVENT_FLEXIBLE);
3547 : 0 : perf_event_sched_in(cpuctx, ctx, task);
3548 : 0 : perf_pmu_enable(ctx->pmu);
3549 : :
3550 : : unlock:
3551 : 0 : perf_ctx_unlock(cpuctx, ctx);
3552 : : }
3553 : :
3554 : : /*
3555 : : * Called from scheduler to add the events of the current task
3556 : : * with interrupts disabled.
3557 : : *
3558 : : * We restore the event value and then enable it.
3559 : : *
3560 : : * This does not protect us against NMI, but enable()
3561 : : * sets the enabled bit in the control field of event _before_
3562 : : * accessing the event control register. If a NMI hits, then it will
3563 : : * keep the event running.
3564 : : */
3565 : 0 : void __perf_event_task_sched_in(struct task_struct *prev,
3566 : : struct task_struct *task)
3567 : : {
3568 : : struct perf_event_context *ctx;
3569 : : int ctxn;
3570 : :
3571 : : /*
3572 : : * If cgroup events exist on this CPU, then we need to check if we have
3573 : : * to switch in PMU state; cgroup event are system-wide mode only.
3574 : : *
3575 : : * Since cgroup events are CPU events, we must schedule these in before
3576 : : * we schedule in the task events.
3577 : : */
3578 [ # # ]: 0 : if (atomic_read(this_cpu_ptr(&perf_cgroup_events)))
3579 : 0 : perf_cgroup_sched_in(prev, task);
3580 : :
3581 [ # # ]: 0 : for_each_task_context_nr(ctxn) {
3582 : 0 : ctx = task->perf_event_ctxp[ctxn];
3583 [ # # ]: 0 : if (likely(!ctx))
3584 : 0 : continue;
3585 : :
3586 : 0 : perf_event_context_sched_in(ctx, task);
3587 : : }
3588 : :
3589 [ # # ]: 0 : if (atomic_read(&nr_switch_events))
3590 : 0 : perf_event_switch(task, prev, true);
3591 : :
3592 [ # # ]: 0 : if (__this_cpu_read(perf_sched_cb_usages))
3593 : 0 : perf_pmu_sched_task(prev, task, true);
3594 : 0 : }
3595 : :
3596 : 0 : static u64 perf_calculate_period(struct perf_event *event, u64 nsec, u64 count)
3597 : : {
3598 : 0 : u64 frequency = event->attr.sample_freq;
3599 : : u64 sec = NSEC_PER_SEC;
3600 : : u64 divisor, dividend;
3601 : :
3602 : : int count_fls, nsec_fls, frequency_fls, sec_fls;
3603 : :
3604 : : count_fls = fls64(count);
3605 : : nsec_fls = fls64(nsec);
3606 : : frequency_fls = fls64(frequency);
3607 : : sec_fls = 30;
3608 : :
3609 : : /*
3610 : : * We got @count in @nsec, with a target of sample_freq HZ
3611 : : * the target period becomes:
3612 : : *
3613 : : * @count * 10^9
3614 : : * period = -------------------
3615 : : * @nsec * sample_freq
3616 : : *
3617 : : */
3618 : :
3619 : : /*
3620 : : * Reduce accuracy by one bit such that @a and @b converge
3621 : : * to a similar magnitude.
3622 : : */
3623 : : #define REDUCE_FLS(a, b) \
3624 : : do { \
3625 : : if (a##_fls > b##_fls) { \
3626 : : a >>= 1; \
3627 : : a##_fls--; \
3628 : : } else { \
3629 : : b >>= 1; \
3630 : : b##_fls--; \
3631 : : } \
3632 : : } while (0)
3633 : :
3634 : : /*
3635 : : * Reduce accuracy until either term fits in a u64, then proceed with
3636 : : * the other, so that finally we can do a u64/u64 division.
3637 : : */
3638 [ # # # # ]: 0 : while (count_fls + sec_fls > 64 && nsec_fls + frequency_fls > 64) {
3639 [ # # ]: 0 : REDUCE_FLS(nsec, frequency);
3640 [ # # ]: 0 : REDUCE_FLS(sec, count);
3641 : : }
3642 : :
3643 [ # # ]: 0 : if (count_fls + sec_fls > 64) {
3644 : 0 : divisor = nsec * frequency;
3645 : :
3646 [ # # ]: 0 : while (count_fls + sec_fls > 64) {
3647 [ # # ]: 0 : REDUCE_FLS(count, sec);
3648 : 0 : divisor >>= 1;
3649 : : }
3650 : :
3651 : 0 : dividend = count * sec;
3652 : : } else {
3653 : 0 : dividend = count * sec;
3654 : :
3655 [ # # ]: 0 : while (nsec_fls + frequency_fls > 64) {
3656 [ # # ]: 0 : REDUCE_FLS(nsec, frequency);
3657 : 0 : dividend >>= 1;
3658 : : }
3659 : :
3660 : 0 : divisor = nsec * frequency;
3661 : : }
3662 : :
3663 [ # # ]: 0 : if (!divisor)
3664 : : return dividend;
3665 : :
3666 : 0 : return div64_u64(dividend, divisor);
3667 : : }
3668 : :
3669 : : static DEFINE_PER_CPU(int, perf_throttled_count);
3670 : : static DEFINE_PER_CPU(u64, perf_throttled_seq);
3671 : :
3672 : 0 : static void perf_adjust_period(struct perf_event *event, u64 nsec, u64 count, bool disable)
3673 : : {
3674 : : struct hw_perf_event *hwc = &event->hw;
3675 : : s64 period, sample_period;
3676 : : s64 delta;
3677 : :
3678 : 0 : period = perf_calculate_period(event, nsec, count);
3679 : :
3680 : 0 : delta = (s64)(period - hwc->sample_period);
3681 : 0 : delta = (delta + 7) / 8; /* low pass filter */
3682 : :
3683 : 0 : sample_period = hwc->sample_period + delta;
3684 : :
3685 [ # # ]: 0 : if (!sample_period)
3686 : : sample_period = 1;
3687 : :
3688 : 0 : hwc->sample_period = sample_period;
3689 : :
3690 [ # # ]: 0 : if (local64_read(&hwc->period_left) > 8*sample_period) {
3691 [ # # ]: 0 : if (disable)
3692 : 0 : event->pmu->stop(event, PERF_EF_UPDATE);
3693 : :
3694 : : local64_set(&hwc->period_left, 0);
3695 : :
3696 [ # # ]: 0 : if (disable)
3697 : 0 : event->pmu->start(event, PERF_EF_RELOAD);
3698 : : }
3699 : 0 : }
3700 : :
3701 : : /*
3702 : : * combine freq adjustment with unthrottling to avoid two passes over the
3703 : : * events. At the same time, make sure, having freq events does not change
3704 : : * the rate of unthrottling as that would introduce bias.
3705 : : */
3706 : 0 : static void perf_adjust_freq_unthr_context(struct perf_event_context *ctx,
3707 : : int needs_unthr)
3708 : : {
3709 : : struct perf_event *event;
3710 : : struct hw_perf_event *hwc;
3711 : : u64 now, period = TICK_NSEC;
3712 : : s64 delta;
3713 : :
3714 : : /*
3715 : : * only need to iterate over all events iff:
3716 : : * - context have events in frequency mode (needs freq adjust)
3717 : : * - there are events to unthrottle on this cpu
3718 : : */
3719 [ # # ]: 0 : if (!(ctx->nr_freq || needs_unthr))
3720 : 0 : return;
3721 : :
3722 : 0 : raw_spin_lock(&ctx->lock);
3723 : 0 : perf_pmu_disable(ctx->pmu);
3724 : :
3725 [ # # ]: 0 : list_for_each_entry_rcu(event, &ctx->event_list, event_entry) {
3726 [ # # ]: 0 : if (event->state != PERF_EVENT_STATE_ACTIVE)
3727 : 0 : continue;
3728 : :
3729 [ # # ]: 0 : if (!event_filter_match(event))
3730 : 0 : continue;
3731 : :
3732 : 0 : perf_pmu_disable(event->pmu);
3733 : :
3734 : : hwc = &event->hw;
3735 : :
3736 [ # # ]: 0 : if (hwc->interrupts == MAX_INTERRUPTS) {
3737 : 0 : hwc->interrupts = 0;
3738 : 0 : perf_log_throttle(event, 1);
3739 : 0 : event->pmu->start(event, 0);
3740 : : }
3741 : :
3742 [ # # # # ]: 0 : if (!event->attr.freq || !event->attr.sample_freq)
3743 : : goto next;
3744 : :
3745 : : /*
3746 : : * stop the event and update event->count
3747 : : */
3748 : 0 : event->pmu->stop(event, PERF_EF_UPDATE);
3749 : :
3750 : 0 : now = local64_read(&event->count);
3751 : 0 : delta = now - hwc->freq_count_stamp;
3752 : 0 : hwc->freq_count_stamp = now;
3753 : :
3754 : : /*
3755 : : * restart the event
3756 : : * reload only if value has changed
3757 : : * we have stopped the event so tell that
3758 : : * to perf_adjust_period() to avoid stopping it
3759 : : * twice.
3760 : : */
3761 [ # # ]: 0 : if (delta > 0)
3762 : 0 : perf_adjust_period(event, period, delta, false);
3763 : :
3764 [ # # ]: 0 : event->pmu->start(event, delta > 0 ? PERF_EF_RELOAD : 0);
3765 : : next:
3766 : 0 : perf_pmu_enable(event->pmu);
3767 : : }
3768 : :
3769 : 0 : perf_pmu_enable(ctx->pmu);
3770 : : raw_spin_unlock(&ctx->lock);
3771 : : }
3772 : :
3773 : : /*
3774 : : * Move @event to the tail of the @ctx's elegible events.
3775 : : */
3776 : 0 : static void rotate_ctx(struct perf_event_context *ctx, struct perf_event *event)
3777 : : {
3778 : : /*
3779 : : * Rotate the first entry last of non-pinned groups. Rotation might be
3780 : : * disabled by the inheritance code.
3781 : : */
3782 [ # # ]: 0 : if (ctx->rotate_disable)
3783 : 0 : return;
3784 : :
3785 : 0 : perf_event_groups_delete(&ctx->flexible_groups, event);
3786 : 0 : perf_event_groups_insert(&ctx->flexible_groups, event);
3787 : : }
3788 : :
3789 : : /* pick an event from the flexible_groups to rotate */
3790 : : static inline struct perf_event *
3791 : 0 : ctx_event_to_rotate(struct perf_event_context *ctx)
3792 : : {
3793 : : struct perf_event *event;
3794 : :
3795 : : /* pick the first active flexible event */
3796 [ # # ]: 0 : event = list_first_entry_or_null(&ctx->flexible_active,
3797 : : struct perf_event, active_list);
3798 : :
3799 : : /* if no active flexible event, pick the first event */
3800 [ # # ]: 0 : if (!event) {
3801 [ # # ]: 0 : event = rb_entry_safe(rb_first(&ctx->flexible_groups.tree),
3802 : : typeof(*event), group_node);
3803 : : }
3804 : :
3805 : : /*
3806 : : * Unconditionally clear rotate_necessary; if ctx_flexible_sched_in()
3807 : : * finds there are unschedulable events, it will set it again.
3808 : : */
3809 : 0 : ctx->rotate_necessary = 0;
3810 : :
3811 : 0 : return event;
3812 : : }
3813 : :
3814 : 0 : static bool perf_rotate_context(struct perf_cpu_context *cpuctx)
3815 : : {
3816 : : struct perf_event *cpu_event = NULL, *task_event = NULL;
3817 : : struct perf_event_context *task_ctx = NULL;
3818 : : int cpu_rotate, task_rotate;
3819 : :
3820 : : /*
3821 : : * Since we run this from IRQ context, nobody can install new
3822 : : * events, thus the event count values are stable.
3823 : : */
3824 : :
3825 : 0 : cpu_rotate = cpuctx->ctx.rotate_necessary;
3826 : 0 : task_ctx = cpuctx->task_ctx;
3827 [ # # ]: 0 : task_rotate = task_ctx ? task_ctx->rotate_necessary : 0;
3828 : :
3829 [ # # ]: 0 : if (!(cpu_rotate || task_rotate))
3830 : : return false;
3831 : :
3832 : : perf_ctx_lock(cpuctx, cpuctx->task_ctx);
3833 : 0 : perf_pmu_disable(cpuctx->ctx.pmu);
3834 : :
3835 [ # # ]: 0 : if (task_rotate)
3836 : 0 : task_event = ctx_event_to_rotate(task_ctx);
3837 [ # # ]: 0 : if (cpu_rotate)
3838 : 0 : cpu_event = ctx_event_to_rotate(&cpuctx->ctx);
3839 : :
3840 : : /*
3841 : : * As per the order given at ctx_resched() first 'pop' task flexible
3842 : : * and then, if needed CPU flexible.
3843 : : */
3844 [ # # # # ]: 0 : if (task_event || (task_ctx && cpu_event))
3845 : 0 : ctx_sched_out(task_ctx, cpuctx, EVENT_FLEXIBLE);
3846 [ # # ]: 0 : if (cpu_event)
3847 : : cpu_ctx_sched_out(cpuctx, EVENT_FLEXIBLE);
3848 : :
3849 [ # # ]: 0 : if (task_event)
3850 : 0 : rotate_ctx(task_ctx, task_event);
3851 [ # # ]: 0 : if (cpu_event)
3852 : 0 : rotate_ctx(&cpuctx->ctx, cpu_event);
3853 : :
3854 : 0 : perf_event_sched_in(cpuctx, task_ctx, current);
3855 : :
3856 : 0 : perf_pmu_enable(cpuctx->ctx.pmu);
3857 : 0 : perf_ctx_unlock(cpuctx, cpuctx->task_ctx);
3858 : :
3859 : 0 : return true;
3860 : : }
3861 : :
3862 : 3240122 : void perf_event_task_tick(void)
3863 : : {
3864 : 6480244 : struct list_head *head = this_cpu_ptr(&active_ctx_list);
3865 : : struct perf_event_context *ctx, *tmp;
3866 : : int throttled;
3867 : :
3868 : : lockdep_assert_irqs_disabled();
3869 : :
3870 : 6480244 : __this_cpu_inc(perf_throttled_seq);
3871 : 6480244 : throttled = __this_cpu_xchg(perf_throttled_count, 0);
3872 : : tick_dep_clear_cpu(smp_processor_id(), TICK_DEP_BIT_PERF_EVENTS);
3873 : :
3874 [ - + ]: 3240122 : list_for_each_entry_safe(ctx, tmp, head, active_ctx_list)
3875 : 0 : perf_adjust_freq_unthr_context(ctx, throttled);
3876 : 3240122 : }
3877 : :
3878 : 0 : static int event_enable_on_exec(struct perf_event *event,
3879 : : struct perf_event_context *ctx)
3880 : : {
3881 [ # # ]: 0 : if (!event->attr.enable_on_exec)
3882 : : return 0;
3883 : :
3884 : 0 : event->attr.enable_on_exec = 0;
3885 [ # # ]: 0 : if (event->state >= PERF_EVENT_STATE_INACTIVE)
3886 : : return 0;
3887 : :
3888 : 0 : perf_event_set_state(event, PERF_EVENT_STATE_INACTIVE);
3889 : :
3890 : 0 : return 1;
3891 : : }
3892 : :
3893 : : /*
3894 : : * Enable all of a task's events that have been marked enable-on-exec.
3895 : : * This expects task == current.
3896 : : */
3897 : 0 : static void perf_event_enable_on_exec(int ctxn)
3898 : : {
3899 : : struct perf_event_context *ctx, *clone_ctx = NULL;
3900 : : enum event_type_t event_type = 0;
3901 : : struct perf_cpu_context *cpuctx;
3902 : : struct perf_event *event;
3903 : : unsigned long flags;
3904 : : int enabled = 0;
3905 : :
3906 : 0 : local_irq_save(flags);
3907 : 0 : ctx = current->perf_event_ctxp[ctxn];
3908 [ # # # # ]: 0 : if (!ctx || !ctx->nr_events)
3909 : : goto out;
3910 : :
3911 : : cpuctx = __get_cpu_context(ctx);
3912 : : perf_ctx_lock(cpuctx, ctx);
3913 : 0 : ctx_sched_out(ctx, cpuctx, EVENT_TIME);
3914 [ # # ]: 0 : list_for_each_entry(event, &ctx->event_list, event_entry) {
3915 : 0 : enabled |= event_enable_on_exec(event, ctx);
3916 : 0 : event_type |= get_event_type(event);
3917 : : }
3918 : :
3919 : : /*
3920 : : * Unclone and reschedule this context if we enabled any event.
3921 : : */
3922 [ # # ]: 0 : if (enabled) {
3923 : : clone_ctx = unclone_ctx(ctx);
3924 : 0 : ctx_resched(cpuctx, ctx, event_type);
3925 : : } else {
3926 : 0 : ctx_sched_in(ctx, cpuctx, EVENT_TIME, current);
3927 : : }
3928 : 0 : perf_ctx_unlock(cpuctx, ctx);
3929 : :
3930 : : out:
3931 [ # # ]: 0 : local_irq_restore(flags);
3932 : :
3933 [ # # ]: 0 : if (clone_ctx)
3934 : 0 : put_ctx(clone_ctx);
3935 : 0 : }
3936 : :
3937 : : struct perf_read_data {
3938 : : struct perf_event *event;
3939 : : bool group;
3940 : : int ret;
3941 : : };
3942 : :
3943 : : static int __perf_event_read_cpu(struct perf_event *event, int event_cpu)
3944 : : {
3945 : : u16 local_pkg, event_pkg;
3946 : :
3947 [ # # ]: 0 : if (event->group_caps & PERF_EV_CAP_READ_ACTIVE_PKG) {
3948 : 0 : int local_cpu = smp_processor_id();
3949 : :
3950 : 0 : event_pkg = topology_physical_package_id(event_cpu);
3951 : 0 : local_pkg = topology_physical_package_id(local_cpu);
3952 : :
3953 [ # # ]: 0 : if (event_pkg == local_pkg)
3954 : : return local_cpu;
3955 : : }
3956 : :
3957 : : return event_cpu;
3958 : : }
3959 : :
3960 : : /*
3961 : : * Cross CPU call to read the hardware event
3962 : : */
3963 : 0 : static void __perf_event_read(void *info)
3964 : : {
3965 : : struct perf_read_data *data = info;
3966 : 0 : struct perf_event *sub, *event = data->event;
3967 : 0 : struct perf_event_context *ctx = event->ctx;
3968 : : struct perf_cpu_context *cpuctx = __get_cpu_context(ctx);
3969 : 0 : struct pmu *pmu = event->pmu;
3970 : :
3971 : : /*
3972 : : * If this is a task context, we need to check whether it is
3973 : : * the current task context of this cpu. If not it has been
3974 : : * scheduled out before the smp call arrived. In that case
3975 : : * event->count would have been updated to a recent sample
3976 : : * when the event was scheduled out.
3977 : : */
3978 [ # # # # ]: 0 : if (ctx->task && cpuctx->task_ctx != ctx)
3979 : 0 : return;
3980 : :
3981 : 0 : raw_spin_lock(&ctx->lock);
3982 [ # # ]: 0 : if (ctx->is_active & EVENT_TIME) {
3983 : 0 : update_context_time(ctx);
3984 : 0 : update_cgrp_time_from_event(event);
3985 : : }
3986 : :
3987 : 0 : perf_event_update_time(event);
3988 [ # # ]: 0 : if (data->group)
3989 : 0 : perf_event_update_sibling_time(event);
3990 : :
3991 [ # # ]: 0 : if (event->state != PERF_EVENT_STATE_ACTIVE)
3992 : : goto unlock;
3993 : :
3994 [ # # ]: 0 : if (!data->group) {
3995 : 0 : pmu->read(event);
3996 : 0 : data->ret = 0;
3997 : 0 : goto unlock;
3998 : : }
3999 : :
4000 : 0 : pmu->start_txn(pmu, PERF_PMU_TXN_READ);
4001 : :
4002 : 0 : pmu->read(event);
4003 : :
4004 [ # # # # ]: 0 : for_each_sibling_event(sub, event) {
4005 [ # # ]: 0 : if (sub->state == PERF_EVENT_STATE_ACTIVE) {
4006 : : /*
4007 : : * Use sibling's PMU rather than @event's since
4008 : : * sibling could be on different (eg: software) PMU.
4009 : : */
4010 : 0 : sub->pmu->read(sub);
4011 : : }
4012 : : }
4013 : :
4014 : 0 : data->ret = pmu->commit_txn(pmu);
4015 : :
4016 : : unlock:
4017 : : raw_spin_unlock(&ctx->lock);
4018 : : }
4019 : :
4020 : : static inline u64 perf_event_count(struct perf_event *event)
4021 : : {
4022 : 0 : return local64_read(&event->count) + atomic64_read(&event->child_count);
4023 : : }
4024 : :
4025 : : /*
4026 : : * NMI-safe method to read a local event, that is an event that
4027 : : * is:
4028 : : * - either for the current task, or for this CPU
4029 : : * - does not have inherit set, for inherited task events
4030 : : * will not be local and we cannot read them atomically
4031 : : * - must not have a pmu::count method
4032 : : */
4033 : 0 : int perf_event_read_local(struct perf_event *event, u64 *value,
4034 : : u64 *enabled, u64 *running)
4035 : : {
4036 : : unsigned long flags;
4037 : : int ret = 0;
4038 : :
4039 : : /*
4040 : : * Disabling interrupts avoids all counter scheduling (context
4041 : : * switches, timer based rotation and IPIs).
4042 : : */
4043 : 0 : local_irq_save(flags);
4044 : :
4045 : : /*
4046 : : * It must not be an event with inherit set, we cannot read
4047 : : * all child counters from atomic context.
4048 : : */
4049 [ # # ]: 0 : if (event->attr.inherit) {
4050 : : ret = -EOPNOTSUPP;
4051 : : goto out;
4052 : : }
4053 : :
4054 : : /* If this is a per-task event, it must be for current */
4055 [ # # # # ]: 0 : if ((event->attach_state & PERF_ATTACH_TASK) &&
4056 : 0 : event->hw.target != current) {
4057 : : ret = -EINVAL;
4058 : : goto out;
4059 : : }
4060 : :
4061 : : /* If this is a per-CPU event, it must be for this CPU */
4062 [ # # # # ]: 0 : if (!(event->attach_state & PERF_ATTACH_TASK) &&
4063 : 0 : event->cpu != smp_processor_id()) {
4064 : : ret = -EINVAL;
4065 : : goto out;
4066 : : }
4067 : :
4068 : : /* If this is a pinned event it must be running on this CPU */
4069 [ # # # # ]: 0 : if (event->attr.pinned && event->oncpu != smp_processor_id()) {
4070 : : ret = -EBUSY;
4071 : : goto out;
4072 : : }
4073 : :
4074 : : /*
4075 : : * If the event is currently on this CPU, its either a per-task event,
4076 : : * or local to this CPU. Furthermore it means its ACTIVE (otherwise
4077 : : * oncpu == -1).
4078 : : */
4079 [ # # ]: 0 : if (event->oncpu == smp_processor_id())
4080 : 0 : event->pmu->read(event);
4081 : :
4082 : 0 : *value = local64_read(&event->count);
4083 [ # # ]: 0 : if (enabled || running) {
4084 : 0 : u64 now = event->shadow_ctx_time + perf_clock();
4085 : : u64 __enabled, __running;
4086 : :
4087 : : __perf_update_times(event, now, &__enabled, &__running);
4088 [ # # ]: 0 : if (enabled)
4089 : 0 : *enabled = __enabled;
4090 [ # # ]: 0 : if (running)
4091 : 0 : *running = __running;
4092 : : }
4093 : : out:
4094 [ # # ]: 0 : local_irq_restore(flags);
4095 : :
4096 : 0 : return ret;
4097 : : }
4098 : :
4099 : 0 : static int perf_event_read(struct perf_event *event, bool group)
4100 : : {
4101 : 0 : enum perf_event_state state = READ_ONCE(event->state);
4102 : : int event_cpu, ret = 0;
4103 : :
4104 : : /*
4105 : : * If event is enabled and currently active on a CPU, update the
4106 : : * value in the event structure:
4107 : : */
4108 : : again:
4109 [ # # ]: 0 : if (state == PERF_EVENT_STATE_ACTIVE) {
4110 : : struct perf_read_data data;
4111 : :
4112 : : /*
4113 : : * Orders the ->state and ->oncpu loads such that if we see
4114 : : * ACTIVE we must also see the right ->oncpu.
4115 : : *
4116 : : * Matches the smp_wmb() from event_sched_in().
4117 : : */
4118 : 0 : smp_rmb();
4119 : :
4120 : 0 : event_cpu = READ_ONCE(event->oncpu);
4121 [ # # ]: 0 : if ((unsigned)event_cpu >= nr_cpu_ids)
4122 : 0 : return 0;
4123 : :
4124 : 0 : data = (struct perf_read_data){
4125 : : .event = event,
4126 : : .group = group,
4127 : : .ret = 0,
4128 : : };
4129 : :
4130 : 0 : preempt_disable();
4131 : : event_cpu = __perf_event_read_cpu(event, event_cpu);
4132 : :
4133 : : /*
4134 : : * Purposely ignore the smp_call_function_single() return
4135 : : * value.
4136 : : *
4137 : : * If event_cpu isn't a valid CPU it means the event got
4138 : : * scheduled out and that will have updated the event count.
4139 : : *
4140 : : * Therefore, either way, we'll have an up-to-date event count
4141 : : * after this.
4142 : : */
4143 : 0 : (void)smp_call_function_single(event_cpu, __perf_event_read, &data, 1);
4144 : 0 : preempt_enable();
4145 : 0 : ret = data.ret;
4146 : :
4147 [ # # ]: 0 : } else if (state == PERF_EVENT_STATE_INACTIVE) {
4148 : 0 : struct perf_event_context *ctx = event->ctx;
4149 : : unsigned long flags;
4150 : :
4151 : 0 : raw_spin_lock_irqsave(&ctx->lock, flags);
4152 : 0 : state = event->state;
4153 [ # # ]: 0 : if (state != PERF_EVENT_STATE_INACTIVE) {
4154 : 0 : raw_spin_unlock_irqrestore(&ctx->lock, flags);
4155 : 0 : goto again;
4156 : : }
4157 : :
4158 : : /*
4159 : : * May read while context is not active (e.g., thread is
4160 : : * blocked), in that case we cannot update context time
4161 : : */
4162 [ # # ]: 0 : if (ctx->is_active & EVENT_TIME) {
4163 : 0 : update_context_time(ctx);
4164 : 0 : update_cgrp_time_from_event(event);
4165 : : }
4166 : :
4167 : 0 : perf_event_update_time(event);
4168 [ # # ]: 0 : if (group)
4169 : 0 : perf_event_update_sibling_time(event);
4170 : 0 : raw_spin_unlock_irqrestore(&ctx->lock, flags);
4171 : : }
4172 : :
4173 : 0 : return ret;
4174 : : }
4175 : :
4176 : : /*
4177 : : * Initialize the perf_event context in a task_struct:
4178 : : */
4179 : 1656 : static void __perf_event_init_context(struct perf_event_context *ctx)
4180 : : {
4181 : 1656 : raw_spin_lock_init(&ctx->lock);
4182 : 1656 : mutex_init(&ctx->mutex);
4183 : 1656 : INIT_LIST_HEAD(&ctx->active_ctx_list);
4184 : : perf_event_groups_init(&ctx->pinned_groups);
4185 : : perf_event_groups_init(&ctx->flexible_groups);
4186 : 1656 : INIT_LIST_HEAD(&ctx->event_list);
4187 : 1656 : INIT_LIST_HEAD(&ctx->pinned_active);
4188 : 1656 : INIT_LIST_HEAD(&ctx->flexible_active);
4189 : : refcount_set(&ctx->refcount, 1);
4190 : 1656 : }
4191 : :
4192 : : static struct perf_event_context *
4193 : 0 : alloc_perf_context(struct pmu *pmu, struct task_struct *task)
4194 : : {
4195 : : struct perf_event_context *ctx;
4196 : :
4197 : 0 : ctx = kzalloc(sizeof(struct perf_event_context), GFP_KERNEL);
4198 [ # # ]: 0 : if (!ctx)
4199 : : return NULL;
4200 : :
4201 : 0 : __perf_event_init_context(ctx);
4202 [ # # ]: 0 : if (task)
4203 : 0 : ctx->task = get_task_struct(task);
4204 : 0 : ctx->pmu = pmu;
4205 : :
4206 : 0 : return ctx;
4207 : : }
4208 : :
4209 : : static struct task_struct *
4210 : 0 : find_lively_task_by_vpid(pid_t vpid)
4211 : : {
4212 : : struct task_struct *task;
4213 : :
4214 : : rcu_read_lock();
4215 [ # # ]: 0 : if (!vpid)
4216 : 0 : task = current;
4217 : : else
4218 : 0 : task = find_task_by_vpid(vpid);
4219 [ # # ]: 0 : if (task)
4220 : : get_task_struct(task);
4221 : : rcu_read_unlock();
4222 : :
4223 [ # # ]: 0 : if (!task)
4224 : : return ERR_PTR(-ESRCH);
4225 : :
4226 : 0 : return task;
4227 : : }
4228 : :
4229 : : /*
4230 : : * Returns a matching context with refcount and pincount.
4231 : : */
4232 : : static struct perf_event_context *
4233 : 0 : find_get_context(struct pmu *pmu, struct task_struct *task,
4234 : : struct perf_event *event)
4235 : : {
4236 : : struct perf_event_context *ctx, *clone_ctx = NULL;
4237 : : struct perf_cpu_context *cpuctx;
4238 : : void *task_ctx_data = NULL;
4239 : : unsigned long flags;
4240 : : int ctxn, err;
4241 : 0 : int cpu = event->cpu;
4242 : :
4243 [ # # ]: 0 : if (!task) {
4244 : : /* Must be root to operate on a CPU event: */
4245 [ # # # # ]: 0 : if (perf_paranoid_cpu() && !capable(CAP_SYS_ADMIN))
4246 : : return ERR_PTR(-EACCES);
4247 : :
4248 : 0 : cpuctx = per_cpu_ptr(pmu->pmu_cpu_context, cpu);
4249 : 0 : ctx = &cpuctx->ctx;
4250 : : get_ctx(ctx);
4251 : 0 : ++ctx->pin_count;
4252 : :
4253 : 0 : return ctx;
4254 : : }
4255 : :
4256 : : err = -EINVAL;
4257 : 0 : ctxn = pmu->task_ctx_nr;
4258 [ # # ]: 0 : if (ctxn < 0)
4259 : : goto errout;
4260 : :
4261 [ # # ]: 0 : if (event->attach_state & PERF_ATTACH_TASK_DATA) {
4262 : 0 : task_ctx_data = kzalloc(pmu->task_ctx_size, GFP_KERNEL);
4263 [ # # ]: 0 : if (!task_ctx_data) {
4264 : : err = -ENOMEM;
4265 : : goto errout;
4266 : : }
4267 : : }
4268 : :
4269 : : retry:
4270 : 0 : ctx = perf_lock_task_context(task, ctxn, &flags);
4271 [ # # ]: 0 : if (ctx) {
4272 : : clone_ctx = unclone_ctx(ctx);
4273 : 0 : ++ctx->pin_count;
4274 : :
4275 [ # # # # ]: 0 : if (task_ctx_data && !ctx->task_ctx_data) {
4276 : 0 : ctx->task_ctx_data = task_ctx_data;
4277 : : task_ctx_data = NULL;
4278 : : }
4279 : 0 : raw_spin_unlock_irqrestore(&ctx->lock, flags);
4280 : :
4281 [ # # ]: 0 : if (clone_ctx)
4282 : 0 : put_ctx(clone_ctx);
4283 : : } else {
4284 : 0 : ctx = alloc_perf_context(pmu, task);
4285 : : err = -ENOMEM;
4286 [ # # ]: 0 : if (!ctx)
4287 : : goto errout;
4288 : :
4289 [ # # ]: 0 : if (task_ctx_data) {
4290 : 0 : ctx->task_ctx_data = task_ctx_data;
4291 : : task_ctx_data = NULL;
4292 : : }
4293 : :
4294 : : err = 0;
4295 : 0 : mutex_lock(&task->perf_event_mutex);
4296 : : /*
4297 : : * If it has already passed perf_event_exit_task().
4298 : : * we must see PF_EXITING, it takes this mutex too.
4299 : : */
4300 [ # # ]: 0 : if (task->flags & PF_EXITING)
4301 : : err = -ESRCH;
4302 [ # # ]: 0 : else if (task->perf_event_ctxp[ctxn])
4303 : : err = -EAGAIN;
4304 : : else {
4305 : : get_ctx(ctx);
4306 : 0 : ++ctx->pin_count;
4307 : 0 : rcu_assign_pointer(task->perf_event_ctxp[ctxn], ctx);
4308 : : }
4309 : 0 : mutex_unlock(&task->perf_event_mutex);
4310 : :
4311 [ # # ]: 0 : if (unlikely(err)) {
4312 : 0 : put_ctx(ctx);
4313 : :
4314 [ # # ]: 0 : if (err == -EAGAIN)
4315 : : goto retry;
4316 : : goto errout;
4317 : : }
4318 : : }
4319 : :
4320 : 0 : kfree(task_ctx_data);
4321 : 0 : return ctx;
4322 : :
4323 : : errout:
4324 : 0 : kfree(task_ctx_data);
4325 : 0 : return ERR_PTR(err);
4326 : : }
4327 : :
4328 : : static void perf_event_free_filter(struct perf_event *event);
4329 : : static void perf_event_free_bpf_prog(struct perf_event *event);
4330 : :
4331 : 0 : static void free_event_rcu(struct rcu_head *head)
4332 : : {
4333 : : struct perf_event *event;
4334 : :
4335 : 0 : event = container_of(head, struct perf_event, rcu_head);
4336 [ # # ]: 0 : if (event->ns)
4337 : 0 : put_pid_ns(event->ns);
4338 : : perf_event_free_filter(event);
4339 : 0 : kfree(event);
4340 : 0 : }
4341 : :
4342 : : static void ring_buffer_attach(struct perf_event *event,
4343 : : struct ring_buffer *rb);
4344 : :
4345 : 0 : static void detach_sb_event(struct perf_event *event)
4346 : : {
4347 : 0 : struct pmu_event_list *pel = per_cpu_ptr(&pmu_sb_events, event->cpu);
4348 : :
4349 : 0 : raw_spin_lock(&pel->lock);
4350 : : list_del_rcu(&event->sb_list);
4351 : : raw_spin_unlock(&pel->lock);
4352 : 0 : }
4353 : :
4354 : : static bool is_sb_event(struct perf_event *event)
4355 : : {
4356 : : struct perf_event_attr *attr = &event->attr;
4357 : :
4358 [ # # # # ]: 0 : if (event->parent)
4359 : : return false;
4360 : :
4361 [ # # # # ]: 0 : if (event->attach_state & PERF_ATTACH_TASK)
4362 : : return false;
4363 : :
4364 [ # # # # ]: 0 : if (attr->mmap || attr->mmap_data || attr->mmap2 ||
4365 : : attr->comm || attr->comm_exec ||
4366 : : attr->task || attr->ksymbol ||
4367 : 0 : attr->context_switch ||
4368 : : attr->bpf_event)
4369 : : return true;
4370 : : return false;
4371 : : }
4372 : :
4373 : 0 : static void unaccount_pmu_sb_event(struct perf_event *event)
4374 : : {
4375 [ # # ]: 0 : if (is_sb_event(event))
4376 : 0 : detach_sb_event(event);
4377 : 0 : }
4378 : :
4379 : 0 : static void unaccount_event_cpu(struct perf_event *event, int cpu)
4380 : : {
4381 [ # # ]: 0 : if (event->parent)
4382 : 0 : return;
4383 : :
4384 [ # # ]: 0 : if (is_cgroup_event(event))
4385 : 0 : atomic_dec(&per_cpu(perf_cgroup_events, cpu));
4386 : : }
4387 : :
4388 : : #ifdef CONFIG_NO_HZ_FULL
4389 : : static DEFINE_SPINLOCK(nr_freq_lock);
4390 : : #endif
4391 : :
4392 : : static void unaccount_freq_event_nohz(void)
4393 : : {
4394 : : #ifdef CONFIG_NO_HZ_FULL
4395 : : spin_lock(&nr_freq_lock);
4396 : : if (atomic_dec_and_test(&nr_freq_events))
4397 : : tick_nohz_dep_clear(TICK_DEP_BIT_PERF_EVENTS);
4398 : : spin_unlock(&nr_freq_lock);
4399 : : #endif
4400 : : }
4401 : :
4402 : 0 : static void unaccount_freq_event(void)
4403 : : {
4404 : : if (tick_nohz_full_enabled())
4405 : : unaccount_freq_event_nohz();
4406 : : else
4407 : : atomic_dec(&nr_freq_events);
4408 : 0 : }
4409 : :
4410 : 0 : static void unaccount_event(struct perf_event *event)
4411 : : {
4412 : : bool dec = false;
4413 : :
4414 [ # # ]: 0 : if (event->parent)
4415 : 0 : return;
4416 : :
4417 [ # # ]: 0 : if (event->attach_state & PERF_ATTACH_TASK)
4418 : : dec = true;
4419 [ # # ]: 0 : if (event->attr.mmap || event->attr.mmap_data)
4420 : : atomic_dec(&nr_mmap_events);
4421 [ # # ]: 0 : if (event->attr.comm)
4422 : : atomic_dec(&nr_comm_events);
4423 [ # # ]: 0 : if (event->attr.namespaces)
4424 : : atomic_dec(&nr_namespaces_events);
4425 [ # # ]: 0 : if (event->attr.task)
4426 : : atomic_dec(&nr_task_events);
4427 [ # # ]: 0 : if (event->attr.freq)
4428 : 0 : unaccount_freq_event();
4429 [ # # ]: 0 : if (event->attr.context_switch) {
4430 : : dec = true;
4431 : : atomic_dec(&nr_switch_events);
4432 : : }
4433 [ # # ]: 0 : if (is_cgroup_event(event))
4434 : : dec = true;
4435 [ # # ]: 0 : if (has_branch_stack(event))
4436 : : dec = true;
4437 [ # # ]: 0 : if (event->attr.ksymbol)
4438 : : atomic_dec(&nr_ksymbol_events);
4439 [ # # ]: 0 : if (event->attr.bpf_event)
4440 : : atomic_dec(&nr_bpf_events);
4441 : :
4442 [ # # ]: 0 : if (dec) {
4443 [ # # ]: 0 : if (!atomic_add_unless(&perf_sched_count, -1, 1))
4444 : : schedule_delayed_work(&perf_sched_work, HZ);
4445 : : }
4446 : :
4447 : 0 : unaccount_event_cpu(event, event->cpu);
4448 : :
4449 : 0 : unaccount_pmu_sb_event(event);
4450 : : }
4451 : :
4452 : 0 : static void perf_sched_delayed(struct work_struct *work)
4453 : : {
4454 : 0 : mutex_lock(&perf_sched_mutex);
4455 [ # # ]: 0 : if (atomic_dec_and_test(&perf_sched_count))
4456 : 0 : static_branch_disable(&perf_sched_events);
4457 : 0 : mutex_unlock(&perf_sched_mutex);
4458 : 0 : }
4459 : :
4460 : : /*
4461 : : * The following implement mutual exclusion of events on "exclusive" pmus
4462 : : * (PERF_PMU_CAP_EXCLUSIVE). Such pmus can only have one event scheduled
4463 : : * at a time, so we disallow creating events that might conflict, namely:
4464 : : *
4465 : : * 1) cpu-wide events in the presence of per-task events,
4466 : : * 2) per-task events in the presence of cpu-wide events,
4467 : : * 3) two matching events on the same context.
4468 : : *
4469 : : * The former two cases are handled in the allocation path (perf_event_alloc(),
4470 : : * _free_event()), the latter -- before the first perf_install_in_context().
4471 : : */
4472 : 0 : static int exclusive_event_init(struct perf_event *event)
4473 : : {
4474 : 0 : struct pmu *pmu = event->pmu;
4475 : :
4476 [ # # ]: 0 : if (!is_exclusive_pmu(pmu))
4477 : : return 0;
4478 : :
4479 : : /*
4480 : : * Prevent co-existence of per-task and cpu-wide events on the
4481 : : * same exclusive pmu.
4482 : : *
4483 : : * Negative pmu::exclusive_cnt means there are cpu-wide
4484 : : * events on this "exclusive" pmu, positive means there are
4485 : : * per-task events.
4486 : : *
4487 : : * Since this is called in perf_event_alloc() path, event::ctx
4488 : : * doesn't exist yet; it is, however, safe to use PERF_ATTACH_TASK
4489 : : * to mean "per-task event", because unlike other attach states it
4490 : : * never gets cleared.
4491 : : */
4492 [ # # ]: 0 : if (event->attach_state & PERF_ATTACH_TASK) {
4493 [ # # ]: 0 : if (!atomic_inc_unless_negative(&pmu->exclusive_cnt))
4494 : : return -EBUSY;
4495 : : } else {
4496 [ # # ]: 0 : if (!atomic_dec_unless_positive(&pmu->exclusive_cnt))
4497 : : return -EBUSY;
4498 : : }
4499 : :
4500 : : return 0;
4501 : : }
4502 : :
4503 : 0 : static void exclusive_event_destroy(struct perf_event *event)
4504 : : {
4505 : 0 : struct pmu *pmu = event->pmu;
4506 : :
4507 [ # # ]: 0 : if (!is_exclusive_pmu(pmu))
4508 : 0 : return;
4509 : :
4510 : : /* see comment in exclusive_event_init() */
4511 [ # # ]: 0 : if (event->attach_state & PERF_ATTACH_TASK)
4512 : 0 : atomic_dec(&pmu->exclusive_cnt);
4513 : : else
4514 : 0 : atomic_inc(&pmu->exclusive_cnt);
4515 : : }
4516 : :
4517 : : static bool exclusive_event_match(struct perf_event *e1, struct perf_event *e2)
4518 : : {
4519 [ # # # # ]: 0 : if ((e1->pmu == e2->pmu) &&
4520 [ # # ]: 0 : (e1->cpu == e2->cpu ||
4521 [ # # ]: 0 : e1->cpu == -1 ||
4522 : : e2->cpu == -1))
4523 : : return true;
4524 : : return false;
4525 : : }
4526 : :
4527 : 0 : static bool exclusive_event_installable(struct perf_event *event,
4528 : : struct perf_event_context *ctx)
4529 : : {
4530 : : struct perf_event *iter_event;
4531 : 0 : struct pmu *pmu = event->pmu;
4532 : :
4533 : : lockdep_assert_held(&ctx->mutex);
4534 : :
4535 [ # # ]: 0 : if (!is_exclusive_pmu(pmu))
4536 : : return true;
4537 : :
4538 [ # # ]: 0 : list_for_each_entry(iter_event, &ctx->event_list, event_entry) {
4539 [ # # ]: 0 : if (exclusive_event_match(iter_event, event))
4540 : : return false;
4541 : : }
4542 : :
4543 : : return true;
4544 : : }
4545 : :
4546 : : static void perf_addr_filters_splice(struct perf_event *event,
4547 : : struct list_head *head);
4548 : :
4549 : 0 : static void _free_event(struct perf_event *event)
4550 : : {
4551 : 0 : irq_work_sync(&event->pending);
4552 : :
4553 : 0 : unaccount_event(event);
4554 : :
4555 [ # # ]: 0 : if (event->rb) {
4556 : : /*
4557 : : * Can happen when we close an event with re-directed output.
4558 : : *
4559 : : * Since we have a 0 refcount, perf_mmap_close() will skip
4560 : : * over us; possibly making our ring_buffer_put() the last.
4561 : : */
4562 : 0 : mutex_lock(&event->mmap_mutex);
4563 : 0 : ring_buffer_attach(event, NULL);
4564 : 0 : mutex_unlock(&event->mmap_mutex);
4565 : : }
4566 : :
4567 [ # # ]: 0 : if (is_cgroup_event(event))
4568 : 0 : perf_detach_cgroup(event);
4569 : :
4570 [ # # ]: 0 : if (!event->parent) {
4571 [ # # ]: 0 : if (event->attr.sample_type & PERF_SAMPLE_CALLCHAIN)
4572 : 0 : put_callchain_buffers();
4573 : : }
4574 : :
4575 : 0 : perf_event_free_bpf_prog(event);
4576 : 0 : perf_addr_filters_splice(event, NULL);
4577 : 0 : kfree(event->addr_filter_ranges);
4578 : :
4579 [ # # ]: 0 : if (event->destroy)
4580 : 0 : event->destroy(event);
4581 : :
4582 : : /*
4583 : : * Must be after ->destroy(), due to uprobe_perf_close() using
4584 : : * hw.target.
4585 : : */
4586 [ # # ]: 0 : if (event->hw.target)
4587 : 0 : put_task_struct(event->hw.target);
4588 : :
4589 : : /*
4590 : : * perf_event_free_task() relies on put_ctx() being 'last', in particular
4591 : : * all task references must be cleaned up.
4592 : : */
4593 [ # # ]: 0 : if (event->ctx)
4594 : 0 : put_ctx(event->ctx);
4595 : :
4596 : 0 : exclusive_event_destroy(event);
4597 : 0 : module_put(event->pmu->module);
4598 : :
4599 : 0 : call_rcu(&event->rcu_head, free_event_rcu);
4600 : 0 : }
4601 : :
4602 : : /*
4603 : : * Used to free events which have a known refcount of 1, such as in error paths
4604 : : * where the event isn't exposed yet and inherited events.
4605 : : */
4606 : 0 : static void free_event(struct perf_event *event)
4607 : : {
4608 [ # # # # ]: 0 : if (WARN(atomic_long_cmpxchg(&event->refcount, 1, 0) != 1,
4609 : : "unexpected event refcount: %ld; ptr=%p\n",
4610 : : atomic_long_read(&event->refcount), event)) {
4611 : : /* leak to avoid use-after-free */
4612 : 0 : return;
4613 : : }
4614 : :
4615 : 0 : _free_event(event);
4616 : : }
4617 : :
4618 : : /*
4619 : : * Remove user event from the owner task.
4620 : : */
4621 : 0 : static void perf_remove_from_owner(struct perf_event *event)
4622 : : {
4623 : : struct task_struct *owner;
4624 : :
4625 : : rcu_read_lock();
4626 : : /*
4627 : : * Matches the smp_store_release() in perf_event_exit_task(). If we
4628 : : * observe !owner it means the list deletion is complete and we can
4629 : : * indeed free this event, otherwise we need to serialize on
4630 : : * owner->perf_event_mutex.
4631 : : */
4632 : 0 : owner = READ_ONCE(event->owner);
4633 [ # # ]: 0 : if (owner) {
4634 : : /*
4635 : : * Since delayed_put_task_struct() also drops the last
4636 : : * task reference we can safely take a new reference
4637 : : * while holding the rcu_read_lock().
4638 : : */
4639 : : get_task_struct(owner);
4640 : : }
4641 : : rcu_read_unlock();
4642 : :
4643 [ # # ]: 0 : if (owner) {
4644 : : /*
4645 : : * If we're here through perf_event_exit_task() we're already
4646 : : * holding ctx->mutex which would be an inversion wrt. the
4647 : : * normal lock order.
4648 : : *
4649 : : * However we can safely take this lock because its the child
4650 : : * ctx->mutex.
4651 : : */
4652 : 0 : mutex_lock_nested(&owner->perf_event_mutex, SINGLE_DEPTH_NESTING);
4653 : :
4654 : : /*
4655 : : * We have to re-check the event->owner field, if it is cleared
4656 : : * we raced with perf_event_exit_task(), acquiring the mutex
4657 : : * ensured they're done, and we can proceed with freeing the
4658 : : * event.
4659 : : */
4660 [ # # ]: 0 : if (event->owner) {
4661 : 0 : list_del_init(&event->owner_entry);
4662 : 0 : smp_store_release(&event->owner, NULL);
4663 : : }
4664 : 0 : mutex_unlock(&owner->perf_event_mutex);
4665 : 0 : put_task_struct(owner);
4666 : : }
4667 : 0 : }
4668 : :
4669 : 0 : static void put_event(struct perf_event *event)
4670 : : {
4671 [ # # ]: 0 : if (!atomic_long_dec_and_test(&event->refcount))
4672 : 0 : return;
4673 : :
4674 : 0 : _free_event(event);
4675 : : }
4676 : :
4677 : : /*
4678 : : * Kill an event dead; while event:refcount will preserve the event
4679 : : * object, it will not preserve its functionality. Once the last 'user'
4680 : : * gives up the object, we'll destroy the thing.
4681 : : */
4682 : 0 : int perf_event_release_kernel(struct perf_event *event)
4683 : : {
4684 : 0 : struct perf_event_context *ctx = event->ctx;
4685 : : struct perf_event *child, *tmp;
4686 : 0 : LIST_HEAD(free_list);
4687 : :
4688 : : /*
4689 : : * If we got here through err_file: fput(event_file); we will not have
4690 : : * attached to a context yet.
4691 : : */
4692 [ # # ]: 0 : if (!ctx) {
4693 [ # # # # ]: 0 : WARN_ON_ONCE(event->attach_state &
4694 : : (PERF_ATTACH_CONTEXT|PERF_ATTACH_GROUP));
4695 : : goto no_ctx;
4696 : : }
4697 : :
4698 [ # # ]: 0 : if (!is_kernel_event(event))
4699 : 0 : perf_remove_from_owner(event);
4700 : :
4701 : : ctx = perf_event_ctx_lock(event);
4702 [ # # # # ]: 0 : WARN_ON_ONCE(ctx->parent_ctx);
4703 : 0 : perf_remove_from_context(event, DETACH_GROUP);
4704 : :
4705 : 0 : raw_spin_lock_irq(&ctx->lock);
4706 : : /*
4707 : : * Mark this event as STATE_DEAD, there is no external reference to it
4708 : : * anymore.
4709 : : *
4710 : : * Anybody acquiring event->child_mutex after the below loop _must_
4711 : : * also see this, most importantly inherit_event() which will avoid
4712 : : * placing more children on the list.
4713 : : *
4714 : : * Thus this guarantees that we will in fact observe and kill _ALL_
4715 : : * child events.
4716 : : */
4717 : 0 : event->state = PERF_EVENT_STATE_DEAD;
4718 : 0 : raw_spin_unlock_irq(&ctx->lock);
4719 : :
4720 : : perf_event_ctx_unlock(event, ctx);
4721 : :
4722 : : again:
4723 : 0 : mutex_lock(&event->child_mutex);
4724 [ # # ]: 0 : list_for_each_entry(child, &event->child_list, child_list) {
4725 : :
4726 : : /*
4727 : : * Cannot change, child events are not migrated, see the
4728 : : * comment with perf_event_ctx_lock_nested().
4729 : : */
4730 : 0 : ctx = READ_ONCE(child->ctx);
4731 : : /*
4732 : : * Since child_mutex nests inside ctx::mutex, we must jump
4733 : : * through hoops. We start by grabbing a reference on the ctx.
4734 : : *
4735 : : * Since the event cannot get freed while we hold the
4736 : : * child_mutex, the context must also exist and have a !0
4737 : : * reference count.
4738 : : */
4739 : : get_ctx(ctx);
4740 : :
4741 : : /*
4742 : : * Now that we have a ctx ref, we can drop child_mutex, and
4743 : : * acquire ctx::mutex without fear of it going away. Then we
4744 : : * can re-acquire child_mutex.
4745 : : */
4746 : 0 : mutex_unlock(&event->child_mutex);
4747 : 0 : mutex_lock(&ctx->mutex);
4748 : 0 : mutex_lock(&event->child_mutex);
4749 : :
4750 : : /*
4751 : : * Now that we hold ctx::mutex and child_mutex, revalidate our
4752 : : * state, if child is still the first entry, it didn't get freed
4753 : : * and we can continue doing so.
4754 : : */
4755 [ # # ]: 0 : tmp = list_first_entry_or_null(&event->child_list,
4756 : : struct perf_event, child_list);
4757 [ # # ]: 0 : if (tmp == child) {
4758 : 0 : perf_remove_from_context(child, DETACH_GROUP);
4759 : 0 : list_move(&child->child_list, &free_list);
4760 : : /*
4761 : : * This matches the refcount bump in inherit_event();
4762 : : * this can't be the last reference.
4763 : : */
4764 : 0 : put_event(event);
4765 : : }
4766 : :
4767 : 0 : mutex_unlock(&event->child_mutex);
4768 : 0 : mutex_unlock(&ctx->mutex);
4769 : 0 : put_ctx(ctx);
4770 : 0 : goto again;
4771 : : }
4772 : 0 : mutex_unlock(&event->child_mutex);
4773 : :
4774 [ # # ]: 0 : list_for_each_entry_safe(child, tmp, &free_list, child_list) {
4775 : 0 : void *var = &child->ctx->refcount;
4776 : :
4777 : : list_del(&child->child_list);
4778 : 0 : free_event(child);
4779 : :
4780 : : /*
4781 : : * Wake any perf_event_free_task() waiting for this event to be
4782 : : * freed.
4783 : : */
4784 : 0 : smp_mb(); /* pairs with wait_var_event() */
4785 : 0 : wake_up_var(var);
4786 : : }
4787 : :
4788 : : no_ctx:
4789 : 0 : put_event(event); /* Must be the 'last' reference */
4790 : 0 : return 0;
4791 : : }
4792 : : EXPORT_SYMBOL_GPL(perf_event_release_kernel);
4793 : :
4794 : : /*
4795 : : * Called when the last reference to the file is gone.
4796 : : */
4797 : 0 : static int perf_release(struct inode *inode, struct file *file)
4798 : : {
4799 : 0 : perf_event_release_kernel(file->private_data);
4800 : 0 : return 0;
4801 : : }
4802 : :
4803 : 0 : static u64 __perf_event_read_value(struct perf_event *event, u64 *enabled, u64 *running)
4804 : : {
4805 : : struct perf_event *child;
4806 : : u64 total = 0;
4807 : :
4808 : 0 : *enabled = 0;
4809 : 0 : *running = 0;
4810 : :
4811 : 0 : mutex_lock(&event->child_mutex);
4812 : :
4813 : 0 : (void)perf_event_read(event, false);
4814 : : total += perf_event_count(event);
4815 : :
4816 : 0 : *enabled += event->total_time_enabled +
4817 : 0 : atomic64_read(&event->child_total_time_enabled);
4818 : 0 : *running += event->total_time_running +
4819 : 0 : atomic64_read(&event->child_total_time_running);
4820 : :
4821 [ # # ]: 0 : list_for_each_entry(child, &event->child_list, child_list) {
4822 : 0 : (void)perf_event_read(child, false);
4823 : 0 : total += perf_event_count(child);
4824 : 0 : *enabled += child->total_time_enabled;
4825 : 0 : *running += child->total_time_running;
4826 : : }
4827 : 0 : mutex_unlock(&event->child_mutex);
4828 : :
4829 : 0 : return total;
4830 : : }
4831 : :
4832 : 0 : u64 perf_event_read_value(struct perf_event *event, u64 *enabled, u64 *running)
4833 : : {
4834 : : struct perf_event_context *ctx;
4835 : : u64 count;
4836 : :
4837 : : ctx = perf_event_ctx_lock(event);
4838 : 0 : count = __perf_event_read_value(event, enabled, running);
4839 : : perf_event_ctx_unlock(event, ctx);
4840 : :
4841 : 0 : return count;
4842 : : }
4843 : : EXPORT_SYMBOL_GPL(perf_event_read_value);
4844 : :
4845 : 0 : static int __perf_read_group_add(struct perf_event *leader,
4846 : : u64 read_format, u64 *values)
4847 : : {
4848 : 0 : struct perf_event_context *ctx = leader->ctx;
4849 : : struct perf_event *sub;
4850 : : unsigned long flags;
4851 : : int n = 1; /* skip @nr */
4852 : : int ret;
4853 : :
4854 : 0 : ret = perf_event_read(leader, true);
4855 [ # # ]: 0 : if (ret)
4856 : : return ret;
4857 : :
4858 : 0 : raw_spin_lock_irqsave(&ctx->lock, flags);
4859 : :
4860 : : /*
4861 : : * Since we co-schedule groups, {enabled,running} times of siblings
4862 : : * will be identical to those of the leader, so we only publish one
4863 : : * set.
4864 : : */
4865 [ # # ]: 0 : if (read_format & PERF_FORMAT_TOTAL_TIME_ENABLED) {
4866 : 0 : values[n++] += leader->total_time_enabled +
4867 : 0 : atomic64_read(&leader->child_total_time_enabled);
4868 : : }
4869 : :
4870 [ # # ]: 0 : if (read_format & PERF_FORMAT_TOTAL_TIME_RUNNING) {
4871 : 0 : values[n++] += leader->total_time_running +
4872 : 0 : atomic64_read(&leader->child_total_time_running);
4873 : : }
4874 : :
4875 : : /*
4876 : : * Write {count,id} tuples for every sibling.
4877 : : */
4878 : 0 : values[n++] += perf_event_count(leader);
4879 [ # # ]: 0 : if (read_format & PERF_FORMAT_ID)
4880 : 0 : values[n++] = primary_event_id(leader);
4881 : :
4882 [ # # # # ]: 0 : for_each_sibling_event(sub, leader) {
4883 : 0 : values[n++] += perf_event_count(sub);
4884 [ # # ]: 0 : if (read_format & PERF_FORMAT_ID)
4885 : 0 : values[n++] = primary_event_id(sub);
4886 : : }
4887 : :
4888 : 0 : raw_spin_unlock_irqrestore(&ctx->lock, flags);
4889 : 0 : return 0;
4890 : : }
4891 : :
4892 : 0 : static int perf_read_group(struct perf_event *event,
4893 : : u64 read_format, char __user *buf)
4894 : : {
4895 : 0 : struct perf_event *leader = event->group_leader, *child;
4896 : : struct perf_event_context *ctx = leader->ctx;
4897 : : int ret;
4898 : : u64 *values;
4899 : :
4900 : : lockdep_assert_held(&ctx->mutex);
4901 : :
4902 : 0 : values = kzalloc(event->read_size, GFP_KERNEL);
4903 [ # # ]: 0 : if (!values)
4904 : : return -ENOMEM;
4905 : :
4906 : 0 : values[0] = 1 + leader->nr_siblings;
4907 : :
4908 : : /*
4909 : : * By locking the child_mutex of the leader we effectively
4910 : : * lock the child list of all siblings.. XXX explain how.
4911 : : */
4912 : 0 : mutex_lock(&leader->child_mutex);
4913 : :
4914 : 0 : ret = __perf_read_group_add(leader, read_format, values);
4915 [ # # ]: 0 : if (ret)
4916 : : goto unlock;
4917 : :
4918 [ # # ]: 0 : list_for_each_entry(child, &leader->child_list, child_list) {
4919 : 0 : ret = __perf_read_group_add(child, read_format, values);
4920 [ # # ]: 0 : if (ret)
4921 : : goto unlock;
4922 : : }
4923 : :
4924 : 0 : mutex_unlock(&leader->child_mutex);
4925 : :
4926 : 0 : ret = event->read_size;
4927 [ # # ]: 0 : if (copy_to_user(buf, values, event->read_size))
4928 : : ret = -EFAULT;
4929 : : goto out;
4930 : :
4931 : : unlock:
4932 : 0 : mutex_unlock(&leader->child_mutex);
4933 : : out:
4934 : 0 : kfree(values);
4935 : 0 : return ret;
4936 : : }
4937 : :
4938 : 0 : static int perf_read_one(struct perf_event *event,
4939 : : u64 read_format, char __user *buf)
4940 : : {
4941 : : u64 enabled, running;
4942 : : u64 values[4];
4943 : : int n = 0;
4944 : :
4945 : 0 : values[n++] = __perf_event_read_value(event, &enabled, &running);
4946 [ # # ]: 0 : if (read_format & PERF_FORMAT_TOTAL_TIME_ENABLED)
4947 : 0 : values[n++] = enabled;
4948 [ # # ]: 0 : if (read_format & PERF_FORMAT_TOTAL_TIME_RUNNING)
4949 : 0 : values[n++] = running;
4950 [ # # ]: 0 : if (read_format & PERF_FORMAT_ID)
4951 : 0 : values[n++] = primary_event_id(event);
4952 : :
4953 [ # # ]: 0 : if (copy_to_user(buf, values, n * sizeof(u64)))
4954 : : return -EFAULT;
4955 : :
4956 : 0 : return n * sizeof(u64);
4957 : : }
4958 : :
4959 : 0 : static bool is_event_hup(struct perf_event *event)
4960 : : {
4961 : : bool no_children;
4962 : :
4963 [ # # ]: 0 : if (event->state > PERF_EVENT_STATE_EXIT)
4964 : : return false;
4965 : :
4966 : 0 : mutex_lock(&event->child_mutex);
4967 : 0 : no_children = list_empty(&event->child_list);
4968 : 0 : mutex_unlock(&event->child_mutex);
4969 : 0 : return no_children;
4970 : : }
4971 : :
4972 : : /*
4973 : : * Read the performance event - simple non blocking version for now
4974 : : */
4975 : : static ssize_t
4976 : 0 : __perf_read(struct perf_event *event, char __user *buf, size_t count)
4977 : : {
4978 : 0 : u64 read_format = event->attr.read_format;
4979 : : int ret;
4980 : :
4981 : : /*
4982 : : * Return end-of-file for a read on an event that is in
4983 : : * error state (i.e. because it was pinned but it couldn't be
4984 : : * scheduled on to the CPU at some point).
4985 : : */
4986 [ # # ]: 0 : if (event->state == PERF_EVENT_STATE_ERROR)
4987 : : return 0;
4988 : :
4989 [ # # ]: 0 : if (count < event->read_size)
4990 : : return -ENOSPC;
4991 : :
4992 [ # # # # ]: 0 : WARN_ON_ONCE(event->ctx->parent_ctx);
4993 [ # # ]: 0 : if (read_format & PERF_FORMAT_GROUP)
4994 : 0 : ret = perf_read_group(event, read_format, buf);
4995 : : else
4996 : 0 : ret = perf_read_one(event, read_format, buf);
4997 : :
4998 : 0 : return ret;
4999 : : }
5000 : :
5001 : : static ssize_t
5002 : 0 : perf_read(struct file *file, char __user *buf, size_t count, loff_t *ppos)
5003 : : {
5004 : 0 : struct perf_event *event = file->private_data;
5005 : : struct perf_event_context *ctx;
5006 : : int ret;
5007 : :
5008 : : ctx = perf_event_ctx_lock(event);
5009 : 0 : ret = __perf_read(event, buf, count);
5010 : : perf_event_ctx_unlock(event, ctx);
5011 : :
5012 : 0 : return ret;
5013 : : }
5014 : :
5015 : 0 : static __poll_t perf_poll(struct file *file, poll_table *wait)
5016 : : {
5017 : 0 : struct perf_event *event = file->private_data;
5018 : : struct ring_buffer *rb;
5019 : : __poll_t events = EPOLLHUP;
5020 : :
5021 : 0 : poll_wait(file, &event->waitq, wait);
5022 : :
5023 [ # # ]: 0 : if (is_event_hup(event))
5024 : : return events;
5025 : :
5026 : : /*
5027 : : * Pin the event->rb by taking event->mmap_mutex; otherwise
5028 : : * perf_event_set_output() can swizzle our rb and make us miss wakeups.
5029 : : */
5030 : 0 : mutex_lock(&event->mmap_mutex);
5031 : 0 : rb = event->rb;
5032 [ # # ]: 0 : if (rb)
5033 : 0 : events = atomic_xchg(&rb->poll, 0);
5034 : 0 : mutex_unlock(&event->mmap_mutex);
5035 : 0 : return events;
5036 : : }
5037 : :
5038 : 0 : static void _perf_event_reset(struct perf_event *event)
5039 : : {
5040 : 0 : (void)perf_event_read(event, false);
5041 : 0 : local64_set(&event->count, 0);
5042 : 0 : perf_event_update_userpage(event);
5043 : 0 : }
5044 : :
5045 : : /*
5046 : : * Holding the top-level event's child_mutex means that any
5047 : : * descendant process that has inherited this event will block
5048 : : * in perf_event_exit_event() if it goes to exit, thus satisfying the
5049 : : * task existence requirements of perf_event_enable/disable.
5050 : : */
5051 : 0 : static void perf_event_for_each_child(struct perf_event *event,
5052 : : void (*func)(struct perf_event *))
5053 : : {
5054 : : struct perf_event *child;
5055 : :
5056 [ # # # # ]: 0 : WARN_ON_ONCE(event->ctx->parent_ctx);
5057 : :
5058 : 0 : mutex_lock(&event->child_mutex);
5059 : 0 : func(event);
5060 [ # # ]: 0 : list_for_each_entry(child, &event->child_list, child_list)
5061 : 0 : func(child);
5062 : 0 : mutex_unlock(&event->child_mutex);
5063 : 0 : }
5064 : :
5065 : 0 : static void perf_event_for_each(struct perf_event *event,
5066 : : void (*func)(struct perf_event *))
5067 : : {
5068 : : struct perf_event_context *ctx = event->ctx;
5069 : : struct perf_event *sibling;
5070 : :
5071 : : lockdep_assert_held(&ctx->mutex);
5072 : :
5073 : 0 : event = event->group_leader;
5074 : :
5075 : 0 : perf_event_for_each_child(event, func);
5076 [ # # # # ]: 0 : for_each_sibling_event(sibling, event)
5077 : 0 : perf_event_for_each_child(sibling, func);
5078 : 0 : }
5079 : :
5080 : 0 : static void __perf_event_period(struct perf_event *event,
5081 : : struct perf_cpu_context *cpuctx,
5082 : : struct perf_event_context *ctx,
5083 : : void *info)
5084 : : {
5085 : 0 : u64 value = *((u64 *)info);
5086 : : bool active;
5087 : :
5088 [ # # ]: 0 : if (event->attr.freq) {
5089 : 0 : event->attr.sample_freq = value;
5090 : : } else {
5091 : 0 : event->attr.sample_period = value;
5092 : 0 : event->hw.sample_period = value;
5093 : : }
5094 : :
5095 : 0 : active = (event->state == PERF_EVENT_STATE_ACTIVE);
5096 [ # # ]: 0 : if (active) {
5097 : 0 : perf_pmu_disable(ctx->pmu);
5098 : : /*
5099 : : * We could be throttled; unthrottle now to avoid the tick
5100 : : * trying to unthrottle while we already re-started the event.
5101 : : */
5102 [ # # ]: 0 : if (event->hw.interrupts == MAX_INTERRUPTS) {
5103 : 0 : event->hw.interrupts = 0;
5104 : 0 : perf_log_throttle(event, 1);
5105 : : }
5106 : 0 : event->pmu->stop(event, PERF_EF_UPDATE);
5107 : : }
5108 : :
5109 : 0 : local64_set(&event->hw.period_left, 0);
5110 : :
5111 [ # # ]: 0 : if (active) {
5112 : 0 : event->pmu->start(event, PERF_EF_RELOAD);
5113 : 0 : perf_pmu_enable(ctx->pmu);
5114 : : }
5115 : 0 : }
5116 : :
5117 : : static int perf_event_check_period(struct perf_event *event, u64 value)
5118 : : {
5119 : 0 : return event->pmu->check_period(event, value);
5120 : : }
5121 : :
5122 : 0 : static int perf_event_period(struct perf_event *event, u64 __user *arg)
5123 : : {
5124 : : u64 value;
5125 : :
5126 [ # # ]: 0 : if (!is_sampling_event(event))
5127 : : return -EINVAL;
5128 : :
5129 [ # # ]: 0 : if (copy_from_user(&value, arg, sizeof(value)))
5130 : : return -EFAULT;
5131 : :
5132 [ # # ]: 0 : if (!value)
5133 : : return -EINVAL;
5134 : :
5135 [ # # # # ]: 0 : if (event->attr.freq && value > sysctl_perf_event_sample_rate)
5136 : : return -EINVAL;
5137 : :
5138 [ # # ]: 0 : if (perf_event_check_period(event, value))
5139 : : return -EINVAL;
5140 : :
5141 [ # # # # ]: 0 : if (!event->attr.freq && (value & (1ULL << 63)))
5142 : : return -EINVAL;
5143 : :
5144 : 0 : event_function_call(event, __perf_event_period, &value);
5145 : :
5146 : 0 : return 0;
5147 : : }
5148 : :
5149 : : static const struct file_operations perf_fops;
5150 : :
5151 : 0 : static inline int perf_fget_light(int fd, struct fd *p)
5152 : : {
5153 : 0 : struct fd f = fdget(fd);
5154 [ # # ]: 0 : if (!f.file)
5155 : : return -EBADF;
5156 : :
5157 [ # # ]: 0 : if (f.file->f_op != &perf_fops) {
5158 : : fdput(f);
5159 : : return -EBADF;
5160 : : }
5161 : 0 : *p = f;
5162 : 0 : return 0;
5163 : : }
5164 : :
5165 : : static int perf_event_set_output(struct perf_event *event,
5166 : : struct perf_event *output_event);
5167 : : static int perf_event_set_filter(struct perf_event *event, void __user *arg);
5168 : : static int perf_event_set_bpf_prog(struct perf_event *event, u32 prog_fd);
5169 : : static int perf_copy_attr(struct perf_event_attr __user *uattr,
5170 : : struct perf_event_attr *attr);
5171 : :
5172 : 0 : static long _perf_ioctl(struct perf_event *event, unsigned int cmd, unsigned long arg)
5173 : : {
5174 : : void (*func)(struct perf_event *);
5175 : : u32 flags = arg;
5176 : :
5177 [ # # # # : 0 : switch (cmd) {
# # # # #
# # # # ]
5178 : : case PERF_EVENT_IOC_ENABLE:
5179 : : func = _perf_event_enable;
5180 : : break;
5181 : : case PERF_EVENT_IOC_DISABLE:
5182 : : func = _perf_event_disable;
5183 : 0 : break;
5184 : : case PERF_EVENT_IOC_RESET:
5185 : : func = _perf_event_reset;
5186 : 0 : break;
5187 : :
5188 : : case PERF_EVENT_IOC_REFRESH:
5189 : 0 : return _perf_event_refresh(event, arg);
5190 : :
5191 : : case PERF_EVENT_IOC_PERIOD:
5192 : 0 : return perf_event_period(event, (u64 __user *)arg);
5193 : :
5194 : : case PERF_EVENT_IOC_ID:
5195 : : {
5196 : 0 : u64 id = primary_event_id(event);
5197 : :
5198 [ # # ]: 0 : if (copy_to_user((void __user *)arg, &id, sizeof(id)))
5199 : : return -EFAULT;
5200 : 0 : return 0;
5201 : : }
5202 : :
5203 : : case PERF_EVENT_IOC_SET_OUTPUT:
5204 : : {
5205 : : int ret;
5206 [ # # ]: 0 : if (arg != -1) {
5207 : : struct perf_event *output_event;
5208 : : struct fd output;
5209 : 0 : ret = perf_fget_light(arg, &output);
5210 [ # # ]: 0 : if (ret)
5211 : 0 : return ret;
5212 : 0 : output_event = output.file->private_data;
5213 : 0 : ret = perf_event_set_output(event, output_event);
5214 : : fdput(output);
5215 : : } else {
5216 : 0 : ret = perf_event_set_output(event, NULL);
5217 : : }
5218 : 0 : return ret;
5219 : : }
5220 : :
5221 : : case PERF_EVENT_IOC_SET_FILTER:
5222 : 0 : return perf_event_set_filter(event, (void __user *)arg);
5223 : :
5224 : : case PERF_EVENT_IOC_SET_BPF:
5225 : 0 : return perf_event_set_bpf_prog(event, arg);
5226 : :
5227 : : case PERF_EVENT_IOC_PAUSE_OUTPUT: {
5228 : : struct ring_buffer *rb;
5229 : :
5230 : : rcu_read_lock();
5231 : 0 : rb = rcu_dereference(event->rb);
5232 [ # # # # ]: 0 : if (!rb || !rb->nr_pages) {
5233 : : rcu_read_unlock();
5234 : 0 : return -EINVAL;
5235 : : }
5236 : : rb_toggle_paused(rb, !!arg);
5237 : : rcu_read_unlock();
5238 : 0 : return 0;
5239 : : }
5240 : :
5241 : : case PERF_EVENT_IOC_QUERY_BPF:
5242 : 0 : return perf_event_query_prog_array(event, (void __user *)arg);
5243 : :
5244 : : case PERF_EVENT_IOC_MODIFY_ATTRIBUTES: {
5245 : : struct perf_event_attr new_attr;
5246 : 0 : int err = perf_copy_attr((struct perf_event_attr __user *)arg,
5247 : : &new_attr);
5248 : :
5249 [ # # ]: 0 : if (err)
5250 : : return err;
5251 : :
5252 : 0 : return perf_event_modify_attr(event, &new_attr);
5253 : : }
5254 : : default:
5255 : : return -ENOTTY;
5256 : : }
5257 : :
5258 [ # # ]: 0 : if (flags & PERF_IOC_FLAG_GROUP)
5259 : 0 : perf_event_for_each(event, func);
5260 : : else
5261 : 0 : perf_event_for_each_child(event, func);
5262 : :
5263 : : return 0;
5264 : : }
5265 : :
5266 : 0 : static long perf_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
5267 : : {
5268 : 0 : struct perf_event *event = file->private_data;
5269 : : struct perf_event_context *ctx;
5270 : : long ret;
5271 : :
5272 : : ctx = perf_event_ctx_lock(event);
5273 : 0 : ret = _perf_ioctl(event, cmd, arg);
5274 : : perf_event_ctx_unlock(event, ctx);
5275 : :
5276 : 0 : return ret;
5277 : : }
5278 : :
5279 : : #ifdef CONFIG_COMPAT
5280 : : static long perf_compat_ioctl(struct file *file, unsigned int cmd,
5281 : : unsigned long arg)
5282 : : {
5283 : : switch (_IOC_NR(cmd)) {
5284 : : case _IOC_NR(PERF_EVENT_IOC_SET_FILTER):
5285 : : case _IOC_NR(PERF_EVENT_IOC_ID):
5286 : : case _IOC_NR(PERF_EVENT_IOC_QUERY_BPF):
5287 : : case _IOC_NR(PERF_EVENT_IOC_MODIFY_ATTRIBUTES):
5288 : : /* Fix up pointer size (usually 4 -> 8 in 32-on-64-bit case */
5289 : : if (_IOC_SIZE(cmd) == sizeof(compat_uptr_t)) {
5290 : : cmd &= ~IOCSIZE_MASK;
5291 : : cmd |= sizeof(void *) << IOCSIZE_SHIFT;
5292 : : }
5293 : : break;
5294 : : }
5295 : : return perf_ioctl(file, cmd, arg);
5296 : : }
5297 : : #else
5298 : : # define perf_compat_ioctl NULL
5299 : : #endif
5300 : :
5301 : 0 : int perf_event_task_enable(void)
5302 : : {
5303 : : struct perf_event_context *ctx;
5304 : : struct perf_event *event;
5305 : :
5306 : 0 : mutex_lock(¤t->perf_event_mutex);
5307 [ # # ]: 0 : list_for_each_entry(event, ¤t->perf_event_list, owner_entry) {
5308 : : ctx = perf_event_ctx_lock(event);
5309 : 0 : perf_event_for_each_child(event, _perf_event_enable);
5310 : : perf_event_ctx_unlock(event, ctx);
5311 : : }
5312 : 0 : mutex_unlock(¤t->perf_event_mutex);
5313 : :
5314 : 0 : return 0;
5315 : : }
5316 : :
5317 : 0 : int perf_event_task_disable(void)
5318 : : {
5319 : : struct perf_event_context *ctx;
5320 : : struct perf_event *event;
5321 : :
5322 : 0 : mutex_lock(¤t->perf_event_mutex);
5323 [ # # ]: 0 : list_for_each_entry(event, ¤t->perf_event_list, owner_entry) {
5324 : : ctx = perf_event_ctx_lock(event);
5325 : 0 : perf_event_for_each_child(event, _perf_event_disable);
5326 : : perf_event_ctx_unlock(event, ctx);
5327 : : }
5328 : 0 : mutex_unlock(¤t->perf_event_mutex);
5329 : :
5330 : 0 : return 0;
5331 : : }
5332 : :
5333 : : static int perf_event_index(struct perf_event *event)
5334 : : {
5335 [ # # ]: 0 : if (event->hw.state & PERF_HES_STOPPED)
5336 : : return 0;
5337 : :
5338 [ # # ]: 0 : if (event->state != PERF_EVENT_STATE_ACTIVE)
5339 : : return 0;
5340 : :
5341 : 0 : return event->pmu->event_idx(event);
5342 : : }
5343 : :
5344 : 0 : static void calc_timer_values(struct perf_event *event,
5345 : : u64 *now,
5346 : : u64 *enabled,
5347 : : u64 *running)
5348 : : {
5349 : : u64 ctx_time;
5350 : :
5351 : 0 : *now = perf_clock();
5352 : 0 : ctx_time = event->shadow_ctx_time + *now;
5353 : : __perf_update_times(event, ctx_time, enabled, running);
5354 : 0 : }
5355 : :
5356 : 0 : static void perf_event_init_userpage(struct perf_event *event)
5357 : : {
5358 : : struct perf_event_mmap_page *userpg;
5359 : : struct ring_buffer *rb;
5360 : :
5361 : : rcu_read_lock();
5362 : 0 : rb = rcu_dereference(event->rb);
5363 [ # # ]: 0 : if (!rb)
5364 : : goto unlock;
5365 : :
5366 : 0 : userpg = rb->user_page;
5367 : :
5368 : : /* Allow new userspace to detect that bit 0 is deprecated */
5369 : 0 : userpg->cap_bit0_is_deprecated = 1;
5370 : 0 : userpg->size = offsetof(struct perf_event_mmap_page, __reserved);
5371 : 0 : userpg->data_offset = PAGE_SIZE;
5372 : 0 : userpg->data_size = perf_data_size(rb);
5373 : :
5374 : : unlock:
5375 : : rcu_read_unlock();
5376 : 0 : }
5377 : :
5378 : 0 : void __weak arch_perf_update_userpage(
5379 : : struct perf_event *event, struct perf_event_mmap_page *userpg, u64 now)
5380 : : {
5381 : 0 : }
5382 : :
5383 : : /*
5384 : : * Callers need to ensure there can be no nesting of this function, otherwise
5385 : : * the seqlock logic goes bad. We can not serialize this because the arch
5386 : : * code calls this from NMI context.
5387 : : */
5388 : 0 : void perf_event_update_userpage(struct perf_event *event)
5389 : : {
5390 : : struct perf_event_mmap_page *userpg;
5391 : : struct ring_buffer *rb;
5392 : : u64 enabled, running, now;
5393 : :
5394 : : rcu_read_lock();
5395 : 0 : rb = rcu_dereference(event->rb);
5396 [ # # ]: 0 : if (!rb)
5397 : : goto unlock;
5398 : :
5399 : : /*
5400 : : * compute total_time_enabled, total_time_running
5401 : : * based on snapshot values taken when the event
5402 : : * was last scheduled in.
5403 : : *
5404 : : * we cannot simply called update_context_time()
5405 : : * because of locking issue as we can be called in
5406 : : * NMI context
5407 : : */
5408 : 0 : calc_timer_values(event, &now, &enabled, &running);
5409 : :
5410 : 0 : userpg = rb->user_page;
5411 : : /*
5412 : : * Disable preemption to guarantee consistent time stamps are stored to
5413 : : * the user page.
5414 : : */
5415 : 0 : preempt_disable();
5416 : 0 : ++userpg->lock;
5417 : 0 : barrier();
5418 : 0 : userpg->index = perf_event_index(event);
5419 : 0 : userpg->offset = perf_event_count(event);
5420 [ # # ]: 0 : if (userpg->index)
5421 : 0 : userpg->offset -= local64_read(&event->hw.prev_count);
5422 : :
5423 : 0 : userpg->time_enabled = enabled +
5424 : 0 : atomic64_read(&event->child_total_time_enabled);
5425 : :
5426 : 0 : userpg->time_running = running +
5427 : 0 : atomic64_read(&event->child_total_time_running);
5428 : :
5429 : 0 : arch_perf_update_userpage(event, userpg, now);
5430 : :
5431 : 0 : barrier();
5432 : 0 : ++userpg->lock;
5433 : 0 : preempt_enable();
5434 : : unlock:
5435 : : rcu_read_unlock();
5436 : 0 : }
5437 : : EXPORT_SYMBOL_GPL(perf_event_update_userpage);
5438 : :
5439 : 0 : static vm_fault_t perf_mmap_fault(struct vm_fault *vmf)
5440 : : {
5441 : 0 : struct perf_event *event = vmf->vma->vm_file->private_data;
5442 : : struct ring_buffer *rb;
5443 : : vm_fault_t ret = VM_FAULT_SIGBUS;
5444 : :
5445 [ # # ]: 0 : if (vmf->flags & FAULT_FLAG_MKWRITE) {
5446 [ # # ]: 0 : if (vmf->pgoff == 0)
5447 : : ret = 0;
5448 : 0 : return ret;
5449 : : }
5450 : :
5451 : : rcu_read_lock();
5452 : 0 : rb = rcu_dereference(event->rb);
5453 [ # # ]: 0 : if (!rb)
5454 : : goto unlock;
5455 : :
5456 [ # # # # ]: 0 : if (vmf->pgoff && (vmf->flags & FAULT_FLAG_WRITE))
5457 : : goto unlock;
5458 : :
5459 : 0 : vmf->page = perf_mmap_to_page(rb, vmf->pgoff);
5460 [ # # ]: 0 : if (!vmf->page)
5461 : : goto unlock;
5462 : :
5463 : 0 : get_page(vmf->page);
5464 : 0 : vmf->page->mapping = vmf->vma->vm_file->f_mapping;
5465 : 0 : vmf->page->index = vmf->pgoff;
5466 : :
5467 : : ret = 0;
5468 : : unlock:
5469 : : rcu_read_unlock();
5470 : :
5471 : 0 : return ret;
5472 : : }
5473 : :
5474 : 0 : static void ring_buffer_attach(struct perf_event *event,
5475 : : struct ring_buffer *rb)
5476 : : {
5477 : : struct ring_buffer *old_rb = NULL;
5478 : : unsigned long flags;
5479 : :
5480 [ # # ]: 0 : if (event->rb) {
5481 : : /*
5482 : : * Should be impossible, we set this when removing
5483 : : * event->rb_entry and wait/clear when adding event->rb_entry.
5484 : : */
5485 [ # # # # ]: 0 : WARN_ON_ONCE(event->rcu_pending);
5486 : :
5487 : 0 : old_rb = event->rb;
5488 : 0 : spin_lock_irqsave(&old_rb->event_lock, flags);
5489 : : list_del_rcu(&event->rb_entry);
5490 : : spin_unlock_irqrestore(&old_rb->event_lock, flags);
5491 : :
5492 : 0 : event->rcu_batches = get_state_synchronize_rcu();
5493 : 0 : event->rcu_pending = 1;
5494 : : }
5495 : :
5496 [ # # ]: 0 : if (rb) {
5497 [ # # ]: 0 : if (event->rcu_pending) {
5498 : 0 : cond_synchronize_rcu(event->rcu_batches);
5499 : 0 : event->rcu_pending = 0;
5500 : : }
5501 : :
5502 : 0 : spin_lock_irqsave(&rb->event_lock, flags);
5503 : 0 : list_add_rcu(&event->rb_entry, &rb->event_list);
5504 : : spin_unlock_irqrestore(&rb->event_lock, flags);
5505 : : }
5506 : :
5507 : : /*
5508 : : * Avoid racing with perf_mmap_close(AUX): stop the event
5509 : : * before swizzling the event::rb pointer; if it's getting
5510 : : * unmapped, its aux_mmap_count will be 0 and it won't
5511 : : * restart. See the comment in __perf_pmu_output_stop().
5512 : : *
5513 : : * Data will inevitably be lost when set_output is done in
5514 : : * mid-air, but then again, whoever does it like this is
5515 : : * not in for the data anyway.
5516 : : */
5517 [ # # ]: 0 : if (has_aux(event))
5518 : 0 : perf_event_stop(event, 0);
5519 : :
5520 : 0 : rcu_assign_pointer(event->rb, rb);
5521 : :
5522 [ # # ]: 0 : if (old_rb) {
5523 : 0 : ring_buffer_put(old_rb);
5524 : : /*
5525 : : * Since we detached before setting the new rb, so that we
5526 : : * could attach the new rb, we could have missed a wakeup.
5527 : : * Provide it now.
5528 : : */
5529 : 0 : wake_up_all(&event->waitq);
5530 : : }
5531 : 0 : }
5532 : :
5533 : 0 : static void ring_buffer_wakeup(struct perf_event *event)
5534 : : {
5535 : : struct ring_buffer *rb;
5536 : :
5537 : : rcu_read_lock();
5538 : 0 : rb = rcu_dereference(event->rb);
5539 [ # # ]: 0 : if (rb) {
5540 [ # # ]: 0 : list_for_each_entry_rcu(event, &rb->event_list, rb_entry)
5541 : 0 : wake_up_all(&event->waitq);
5542 : : }
5543 : : rcu_read_unlock();
5544 : 0 : }
5545 : :
5546 : 0 : struct ring_buffer *ring_buffer_get(struct perf_event *event)
5547 : : {
5548 : : struct ring_buffer *rb;
5549 : :
5550 : : rcu_read_lock();
5551 : 0 : rb = rcu_dereference(event->rb);
5552 [ # # ]: 0 : if (rb) {
5553 [ # # ]: 0 : if (!refcount_inc_not_zero(&rb->refcount))
5554 : : rb = NULL;
5555 : : }
5556 : : rcu_read_unlock();
5557 : :
5558 : 0 : return rb;
5559 : : }
5560 : :
5561 : 0 : void ring_buffer_put(struct ring_buffer *rb)
5562 : : {
5563 [ # # ]: 0 : if (!refcount_dec_and_test(&rb->refcount))
5564 : 0 : return;
5565 : :
5566 [ # # # # ]: 0 : WARN_ON_ONCE(!list_empty(&rb->event_list));
5567 : :
5568 : 0 : call_rcu(&rb->rcu_head, rb_free_rcu);
5569 : : }
5570 : :
5571 : 0 : static void perf_mmap_open(struct vm_area_struct *vma)
5572 : : {
5573 : 0 : struct perf_event *event = vma->vm_file->private_data;
5574 : :
5575 : 0 : atomic_inc(&event->mmap_count);
5576 : 0 : atomic_inc(&event->rb->mmap_count);
5577 : :
5578 [ # # ]: 0 : if (vma->vm_pgoff)
5579 : 0 : atomic_inc(&event->rb->aux_mmap_count);
5580 : :
5581 [ # # ]: 0 : if (event->pmu->event_mapped)
5582 : 0 : event->pmu->event_mapped(event, vma->vm_mm);
5583 : 0 : }
5584 : :
5585 : : static void perf_pmu_output_stop(struct perf_event *event);
5586 : :
5587 : : /*
5588 : : * A buffer can be mmap()ed multiple times; either directly through the same
5589 : : * event, or through other events by use of perf_event_set_output().
5590 : : *
5591 : : * In order to undo the VM accounting done by perf_mmap() we need to destroy
5592 : : * the buffer here, where we still have a VM context. This means we need
5593 : : * to detach all events redirecting to us.
5594 : : */
5595 : 0 : static void perf_mmap_close(struct vm_area_struct *vma)
5596 : : {
5597 : 0 : struct perf_event *event = vma->vm_file->private_data;
5598 : :
5599 : 0 : struct ring_buffer *rb = ring_buffer_get(event);
5600 : 0 : struct user_struct *mmap_user = rb->mmap_user;
5601 : 0 : int mmap_locked = rb->mmap_locked;
5602 : : unsigned long size = perf_data_size(rb);
5603 : :
5604 [ # # ]: 0 : if (event->pmu->event_unmapped)
5605 : 0 : event->pmu->event_unmapped(event, vma->vm_mm);
5606 : :
5607 : : /*
5608 : : * rb->aux_mmap_count will always drop before rb->mmap_count and
5609 : : * event->mmap_count, so it is ok to use event->mmap_mutex to
5610 : : * serialize with perf_mmap here.
5611 : : */
5612 [ # # # # : 0 : if (rb_has_aux(rb) && vma->vm_pgoff == rb->aux_pgoff &&
# # ]
5613 : 0 : atomic_dec_and_mutex_lock(&rb->aux_mmap_count, &event->mmap_mutex)) {
5614 : : /*
5615 : : * Stop all AUX events that are writing to this buffer,
5616 : : * so that we can free its AUX pages and corresponding PMU
5617 : : * data. Note that after rb::aux_mmap_count dropped to zero,
5618 : : * they won't start any more (see perf_aux_output_begin()).
5619 : : */
5620 : 0 : perf_pmu_output_stop(event);
5621 : :
5622 : : /* now it's safe to free the pages */
5623 : 0 : atomic_long_sub(rb->aux_nr_pages - rb->aux_mmap_locked, &mmap_user->locked_vm);
5624 : 0 : atomic64_sub(rb->aux_mmap_locked, &vma->vm_mm->pinned_vm);
5625 : :
5626 : : /* this has to be the last one */
5627 : 0 : rb_free_aux(rb);
5628 [ # # # # ]: 0 : WARN_ON_ONCE(refcount_read(&rb->aux_refcount));
5629 : :
5630 : 0 : mutex_unlock(&event->mmap_mutex);
5631 : : }
5632 : :
5633 : 0 : atomic_dec(&rb->mmap_count);
5634 : :
5635 [ # # ]: 0 : if (!atomic_dec_and_mutex_lock(&event->mmap_count, &event->mmap_mutex))
5636 : : goto out_put;
5637 : :
5638 : 0 : ring_buffer_attach(event, NULL);
5639 : 0 : mutex_unlock(&event->mmap_mutex);
5640 : :
5641 : : /* If there's still other mmap()s of this buffer, we're done. */
5642 [ # # ]: 0 : if (atomic_read(&rb->mmap_count))
5643 : : goto out_put;
5644 : :
5645 : : /*
5646 : : * No other mmap()s, detach from all other events that might redirect
5647 : : * into the now unreachable buffer. Somewhat complicated by the
5648 : : * fact that rb::event_lock otherwise nests inside mmap_mutex.
5649 : : */
5650 : : again:
5651 : : rcu_read_lock();
5652 [ # # ]: 0 : list_for_each_entry_rcu(event, &rb->event_list, rb_entry) {
5653 [ # # ]: 0 : if (!atomic_long_inc_not_zero(&event->refcount)) {
5654 : : /*
5655 : : * This event is en-route to free_event() which will
5656 : : * detach it and remove it from the list.
5657 : : */
5658 : 0 : continue;
5659 : : }
5660 : : rcu_read_unlock();
5661 : :
5662 : 0 : mutex_lock(&event->mmap_mutex);
5663 : : /*
5664 : : * Check we didn't race with perf_event_set_output() which can
5665 : : * swizzle the rb from under us while we were waiting to
5666 : : * acquire mmap_mutex.
5667 : : *
5668 : : * If we find a different rb; ignore this event, a next
5669 : : * iteration will no longer find it on the list. We have to
5670 : : * still restart the iteration to make sure we're not now
5671 : : * iterating the wrong list.
5672 : : */
5673 [ # # ]: 0 : if (event->rb == rb)
5674 : 0 : ring_buffer_attach(event, NULL);
5675 : :
5676 : 0 : mutex_unlock(&event->mmap_mutex);
5677 : 0 : put_event(event);
5678 : :
5679 : : /*
5680 : : * Restart the iteration; either we're on the wrong list or
5681 : : * destroyed its integrity by doing a deletion.
5682 : : */
5683 : 0 : goto again;
5684 : : }
5685 : : rcu_read_unlock();
5686 : :
5687 : : /*
5688 : : * It could be there's still a few 0-ref events on the list; they'll
5689 : : * get cleaned up by free_event() -- they'll also still have their
5690 : : * ref on the rb and will free it whenever they are done with it.
5691 : : *
5692 : : * Aside from that, this buffer is 'fully' detached and unmapped,
5693 : : * undo the VM accounting.
5694 : : */
5695 : :
5696 : 0 : atomic_long_sub((size >> PAGE_SHIFT) + 1 - mmap_locked,
5697 : : &mmap_user->locked_vm);
5698 : 0 : atomic64_sub(mmap_locked, &vma->vm_mm->pinned_vm);
5699 : 0 : free_uid(mmap_user);
5700 : :
5701 : : out_put:
5702 : 0 : ring_buffer_put(rb); /* could be last */
5703 : 0 : }
5704 : :
5705 : : static const struct vm_operations_struct perf_mmap_vmops = {
5706 : : .open = perf_mmap_open,
5707 : : .close = perf_mmap_close, /* non mergeable */
5708 : : .fault = perf_mmap_fault,
5709 : : .page_mkwrite = perf_mmap_fault,
5710 : : };
5711 : :
5712 : 0 : static int perf_mmap(struct file *file, struct vm_area_struct *vma)
5713 : : {
5714 : 0 : struct perf_event *event = file->private_data;
5715 : : unsigned long user_locked, user_lock_limit;
5716 : 0 : struct user_struct *user = current_user();
5717 : : unsigned long locked, lock_limit;
5718 : : struct ring_buffer *rb = NULL;
5719 : : unsigned long vma_size;
5720 : : unsigned long nr_pages;
5721 : : long user_extra = 0, extra = 0;
5722 : : int ret = 0, flags = 0;
5723 : :
5724 : : /*
5725 : : * Don't allow mmap() of inherited per-task counters. This would
5726 : : * create a performance issue due to all children writing to the
5727 : : * same rb.
5728 : : */
5729 [ # # # # ]: 0 : if (event->cpu == -1 && event->attr.inherit)
5730 : : return -EINVAL;
5731 : :
5732 [ # # ]: 0 : if (!(vma->vm_flags & VM_SHARED))
5733 : : return -EINVAL;
5734 : :
5735 : 0 : vma_size = vma->vm_end - vma->vm_start;
5736 : :
5737 [ # # ]: 0 : if (vma->vm_pgoff == 0) {
5738 : 0 : nr_pages = (vma_size / PAGE_SIZE) - 1;
5739 : : } else {
5740 : : /*
5741 : : * AUX area mapping: if rb->aux_nr_pages != 0, it's already
5742 : : * mapped, all subsequent mappings should have the same size
5743 : : * and offset. Must be above the normal perf buffer.
5744 : : */
5745 : : u64 aux_offset, aux_size;
5746 : :
5747 [ # # ]: 0 : if (!event->rb)
5748 : : return -EINVAL;
5749 : :
5750 : 0 : nr_pages = vma_size / PAGE_SIZE;
5751 : :
5752 : 0 : mutex_lock(&event->mmap_mutex);
5753 : : ret = -EINVAL;
5754 : :
5755 : 0 : rb = event->rb;
5756 [ # # ]: 0 : if (!rb)
5757 : : goto aux_unlock;
5758 : :
5759 : 0 : aux_offset = READ_ONCE(rb->user_page->aux_offset);
5760 : : aux_size = READ_ONCE(rb->user_page->aux_size);
5761 : :
5762 [ # # ]: 0 : if (aux_offset < perf_data_size(rb) + PAGE_SIZE)
5763 : : goto aux_unlock;
5764 : :
5765 [ # # ]: 0 : if (aux_offset != vma->vm_pgoff << PAGE_SHIFT)
5766 : : goto aux_unlock;
5767 : :
5768 : : /* already mapped with a different offset */
5769 [ # # # # ]: 0 : if (rb_has_aux(rb) && rb->aux_pgoff != vma->vm_pgoff)
5770 : : goto aux_unlock;
5771 : :
5772 [ # # # # ]: 0 : if (aux_size != vma_size || aux_size != nr_pages * PAGE_SIZE)
5773 : : goto aux_unlock;
5774 : :
5775 : : /* already mapped with a different size */
5776 [ # # # # ]: 0 : if (rb_has_aux(rb) && rb->aux_nr_pages != nr_pages)
5777 : : goto aux_unlock;
5778 : :
5779 [ # # ]: 0 : if (!is_power_of_2(nr_pages))
5780 : : goto aux_unlock;
5781 : :
5782 [ # # ]: 0 : if (!atomic_inc_not_zero(&rb->mmap_count))
5783 : : goto aux_unlock;
5784 : :
5785 [ # # ]: 0 : if (rb_has_aux(rb)) {
5786 : 0 : atomic_inc(&rb->aux_mmap_count);
5787 : : ret = 0;
5788 : 0 : goto unlock;
5789 : : }
5790 : :
5791 : : atomic_set(&rb->aux_mmap_count, 1);
5792 : 0 : user_extra = nr_pages;
5793 : :
5794 : 0 : goto accounting;
5795 : : }
5796 : :
5797 : : /*
5798 : : * If we have rb pages ensure they're a power-of-two number, so we
5799 : : * can do bitmasks instead of modulo.
5800 : : */
5801 [ # # # # ]: 0 : if (nr_pages != 0 && !is_power_of_2(nr_pages))
5802 : : return -EINVAL;
5803 : :
5804 [ # # ]: 0 : if (vma_size != PAGE_SIZE * (1 + nr_pages))
5805 : : return -EINVAL;
5806 : :
5807 [ # # # # ]: 0 : WARN_ON_ONCE(event->ctx->parent_ctx);
5808 : : again:
5809 : 0 : mutex_lock(&event->mmap_mutex);
5810 [ # # ]: 0 : if (event->rb) {
5811 [ # # ]: 0 : if (event->rb->nr_pages != nr_pages) {
5812 : : ret = -EINVAL;
5813 : : goto unlock;
5814 : : }
5815 : :
5816 [ # # ]: 0 : if (!atomic_inc_not_zero(&event->rb->mmap_count)) {
5817 : : /*
5818 : : * Raced against perf_mmap_close() through
5819 : : * perf_event_set_output(). Try again, hope for better
5820 : : * luck.
5821 : : */
5822 : 0 : mutex_unlock(&event->mmap_mutex);
5823 : 0 : goto again;
5824 : : }
5825 : :
5826 : : goto unlock;
5827 : : }
5828 : :
5829 : 0 : user_extra = nr_pages + 1;
5830 : :
5831 : : accounting:
5832 : 0 : user_lock_limit = sysctl_perf_event_mlock >> (PAGE_SHIFT - 10);
5833 : :
5834 : : /*
5835 : : * Increase the limit linearly with more CPUs:
5836 : : */
5837 : 0 : user_lock_limit *= num_online_cpus();
5838 : :
5839 : 0 : user_locked = atomic_long_read(&user->locked_vm);
5840 : :
5841 : : /*
5842 : : * sysctl_perf_event_mlock may have changed, so that
5843 : : * user->locked_vm > user_lock_limit
5844 : : */
5845 [ # # ]: 0 : if (user_locked > user_lock_limit)
5846 : : user_locked = user_lock_limit;
5847 : 0 : user_locked += user_extra;
5848 : :
5849 [ # # ]: 0 : if (user_locked <= user_lock_limit) {
5850 : : /* charge all to locked_vm */
5851 [ # # ]: 0 : } else if (atomic_long_read(&user->locked_vm) >= user_lock_limit) {
5852 : : /* charge all to pinned_vm */
5853 : : extra = user_extra;
5854 : : user_extra = 0;
5855 : : } else {
5856 : : /*
5857 : : * charge locked_vm until it hits user_lock_limit;
5858 : : * charge the rest from pinned_vm
5859 : : */
5860 : 0 : extra = user_locked - user_lock_limit;
5861 : 0 : user_extra -= extra;
5862 : : }
5863 : :
5864 : : lock_limit = rlimit(RLIMIT_MEMLOCK);
5865 : 0 : lock_limit >>= PAGE_SHIFT;
5866 : 0 : locked = atomic64_read(&vma->vm_mm->pinned_vm) + extra;
5867 : :
5868 [ # # # # : 0 : if ((locked > lock_limit) && perf_paranoid_tracepoint_raw() &&
# # ]
5869 : 0 : !capable(CAP_IPC_LOCK)) {
5870 : : ret = -EPERM;
5871 : : goto unlock;
5872 : : }
5873 : :
5874 [ # # # # : 0 : WARN_ON(!rb && event->rb);
# # ]
5875 : :
5876 [ # # ]: 0 : if (vma->vm_flags & VM_WRITE)
5877 : : flags |= RING_BUFFER_WRITABLE;
5878 : :
5879 [ # # ]: 0 : if (!rb) {
5880 [ # # ]: 0 : rb = rb_alloc(nr_pages,
5881 : 0 : event->attr.watermark ? event->attr.wakeup_watermark : 0,
5882 : : event->cpu, flags);
5883 : :
5884 [ # # ]: 0 : if (!rb) {
5885 : : ret = -ENOMEM;
5886 : : goto unlock;
5887 : : }
5888 : :
5889 : : atomic_set(&rb->mmap_count, 1);
5890 : 0 : rb->mmap_user = get_current_user();
5891 : 0 : rb->mmap_locked = extra;
5892 : :
5893 : 0 : ring_buffer_attach(event, rb);
5894 : :
5895 : 0 : perf_event_init_userpage(event);
5896 : 0 : perf_event_update_userpage(event);
5897 : : } else {
5898 : 0 : ret = rb_alloc_aux(rb, event, vma->vm_pgoff, nr_pages,
5899 : 0 : event->attr.aux_watermark, flags);
5900 [ # # ]: 0 : if (!ret)
5901 : 0 : rb->aux_mmap_locked = extra;
5902 : : }
5903 : :
5904 : : unlock:
5905 [ # # ]: 0 : if (!ret) {
5906 : 0 : atomic_long_add(user_extra, &user->locked_vm);
5907 : 0 : atomic64_add(extra, &vma->vm_mm->pinned_vm);
5908 : :
5909 : 0 : atomic_inc(&event->mmap_count);
5910 [ # # ]: 0 : } else if (rb) {
5911 : 0 : atomic_dec(&rb->mmap_count);
5912 : : }
5913 : : aux_unlock:
5914 : 0 : mutex_unlock(&event->mmap_mutex);
5915 : :
5916 : : /*
5917 : : * Since pinned accounting is per vm we cannot allow fork() to copy our
5918 : : * vma.
5919 : : */
5920 : 0 : vma->vm_flags |= VM_DONTCOPY | VM_DONTEXPAND | VM_DONTDUMP;
5921 : 0 : vma->vm_ops = &perf_mmap_vmops;
5922 : :
5923 [ # # ]: 0 : if (event->pmu->event_mapped)
5924 : 0 : event->pmu->event_mapped(event, vma->vm_mm);
5925 : :
5926 : 0 : return ret;
5927 : : }
5928 : :
5929 : 0 : static int perf_fasync(int fd, struct file *filp, int on)
5930 : : {
5931 : : struct inode *inode = file_inode(filp);
5932 : 0 : struct perf_event *event = filp->private_data;
5933 : : int retval;
5934 : :
5935 : : inode_lock(inode);
5936 : 0 : retval = fasync_helper(fd, filp, on, &event->fasync);
5937 : : inode_unlock(inode);
5938 : :
5939 [ # # ]: 0 : if (retval < 0)
5940 : 0 : return retval;
5941 : :
5942 : : return 0;
5943 : : }
5944 : :
5945 : : static const struct file_operations perf_fops = {
5946 : : .llseek = no_llseek,
5947 : : .release = perf_release,
5948 : : .read = perf_read,
5949 : : .poll = perf_poll,
5950 : : .unlocked_ioctl = perf_ioctl,
5951 : : .compat_ioctl = perf_compat_ioctl,
5952 : : .mmap = perf_mmap,
5953 : : .fasync = perf_fasync,
5954 : : };
5955 : :
5956 : : /*
5957 : : * Perf event wakeup
5958 : : *
5959 : : * If there's data, ensure we set the poll() state and publish everything
5960 : : * to user-space before waking everybody up.
5961 : : */
5962 : :
5963 : : static inline struct fasync_struct **perf_event_fasync(struct perf_event *event)
5964 : : {
5965 : : /* only the parent has fasync state */
5966 [ # # # # ]: 0 : if (event->parent)
5967 : : event = event->parent;
5968 : 0 : return &event->fasync;
5969 : : }
5970 : :
5971 : 0 : void perf_event_wakeup(struct perf_event *event)
5972 : : {
5973 : 0 : ring_buffer_wakeup(event);
5974 : :
5975 [ # # ]: 0 : if (event->pending_kill) {
5976 : 0 : kill_fasync(perf_event_fasync(event), SIGIO, event->pending_kill);
5977 : 0 : event->pending_kill = 0;
5978 : : }
5979 : 0 : }
5980 : :
5981 : 0 : static void perf_pending_event_disable(struct perf_event *event)
5982 : : {
5983 : 0 : int cpu = READ_ONCE(event->pending_disable);
5984 : :
5985 [ # # ]: 0 : if (cpu < 0)
5986 : : return;
5987 : :
5988 [ # # ]: 0 : if (cpu == smp_processor_id()) {
5989 : : WRITE_ONCE(event->pending_disable, -1);
5990 : : perf_event_disable_local(event);
5991 : : return;
5992 : : }
5993 : :
5994 : : /*
5995 : : * CPU-A CPU-B
5996 : : *
5997 : : * perf_event_disable_inatomic()
5998 : : * @pending_disable = CPU-A;
5999 : : * irq_work_queue();
6000 : : *
6001 : : * sched-out
6002 : : * @pending_disable = -1;
6003 : : *
6004 : : * sched-in
6005 : : * perf_event_disable_inatomic()
6006 : : * @pending_disable = CPU-B;
6007 : : * irq_work_queue(); // FAILS
6008 : : *
6009 : : * irq_work_run()
6010 : : * perf_pending_event()
6011 : : *
6012 : : * But the event runs on CPU-B and wants disabling there.
6013 : : */
6014 : 0 : irq_work_queue_on(&event->pending, cpu);
6015 : : }
6016 : :
6017 : 0 : static void perf_pending_event(struct irq_work *entry)
6018 : : {
6019 : 0 : struct perf_event *event = container_of(entry, struct perf_event, pending);
6020 : : int rctx;
6021 : :
6022 : : rctx = perf_swevent_get_recursion_context();
6023 : : /*
6024 : : * If we 'fail' here, that's OK, it means recursion is already disabled
6025 : : * and we won't recurse 'further'.
6026 : : */
6027 : :
6028 : 0 : perf_pending_event_disable(event);
6029 : :
6030 [ # # ]: 0 : if (event->pending_wakeup) {
6031 : 0 : event->pending_wakeup = 0;
6032 : 0 : perf_event_wakeup(event);
6033 : : }
6034 : :
6035 [ # # ]: 0 : if (rctx >= 0)
6036 : : perf_swevent_put_recursion_context(rctx);
6037 : 0 : }
6038 : :
6039 : : /*
6040 : : * We assume there is only KVM supporting the callbacks.
6041 : : * Later on, we might change it to a list if there is
6042 : : * another virtualization implementation supporting the callbacks.
6043 : : */
6044 : : struct perf_guest_info_callbacks *perf_guest_cbs;
6045 : :
6046 : 0 : int perf_register_guest_info_callbacks(struct perf_guest_info_callbacks *cbs)
6047 : : {
6048 : 0 : perf_guest_cbs = cbs;
6049 : 0 : return 0;
6050 : : }
6051 : : EXPORT_SYMBOL_GPL(perf_register_guest_info_callbacks);
6052 : :
6053 : 0 : int perf_unregister_guest_info_callbacks(struct perf_guest_info_callbacks *cbs)
6054 : : {
6055 : 0 : perf_guest_cbs = NULL;
6056 : 0 : return 0;
6057 : : }
6058 : : EXPORT_SYMBOL_GPL(perf_unregister_guest_info_callbacks);
6059 : :
6060 : : static void
6061 : 0 : perf_output_sample_regs(struct perf_output_handle *handle,
6062 : : struct pt_regs *regs, u64 mask)
6063 : : {
6064 : : int bit;
6065 : : DECLARE_BITMAP(_mask, 64);
6066 : :
6067 : : bitmap_from_u64(_mask, mask);
6068 [ # # ]: 0 : for_each_set_bit(bit, _mask, sizeof(mask) * BITS_PER_BYTE) {
6069 : : u64 val;
6070 : :
6071 : 0 : val = perf_reg_value(regs, bit);
6072 : 0 : perf_output_put(handle, val);
6073 : : }
6074 : 0 : }
6075 : :
6076 : 0 : static void perf_sample_regs_user(struct perf_regs *regs_user,
6077 : : struct pt_regs *regs,
6078 : : struct pt_regs *regs_user_copy)
6079 : : {
6080 [ # # ]: 0 : if (user_mode(regs)) {
6081 : 0 : regs_user->abi = perf_reg_abi(current);
6082 : 0 : regs_user->regs = regs;
6083 [ # # ]: 0 : } else if (!(current->flags & PF_KTHREAD)) {
6084 : 0 : perf_get_regs_user(regs_user, regs, regs_user_copy);
6085 : : } else {
6086 : 0 : regs_user->abi = PERF_SAMPLE_REGS_ABI_NONE;
6087 : 0 : regs_user->regs = NULL;
6088 : : }
6089 : 0 : }
6090 : :
6091 : 0 : static void perf_sample_regs_intr(struct perf_regs *regs_intr,
6092 : : struct pt_regs *regs)
6093 : : {
6094 : 0 : regs_intr->regs = regs;
6095 : 0 : regs_intr->abi = perf_reg_abi(current);
6096 : 0 : }
6097 : :
6098 : :
6099 : : /*
6100 : : * Get remaining task size from user stack pointer.
6101 : : *
6102 : : * It'd be better to take stack vma map and limit this more
6103 : : * precisely, but there's no way to get it safely under interrupt,
6104 : : * so using TASK_SIZE as limit.
6105 : : */
6106 : : static u64 perf_ustack_task_size(struct pt_regs *regs)
6107 : : {
6108 : : unsigned long addr = perf_user_stack_pointer(regs);
6109 : :
6110 [ # # ]: 0 : if (!addr || addr >= TASK_SIZE)
6111 : : return 0;
6112 : :
6113 : 0 : return TASK_SIZE - addr;
6114 : : }
6115 : :
6116 : : static u16
6117 : 0 : perf_sample_ustack_size(u16 stack_size, u16 header_size,
6118 : : struct pt_regs *regs)
6119 : : {
6120 : : u64 task_size;
6121 : :
6122 : : /* No regs, no stack pointer, no dump. */
6123 [ # # ]: 0 : if (!regs)
6124 : : return 0;
6125 : :
6126 : : /*
6127 : : * Check if we fit in with the requested stack size into the:
6128 : : * - TASK_SIZE
6129 : : * If we don't, we limit the size to the TASK_SIZE.
6130 : : *
6131 : : * - remaining sample size
6132 : : * If we don't, we customize the stack size to
6133 : : * fit in to the remaining sample size.
6134 : : */
6135 : :
6136 : 0 : task_size = min((u64) USHRT_MAX, perf_ustack_task_size(regs));
6137 [ # # ]: 0 : stack_size = min(stack_size, (u16) task_size);
6138 : :
6139 : : /* Current header size plus static size and dynamic size. */
6140 : 0 : header_size += 2 * sizeof(u64);
6141 : :
6142 : : /* Do we fit in with the current stack dump size? */
6143 [ # # ]: 0 : if ((u16) (header_size + stack_size) < header_size) {
6144 : : /*
6145 : : * If we overflow the maximum size for the sample,
6146 : : * we customize the stack dump size to fit in.
6147 : : */
6148 : : stack_size = USHRT_MAX - header_size - sizeof(u64);
6149 : 0 : stack_size = round_up(stack_size, sizeof(u64));
6150 : : }
6151 : :
6152 : 0 : return stack_size;
6153 : : }
6154 : :
6155 : : static void
6156 : 0 : perf_output_sample_ustack(struct perf_output_handle *handle, u64 dump_size,
6157 : : struct pt_regs *regs)
6158 : : {
6159 : : /* Case of a kernel thread, nothing to dump */
6160 [ # # ]: 0 : if (!regs) {
6161 : 0 : u64 size = 0;
6162 : 0 : perf_output_put(handle, size);
6163 : : } else {
6164 : : unsigned long sp;
6165 : : unsigned int rem;
6166 : : u64 dyn_size;
6167 : : mm_segment_t fs;
6168 : :
6169 : : /*
6170 : : * We dump:
6171 : : * static size
6172 : : * - the size requested by user or the best one we can fit
6173 : : * in to the sample max size
6174 : : * data
6175 : : * - user stack dump data
6176 : : * dynamic size
6177 : : * - the actual dumped size
6178 : : */
6179 : :
6180 : : /* Static size. */
6181 : 0 : perf_output_put(handle, dump_size);
6182 : :
6183 : : /* Data. */
6184 : : sp = perf_user_stack_pointer(regs);
6185 : 0 : fs = get_fs();
6186 : : set_fs(USER_DS);
6187 : 0 : rem = __output_copy_user(handle, (void *) sp, dump_size);
6188 : : set_fs(fs);
6189 : 0 : dyn_size = dump_size - rem;
6190 : :
6191 : 0 : perf_output_skip(handle, rem);
6192 : :
6193 : : /* Dynamic size. */
6194 : 0 : perf_output_put(handle, dyn_size);
6195 : : }
6196 : 0 : }
6197 : :
6198 : 0 : static void __perf_event_header__init_id(struct perf_event_header *header,
6199 : : struct perf_sample_data *data,
6200 : : struct perf_event *event)
6201 : : {
6202 : 0 : u64 sample_type = event->attr.sample_type;
6203 : :
6204 : 0 : data->type = sample_type;
6205 : 0 : header->size += event->id_header_size;
6206 : :
6207 [ # # ]: 0 : if (sample_type & PERF_SAMPLE_TID) {
6208 : : /* namespace issues */
6209 : 0 : data->tid_entry.pid = perf_event_pid(event, current);
6210 : 0 : data->tid_entry.tid = perf_event_tid(event, current);
6211 : : }
6212 : :
6213 [ # # ]: 0 : if (sample_type & PERF_SAMPLE_TIME)
6214 : 0 : data->time = perf_event_clock(event);
6215 : :
6216 [ # # ]: 0 : if (sample_type & (PERF_SAMPLE_ID | PERF_SAMPLE_IDENTIFIER))
6217 : 0 : data->id = primary_event_id(event);
6218 : :
6219 [ # # ]: 0 : if (sample_type & PERF_SAMPLE_STREAM_ID)
6220 : 0 : data->stream_id = event->id;
6221 : :
6222 [ # # ]: 0 : if (sample_type & PERF_SAMPLE_CPU) {
6223 : 0 : data->cpu_entry.cpu = raw_smp_processor_id();
6224 : 0 : data->cpu_entry.reserved = 0;
6225 : : }
6226 : 0 : }
6227 : :
6228 : 0 : void perf_event_header__init_id(struct perf_event_header *header,
6229 : : struct perf_sample_data *data,
6230 : : struct perf_event *event)
6231 : : {
6232 [ # # # # : 0 : if (event->attr.sample_id_all)
# # # # #
# # # # #
# # # # #
# # # # #
# # ]
6233 : 0 : __perf_event_header__init_id(header, data, event);
6234 : 0 : }
6235 : :
6236 : 0 : static void __perf_event__output_id_sample(struct perf_output_handle *handle,
6237 : : struct perf_sample_data *data)
6238 : : {
6239 : 0 : u64 sample_type = data->type;
6240 : :
6241 [ # # ]: 0 : if (sample_type & PERF_SAMPLE_TID)
6242 : 0 : perf_output_put(handle, data->tid_entry);
6243 : :
6244 [ # # ]: 0 : if (sample_type & PERF_SAMPLE_TIME)
6245 : 0 : perf_output_put(handle, data->time);
6246 : :
6247 [ # # ]: 0 : if (sample_type & PERF_SAMPLE_ID)
6248 : 0 : perf_output_put(handle, data->id);
6249 : :
6250 [ # # ]: 0 : if (sample_type & PERF_SAMPLE_STREAM_ID)
6251 : 0 : perf_output_put(handle, data->stream_id);
6252 : :
6253 [ # # ]: 0 : if (sample_type & PERF_SAMPLE_CPU)
6254 : 0 : perf_output_put(handle, data->cpu_entry);
6255 : :
6256 [ # # ]: 0 : if (sample_type & PERF_SAMPLE_IDENTIFIER)
6257 : 0 : perf_output_put(handle, data->id);
6258 : 0 : }
6259 : :
6260 : 0 : void perf_event__output_id_sample(struct perf_event *event,
6261 : : struct perf_output_handle *handle,
6262 : : struct perf_sample_data *sample)
6263 : : {
6264 [ # # # # : 0 : if (event->attr.sample_id_all)
# # # # #
# # # # #
# # # # #
# # # # #
# # ]
6265 : 0 : __perf_event__output_id_sample(handle, sample);
6266 : 0 : }
6267 : :
6268 : 0 : static void perf_output_read_one(struct perf_output_handle *handle,
6269 : : struct perf_event *event,
6270 : : u64 enabled, u64 running)
6271 : : {
6272 : 0 : u64 read_format = event->attr.read_format;
6273 : : u64 values[4];
6274 : : int n = 0;
6275 : :
6276 : 0 : values[n++] = perf_event_count(event);
6277 [ # # ]: 0 : if (read_format & PERF_FORMAT_TOTAL_TIME_ENABLED) {
6278 : 0 : values[n++] = enabled +
6279 : 0 : atomic64_read(&event->child_total_time_enabled);
6280 : : }
6281 [ # # ]: 0 : if (read_format & PERF_FORMAT_TOTAL_TIME_RUNNING) {
6282 : 0 : values[n++] = running +
6283 : 0 : atomic64_read(&event->child_total_time_running);
6284 : : }
6285 [ # # ]: 0 : if (read_format & PERF_FORMAT_ID)
6286 : 0 : values[n++] = primary_event_id(event);
6287 : :
6288 : 0 : __output_copy(handle, values, n * sizeof(u64));
6289 : 0 : }
6290 : :
6291 : 0 : static void perf_output_read_group(struct perf_output_handle *handle,
6292 : : struct perf_event *event,
6293 : : u64 enabled, u64 running)
6294 : : {
6295 : 0 : struct perf_event *leader = event->group_leader, *sub;
6296 : 0 : u64 read_format = event->attr.read_format;
6297 : : u64 values[5];
6298 : : int n = 0;
6299 : :
6300 : 0 : values[n++] = 1 + leader->nr_siblings;
6301 : :
6302 [ # # ]: 0 : if (read_format & PERF_FORMAT_TOTAL_TIME_ENABLED)
6303 : 0 : values[n++] = enabled;
6304 : :
6305 [ # # ]: 0 : if (read_format & PERF_FORMAT_TOTAL_TIME_RUNNING)
6306 : 0 : values[n++] = running;
6307 : :
6308 [ # # # # ]: 0 : if ((leader != event) &&
6309 : 0 : (leader->state == PERF_EVENT_STATE_ACTIVE))
6310 : 0 : leader->pmu->read(leader);
6311 : :
6312 : 0 : values[n++] = perf_event_count(leader);
6313 [ # # ]: 0 : if (read_format & PERF_FORMAT_ID)
6314 : 0 : values[n++] = primary_event_id(leader);
6315 : :
6316 : 0 : __output_copy(handle, values, n * sizeof(u64));
6317 : :
6318 [ # # # # ]: 0 : for_each_sibling_event(sub, leader) {
6319 : : n = 0;
6320 : :
6321 [ # # # # ]: 0 : if ((sub != event) &&
6322 : 0 : (sub->state == PERF_EVENT_STATE_ACTIVE))
6323 : 0 : sub->pmu->read(sub);
6324 : :
6325 : 0 : values[n++] = perf_event_count(sub);
6326 [ # # ]: 0 : if (read_format & PERF_FORMAT_ID)
6327 : 0 : values[n++] = primary_event_id(sub);
6328 : :
6329 : 0 : __output_copy(handle, values, n * sizeof(u64));
6330 : : }
6331 : 0 : }
6332 : :
6333 : : #define PERF_FORMAT_TOTAL_TIMES (PERF_FORMAT_TOTAL_TIME_ENABLED|\
6334 : : PERF_FORMAT_TOTAL_TIME_RUNNING)
6335 : :
6336 : : /*
6337 : : * XXX PERF_SAMPLE_READ vs inherited events seems difficult.
6338 : : *
6339 : : * The problem is that its both hard and excessively expensive to iterate the
6340 : : * child list, not to mention that its impossible to IPI the children running
6341 : : * on another CPU, from interrupt/NMI context.
6342 : : */
6343 : 0 : static void perf_output_read(struct perf_output_handle *handle,
6344 : : struct perf_event *event)
6345 : : {
6346 : 0 : u64 enabled = 0, running = 0, now;
6347 : 0 : u64 read_format = event->attr.read_format;
6348 : :
6349 : : /*
6350 : : * compute total_time_enabled, total_time_running
6351 : : * based on snapshot values taken when the event
6352 : : * was last scheduled in.
6353 : : *
6354 : : * we cannot simply called update_context_time()
6355 : : * because of locking issue as we are called in
6356 : : * NMI context
6357 : : */
6358 [ # # ]: 0 : if (read_format & PERF_FORMAT_TOTAL_TIMES)
6359 : 0 : calc_timer_values(event, &now, &enabled, &running);
6360 : :
6361 [ # # ]: 0 : if (event->attr.read_format & PERF_FORMAT_GROUP)
6362 : 0 : perf_output_read_group(handle, event, enabled, running);
6363 : : else
6364 : 0 : perf_output_read_one(handle, event, enabled, running);
6365 : 0 : }
6366 : :
6367 : 0 : void perf_output_sample(struct perf_output_handle *handle,
6368 : : struct perf_event_header *header,
6369 : : struct perf_sample_data *data,
6370 : : struct perf_event *event)
6371 : : {
6372 : 0 : u64 sample_type = data->type;
6373 : :
6374 : 0 : perf_output_put(handle, *header);
6375 : :
6376 [ # # ]: 0 : if (sample_type & PERF_SAMPLE_IDENTIFIER)
6377 : 0 : perf_output_put(handle, data->id);
6378 : :
6379 [ # # ]: 0 : if (sample_type & PERF_SAMPLE_IP)
6380 : 0 : perf_output_put(handle, data->ip);
6381 : :
6382 [ # # ]: 0 : if (sample_type & PERF_SAMPLE_TID)
6383 : 0 : perf_output_put(handle, data->tid_entry);
6384 : :
6385 [ # # ]: 0 : if (sample_type & PERF_SAMPLE_TIME)
6386 : 0 : perf_output_put(handle, data->time);
6387 : :
6388 [ # # ]: 0 : if (sample_type & PERF_SAMPLE_ADDR)
6389 : 0 : perf_output_put(handle, data->addr);
6390 : :
6391 [ # # ]: 0 : if (sample_type & PERF_SAMPLE_ID)
6392 : 0 : perf_output_put(handle, data->id);
6393 : :
6394 [ # # ]: 0 : if (sample_type & PERF_SAMPLE_STREAM_ID)
6395 : 0 : perf_output_put(handle, data->stream_id);
6396 : :
6397 [ # # ]: 0 : if (sample_type & PERF_SAMPLE_CPU)
6398 : 0 : perf_output_put(handle, data->cpu_entry);
6399 : :
6400 [ # # ]: 0 : if (sample_type & PERF_SAMPLE_PERIOD)
6401 : 0 : perf_output_put(handle, data->period);
6402 : :
6403 [ # # ]: 0 : if (sample_type & PERF_SAMPLE_READ)
6404 : 0 : perf_output_read(handle, event);
6405 : :
6406 [ # # ]: 0 : if (sample_type & PERF_SAMPLE_CALLCHAIN) {
6407 : : int size = 1;
6408 : :
6409 : 0 : size += data->callchain->nr;
6410 : 0 : size *= sizeof(u64);
6411 : 0 : __output_copy(handle, data->callchain, size);
6412 : : }
6413 : :
6414 [ # # ]: 0 : if (sample_type & PERF_SAMPLE_RAW) {
6415 : 0 : struct perf_raw_record *raw = data->raw;
6416 : :
6417 [ # # ]: 0 : if (raw) {
6418 : 0 : struct perf_raw_frag *frag = &raw->frag;
6419 : :
6420 : 0 : perf_output_put(handle, raw->size);
6421 : : do {
6422 [ # # ]: 0 : if (frag->copy) {
6423 : 0 : __output_custom(handle, frag->copy,
6424 : 0 : frag->data, frag->size);
6425 : : } else {
6426 : 0 : __output_copy(handle, frag->data,
6427 : 0 : frag->size);
6428 : : }
6429 [ # # ]: 0 : if (perf_raw_frag_last(frag))
6430 : : break;
6431 : 0 : frag = frag->next;
6432 : 0 : } while (1);
6433 [ # # ]: 0 : if (frag->pad)
6434 : 0 : __output_skip(handle, NULL, frag->pad);
6435 : : } else {
6436 : : struct {
6437 : : u32 size;
6438 : : u32 data;
6439 : 0 : } raw = {
6440 : : .size = sizeof(u32),
6441 : : .data = 0,
6442 : : };
6443 : 0 : perf_output_put(handle, raw);
6444 : : }
6445 : : }
6446 : :
6447 [ # # ]: 0 : if (sample_type & PERF_SAMPLE_BRANCH_STACK) {
6448 [ # # ]: 0 : if (data->br_stack) {
6449 : : size_t size;
6450 : :
6451 : 0 : size = data->br_stack->nr
6452 : : * sizeof(struct perf_branch_entry);
6453 : :
6454 : 0 : perf_output_put(handle, data->br_stack->nr);
6455 : 0 : perf_output_copy(handle, data->br_stack->entries, size);
6456 : : } else {
6457 : : /*
6458 : : * we always store at least the value of nr
6459 : : */
6460 : 0 : u64 nr = 0;
6461 : 0 : perf_output_put(handle, nr);
6462 : : }
6463 : : }
6464 : :
6465 [ # # ]: 0 : if (sample_type & PERF_SAMPLE_REGS_USER) {
6466 : 0 : u64 abi = data->regs_user.abi;
6467 : :
6468 : : /*
6469 : : * If there are no regs to dump, notice it through
6470 : : * first u64 being zero (PERF_SAMPLE_REGS_ABI_NONE).
6471 : : */
6472 : 0 : perf_output_put(handle, abi);
6473 : :
6474 [ # # ]: 0 : if (abi) {
6475 : 0 : u64 mask = event->attr.sample_regs_user;
6476 : 0 : perf_output_sample_regs(handle,
6477 : : data->regs_user.regs,
6478 : : mask);
6479 : : }
6480 : : }
6481 : :
6482 [ # # ]: 0 : if (sample_type & PERF_SAMPLE_STACK_USER) {
6483 : 0 : perf_output_sample_ustack(handle,
6484 : : data->stack_user_size,
6485 : : data->regs_user.regs);
6486 : : }
6487 : :
6488 [ # # ]: 0 : if (sample_type & PERF_SAMPLE_WEIGHT)
6489 : 0 : perf_output_put(handle, data->weight);
6490 : :
6491 [ # # ]: 0 : if (sample_type & PERF_SAMPLE_DATA_SRC)
6492 : 0 : perf_output_put(handle, data->data_src.val);
6493 : :
6494 [ # # ]: 0 : if (sample_type & PERF_SAMPLE_TRANSACTION)
6495 : 0 : perf_output_put(handle, data->txn);
6496 : :
6497 [ # # ]: 0 : if (sample_type & PERF_SAMPLE_REGS_INTR) {
6498 : 0 : u64 abi = data->regs_intr.abi;
6499 : : /*
6500 : : * If there are no regs to dump, notice it through
6501 : : * first u64 being zero (PERF_SAMPLE_REGS_ABI_NONE).
6502 : : */
6503 : 0 : perf_output_put(handle, abi);
6504 : :
6505 [ # # ]: 0 : if (abi) {
6506 : 0 : u64 mask = event->attr.sample_regs_intr;
6507 : :
6508 : 0 : perf_output_sample_regs(handle,
6509 : : data->regs_intr.regs,
6510 : : mask);
6511 : : }
6512 : : }
6513 : :
6514 [ # # ]: 0 : if (sample_type & PERF_SAMPLE_PHYS_ADDR)
6515 : 0 : perf_output_put(handle, data->phys_addr);
6516 : :
6517 [ # # ]: 0 : if (!event->attr.watermark) {
6518 : 0 : int wakeup_events = event->attr.wakeup_events;
6519 : :
6520 [ # # ]: 0 : if (wakeup_events) {
6521 : 0 : struct ring_buffer *rb = handle->rb;
6522 : 0 : int events = local_inc_return(&rb->events);
6523 : :
6524 [ # # ]: 0 : if (events >= wakeup_events) {
6525 : : local_sub(wakeup_events, &rb->events);
6526 : 0 : local_inc(&rb->wakeup);
6527 : : }
6528 : : }
6529 : : }
6530 : 0 : }
6531 : :
6532 : 0 : static u64 perf_virt_to_phys(u64 virt)
6533 : : {
6534 : : u64 phys_addr = 0;
6535 : 0 : struct page *p = NULL;
6536 : :
6537 [ # # ]: 0 : if (!virt)
6538 : : return 0;
6539 : :
6540 [ # # ]: 0 : if (virt >= TASK_SIZE) {
6541 : : /* If it's vmalloc()d memory, leave phys_addr as 0 */
6542 [ # # # # : 0 : if (virt_addr_valid((void *)(uintptr_t)virt) &&
# # # # ]
6543 [ # # ]: 0 : !(virt >= VMALLOC_START && virt < VMALLOC_END))
6544 : 0 : phys_addr = (u64)virt_to_phys((void *)(uintptr_t)virt);
6545 : : } else {
6546 : : /*
6547 : : * Walking the pages tables for user address.
6548 : : * Interrupts are disabled, so it prevents any tear down
6549 : : * of the page tables.
6550 : : * Try IRQ-safe __get_user_pages_fast first.
6551 : : * If failed, leave phys_addr as 0.
6552 : : */
6553 [ # # ]: 0 : if (current->mm != NULL) {
6554 : : pagefault_disable();
6555 [ # # ]: 0 : if (__get_user_pages_fast(virt, 1, 0, &p) == 1)
6556 : 0 : phys_addr = page_to_phys(p) + virt % PAGE_SIZE;
6557 : : pagefault_enable();
6558 : : }
6559 : :
6560 [ # # ]: 0 : if (p)
6561 : 0 : put_page(p);
6562 : : }
6563 : :
6564 : 0 : return phys_addr;
6565 : : }
6566 : :
6567 : : static struct perf_callchain_entry __empty_callchain = { .nr = 0, };
6568 : :
6569 : : struct perf_callchain_entry *
6570 : 0 : perf_callchain(struct perf_event *event, struct pt_regs *regs)
6571 : : {
6572 : 0 : bool kernel = !event->attr.exclude_callchain_kernel;
6573 : 0 : bool user = !event->attr.exclude_callchain_user;
6574 : : /* Disallow cross-task user callchains. */
6575 [ # # # # ]: 0 : bool crosstask = event->ctx->task && event->ctx->task != current;
6576 : 0 : const u32 max_stack = event->attr.sample_max_stack;
6577 : : struct perf_callchain_entry *callchain;
6578 : :
6579 [ # # ]: 0 : if (!kernel && !user)
6580 : : return &__empty_callchain;
6581 : :
6582 : 0 : callchain = get_perf_callchain(regs, 0, kernel, user,
6583 : : max_stack, crosstask, true);
6584 [ # # ]: 0 : return callchain ?: &__empty_callchain;
6585 : : }
6586 : :
6587 : 0 : void perf_prepare_sample(struct perf_event_header *header,
6588 : : struct perf_sample_data *data,
6589 : : struct perf_event *event,
6590 : : struct pt_regs *regs)
6591 : : {
6592 : 0 : u64 sample_type = event->attr.sample_type;
6593 : :
6594 : 0 : header->type = PERF_RECORD_SAMPLE;
6595 : 0 : header->size = sizeof(*header) + event->header_size;
6596 : :
6597 : 0 : header->misc = 0;
6598 : 0 : header->misc |= perf_misc_flags(regs);
6599 : :
6600 : 0 : __perf_event_header__init_id(header, data, event);
6601 : :
6602 [ # # ]: 0 : if (sample_type & PERF_SAMPLE_IP)
6603 : 0 : data->ip = perf_instruction_pointer(regs);
6604 : :
6605 [ # # ]: 0 : if (sample_type & PERF_SAMPLE_CALLCHAIN) {
6606 : : int size = 1;
6607 : :
6608 [ # # ]: 0 : if (!(sample_type & __PERF_SAMPLE_CALLCHAIN_EARLY))
6609 : 0 : data->callchain = perf_callchain(event, regs);
6610 : :
6611 : 0 : size += data->callchain->nr;
6612 : :
6613 : 0 : header->size += size * sizeof(u64);
6614 : : }
6615 : :
6616 [ # # ]: 0 : if (sample_type & PERF_SAMPLE_RAW) {
6617 : 0 : struct perf_raw_record *raw = data->raw;
6618 : : int size;
6619 : :
6620 [ # # ]: 0 : if (raw) {
6621 : 0 : struct perf_raw_frag *frag = &raw->frag;
6622 : : u32 sum = 0;
6623 : :
6624 : : do {
6625 : 0 : sum += frag->size;
6626 [ # # ]: 0 : if (perf_raw_frag_last(frag))
6627 : : break;
6628 : 0 : frag = frag->next;
6629 : 0 : } while (1);
6630 : :
6631 : 0 : size = round_up(sum + sizeof(u32), sizeof(u64));
6632 : 0 : raw->size = size - sizeof(u32);
6633 : 0 : frag->pad = raw->size - sum;
6634 : : } else {
6635 : : size = sizeof(u64);
6636 : : }
6637 : :
6638 : 0 : header->size += size;
6639 : : }
6640 : :
6641 [ # # ]: 0 : if (sample_type & PERF_SAMPLE_BRANCH_STACK) {
6642 : : int size = sizeof(u64); /* nr */
6643 [ # # ]: 0 : if (data->br_stack) {
6644 : 0 : size += data->br_stack->nr
6645 : : * sizeof(struct perf_branch_entry);
6646 : : }
6647 : 0 : header->size += size;
6648 : : }
6649 : :
6650 [ # # ]: 0 : if (sample_type & (PERF_SAMPLE_REGS_USER | PERF_SAMPLE_STACK_USER))
6651 : 0 : perf_sample_regs_user(&data->regs_user, regs,
6652 : : &data->regs_user_copy);
6653 : :
6654 [ # # ]: 0 : if (sample_type & PERF_SAMPLE_REGS_USER) {
6655 : : /* regs dump ABI info */
6656 : : int size = sizeof(u64);
6657 : :
6658 [ # # ]: 0 : if (data->regs_user.regs) {
6659 : 0 : u64 mask = event->attr.sample_regs_user;
6660 [ # # ]: 0 : size += hweight64(mask) * sizeof(u64);
6661 : : }
6662 : :
6663 : 0 : header->size += size;
6664 : : }
6665 : :
6666 [ # # ]: 0 : if (sample_type & PERF_SAMPLE_STACK_USER) {
6667 : : /*
6668 : : * Either we need PERF_SAMPLE_STACK_USER bit to be always
6669 : : * processed as the last one or have additional check added
6670 : : * in case new sample type is added, because we could eat
6671 : : * up the rest of the sample size.
6672 : : */
6673 : 0 : u16 stack_size = event->attr.sample_stack_user;
6674 : : u16 size = sizeof(u64);
6675 : :
6676 : 0 : stack_size = perf_sample_ustack_size(stack_size, header->size,
6677 : : data->regs_user.regs);
6678 : :
6679 : : /*
6680 : : * If there is something to dump, add space for the dump
6681 : : * itself and for the field that tells the dynamic size,
6682 : : * which is how many have been actually dumped.
6683 : : */
6684 [ # # ]: 0 : if (stack_size)
6685 : 0 : size += sizeof(u64) + stack_size;
6686 : :
6687 : 0 : data->stack_user_size = stack_size;
6688 : 0 : header->size += size;
6689 : : }
6690 : :
6691 [ # # ]: 0 : if (sample_type & PERF_SAMPLE_REGS_INTR) {
6692 : : /* regs dump ABI info */
6693 : : int size = sizeof(u64);
6694 : :
6695 : 0 : perf_sample_regs_intr(&data->regs_intr, regs);
6696 : :
6697 [ # # ]: 0 : if (data->regs_intr.regs) {
6698 : 0 : u64 mask = event->attr.sample_regs_intr;
6699 : :
6700 [ # # ]: 0 : size += hweight64(mask) * sizeof(u64);
6701 : : }
6702 : :
6703 : 0 : header->size += size;
6704 : : }
6705 : :
6706 [ # # ]: 0 : if (sample_type & PERF_SAMPLE_PHYS_ADDR)
6707 : 0 : data->phys_addr = perf_virt_to_phys(data->addr);
6708 : 0 : }
6709 : :
6710 : : static __always_inline int
6711 : : __perf_event_output(struct perf_event *event,
6712 : : struct perf_sample_data *data,
6713 : : struct pt_regs *regs,
6714 : : int (*output_begin)(struct perf_output_handle *,
6715 : : struct perf_event *,
6716 : : unsigned int))
6717 : : {
6718 : : struct perf_output_handle handle;
6719 : : struct perf_event_header header;
6720 : : int err;
6721 : :
6722 : : /* protect the callchain buffers */
6723 : : rcu_read_lock();
6724 : :
6725 : 0 : perf_prepare_sample(&header, data, event, regs);
6726 : :
6727 : 0 : err = output_begin(&handle, event, header.size);
6728 [ # # # # : 0 : if (err)
# # ]
6729 : : goto exit;
6730 : :
6731 : 0 : perf_output_sample(&handle, &header, data, event);
6732 : :
6733 : 0 : perf_output_end(&handle);
6734 : :
6735 : : exit:
6736 : 0 : rcu_read_unlock();
6737 : : return err;
6738 : : }
6739 : :
6740 : : void
6741 : 0 : perf_event_output_forward(struct perf_event *event,
6742 : : struct perf_sample_data *data,
6743 : : struct pt_regs *regs)
6744 : : {
6745 : : __perf_event_output(event, data, regs, perf_output_begin_forward);
6746 : 0 : }
6747 : :
6748 : : void
6749 : 0 : perf_event_output_backward(struct perf_event *event,
6750 : : struct perf_sample_data *data,
6751 : : struct pt_regs *regs)
6752 : : {
6753 : : __perf_event_output(event, data, regs, perf_output_begin_backward);
6754 : 0 : }
6755 : :
6756 : : int
6757 : 0 : perf_event_output(struct perf_event *event,
6758 : : struct perf_sample_data *data,
6759 : : struct pt_regs *regs)
6760 : : {
6761 : 0 : return __perf_event_output(event, data, regs, perf_output_begin);
6762 : : }
6763 : :
6764 : : /*
6765 : : * read event_id
6766 : : */
6767 : :
6768 : : struct perf_read_event {
6769 : : struct perf_event_header header;
6770 : :
6771 : : u32 pid;
6772 : : u32 tid;
6773 : : };
6774 : :
6775 : : static void
6776 : 0 : perf_event_read_event(struct perf_event *event,
6777 : : struct task_struct *task)
6778 : : {
6779 : : struct perf_output_handle handle;
6780 : : struct perf_sample_data sample;
6781 : 0 : struct perf_read_event read_event = {
6782 : : .header = {
6783 : : .type = PERF_RECORD_READ,
6784 : : .misc = 0,
6785 : 0 : .size = sizeof(read_event) + event->read_size,
6786 : : },
6787 : : .pid = perf_event_pid(event, task),
6788 : : .tid = perf_event_tid(event, task),
6789 : : };
6790 : : int ret;
6791 : :
6792 : : perf_event_header__init_id(&read_event.header, &sample, event);
6793 : 0 : ret = perf_output_begin(&handle, event, read_event.header.size);
6794 [ # # ]: 0 : if (ret)
6795 : 0 : return;
6796 : :
6797 : 0 : perf_output_put(&handle, read_event);
6798 : 0 : perf_output_read(&handle, event);
6799 : : perf_event__output_id_sample(event, &handle, &sample);
6800 : :
6801 : 0 : perf_output_end(&handle);
6802 : : }
6803 : :
6804 : : typedef void (perf_iterate_f)(struct perf_event *event, void *data);
6805 : :
6806 : : static void
6807 : 0 : perf_iterate_ctx(struct perf_event_context *ctx,
6808 : : perf_iterate_f output,
6809 : : void *data, bool all)
6810 : : {
6811 : : struct perf_event *event;
6812 : :
6813 [ # # ]: 0 : list_for_each_entry_rcu(event, &ctx->event_list, event_entry) {
6814 [ # # ]: 0 : if (!all) {
6815 [ # # ]: 0 : if (event->state < PERF_EVENT_STATE_INACTIVE)
6816 : 0 : continue;
6817 [ # # ]: 0 : if (!event_filter_match(event))
6818 : 0 : continue;
6819 : : }
6820 : :
6821 : 0 : output(event, data);
6822 : : }
6823 : 0 : }
6824 : :
6825 : 0 : static void perf_iterate_sb_cpu(perf_iterate_f output, void *data)
6826 : : {
6827 : 0 : struct pmu_event_list *pel = this_cpu_ptr(&pmu_sb_events);
6828 : : struct perf_event *event;
6829 : :
6830 [ # # ]: 0 : list_for_each_entry_rcu(event, &pel->list, sb_list) {
6831 : : /*
6832 : : * Skip events that are not fully formed yet; ensure that
6833 : : * if we observe event->ctx, both event and ctx will be
6834 : : * complete enough. See perf_install_in_context().
6835 : : */
6836 [ # # ]: 0 : if (!smp_load_acquire(&event->ctx))
6837 : 0 : continue;
6838 : :
6839 [ # # ]: 0 : if (event->state < PERF_EVENT_STATE_INACTIVE)
6840 : 0 : continue;
6841 [ # # ]: 0 : if (!event_filter_match(event))
6842 : 0 : continue;
6843 : 0 : output(event, data);
6844 : : }
6845 : 0 : }
6846 : :
6847 : : /*
6848 : : * Iterate all events that need to receive side-band events.
6849 : : *
6850 : : * For new callers; ensure that account_pmu_sb_event() includes
6851 : : * your event, otherwise it might not get delivered.
6852 : : */
6853 : : static void
6854 : 0 : perf_iterate_sb(perf_iterate_f output, void *data,
6855 : : struct perf_event_context *task_ctx)
6856 : : {
6857 : : struct perf_event_context *ctx;
6858 : : int ctxn;
6859 : :
6860 : : rcu_read_lock();
6861 : 0 : preempt_disable();
6862 : :
6863 : : /*
6864 : : * If we have task_ctx != NULL we only notify the task context itself.
6865 : : * The task_ctx is set only for EXIT events before releasing task
6866 : : * context.
6867 : : */
6868 [ # # ]: 0 : if (task_ctx) {
6869 : 0 : perf_iterate_ctx(task_ctx, output, data, false);
6870 : 0 : goto done;
6871 : : }
6872 : :
6873 : 0 : perf_iterate_sb_cpu(output, data);
6874 : :
6875 [ # # ]: 0 : for_each_task_context_nr(ctxn) {
6876 : 0 : ctx = rcu_dereference(current->perf_event_ctxp[ctxn]);
6877 [ # # ]: 0 : if (ctx)
6878 : 0 : perf_iterate_ctx(ctx, output, data, false);
6879 : : }
6880 : : done:
6881 : 0 : preempt_enable();
6882 : : rcu_read_unlock();
6883 : 0 : }
6884 : :
6885 : : /*
6886 : : * Clear all file-based filters at exec, they'll have to be
6887 : : * re-instated when/if these objects are mmapped again.
6888 : : */
6889 : 0 : static void perf_event_addr_filters_exec(struct perf_event *event, void *data)
6890 : : {
6891 : : struct perf_addr_filters_head *ifh = perf_event_addr_filters(event);
6892 : : struct perf_addr_filter *filter;
6893 : : unsigned int restart = 0, count = 0;
6894 : : unsigned long flags;
6895 : :
6896 [ # # ]: 0 : if (!has_addr_filter(event))
6897 : 0 : return;
6898 : :
6899 : 0 : raw_spin_lock_irqsave(&ifh->lock, flags);
6900 [ # # ]: 0 : list_for_each_entry(filter, &ifh->list, entry) {
6901 [ # # ]: 0 : if (filter->path.dentry) {
6902 : 0 : event->addr_filter_ranges[count].start = 0;
6903 : 0 : event->addr_filter_ranges[count].size = 0;
6904 : 0 : restart++;
6905 : : }
6906 : :
6907 : 0 : count++;
6908 : : }
6909 : :
6910 [ # # ]: 0 : if (restart)
6911 : 0 : event->addr_filters_gen++;
6912 : 0 : raw_spin_unlock_irqrestore(&ifh->lock, flags);
6913 : :
6914 [ # # ]: 0 : if (restart)
6915 : 0 : perf_event_stop(event, 1);
6916 : : }
6917 : :
6918 : 220770 : void perf_event_exec(void)
6919 : : {
6920 : : struct perf_event_context *ctx;
6921 : : int ctxn;
6922 : :
6923 : : rcu_read_lock();
6924 [ + + ]: 662440 : for_each_task_context_nr(ctxn) {
6925 : 441582 : ctx = current->perf_event_ctxp[ctxn];
6926 [ + + ]: 441582 : if (!ctx)
6927 : 441616 : continue;
6928 : :
6929 : 10 : perf_event_enable_on_exec(ctxn);
6930 : :
6931 : 0 : perf_iterate_ctx(ctx, perf_event_addr_filters_exec, NULL,
6932 : : true);
6933 : : }
6934 : : rcu_read_unlock();
6935 : 220861 : }
6936 : :
6937 : : struct remote_output {
6938 : : struct ring_buffer *rb;
6939 : : int err;
6940 : : };
6941 : :
6942 : 0 : static void __perf_event_output_stop(struct perf_event *event, void *data)
6943 : : {
6944 : 0 : struct perf_event *parent = event->parent;
6945 : : struct remote_output *ro = data;
6946 : 0 : struct ring_buffer *rb = ro->rb;
6947 : 0 : struct stop_event_data sd = {
6948 : : .event = event,
6949 : : };
6950 : :
6951 [ # # ]: 0 : if (!has_aux(event))
6952 : 0 : return;
6953 : :
6954 [ # # ]: 0 : if (!parent)
6955 : : parent = event;
6956 : :
6957 : : /*
6958 : : * In case of inheritance, it will be the parent that links to the
6959 : : * ring-buffer, but it will be the child that's actually using it.
6960 : : *
6961 : : * We are using event::rb to determine if the event should be stopped,
6962 : : * however this may race with ring_buffer_attach() (through set_output),
6963 : : * which will make us skip the event that actually needs to be stopped.
6964 : : * So ring_buffer_attach() has to stop an aux event before re-assigning
6965 : : * its rb pointer.
6966 : : */
6967 [ # # ]: 0 : if (rcu_dereference(parent->rb) == rb)
6968 : 0 : ro->err = __perf_event_stop(&sd);
6969 : : }
6970 : :
6971 : 0 : static int __perf_pmu_output_stop(void *info)
6972 : : {
6973 : : struct perf_event *event = info;
6974 : 0 : struct pmu *pmu = event->ctx->pmu;
6975 : 0 : struct perf_cpu_context *cpuctx = this_cpu_ptr(pmu->pmu_cpu_context);
6976 : 0 : struct remote_output ro = {
6977 : 0 : .rb = event->rb,
6978 : : };
6979 : :
6980 : : rcu_read_lock();
6981 : 0 : perf_iterate_ctx(&cpuctx->ctx, __perf_event_output_stop, &ro, false);
6982 [ # # ]: 0 : if (cpuctx->task_ctx)
6983 : 0 : perf_iterate_ctx(cpuctx->task_ctx, __perf_event_output_stop,
6984 : : &ro, false);
6985 : : rcu_read_unlock();
6986 : :
6987 : 0 : return ro.err;
6988 : : }
6989 : :
6990 : 0 : static void perf_pmu_output_stop(struct perf_event *event)
6991 : : {
6992 : : struct perf_event *iter;
6993 : : int err, cpu;
6994 : :
6995 : : restart:
6996 : : rcu_read_lock();
6997 [ # # ]: 0 : list_for_each_entry_rcu(iter, &event->rb->event_list, rb_entry) {
6998 : : /*
6999 : : * For per-CPU events, we need to make sure that neither they
7000 : : * nor their children are running; for cpu==-1 events it's
7001 : : * sufficient to stop the event itself if it's active, since
7002 : : * it can't have children.
7003 : : */
7004 : 0 : cpu = iter->cpu;
7005 [ # # ]: 0 : if (cpu == -1)
7006 : 0 : cpu = READ_ONCE(iter->oncpu);
7007 : :
7008 [ # # ]: 0 : if (cpu == -1)
7009 : 0 : continue;
7010 : :
7011 : : err = cpu_function_call(cpu, __perf_pmu_output_stop, event);
7012 [ # # ]: 0 : if (err == -EAGAIN) {
7013 : : rcu_read_unlock();
7014 : : goto restart;
7015 : : }
7016 : : }
7017 : : rcu_read_unlock();
7018 : 0 : }
7019 : :
7020 : : /*
7021 : : * task tracking -- fork/exit
7022 : : *
7023 : : * enabled by: attr.comm | attr.mmap | attr.mmap2 | attr.mmap_data | attr.task
7024 : : */
7025 : :
7026 : : struct perf_task_event {
7027 : : struct task_struct *task;
7028 : : struct perf_event_context *task_ctx;
7029 : :
7030 : : struct {
7031 : : struct perf_event_header header;
7032 : :
7033 : : u32 pid;
7034 : : u32 ppid;
7035 : : u32 tid;
7036 : : u32 ptid;
7037 : : u64 time;
7038 : : } event_id;
7039 : : };
7040 : :
7041 : : static int perf_event_task_match(struct perf_event *event)
7042 : : {
7043 : : return event->attr.comm || event->attr.mmap ||
7044 : 0 : event->attr.mmap2 || event->attr.mmap_data ||
7045 : : event->attr.task;
7046 : : }
7047 : :
7048 : 0 : static void perf_event_task_output(struct perf_event *event,
7049 : : void *data)
7050 : : {
7051 : : struct perf_task_event *task_event = data;
7052 : : struct perf_output_handle handle;
7053 : : struct perf_sample_data sample;
7054 : 0 : struct task_struct *task = task_event->task;
7055 : 0 : int ret, size = task_event->event_id.header.size;
7056 : :
7057 [ # # ]: 0 : if (!perf_event_task_match(event))
7058 : 0 : return;
7059 : :
7060 : 0 : perf_event_header__init_id(&task_event->event_id.header, &sample, event);
7061 : :
7062 : 0 : ret = perf_output_begin(&handle, event,
7063 : 0 : task_event->event_id.header.size);
7064 [ # # ]: 0 : if (ret)
7065 : : goto out;
7066 : :
7067 : 0 : task_event->event_id.pid = perf_event_pid(event, task);
7068 : 0 : task_event->event_id.tid = perf_event_tid(event, task);
7069 : :
7070 [ # # ]: 0 : if (task_event->event_id.header.type == PERF_RECORD_EXIT) {
7071 : 0 : task_event->event_id.ppid = perf_event_pid(event,
7072 : : task->real_parent);
7073 : 0 : task_event->event_id.ptid = perf_event_pid(event,
7074 : : task->real_parent);
7075 : : } else { /* PERF_RECORD_FORK */
7076 : 0 : task_event->event_id.ppid = perf_event_pid(event, current);
7077 : 0 : task_event->event_id.ptid = perf_event_tid(event, current);
7078 : : }
7079 : :
7080 : 0 : task_event->event_id.time = perf_event_clock(event);
7081 : :
7082 : 0 : perf_output_put(&handle, task_event->event_id);
7083 : :
7084 : : perf_event__output_id_sample(event, &handle, &sample);
7085 : :
7086 : 0 : perf_output_end(&handle);
7087 : : out:
7088 : 0 : task_event->event_id.header.size = size;
7089 : : }
7090 : :
7091 : 549222 : static void perf_event_task(struct task_struct *task,
7092 : : struct perf_event_context *task_ctx,
7093 : : int new)
7094 : : {
7095 : : struct perf_task_event task_event;
7096 : :
7097 [ + - + + ]: 1098856 : if (!atomic_read(&nr_comm_events) &&
7098 [ + + ]: 1099277 : !atomic_read(&nr_mmap_events) &&
7099 : 549643 : !atomic_read(&nr_task_events))
7100 : 549616 : return;
7101 : :
7102 [ - - ]: 0 : task_event = (struct perf_task_event){
7103 : : .task = task,
7104 : : .task_ctx = task_ctx,
7105 : : .event_id = {
7106 : : .header = {
7107 : : .type = new ? PERF_RECORD_FORK : PERF_RECORD_EXIT,
7108 : : .misc = 0,
7109 : : .size = sizeof(task_event.event_id),
7110 : : },
7111 : : /* .pid */
7112 : : /* .ppid */
7113 : : /* .tid */
7114 : : /* .ptid */
7115 : : /* .time */
7116 : : },
7117 : : };
7118 : :
7119 : 0 : perf_iterate_sb(perf_event_task_output,
7120 : : &task_event,
7121 : : task_ctx);
7122 : : }
7123 : :
7124 : 293809 : void perf_event_fork(struct task_struct *task)
7125 : : {
7126 : 293809 : perf_event_task(task, NULL, 1);
7127 : 293819 : perf_event_namespaces(task);
7128 : 293800 : }
7129 : :
7130 : : /*
7131 : : * comm tracking
7132 : : */
7133 : :
7134 : : struct perf_comm_event {
7135 : : struct task_struct *task;
7136 : : char *comm;
7137 : : int comm_size;
7138 : :
7139 : : struct {
7140 : : struct perf_event_header header;
7141 : :
7142 : : u32 pid;
7143 : : u32 tid;
7144 : : } event_id;
7145 : : };
7146 : :
7147 : : static int perf_event_comm_match(struct perf_event *event)
7148 : : {
7149 : 0 : return event->attr.comm;
7150 : : }
7151 : :
7152 : 0 : static void perf_event_comm_output(struct perf_event *event,
7153 : : void *data)
7154 : : {
7155 : : struct perf_comm_event *comm_event = data;
7156 : : struct perf_output_handle handle;
7157 : : struct perf_sample_data sample;
7158 : 0 : int size = comm_event->event_id.header.size;
7159 : : int ret;
7160 : :
7161 [ # # ]: 0 : if (!perf_event_comm_match(event))
7162 : 0 : return;
7163 : :
7164 : 0 : perf_event_header__init_id(&comm_event->event_id.header, &sample, event);
7165 : 0 : ret = perf_output_begin(&handle, event,
7166 : 0 : comm_event->event_id.header.size);
7167 : :
7168 [ # # ]: 0 : if (ret)
7169 : : goto out;
7170 : :
7171 : 0 : comm_event->event_id.pid = perf_event_pid(event, comm_event->task);
7172 : 0 : comm_event->event_id.tid = perf_event_tid(event, comm_event->task);
7173 : :
7174 : 0 : perf_output_put(&handle, comm_event->event_id);
7175 : 0 : __output_copy(&handle, comm_event->comm,
7176 : 0 : comm_event->comm_size);
7177 : :
7178 : : perf_event__output_id_sample(event, &handle, &sample);
7179 : :
7180 : 0 : perf_output_end(&handle);
7181 : : out:
7182 : 0 : comm_event->event_id.header.size = size;
7183 : : }
7184 : :
7185 : 0 : static void perf_event_comm_event(struct perf_comm_event *comm_event)
7186 : : {
7187 : : char comm[TASK_COMM_LEN];
7188 : : unsigned int size;
7189 : :
7190 : 0 : memset(comm, 0, sizeof(comm));
7191 : 0 : strlcpy(comm, comm_event->task->comm, sizeof(comm));
7192 : 0 : size = ALIGN(strlen(comm)+1, sizeof(u64));
7193 : :
7194 : 0 : comm_event->comm = comm;
7195 : 0 : comm_event->comm_size = size;
7196 : :
7197 : 0 : comm_event->event_id.header.size = sizeof(comm_event->event_id) + size;
7198 : :
7199 : 0 : perf_iterate_sb(perf_event_comm_output,
7200 : : comm_event,
7201 : : NULL);
7202 : 0 : }
7203 : :
7204 : 283743 : void perf_event_comm(struct task_struct *task, bool exec)
7205 : : {
7206 : : struct perf_comm_event comm_event;
7207 : :
7208 [ - + ]: 283743 : if (!atomic_read(&nr_comm_events))
7209 : 283743 : return;
7210 : :
7211 [ # # ]: 0 : comm_event = (struct perf_comm_event){
7212 : : .task = task,
7213 : : /* .comm */
7214 : : /* .comm_size */
7215 : : .event_id = {
7216 : : .header = {
7217 : : .type = PERF_RECORD_COMM,
7218 : : .misc = exec ? PERF_RECORD_MISC_COMM_EXEC : 0,
7219 : : /* .size */
7220 : : },
7221 : : /* .pid */
7222 : : /* .tid */
7223 : : },
7224 : : };
7225 : :
7226 : 0 : perf_event_comm_event(&comm_event);
7227 : : }
7228 : :
7229 : : /*
7230 : : * namespaces tracking
7231 : : */
7232 : :
7233 : : struct perf_namespaces_event {
7234 : : struct task_struct *task;
7235 : :
7236 : : struct {
7237 : : struct perf_event_header header;
7238 : :
7239 : : u32 pid;
7240 : : u32 tid;
7241 : : u64 nr_namespaces;
7242 : : struct perf_ns_link_info link_info[NR_NAMESPACES];
7243 : : } event_id;
7244 : : };
7245 : :
7246 : : static int perf_event_namespaces_match(struct perf_event *event)
7247 : : {
7248 : 0 : return event->attr.namespaces;
7249 : : }
7250 : :
7251 : 0 : static void perf_event_namespaces_output(struct perf_event *event,
7252 : : void *data)
7253 : : {
7254 : : struct perf_namespaces_event *namespaces_event = data;
7255 : : struct perf_output_handle handle;
7256 : : struct perf_sample_data sample;
7257 : 0 : u16 header_size = namespaces_event->event_id.header.size;
7258 : : int ret;
7259 : :
7260 [ # # ]: 0 : if (!perf_event_namespaces_match(event))
7261 : 0 : return;
7262 : :
7263 : 0 : perf_event_header__init_id(&namespaces_event->event_id.header,
7264 : : &sample, event);
7265 : 0 : ret = perf_output_begin(&handle, event,
7266 : 0 : namespaces_event->event_id.header.size);
7267 [ # # ]: 0 : if (ret)
7268 : : goto out;
7269 : :
7270 : 0 : namespaces_event->event_id.pid = perf_event_pid(event,
7271 : : namespaces_event->task);
7272 : 0 : namespaces_event->event_id.tid = perf_event_tid(event,
7273 : : namespaces_event->task);
7274 : :
7275 : 0 : perf_output_put(&handle, namespaces_event->event_id);
7276 : :
7277 : : perf_event__output_id_sample(event, &handle, &sample);
7278 : :
7279 : 0 : perf_output_end(&handle);
7280 : : out:
7281 : 0 : namespaces_event->event_id.header.size = header_size;
7282 : : }
7283 : :
7284 : 0 : static void perf_fill_ns_link_info(struct perf_ns_link_info *ns_link_info,
7285 : : struct task_struct *task,
7286 : : const struct proc_ns_operations *ns_ops)
7287 : : {
7288 : : struct path ns_path;
7289 : : struct inode *ns_inode;
7290 : : void *error;
7291 : :
7292 : 0 : error = ns_get_path(&ns_path, task, ns_ops);
7293 [ # # ]: 0 : if (!error) {
7294 : 0 : ns_inode = ns_path.dentry->d_inode;
7295 : 0 : ns_link_info->dev = new_encode_dev(ns_inode->i_sb->s_dev);
7296 : 0 : ns_link_info->ino = ns_inode->i_ino;
7297 : 0 : path_put(&ns_path);
7298 : : }
7299 : 0 : }
7300 : :
7301 : 294459 : void perf_event_namespaces(struct task_struct *task)
7302 : : {
7303 : : struct perf_namespaces_event namespaces_event;
7304 : : struct perf_ns_link_info *ns_link_info;
7305 : :
7306 [ - + ]: 294459 : if (!atomic_read(&nr_namespaces_events))
7307 : 294459 : return;
7308 : :
7309 : 0 : namespaces_event = (struct perf_namespaces_event){
7310 : : .task = task,
7311 : : .event_id = {
7312 : : .header = {
7313 : : .type = PERF_RECORD_NAMESPACES,
7314 : : .misc = 0,
7315 : : .size = sizeof(namespaces_event.event_id),
7316 : : },
7317 : : /* .pid */
7318 : : /* .tid */
7319 : : .nr_namespaces = NR_NAMESPACES,
7320 : : /* .link_info[NR_NAMESPACES] */
7321 : : },
7322 : : };
7323 : :
7324 : : ns_link_info = namespaces_event.event_id.link_info;
7325 : :
7326 : 0 : perf_fill_ns_link_info(&ns_link_info[MNT_NS_INDEX],
7327 : : task, &mntns_operations);
7328 : :
7329 : : #ifdef CONFIG_USER_NS
7330 : 0 : perf_fill_ns_link_info(&ns_link_info[USER_NS_INDEX],
7331 : : task, &userns_operations);
7332 : : #endif
7333 : : #ifdef CONFIG_NET_NS
7334 : 0 : perf_fill_ns_link_info(&ns_link_info[NET_NS_INDEX],
7335 : : task, &netns_operations);
7336 : : #endif
7337 : : #ifdef CONFIG_UTS_NS
7338 : 0 : perf_fill_ns_link_info(&ns_link_info[UTS_NS_INDEX],
7339 : : task, &utsns_operations);
7340 : : #endif
7341 : : #ifdef CONFIG_IPC_NS
7342 : 0 : perf_fill_ns_link_info(&ns_link_info[IPC_NS_INDEX],
7343 : : task, &ipcns_operations);
7344 : : #endif
7345 : : #ifdef CONFIG_PID_NS
7346 : 0 : perf_fill_ns_link_info(&ns_link_info[PID_NS_INDEX],
7347 : : task, &pidns_operations);
7348 : : #endif
7349 : : #ifdef CONFIG_CGROUPS
7350 : 0 : perf_fill_ns_link_info(&ns_link_info[CGROUP_NS_INDEX],
7351 : : task, &cgroupns_operations);
7352 : : #endif
7353 : :
7354 : 0 : perf_iterate_sb(perf_event_namespaces_output,
7355 : : &namespaces_event,
7356 : : NULL);
7357 : : }
7358 : :
7359 : : /*
7360 : : * mmap tracking
7361 : : */
7362 : :
7363 : : struct perf_mmap_event {
7364 : : struct vm_area_struct *vma;
7365 : :
7366 : : const char *file_name;
7367 : : int file_size;
7368 : : int maj, min;
7369 : : u64 ino;
7370 : : u64 ino_generation;
7371 : : u32 prot, flags;
7372 : :
7373 : : struct {
7374 : : struct perf_event_header header;
7375 : :
7376 : : u32 pid;
7377 : : u32 tid;
7378 : : u64 start;
7379 : : u64 len;
7380 : : u64 pgoff;
7381 : : } event_id;
7382 : : };
7383 : :
7384 : : static int perf_event_mmap_match(struct perf_event *event,
7385 : : void *data)
7386 : : {
7387 : : struct perf_mmap_event *mmap_event = data;
7388 : 0 : struct vm_area_struct *vma = mmap_event->vma;
7389 : 0 : int executable = vma->vm_flags & VM_EXEC;
7390 : :
7391 [ # # # # : 0 : return (!executable && event->attr.mmap_data) ||
# # ]
7392 [ # # ]: 0 : (executable && (event->attr.mmap || event->attr.mmap2));
7393 : : }
7394 : :
7395 : 0 : static void perf_event_mmap_output(struct perf_event *event,
7396 : : void *data)
7397 : : {
7398 : : struct perf_mmap_event *mmap_event = data;
7399 : : struct perf_output_handle handle;
7400 : : struct perf_sample_data sample;
7401 : 0 : int size = mmap_event->event_id.header.size;
7402 : 0 : u32 type = mmap_event->event_id.header.type;
7403 : : int ret;
7404 : :
7405 [ # # ]: 0 : if (!perf_event_mmap_match(event, data))
7406 : 0 : return;
7407 : :
7408 [ # # ]: 0 : if (event->attr.mmap2) {
7409 : 0 : mmap_event->event_id.header.type = PERF_RECORD_MMAP2;
7410 : 0 : mmap_event->event_id.header.size += sizeof(mmap_event->maj);
7411 : 0 : mmap_event->event_id.header.size += sizeof(mmap_event->min);
7412 : 0 : mmap_event->event_id.header.size += sizeof(mmap_event->ino);
7413 : 0 : mmap_event->event_id.header.size += sizeof(mmap_event->ino_generation);
7414 : 0 : mmap_event->event_id.header.size += sizeof(mmap_event->prot);
7415 : 0 : mmap_event->event_id.header.size += sizeof(mmap_event->flags);
7416 : : }
7417 : :
7418 : 0 : perf_event_header__init_id(&mmap_event->event_id.header, &sample, event);
7419 : 0 : ret = perf_output_begin(&handle, event,
7420 : 0 : mmap_event->event_id.header.size);
7421 [ # # ]: 0 : if (ret)
7422 : : goto out;
7423 : :
7424 : 0 : mmap_event->event_id.pid = perf_event_pid(event, current);
7425 : 0 : mmap_event->event_id.tid = perf_event_tid(event, current);
7426 : :
7427 : 0 : perf_output_put(&handle, mmap_event->event_id);
7428 : :
7429 [ # # ]: 0 : if (event->attr.mmap2) {
7430 : 0 : perf_output_put(&handle, mmap_event->maj);
7431 : 0 : perf_output_put(&handle, mmap_event->min);
7432 : 0 : perf_output_put(&handle, mmap_event->ino);
7433 : 0 : perf_output_put(&handle, mmap_event->ino_generation);
7434 : 0 : perf_output_put(&handle, mmap_event->prot);
7435 : 0 : perf_output_put(&handle, mmap_event->flags);
7436 : : }
7437 : :
7438 : 0 : __output_copy(&handle, mmap_event->file_name,
7439 : 0 : mmap_event->file_size);
7440 : :
7441 : : perf_event__output_id_sample(event, &handle, &sample);
7442 : :
7443 : 0 : perf_output_end(&handle);
7444 : : out:
7445 : 0 : mmap_event->event_id.header.size = size;
7446 : 0 : mmap_event->event_id.header.type = type;
7447 : : }
7448 : :
7449 : 0 : static void perf_event_mmap_event(struct perf_mmap_event *mmap_event)
7450 : : {
7451 : 0 : struct vm_area_struct *vma = mmap_event->vma;
7452 : 0 : struct file *file = vma->vm_file;
7453 : : int maj = 0, min = 0;
7454 : : u64 ino = 0, gen = 0;
7455 : : u32 prot = 0, flags = 0;
7456 : : unsigned int size;
7457 : : char tmp[16];
7458 : : char *buf = NULL;
7459 : : char *name;
7460 : :
7461 [ # # ]: 0 : if (vma->vm_flags & VM_READ)
7462 : : prot |= PROT_READ;
7463 [ # # ]: 0 : if (vma->vm_flags & VM_WRITE)
7464 : 0 : prot |= PROT_WRITE;
7465 [ # # ]: 0 : if (vma->vm_flags & VM_EXEC)
7466 : 0 : prot |= PROT_EXEC;
7467 : :
7468 [ # # ]: 0 : if (vma->vm_flags & VM_MAYSHARE)
7469 : : flags = MAP_SHARED;
7470 : : else
7471 : : flags = MAP_PRIVATE;
7472 : :
7473 [ # # ]: 0 : if (vma->vm_flags & VM_DENYWRITE)
7474 : 0 : flags |= MAP_DENYWRITE;
7475 [ # # ]: 0 : if (vma->vm_flags & VM_MAYEXEC)
7476 : 0 : flags |= MAP_EXECUTABLE;
7477 [ # # ]: 0 : if (vma->vm_flags & VM_LOCKED)
7478 : 0 : flags |= MAP_LOCKED;
7479 [ # # ]: 0 : if (vma->vm_flags & VM_HUGETLB)
7480 : 0 : flags |= MAP_HUGETLB;
7481 : :
7482 [ # # ]: 0 : if (file) {
7483 : : struct inode *inode;
7484 : : dev_t dev;
7485 : :
7486 : : buf = kmalloc(PATH_MAX, GFP_KERNEL);
7487 [ # # ]: 0 : if (!buf) {
7488 : : name = "//enomem";
7489 : : goto cpy_name;
7490 : : }
7491 : : /*
7492 : : * d_path() works from the end of the rb backwards, so we
7493 : : * need to add enough zero bytes after the string to handle
7494 : : * the 64bit alignment we do later.
7495 : : */
7496 : 0 : name = file_path(file, buf, PATH_MAX - sizeof(u64));
7497 [ # # ]: 0 : if (IS_ERR(name)) {
7498 : : name = "//toolong";
7499 : : goto cpy_name;
7500 : : }
7501 : 0 : inode = file_inode(vma->vm_file);
7502 : 0 : dev = inode->i_sb->s_dev;
7503 : 0 : ino = inode->i_ino;
7504 : 0 : gen = inode->i_generation;
7505 : 0 : maj = MAJOR(dev);
7506 : 0 : min = MINOR(dev);
7507 : :
7508 : 0 : goto got_name;
7509 : : } else {
7510 [ # # # # ]: 0 : if (vma->vm_ops && vma->vm_ops->name) {
7511 : 0 : name = (char *) vma->vm_ops->name(vma);
7512 [ # # ]: 0 : if (name)
7513 : : goto cpy_name;
7514 : : }
7515 : :
7516 : 0 : name = (char *)arch_vma_name(vma);
7517 [ # # ]: 0 : if (name)
7518 : : goto cpy_name;
7519 : :
7520 [ # # # # ]: 0 : if (vma->vm_start <= vma->vm_mm->start_brk &&
7521 : 0 : vma->vm_end >= vma->vm_mm->brk) {
7522 : : name = "[heap]";
7523 : : goto cpy_name;
7524 : : }
7525 [ # # # # ]: 0 : if (vma->vm_start <= vma->vm_mm->start_stack &&
7526 : 0 : vma->vm_end >= vma->vm_mm->start_stack) {
7527 : : name = "[stack]";
7528 : : goto cpy_name;
7529 : : }
7530 : :
7531 : : name = "//anon";
7532 : 0 : goto cpy_name;
7533 : : }
7534 : :
7535 : : cpy_name:
7536 : 0 : strlcpy(tmp, name, sizeof(tmp));
7537 : : name = tmp;
7538 : : got_name:
7539 : : /*
7540 : : * Since our buffer works in 8 byte units we need to align our string
7541 : : * size to a multiple of 8. However, we must guarantee the tail end is
7542 : : * zero'd out to avoid leaking random bits to userspace.
7543 : : */
7544 : 0 : size = strlen(name)+1;
7545 [ # # ]: 0 : while (!IS_ALIGNED(size, sizeof(u64)))
7546 : 0 : name[size++] = '\0';
7547 : :
7548 : 0 : mmap_event->file_name = name;
7549 : 0 : mmap_event->file_size = size;
7550 : 0 : mmap_event->maj = maj;
7551 : 0 : mmap_event->min = min;
7552 : 0 : mmap_event->ino = ino;
7553 : 0 : mmap_event->ino_generation = gen;
7554 : 0 : mmap_event->prot = prot;
7555 : 0 : mmap_event->flags = flags;
7556 : :
7557 [ # # ]: 0 : if (!(vma->vm_flags & VM_EXEC))
7558 : 0 : mmap_event->event_id.header.misc |= PERF_RECORD_MISC_MMAP_DATA;
7559 : :
7560 : 0 : mmap_event->event_id.header.size = sizeof(mmap_event->event_id) + size;
7561 : :
7562 : 0 : perf_iterate_sb(perf_event_mmap_output,
7563 : : mmap_event,
7564 : : NULL);
7565 : :
7566 : 0 : kfree(buf);
7567 : 0 : }
7568 : :
7569 : : /*
7570 : : * Check whether inode and address range match filter criteria.
7571 : : */
7572 : : static bool perf_addr_filter_match(struct perf_addr_filter *filter,
7573 : : struct file *file, unsigned long offset,
7574 : : unsigned long size)
7575 : : {
7576 : : /* d_inode(NULL) won't be equal to any mapped user-space file */
7577 [ # # ]: 0 : if (!filter->path.dentry)
7578 : : return false;
7579 : :
7580 [ # # ]: 0 : if (d_inode(filter->path.dentry) != file_inode(file))
7581 : : return false;
7582 : :
7583 [ # # ]: 0 : if (filter->offset > offset + size)
7584 : : return false;
7585 : :
7586 [ # # ]: 0 : if (filter->offset + filter->size < offset)
7587 : : return false;
7588 : :
7589 : : return true;
7590 : : }
7591 : :
7592 : 0 : static bool perf_addr_filter_vma_adjust(struct perf_addr_filter *filter,
7593 : : struct vm_area_struct *vma,
7594 : : struct perf_addr_filter_range *fr)
7595 : : {
7596 : 0 : unsigned long vma_size = vma->vm_end - vma->vm_start;
7597 : 0 : unsigned long off = vma->vm_pgoff << PAGE_SHIFT;
7598 : 0 : struct file *file = vma->vm_file;
7599 : :
7600 [ # # ]: 0 : if (!perf_addr_filter_match(filter, file, off, vma_size))
7601 : : return false;
7602 : :
7603 [ # # ]: 0 : if (filter->offset < off) {
7604 : 0 : fr->start = vma->vm_start;
7605 : 0 : fr->size = min(vma_size, filter->size - (off - filter->offset));
7606 : : } else {
7607 : 0 : fr->start = vma->vm_start + filter->offset - off;
7608 : 0 : fr->size = min(vma->vm_end - fr->start, filter->size);
7609 : : }
7610 : :
7611 : : return true;
7612 : : }
7613 : :
7614 : 0 : static void __perf_addr_filters_adjust(struct perf_event *event, void *data)
7615 : : {
7616 : : struct perf_addr_filters_head *ifh = perf_event_addr_filters(event);
7617 : : struct vm_area_struct *vma = data;
7618 : : struct perf_addr_filter *filter;
7619 : : unsigned int restart = 0, count = 0;
7620 : : unsigned long flags;
7621 : :
7622 [ # # ]: 0 : if (!has_addr_filter(event))
7623 : : return;
7624 : :
7625 [ # # ]: 0 : if (!vma->vm_file)
7626 : : return;
7627 : :
7628 : 0 : raw_spin_lock_irqsave(&ifh->lock, flags);
7629 [ # # ]: 0 : list_for_each_entry(filter, &ifh->list, entry) {
7630 [ # # ]: 0 : if (perf_addr_filter_vma_adjust(filter, vma,
7631 : 0 : &event->addr_filter_ranges[count]))
7632 : 0 : restart++;
7633 : :
7634 : 0 : count++;
7635 : : }
7636 : :
7637 [ # # ]: 0 : if (restart)
7638 : 0 : event->addr_filters_gen++;
7639 : 0 : raw_spin_unlock_irqrestore(&ifh->lock, flags);
7640 : :
7641 [ # # ]: 0 : if (restart)
7642 : 0 : perf_event_stop(event, 1);
7643 : : }
7644 : :
7645 : : /*
7646 : : * Adjust all task's events' filters to the new vma
7647 : : */
7648 : 0 : static void perf_addr_filters_adjust(struct vm_area_struct *vma)
7649 : : {
7650 : : struct perf_event_context *ctx;
7651 : : int ctxn;
7652 : :
7653 : : /*
7654 : : * Data tracing isn't supported yet and as such there is no need
7655 : : * to keep track of anything that isn't related to executable code:
7656 : : */
7657 [ # # ]: 0 : if (!(vma->vm_flags & VM_EXEC))
7658 : 0 : return;
7659 : :
7660 : : rcu_read_lock();
7661 [ # # ]: 0 : for_each_task_context_nr(ctxn) {
7662 : 0 : ctx = rcu_dereference(current->perf_event_ctxp[ctxn]);
7663 [ # # ]: 0 : if (!ctx)
7664 : 0 : continue;
7665 : :
7666 : 0 : perf_iterate_ctx(ctx, __perf_addr_filters_adjust, vma, true);
7667 : : }
7668 : : rcu_read_unlock();
7669 : : }
7670 : :
7671 : 9213611 : void perf_event_mmap(struct vm_area_struct *vma)
7672 : : {
7673 : : struct perf_mmap_event mmap_event;
7674 : :
7675 [ - + ]: 9213611 : if (!atomic_read(&nr_mmap_events))
7676 : 9213611 : return;
7677 : :
7678 : 0 : mmap_event = (struct perf_mmap_event){
7679 : : .vma = vma,
7680 : : /* .file_name */
7681 : : /* .file_size */
7682 : : .event_id = {
7683 : : .header = {
7684 : : .type = PERF_RECORD_MMAP,
7685 : : .misc = PERF_RECORD_MISC_USER,
7686 : : /* .size */
7687 : : },
7688 : : /* .pid */
7689 : : /* .tid */
7690 : 0 : .start = vma->vm_start,
7691 : 0 : .len = vma->vm_end - vma->vm_start,
7692 : 0 : .pgoff = (u64)vma->vm_pgoff << PAGE_SHIFT,
7693 : : },
7694 : : /* .maj (attr_mmap2 only) */
7695 : : /* .min (attr_mmap2 only) */
7696 : : /* .ino (attr_mmap2 only) */
7697 : : /* .ino_generation (attr_mmap2 only) */
7698 : : /* .prot (attr_mmap2 only) */
7699 : : /* .flags (attr_mmap2 only) */
7700 : : };
7701 : :
7702 : 0 : perf_addr_filters_adjust(vma);
7703 : 0 : perf_event_mmap_event(&mmap_event);
7704 : : }
7705 : :
7706 : 0 : void perf_event_aux_event(struct perf_event *event, unsigned long head,
7707 : : unsigned long size, u64 flags)
7708 : : {
7709 : : struct perf_output_handle handle;
7710 : : struct perf_sample_data sample;
7711 : : struct perf_aux_event {
7712 : : struct perf_event_header header;
7713 : : u64 offset;
7714 : : u64 size;
7715 : : u64 flags;
7716 : 0 : } rec = {
7717 : : .header = {
7718 : : .type = PERF_RECORD_AUX,
7719 : : .misc = 0,
7720 : : .size = sizeof(rec),
7721 : : },
7722 : : .offset = head,
7723 : : .size = size,
7724 : : .flags = flags,
7725 : : };
7726 : : int ret;
7727 : :
7728 : : perf_event_header__init_id(&rec.header, &sample, event);
7729 : 0 : ret = perf_output_begin(&handle, event, rec.header.size);
7730 : :
7731 [ # # ]: 0 : if (ret)
7732 : 0 : return;
7733 : :
7734 : 0 : perf_output_put(&handle, rec);
7735 : : perf_event__output_id_sample(event, &handle, &sample);
7736 : :
7737 : 0 : perf_output_end(&handle);
7738 : : }
7739 : :
7740 : : /*
7741 : : * Lost/dropped samples logging
7742 : : */
7743 : 0 : void perf_log_lost_samples(struct perf_event *event, u64 lost)
7744 : : {
7745 : : struct perf_output_handle handle;
7746 : : struct perf_sample_data sample;
7747 : : int ret;
7748 : :
7749 : : struct {
7750 : : struct perf_event_header header;
7751 : : u64 lost;
7752 : 0 : } lost_samples_event = {
7753 : : .header = {
7754 : : .type = PERF_RECORD_LOST_SAMPLES,
7755 : : .misc = 0,
7756 : : .size = sizeof(lost_samples_event),
7757 : : },
7758 : : .lost = lost,
7759 : : };
7760 : :
7761 : : perf_event_header__init_id(&lost_samples_event.header, &sample, event);
7762 : :
7763 : 0 : ret = perf_output_begin(&handle, event,
7764 : 0 : lost_samples_event.header.size);
7765 [ # # ]: 0 : if (ret)
7766 : 0 : return;
7767 : :
7768 : 0 : perf_output_put(&handle, lost_samples_event);
7769 : : perf_event__output_id_sample(event, &handle, &sample);
7770 : 0 : perf_output_end(&handle);
7771 : : }
7772 : :
7773 : : /*
7774 : : * context_switch tracking
7775 : : */
7776 : :
7777 : : struct perf_switch_event {
7778 : : struct task_struct *task;
7779 : : struct task_struct *next_prev;
7780 : :
7781 : : struct {
7782 : : struct perf_event_header header;
7783 : : u32 next_prev_pid;
7784 : : u32 next_prev_tid;
7785 : : } event_id;
7786 : : };
7787 : :
7788 : : static int perf_event_switch_match(struct perf_event *event)
7789 : : {
7790 : 0 : return event->attr.context_switch;
7791 : : }
7792 : :
7793 : 0 : static void perf_event_switch_output(struct perf_event *event, void *data)
7794 : : {
7795 : : struct perf_switch_event *se = data;
7796 : : struct perf_output_handle handle;
7797 : : struct perf_sample_data sample;
7798 : : int ret;
7799 : :
7800 [ # # ]: 0 : if (!perf_event_switch_match(event))
7801 : 0 : return;
7802 : :
7803 : : /* Only CPU-wide events are allowed to see next/prev pid/tid */
7804 [ # # ]: 0 : if (event->ctx->task) {
7805 : 0 : se->event_id.header.type = PERF_RECORD_SWITCH;
7806 : 0 : se->event_id.header.size = sizeof(se->event_id.header);
7807 : : } else {
7808 : 0 : se->event_id.header.type = PERF_RECORD_SWITCH_CPU_WIDE;
7809 : 0 : se->event_id.header.size = sizeof(se->event_id);
7810 : 0 : se->event_id.next_prev_pid =
7811 : 0 : perf_event_pid(event, se->next_prev);
7812 : 0 : se->event_id.next_prev_tid =
7813 : 0 : perf_event_tid(event, se->next_prev);
7814 : : }
7815 : :
7816 : 0 : perf_event_header__init_id(&se->event_id.header, &sample, event);
7817 : :
7818 : 0 : ret = perf_output_begin(&handle, event, se->event_id.header.size);
7819 [ # # ]: 0 : if (ret)
7820 : : return;
7821 : :
7822 [ # # ]: 0 : if (event->ctx->task)
7823 : 0 : perf_output_put(&handle, se->event_id.header);
7824 : : else
7825 : 0 : perf_output_put(&handle, se->event_id);
7826 : :
7827 : : perf_event__output_id_sample(event, &handle, &sample);
7828 : :
7829 : 0 : perf_output_end(&handle);
7830 : : }
7831 : :
7832 : 0 : static void perf_event_switch(struct task_struct *task,
7833 : : struct task_struct *next_prev, bool sched_in)
7834 : : {
7835 : : struct perf_switch_event switch_event;
7836 : :
7837 : : /* N.B. caller checks nr_switch_events != 0 */
7838 : :
7839 [ # # ]: 0 : switch_event = (struct perf_switch_event){
7840 : : .task = task,
7841 : : .next_prev = next_prev,
7842 : : .event_id = {
7843 : : .header = {
7844 : : /* .type */
7845 : : .misc = sched_in ? 0 : PERF_RECORD_MISC_SWITCH_OUT,
7846 : : /* .size */
7847 : : },
7848 : : /* .next_prev_pid */
7849 : : /* .next_prev_tid */
7850 : : },
7851 : : };
7852 : :
7853 [ # # # # ]: 0 : if (!sched_in && task->state == TASK_RUNNING)
7854 : 0 : switch_event.event_id.header.misc |=
7855 : : PERF_RECORD_MISC_SWITCH_OUT_PREEMPT;
7856 : :
7857 : 0 : perf_iterate_sb(perf_event_switch_output,
7858 : : &switch_event,
7859 : : NULL);
7860 : 0 : }
7861 : :
7862 : : /*
7863 : : * IRQ throttle logging
7864 : : */
7865 : :
7866 : 0 : static void perf_log_throttle(struct perf_event *event, int enable)
7867 : : {
7868 : : struct perf_output_handle handle;
7869 : : struct perf_sample_data sample;
7870 : : int ret;
7871 : :
7872 : : struct {
7873 : : struct perf_event_header header;
7874 : : u64 time;
7875 : : u64 id;
7876 : : u64 stream_id;
7877 : 0 : } throttle_event = {
7878 : : .header = {
7879 : : .type = PERF_RECORD_THROTTLE,
7880 : : .misc = 0,
7881 : : .size = sizeof(throttle_event),
7882 : : },
7883 : : .time = perf_event_clock(event),
7884 : : .id = primary_event_id(event),
7885 : : .stream_id = event->id,
7886 : : };
7887 : :
7888 [ # # ]: 0 : if (enable)
7889 : 0 : throttle_event.header.type = PERF_RECORD_UNTHROTTLE;
7890 : :
7891 : : perf_event_header__init_id(&throttle_event.header, &sample, event);
7892 : :
7893 : 0 : ret = perf_output_begin(&handle, event,
7894 : 0 : throttle_event.header.size);
7895 [ # # ]: 0 : if (ret)
7896 : 0 : return;
7897 : :
7898 : 0 : perf_output_put(&handle, throttle_event);
7899 : : perf_event__output_id_sample(event, &handle, &sample);
7900 : 0 : perf_output_end(&handle);
7901 : : }
7902 : :
7903 : : /*
7904 : : * ksymbol register/unregister tracking
7905 : : */
7906 : :
7907 : : struct perf_ksymbol_event {
7908 : : const char *name;
7909 : : int name_len;
7910 : : struct {
7911 : : struct perf_event_header header;
7912 : : u64 addr;
7913 : : u32 len;
7914 : : u16 ksym_type;
7915 : : u16 flags;
7916 : : } event_id;
7917 : : };
7918 : :
7919 : : static int perf_event_ksymbol_match(struct perf_event *event)
7920 : : {
7921 : 0 : return event->attr.ksymbol;
7922 : : }
7923 : :
7924 : 0 : static void perf_event_ksymbol_output(struct perf_event *event, void *data)
7925 : : {
7926 : : struct perf_ksymbol_event *ksymbol_event = data;
7927 : : struct perf_output_handle handle;
7928 : : struct perf_sample_data sample;
7929 : : int ret;
7930 : :
7931 [ # # ]: 0 : if (!perf_event_ksymbol_match(event))
7932 : 0 : return;
7933 : :
7934 : 0 : perf_event_header__init_id(&ksymbol_event->event_id.header,
7935 : : &sample, event);
7936 : 0 : ret = perf_output_begin(&handle, event,
7937 : 0 : ksymbol_event->event_id.header.size);
7938 [ # # ]: 0 : if (ret)
7939 : : return;
7940 : :
7941 : 0 : perf_output_put(&handle, ksymbol_event->event_id);
7942 : 0 : __output_copy(&handle, ksymbol_event->name, ksymbol_event->name_len);
7943 : : perf_event__output_id_sample(event, &handle, &sample);
7944 : :
7945 : 0 : perf_output_end(&handle);
7946 : : }
7947 : :
7948 : 0 : void perf_event_ksymbol(u16 ksym_type, u64 addr, u32 len, bool unregister,
7949 : : const char *sym)
7950 : : {
7951 : : struct perf_ksymbol_event ksymbol_event;
7952 : : char name[KSYM_NAME_LEN];
7953 : : u16 flags = 0;
7954 : : int name_len;
7955 : :
7956 [ # # ]: 0 : if (!atomic_read(&nr_ksymbol_events))
7957 : 0 : return;
7958 : :
7959 [ # # ]: 0 : if (ksym_type >= PERF_RECORD_KSYMBOL_TYPE_MAX ||
7960 : : ksym_type == PERF_RECORD_KSYMBOL_TYPE_UNKNOWN)
7961 : : goto err;
7962 : :
7963 : 0 : strlcpy(name, sym, KSYM_NAME_LEN);
7964 : 0 : name_len = strlen(name) + 1;
7965 [ # # ]: 0 : while (!IS_ALIGNED(name_len, sizeof(u64)))
7966 : 0 : name[name_len++] = '\0';
7967 : : BUILD_BUG_ON(KSYM_NAME_LEN % sizeof(u64));
7968 : :
7969 [ # # ]: 0 : if (unregister)
7970 : : flags |= PERF_RECORD_KSYMBOL_FLAGS_UNREGISTER;
7971 : :
7972 : 0 : ksymbol_event = (struct perf_ksymbol_event){
7973 : : .name = name,
7974 : : .name_len = name_len,
7975 : : .event_id = {
7976 : : .header = {
7977 : : .type = PERF_RECORD_KSYMBOL,
7978 : : .size = sizeof(ksymbol_event.event_id) +
7979 : : name_len,
7980 : : },
7981 : : .addr = addr,
7982 : : .len = len,
7983 : : .ksym_type = ksym_type,
7984 : : .flags = flags,
7985 : : },
7986 : : };
7987 : :
7988 : 0 : perf_iterate_sb(perf_event_ksymbol_output, &ksymbol_event, NULL);
7989 : 0 : return;
7990 : : err:
7991 [ # # ]: 0 : WARN_ONCE(1, "%s: Invalid KSYMBOL type 0x%x\n", __func__, ksym_type);
7992 : : }
7993 : :
7994 : : /*
7995 : : * bpf program load/unload tracking
7996 : : */
7997 : :
7998 : : struct perf_bpf_event {
7999 : : struct bpf_prog *prog;
8000 : : struct {
8001 : : struct perf_event_header header;
8002 : : u16 type;
8003 : : u16 flags;
8004 : : u32 id;
8005 : : u8 tag[BPF_TAG_SIZE];
8006 : : } event_id;
8007 : : };
8008 : :
8009 : : static int perf_event_bpf_match(struct perf_event *event)
8010 : : {
8011 : 0 : return event->attr.bpf_event;
8012 : : }
8013 : :
8014 : 0 : static void perf_event_bpf_output(struct perf_event *event, void *data)
8015 : : {
8016 : : struct perf_bpf_event *bpf_event = data;
8017 : : struct perf_output_handle handle;
8018 : : struct perf_sample_data sample;
8019 : : int ret;
8020 : :
8021 [ # # ]: 0 : if (!perf_event_bpf_match(event))
8022 : 0 : return;
8023 : :
8024 : 0 : perf_event_header__init_id(&bpf_event->event_id.header,
8025 : : &sample, event);
8026 : 0 : ret = perf_output_begin(&handle, event,
8027 : 0 : bpf_event->event_id.header.size);
8028 [ # # ]: 0 : if (ret)
8029 : : return;
8030 : :
8031 : 0 : perf_output_put(&handle, bpf_event->event_id);
8032 : : perf_event__output_id_sample(event, &handle, &sample);
8033 : :
8034 : 0 : perf_output_end(&handle);
8035 : : }
8036 : :
8037 : 0 : static void perf_event_bpf_emit_ksymbols(struct bpf_prog *prog,
8038 : : enum perf_bpf_event_type type)
8039 : : {
8040 : 0 : bool unregister = type == PERF_BPF_EVENT_PROG_UNLOAD;
8041 : : char sym[KSYM_NAME_LEN];
8042 : : int i;
8043 : :
8044 [ # # ]: 0 : if (prog->aux->func_cnt == 0) {
8045 : : bpf_get_prog_name(prog, sym);
8046 : 0 : perf_event_ksymbol(PERF_RECORD_KSYMBOL_TYPE_BPF,
8047 : 0 : (u64)(unsigned long)prog->bpf_func,
8048 : : prog->jited_len, unregister, sym);
8049 : : } else {
8050 [ # # ]: 0 : for (i = 0; i < prog->aux->func_cnt; i++) {
8051 : 0 : struct bpf_prog *subprog = prog->aux->func[i];
8052 : :
8053 : : bpf_get_prog_name(subprog, sym);
8054 : 0 : perf_event_ksymbol(
8055 : : PERF_RECORD_KSYMBOL_TYPE_BPF,
8056 : 0 : (u64)(unsigned long)subprog->bpf_func,
8057 : : subprog->jited_len, unregister, sym);
8058 : : }
8059 : : }
8060 : 0 : }
8061 : :
8062 : 2070 : void perf_event_bpf_event(struct bpf_prog *prog,
8063 : : enum perf_bpf_event_type type,
8064 : : u16 flags)
8065 : : {
8066 : : struct perf_bpf_event bpf_event;
8067 : :
8068 [ + - ]: 2070 : if (type <= PERF_BPF_EVENT_UNKNOWN ||
8069 : : type >= PERF_BPF_EVENT_MAX)
8070 : 2070 : return;
8071 : :
8072 [ + - ]: 2070 : switch (type) {
8073 : : case PERF_BPF_EVENT_PROG_LOAD:
8074 : : case PERF_BPF_EVENT_PROG_UNLOAD:
8075 [ - + ]: 2070 : if (atomic_read(&nr_ksymbol_events))
8076 : 0 : perf_event_bpf_emit_ksymbols(prog, type);
8077 : : break;
8078 : : default:
8079 : : break;
8080 : : }
8081 : :
8082 [ - + ]: 2070 : if (!atomic_read(&nr_bpf_events))
8083 : : return;
8084 : :
8085 : 0 : bpf_event = (struct perf_bpf_event){
8086 : : .prog = prog,
8087 : : .event_id = {
8088 : : .header = {
8089 : : .type = PERF_RECORD_BPF_EVENT,
8090 : : .size = sizeof(bpf_event.event_id),
8091 : : },
8092 : : .type = type,
8093 : : .flags = flags,
8094 : 0 : .id = prog->aux->id,
8095 : : },
8096 : : };
8097 : :
8098 : : BUILD_BUG_ON(BPF_TAG_SIZE % sizeof(u64));
8099 : :
8100 : 0 : memcpy(bpf_event.event_id.tag, prog->tag, BPF_TAG_SIZE);
8101 : 0 : perf_iterate_sb(perf_event_bpf_output, &bpf_event, NULL);
8102 : : }
8103 : :
8104 : 0 : void perf_event_itrace_started(struct perf_event *event)
8105 : : {
8106 : 0 : event->attach_state |= PERF_ATTACH_ITRACE;
8107 : 0 : }
8108 : :
8109 : 0 : static void perf_log_itrace_start(struct perf_event *event)
8110 : : {
8111 : : struct perf_output_handle handle;
8112 : : struct perf_sample_data sample;
8113 : : struct perf_aux_event {
8114 : : struct perf_event_header header;
8115 : : u32 pid;
8116 : : u32 tid;
8117 : : } rec;
8118 : : int ret;
8119 : :
8120 [ # # ]: 0 : if (event->parent)
8121 : : event = event->parent;
8122 : :
8123 [ # # # # ]: 0 : if (!(event->pmu->capabilities & PERF_PMU_CAP_ITRACE) ||
8124 : 0 : event->attach_state & PERF_ATTACH_ITRACE)
8125 : 0 : return;
8126 : :
8127 : 0 : rec.header.type = PERF_RECORD_ITRACE_START;
8128 : 0 : rec.header.misc = 0;
8129 : 0 : rec.header.size = sizeof(rec);
8130 : 0 : rec.pid = perf_event_pid(event, current);
8131 : 0 : rec.tid = perf_event_tid(event, current);
8132 : :
8133 : : perf_event_header__init_id(&rec.header, &sample, event);
8134 : 0 : ret = perf_output_begin(&handle, event, rec.header.size);
8135 : :
8136 [ # # ]: 0 : if (ret)
8137 : : return;
8138 : :
8139 : 0 : perf_output_put(&handle, rec);
8140 : : perf_event__output_id_sample(event, &handle, &sample);
8141 : :
8142 : 0 : perf_output_end(&handle);
8143 : : }
8144 : :
8145 : : static int
8146 : 0 : __perf_event_account_interrupt(struct perf_event *event, int throttle)
8147 : : {
8148 : : struct hw_perf_event *hwc = &event->hw;
8149 : : int ret = 0;
8150 : : u64 seq;
8151 : :
8152 : 0 : seq = __this_cpu_read(perf_throttled_seq);
8153 [ # # ]: 0 : if (seq != hwc->interrupts_seq) {
8154 : 0 : hwc->interrupts_seq = seq;
8155 : 0 : hwc->interrupts = 1;
8156 : : } else {
8157 : 0 : hwc->interrupts++;
8158 [ # # # # ]: 0 : if (unlikely(throttle
8159 : : && hwc->interrupts >= max_samples_per_tick)) {
8160 : 0 : __this_cpu_inc(perf_throttled_count);
8161 : : tick_dep_set_cpu(smp_processor_id(), TICK_DEP_BIT_PERF_EVENTS);
8162 : 0 : hwc->interrupts = MAX_INTERRUPTS;
8163 : 0 : perf_log_throttle(event, 0);
8164 : : ret = 1;
8165 : : }
8166 : : }
8167 : :
8168 [ # # ]: 0 : if (event->attr.freq) {
8169 : : u64 now = perf_clock();
8170 : 0 : s64 delta = now - hwc->freq_time_stamp;
8171 : :
8172 : 0 : hwc->freq_time_stamp = now;
8173 : :
8174 [ # # ]: 0 : if (delta > 0 && delta < 2*TICK_NSEC)
8175 : 0 : perf_adjust_period(event, delta, hwc->last_period, true);
8176 : : }
8177 : :
8178 : 0 : return ret;
8179 : : }
8180 : :
8181 : 0 : int perf_event_account_interrupt(struct perf_event *event)
8182 : : {
8183 : 0 : return __perf_event_account_interrupt(event, 1);
8184 : : }
8185 : :
8186 : : /*
8187 : : * Generic event overflow handling, sampling.
8188 : : */
8189 : :
8190 : 0 : static int __perf_event_overflow(struct perf_event *event,
8191 : : int throttle, struct perf_sample_data *data,
8192 : : struct pt_regs *regs)
8193 : : {
8194 : 0 : int events = atomic_read(&event->event_limit);
8195 : : int ret = 0;
8196 : :
8197 : : /*
8198 : : * Non-sampling counters might still use the PMI to fold short
8199 : : * hardware counters, ignore those.
8200 : : */
8201 [ # # ]: 0 : if (unlikely(!is_sampling_event(event)))
8202 : : return 0;
8203 : :
8204 : 0 : ret = __perf_event_account_interrupt(event, throttle);
8205 : :
8206 : : /*
8207 : : * XXX event_limit might not quite work as expected on inherited
8208 : : * events
8209 : : */
8210 : :
8211 : 0 : event->pending_kill = POLL_IN;
8212 [ # # # # ]: 0 : if (events && atomic_dec_and_test(&event->event_limit)) {
8213 : : ret = 1;
8214 : 0 : event->pending_kill = POLL_HUP;
8215 : :
8216 : : perf_event_disable_inatomic(event);
8217 : : }
8218 : :
8219 : 0 : READ_ONCE(event->overflow_handler)(event, data, regs);
8220 : :
8221 [ # # # # ]: 0 : if (*perf_event_fasync(event) && event->pending_kill) {
8222 : 0 : event->pending_wakeup = 1;
8223 : 0 : irq_work_queue(&event->pending);
8224 : : }
8225 : :
8226 : 0 : return ret;
8227 : : }
8228 : :
8229 : 0 : int perf_event_overflow(struct perf_event *event,
8230 : : struct perf_sample_data *data,
8231 : : struct pt_regs *regs)
8232 : : {
8233 : 0 : return __perf_event_overflow(event, 1, data, regs);
8234 : : }
8235 : :
8236 : : /*
8237 : : * Generic software event infrastructure
8238 : : */
8239 : :
8240 : : struct swevent_htable {
8241 : : struct swevent_hlist *swevent_hlist;
8242 : : struct mutex hlist_mutex;
8243 : : int hlist_refcount;
8244 : :
8245 : : /* Recursion avoidance in each contexts */
8246 : : int recursion[PERF_NR_CONTEXTS];
8247 : : };
8248 : :
8249 : : static DEFINE_PER_CPU(struct swevent_htable, swevent_htable);
8250 : :
8251 : : /*
8252 : : * We directly increment event->count and keep a second value in
8253 : : * event->hw.period_left to count intervals. This period event
8254 : : * is kept in the range [-sample_period, 0] so that we can use the
8255 : : * sign as trigger.
8256 : : */
8257 : :
8258 : 0 : u64 perf_swevent_set_period(struct perf_event *event)
8259 : : {
8260 : : struct hw_perf_event *hwc = &event->hw;
8261 : 0 : u64 period = hwc->last_period;
8262 : : u64 nr, offset;
8263 : : s64 old, val;
8264 : :
8265 : 0 : hwc->last_period = hwc->sample_period;
8266 : :
8267 : : again:
8268 : 0 : old = val = local64_read(&hwc->period_left);
8269 [ # # ]: 0 : if (val < 0)
8270 : : return 0;
8271 : :
8272 : 0 : nr = div64_u64(period + val, period);
8273 : 0 : offset = nr * period;
8274 : 0 : val -= offset;
8275 [ # # ]: 0 : if (local64_cmpxchg(&hwc->period_left, old, val) != old)
8276 : : goto again;
8277 : :
8278 : 0 : return nr;
8279 : : }
8280 : :
8281 : 0 : static void perf_swevent_overflow(struct perf_event *event, u64 overflow,
8282 : : struct perf_sample_data *data,
8283 : : struct pt_regs *regs)
8284 : : {
8285 : : struct hw_perf_event *hwc = &event->hw;
8286 : : int throttle = 0;
8287 : :
8288 [ # # ]: 0 : if (!overflow)
8289 : 0 : overflow = perf_swevent_set_period(event);
8290 : :
8291 [ # # ]: 0 : if (hwc->interrupts == MAX_INTERRUPTS)
8292 : 0 : return;
8293 : :
8294 [ # # ]: 0 : for (; overflow; overflow--) {
8295 [ # # ]: 0 : if (__perf_event_overflow(event, throttle,
8296 : : data, regs)) {
8297 : : /*
8298 : : * We inhibit the overflow from happening when
8299 : : * hwc->interrupts == MAX_INTERRUPTS.
8300 : : */
8301 : : break;
8302 : : }
8303 : : throttle = 1;
8304 : : }
8305 : : }
8306 : :
8307 : 0 : static void perf_swevent_event(struct perf_event *event, u64 nr,
8308 : : struct perf_sample_data *data,
8309 : : struct pt_regs *regs)
8310 : : {
8311 : : struct hw_perf_event *hwc = &event->hw;
8312 : :
8313 : 0 : local64_add(nr, &event->count);
8314 : :
8315 [ # # ]: 0 : if (!regs)
8316 : : return;
8317 : :
8318 [ # # ]: 0 : if (!is_sampling_event(event))
8319 : : return;
8320 : :
8321 [ # # # # ]: 0 : if ((event->attr.sample_type & PERF_SAMPLE_PERIOD) && !event->attr.freq) {
8322 : 0 : data->period = nr;
8323 : 0 : return perf_swevent_overflow(event, 1, data, regs);
8324 : : } else
8325 : 0 : data->period = event->hw.last_period;
8326 : :
8327 [ # # # # : 0 : if (nr == 1 && hwc->sample_period == 1 && !event->attr.freq)
# # ]
8328 : 0 : return perf_swevent_overflow(event, 1, data, regs);
8329 : :
8330 [ # # ]: 0 : if (local64_add_negative(nr, &hwc->period_left))
8331 : : return;
8332 : :
8333 : 0 : perf_swevent_overflow(event, 0, data, regs);
8334 : : }
8335 : :
8336 : 0 : static int perf_exclude_event(struct perf_event *event,
8337 : : struct pt_regs *regs)
8338 : : {
8339 [ # # ]: 0 : if (event->hw.state & PERF_HES_STOPPED)
8340 : : return 1;
8341 : :
8342 [ # # ]: 0 : if (regs) {
8343 [ # # # # ]: 0 : if (event->attr.exclude_user && user_mode(regs))
8344 : : return 1;
8345 : :
8346 [ # # # # ]: 0 : if (event->attr.exclude_kernel && !user_mode(regs))
8347 : : return 1;
8348 : : }
8349 : :
8350 : 0 : return 0;
8351 : : }
8352 : :
8353 : : static int perf_swevent_match(struct perf_event *event,
8354 : : enum perf_type_id type,
8355 : : u32 event_id,
8356 : : struct perf_sample_data *data,
8357 : : struct pt_regs *regs)
8358 : : {
8359 [ # # ]: 0 : if (event->attr.type != type)
8360 : : return 0;
8361 : :
8362 [ # # ]: 0 : if (event->attr.config != event_id)
8363 : : return 0;
8364 : :
8365 [ # # ]: 0 : if (perf_exclude_event(event, regs))
8366 : : return 0;
8367 : :
8368 : : return 1;
8369 : : }
8370 : :
8371 : 0 : static inline u64 swevent_hash(u64 type, u32 event_id)
8372 : : {
8373 : 0 : u64 val = event_id | (type << 32);
8374 : :
8375 : 0 : return hash_64(val, SWEVENT_HLIST_BITS);
8376 : : }
8377 : :
8378 : : static inline struct hlist_head *
8379 : : __find_swevent_head(struct swevent_hlist *hlist, u64 type, u32 event_id)
8380 : : {
8381 : 0 : u64 hash = swevent_hash(type, event_id);
8382 : :
8383 : 0 : return &hlist->heads[hash];
8384 : : }
8385 : :
8386 : : /* For the read side: events when they trigger */
8387 : : static inline struct hlist_head *
8388 : : find_swevent_head_rcu(struct swevent_htable *swhash, u64 type, u32 event_id)
8389 : : {
8390 : : struct swevent_hlist *hlist;
8391 : :
8392 : 0 : hlist = rcu_dereference(swhash->swevent_hlist);
8393 [ # # ]: 0 : if (!hlist)
8394 : : return NULL;
8395 : :
8396 : : return __find_swevent_head(hlist, type, event_id);
8397 : : }
8398 : :
8399 : : /* For the event head insertion and removal in the hlist */
8400 : : static inline struct hlist_head *
8401 : 0 : find_swevent_head(struct swevent_htable *swhash, struct perf_event *event)
8402 : : {
8403 : : struct swevent_hlist *hlist;
8404 : 0 : u32 event_id = event->attr.config;
8405 : 0 : u64 type = event->attr.type;
8406 : :
8407 : : /*
8408 : : * Event scheduling is always serialized against hlist allocation
8409 : : * and release. Which makes the protected version suitable here.
8410 : : * The context lock guarantees that.
8411 : : */
8412 : 0 : hlist = rcu_dereference_protected(swhash->swevent_hlist,
8413 : : lockdep_is_held(&event->ctx->lock));
8414 [ # # ]: 0 : if (!hlist)
8415 : : return NULL;
8416 : :
8417 : 0 : return __find_swevent_head(hlist, type, event_id);
8418 : : }
8419 : :
8420 : 0 : static void do_perf_sw_event(enum perf_type_id type, u32 event_id,
8421 : : u64 nr,
8422 : : struct perf_sample_data *data,
8423 : : struct pt_regs *regs)
8424 : : {
8425 : 0 : struct swevent_htable *swhash = this_cpu_ptr(&swevent_htable);
8426 : : struct perf_event *event;
8427 : : struct hlist_head *head;
8428 : :
8429 : : rcu_read_lock();
8430 : 0 : head = find_swevent_head_rcu(swhash, type, event_id);
8431 [ # # ]: 0 : if (!head)
8432 : : goto end;
8433 : :
8434 [ # # # # : 0 : hlist_for_each_entry_rcu(event, head, hlist_entry) {
# # ]
8435 [ # # ]: 0 : if (perf_swevent_match(event, type, event_id, data, regs))
8436 : 0 : perf_swevent_event(event, nr, data, regs);
8437 : : }
8438 : : end:
8439 : : rcu_read_unlock();
8440 : 0 : }
8441 : :
8442 : : DEFINE_PER_CPU(struct pt_regs, __perf_regs[4]);
8443 : :
8444 : 0 : int perf_swevent_get_recursion_context(void)
8445 : : {
8446 : 0 : struct swevent_htable *swhash = this_cpu_ptr(&swevent_htable);
8447 : :
8448 : 0 : return get_recursion_context(swhash->recursion);
8449 : : }
8450 : : EXPORT_SYMBOL_GPL(perf_swevent_get_recursion_context);
8451 : :
8452 : 0 : void perf_swevent_put_recursion_context(int rctx)
8453 : : {
8454 : 0 : struct swevent_htable *swhash = this_cpu_ptr(&swevent_htable);
8455 : :
8456 : 0 : put_recursion_context(swhash->recursion, rctx);
8457 : 0 : }
8458 : :
8459 : 0 : void ___perf_sw_event(u32 event_id, u64 nr, struct pt_regs *regs, u64 addr)
8460 : : {
8461 : : struct perf_sample_data data;
8462 : :
8463 [ # # # # : 0 : if (WARN_ON_ONCE(!regs))
# # ]
8464 : 0 : return;
8465 : :
8466 : : perf_sample_data_init(&data, addr, 0);
8467 : 0 : do_perf_sw_event(PERF_TYPE_SOFTWARE, event_id, nr, &data, regs);
8468 : : }
8469 : :
8470 : 0 : void __perf_sw_event(u32 event_id, u64 nr, struct pt_regs *regs, u64 addr)
8471 : : {
8472 : : int rctx;
8473 : :
8474 : 0 : preempt_disable_notrace();
8475 : : rctx = perf_swevent_get_recursion_context();
8476 [ # # ]: 0 : if (unlikely(rctx < 0))
8477 : : goto fail;
8478 : :
8479 : 0 : ___perf_sw_event(event_id, nr, regs, addr);
8480 : :
8481 : : perf_swevent_put_recursion_context(rctx);
8482 : : fail:
8483 : 0 : preempt_enable_notrace();
8484 : 0 : }
8485 : :
8486 : 0 : static void perf_swevent_read(struct perf_event *event)
8487 : : {
8488 : 0 : }
8489 : :
8490 : 0 : static int perf_swevent_add(struct perf_event *event, int flags)
8491 : : {
8492 : 0 : struct swevent_htable *swhash = this_cpu_ptr(&swevent_htable);
8493 : : struct hw_perf_event *hwc = &event->hw;
8494 : : struct hlist_head *head;
8495 : :
8496 [ # # ]: 0 : if (is_sampling_event(event)) {
8497 : 0 : hwc->last_period = hwc->sample_period;
8498 : 0 : perf_swevent_set_period(event);
8499 : : }
8500 : :
8501 : 0 : hwc->state = !(flags & PERF_EF_START);
8502 : :
8503 : 0 : head = find_swevent_head(swhash, event);
8504 [ # # # # : 0 : if (WARN_ON_ONCE(!head))
# # ]
8505 : : return -EINVAL;
8506 : :
8507 : 0 : hlist_add_head_rcu(&event->hlist_entry, head);
8508 : 0 : perf_event_update_userpage(event);
8509 : :
8510 : 0 : return 0;
8511 : : }
8512 : :
8513 : 0 : static void perf_swevent_del(struct perf_event *event, int flags)
8514 : : {
8515 : : hlist_del_rcu(&event->hlist_entry);
8516 : 0 : }
8517 : :
8518 : 0 : static void perf_swevent_start(struct perf_event *event, int flags)
8519 : : {
8520 : 0 : event->hw.state = 0;
8521 : 0 : }
8522 : :
8523 : 0 : static void perf_swevent_stop(struct perf_event *event, int flags)
8524 : : {
8525 : 0 : event->hw.state = PERF_HES_STOPPED;
8526 : 0 : }
8527 : :
8528 : : /* Deref the hlist from the update side */
8529 : : static inline struct swevent_hlist *
8530 : : swevent_hlist_deref(struct swevent_htable *swhash)
8531 : : {
8532 : 0 : return rcu_dereference_protected(swhash->swevent_hlist,
8533 : : lockdep_is_held(&swhash->hlist_mutex));
8534 : : }
8535 : :
8536 : 0 : static void swevent_hlist_release(struct swevent_htable *swhash)
8537 : : {
8538 : : struct swevent_hlist *hlist = swevent_hlist_deref(swhash);
8539 : :
8540 [ # # ]: 0 : if (!hlist)
8541 : 0 : return;
8542 : :
8543 : : RCU_INIT_POINTER(swhash->swevent_hlist, NULL);
8544 [ # # ]: 0 : kfree_rcu(hlist, rcu_head);
8545 : : }
8546 : :
8547 : 0 : static void swevent_hlist_put_cpu(int cpu)
8548 : : {
8549 : 0 : struct swevent_htable *swhash = &per_cpu(swevent_htable, cpu);
8550 : :
8551 : 0 : mutex_lock(&swhash->hlist_mutex);
8552 : :
8553 [ # # ]: 0 : if (!--swhash->hlist_refcount)
8554 : 0 : swevent_hlist_release(swhash);
8555 : :
8556 : 0 : mutex_unlock(&swhash->hlist_mutex);
8557 : 0 : }
8558 : :
8559 : 0 : static void swevent_hlist_put(void)
8560 : : {
8561 : : int cpu;
8562 : :
8563 [ # # ]: 0 : for_each_possible_cpu(cpu)
8564 : 0 : swevent_hlist_put_cpu(cpu);
8565 : 0 : }
8566 : :
8567 : 0 : static int swevent_hlist_get_cpu(int cpu)
8568 : : {
8569 : 0 : struct swevent_htable *swhash = &per_cpu(swevent_htable, cpu);
8570 : : int err = 0;
8571 : :
8572 : 0 : mutex_lock(&swhash->hlist_mutex);
8573 [ # # # # ]: 0 : if (!swevent_hlist_deref(swhash) &&
8574 : : cpumask_test_cpu(cpu, perf_online_mask)) {
8575 : : struct swevent_hlist *hlist;
8576 : :
8577 : 0 : hlist = kzalloc(sizeof(*hlist), GFP_KERNEL);
8578 [ # # ]: 0 : if (!hlist) {
8579 : : err = -ENOMEM;
8580 : : goto exit;
8581 : : }
8582 : 0 : rcu_assign_pointer(swhash->swevent_hlist, hlist);
8583 : : }
8584 : 0 : swhash->hlist_refcount++;
8585 : : exit:
8586 : 0 : mutex_unlock(&swhash->hlist_mutex);
8587 : :
8588 : 0 : return err;
8589 : : }
8590 : :
8591 : 0 : static int swevent_hlist_get(void)
8592 : : {
8593 : : int err, cpu, failed_cpu;
8594 : :
8595 : 0 : mutex_lock(&pmus_lock);
8596 [ # # ]: 0 : for_each_possible_cpu(cpu) {
8597 : 0 : err = swevent_hlist_get_cpu(cpu);
8598 [ # # ]: 0 : if (err) {
8599 : 0 : failed_cpu = cpu;
8600 : : goto fail;
8601 : : }
8602 : : }
8603 : 0 : mutex_unlock(&pmus_lock);
8604 : 0 : return 0;
8605 : : fail:
8606 [ # # ]: 0 : for_each_possible_cpu(cpu) {
8607 [ # # ]: 0 : if (cpu == failed_cpu)
8608 : : break;
8609 : 0 : swevent_hlist_put_cpu(cpu);
8610 : : }
8611 : 0 : mutex_unlock(&pmus_lock);
8612 : 0 : return err;
8613 : : }
8614 : :
8615 : : struct static_key perf_swevent_enabled[PERF_COUNT_SW_MAX];
8616 : :
8617 : 0 : static void sw_perf_event_destroy(struct perf_event *event)
8618 : : {
8619 : 0 : u64 event_id = event->attr.config;
8620 : :
8621 [ # # ]: 0 : WARN_ON(event->parent);
8622 : :
8623 : 0 : static_key_slow_dec(&perf_swevent_enabled[event_id]);
8624 : 0 : swevent_hlist_put();
8625 : 0 : }
8626 : :
8627 : 0 : static int perf_swevent_init(struct perf_event *event)
8628 : : {
8629 : 0 : u64 event_id = event->attr.config;
8630 : :
8631 [ # # ]: 0 : if (event->attr.type != PERF_TYPE_SOFTWARE)
8632 : : return -ENOENT;
8633 : :
8634 : : /*
8635 : : * no branch sampling for software events
8636 : : */
8637 [ # # ]: 0 : if (has_branch_stack(event))
8638 : : return -EOPNOTSUPP;
8639 : :
8640 [ # # ]: 0 : switch (event_id) {
8641 : : case PERF_COUNT_SW_CPU_CLOCK:
8642 : : case PERF_COUNT_SW_TASK_CLOCK:
8643 : : return -ENOENT;
8644 : :
8645 : : default:
8646 : : break;
8647 : : }
8648 : :
8649 [ # # ]: 0 : if (event_id >= PERF_COUNT_SW_MAX)
8650 : : return -ENOENT;
8651 : :
8652 [ # # ]: 0 : if (!event->parent) {
8653 : : int err;
8654 : :
8655 : 0 : err = swevent_hlist_get();
8656 [ # # ]: 0 : if (err)
8657 : : return err;
8658 : :
8659 : 0 : static_key_slow_inc(&perf_swevent_enabled[event_id]);
8660 : 0 : event->destroy = sw_perf_event_destroy;
8661 : : }
8662 : :
8663 : : return 0;
8664 : : }
8665 : :
8666 : : static struct pmu perf_swevent = {
8667 : : .task_ctx_nr = perf_sw_context,
8668 : :
8669 : : .capabilities = PERF_PMU_CAP_NO_NMI,
8670 : :
8671 : : .event_init = perf_swevent_init,
8672 : : .add = perf_swevent_add,
8673 : : .del = perf_swevent_del,
8674 : : .start = perf_swevent_start,
8675 : : .stop = perf_swevent_stop,
8676 : : .read = perf_swevent_read,
8677 : : };
8678 : :
8679 : : #ifdef CONFIG_EVENT_TRACING
8680 : :
8681 : 0 : static int perf_tp_filter_match(struct perf_event *event,
8682 : : struct perf_sample_data *data)
8683 : : {
8684 : 0 : void *record = data->raw->frag.data;
8685 : :
8686 : : /* only top level events have filters set */
8687 [ # # ]: 0 : if (event->parent)
8688 : : event = event->parent;
8689 : :
8690 [ # # # # ]: 0 : if (likely(!event->filter) || filter_match_preds(event->filter, record))
8691 : : return 1;
8692 : : return 0;
8693 : : }
8694 : :
8695 : 0 : static int perf_tp_event_match(struct perf_event *event,
8696 : : struct perf_sample_data *data,
8697 : : struct pt_regs *regs)
8698 : : {
8699 [ # # ]: 0 : if (event->hw.state & PERF_HES_STOPPED)
8700 : : return 0;
8701 : : /*
8702 : : * If exclude_kernel, only trace user-space tracepoints (uprobes)
8703 : : */
8704 [ # # # # ]: 0 : if (event->attr.exclude_kernel && !user_mode(regs))
8705 : : return 0;
8706 : :
8707 [ # # ]: 0 : if (!perf_tp_filter_match(event, data))
8708 : : return 0;
8709 : :
8710 : 0 : return 1;
8711 : : }
8712 : :
8713 : 0 : void perf_trace_run_bpf_submit(void *raw_data, int size, int rctx,
8714 : : struct trace_event_call *call, u64 count,
8715 : : struct pt_regs *regs, struct hlist_head *head,
8716 : : struct task_struct *task)
8717 : : {
8718 [ # # ]: 0 : if (bpf_prog_array_valid(call)) {
8719 : 0 : *(struct pt_regs **)raw_data = regs;
8720 [ # # # # ]: 0 : if (!trace_call_bpf(call, raw_data) || hlist_empty(head)) {
8721 : : perf_swevent_put_recursion_context(rctx);
8722 : 0 : return;
8723 : : }
8724 : : }
8725 : 0 : perf_tp_event(call->event.type, count, raw_data, size, regs, head,
8726 : : rctx, task);
8727 : : }
8728 : : EXPORT_SYMBOL_GPL(perf_trace_run_bpf_submit);
8729 : :
8730 : 0 : void perf_tp_event(u16 event_type, u64 count, void *record, int entry_size,
8731 : : struct pt_regs *regs, struct hlist_head *head, int rctx,
8732 : : struct task_struct *task)
8733 : : {
8734 : : struct perf_sample_data data;
8735 : : struct perf_event *event;
8736 : :
8737 : 0 : struct perf_raw_record raw = {
8738 : : .frag = {
8739 : : .size = entry_size,
8740 : : .data = record,
8741 : : },
8742 : : };
8743 : :
8744 : : perf_sample_data_init(&data, 0, 0);
8745 : 0 : data.raw = &raw;
8746 : :
8747 : 0 : perf_trace_buf_update(record, event_type);
8748 : :
8749 [ # # # # : 0 : hlist_for_each_entry_rcu(event, head, hlist_entry) {
# # ]
8750 [ # # ]: 0 : if (perf_tp_event_match(event, &data, regs))
8751 : 0 : perf_swevent_event(event, count, &data, regs);
8752 : : }
8753 : :
8754 : : /*
8755 : : * If we got specified a target task, also iterate its context and
8756 : : * deliver this event there too.
8757 : : */
8758 [ # # # # ]: 0 : if (task && task != current) {
8759 : : struct perf_event_context *ctx;
8760 : : struct trace_entry *entry = record;
8761 : :
8762 : : rcu_read_lock();
8763 : 0 : ctx = rcu_dereference(task->perf_event_ctxp[perf_sw_context]);
8764 [ # # ]: 0 : if (!ctx)
8765 : : goto unlock;
8766 : :
8767 [ # # ]: 0 : list_for_each_entry_rcu(event, &ctx->event_list, event_entry) {
8768 [ # # ]: 0 : if (event->cpu != smp_processor_id())
8769 : 0 : continue;
8770 [ # # ]: 0 : if (event->attr.type != PERF_TYPE_TRACEPOINT)
8771 : 0 : continue;
8772 [ # # ]: 0 : if (event->attr.config != entry->type)
8773 : 0 : continue;
8774 [ # # ]: 0 : if (perf_tp_event_match(event, &data, regs))
8775 : 0 : perf_swevent_event(event, count, &data, regs);
8776 : : }
8777 : : unlock:
8778 : : rcu_read_unlock();
8779 : : }
8780 : :
8781 : : perf_swevent_put_recursion_context(rctx);
8782 : 0 : }
8783 : : EXPORT_SYMBOL_GPL(perf_tp_event);
8784 : :
8785 : 0 : static void tp_perf_event_destroy(struct perf_event *event)
8786 : : {
8787 : 0 : perf_trace_destroy(event);
8788 : 0 : }
8789 : :
8790 : 0 : static int perf_tp_event_init(struct perf_event *event)
8791 : : {
8792 : : int err;
8793 : :
8794 [ # # ]: 0 : if (event->attr.type != PERF_TYPE_TRACEPOINT)
8795 : : return -ENOENT;
8796 : :
8797 : : /*
8798 : : * no branch sampling for tracepoint events
8799 : : */
8800 [ # # ]: 0 : if (has_branch_stack(event))
8801 : : return -EOPNOTSUPP;
8802 : :
8803 : 0 : err = perf_trace_init(event);
8804 [ # # ]: 0 : if (err)
8805 : : return err;
8806 : :
8807 : 0 : event->destroy = tp_perf_event_destroy;
8808 : :
8809 : 0 : return 0;
8810 : : }
8811 : :
8812 : : static struct pmu perf_tracepoint = {
8813 : : .task_ctx_nr = perf_sw_context,
8814 : :
8815 : : .event_init = perf_tp_event_init,
8816 : : .add = perf_trace_add,
8817 : : .del = perf_trace_del,
8818 : : .start = perf_swevent_start,
8819 : : .stop = perf_swevent_stop,
8820 : : .read = perf_swevent_read,
8821 : : };
8822 : :
8823 : : #if defined(CONFIG_KPROBE_EVENTS) || defined(CONFIG_UPROBE_EVENTS)
8824 : : /*
8825 : : * Flags in config, used by dynamic PMU kprobe and uprobe
8826 : : * The flags should match following PMU_FORMAT_ATTR().
8827 : : *
8828 : : * PERF_PROBE_CONFIG_IS_RETPROBE if set, create kretprobe/uretprobe
8829 : : * if not set, create kprobe/uprobe
8830 : : *
8831 : : * The following values specify a reference counter (or semaphore in the
8832 : : * terminology of tools like dtrace, systemtap, etc.) Userspace Statically
8833 : : * Defined Tracepoints (USDT). Currently, we use 40 bit for the offset.
8834 : : *
8835 : : * PERF_UPROBE_REF_CTR_OFFSET_BITS # of bits in config as th offset
8836 : : * PERF_UPROBE_REF_CTR_OFFSET_SHIFT # of bits to shift left
8837 : : */
8838 : : enum perf_probe_config {
8839 : : PERF_PROBE_CONFIG_IS_RETPROBE = 1U << 0, /* [k,u]retprobe */
8840 : : PERF_UPROBE_REF_CTR_OFFSET_BITS = 32,
8841 : : PERF_UPROBE_REF_CTR_OFFSET_SHIFT = 64 - PERF_UPROBE_REF_CTR_OFFSET_BITS,
8842 : : };
8843 : :
8844 : 0 : PMU_FORMAT_ATTR(retprobe, "config:0");
8845 : : #endif
8846 : :
8847 : : #ifdef CONFIG_KPROBE_EVENTS
8848 : : static struct attribute *kprobe_attrs[] = {
8849 : : &format_attr_retprobe.attr,
8850 : : NULL,
8851 : : };
8852 : :
8853 : : static struct attribute_group kprobe_format_group = {
8854 : : .name = "format",
8855 : : .attrs = kprobe_attrs,
8856 : : };
8857 : :
8858 : : static const struct attribute_group *kprobe_attr_groups[] = {
8859 : : &kprobe_format_group,
8860 : : NULL,
8861 : : };
8862 : :
8863 : : static int perf_kprobe_event_init(struct perf_event *event);
8864 : : static struct pmu perf_kprobe = {
8865 : : .task_ctx_nr = perf_sw_context,
8866 : : .event_init = perf_kprobe_event_init,
8867 : : .add = perf_trace_add,
8868 : : .del = perf_trace_del,
8869 : : .start = perf_swevent_start,
8870 : : .stop = perf_swevent_stop,
8871 : : .read = perf_swevent_read,
8872 : : .attr_groups = kprobe_attr_groups,
8873 : : };
8874 : :
8875 : 0 : static int perf_kprobe_event_init(struct perf_event *event)
8876 : : {
8877 : : int err;
8878 : : bool is_retprobe;
8879 : :
8880 [ # # ]: 0 : if (event->attr.type != perf_kprobe.type)
8881 : : return -ENOENT;
8882 : :
8883 [ # # ]: 0 : if (!capable(CAP_SYS_ADMIN))
8884 : : return -EACCES;
8885 : :
8886 : : /*
8887 : : * no branch sampling for probe events
8888 : : */
8889 [ # # ]: 0 : if (has_branch_stack(event))
8890 : : return -EOPNOTSUPP;
8891 : :
8892 : 0 : is_retprobe = event->attr.config & PERF_PROBE_CONFIG_IS_RETPROBE;
8893 : 0 : err = perf_kprobe_init(event, is_retprobe);
8894 [ # # ]: 0 : if (err)
8895 : : return err;
8896 : :
8897 : 0 : event->destroy = perf_kprobe_destroy;
8898 : :
8899 : 0 : return 0;
8900 : : }
8901 : : #endif /* CONFIG_KPROBE_EVENTS */
8902 : :
8903 : : #ifdef CONFIG_UPROBE_EVENTS
8904 : : PMU_FORMAT_ATTR(ref_ctr_offset, "config:32-63");
8905 : :
8906 : : static struct attribute *uprobe_attrs[] = {
8907 : : &format_attr_retprobe.attr,
8908 : : &format_attr_ref_ctr_offset.attr,
8909 : : NULL,
8910 : : };
8911 : :
8912 : : static struct attribute_group uprobe_format_group = {
8913 : : .name = "format",
8914 : : .attrs = uprobe_attrs,
8915 : : };
8916 : :
8917 : : static const struct attribute_group *uprobe_attr_groups[] = {
8918 : : &uprobe_format_group,
8919 : : NULL,
8920 : : };
8921 : :
8922 : : static int perf_uprobe_event_init(struct perf_event *event);
8923 : : static struct pmu perf_uprobe = {
8924 : : .task_ctx_nr = perf_sw_context,
8925 : : .event_init = perf_uprobe_event_init,
8926 : : .add = perf_trace_add,
8927 : : .del = perf_trace_del,
8928 : : .start = perf_swevent_start,
8929 : : .stop = perf_swevent_stop,
8930 : : .read = perf_swevent_read,
8931 : : .attr_groups = uprobe_attr_groups,
8932 : : };
8933 : :
8934 : : static int perf_uprobe_event_init(struct perf_event *event)
8935 : : {
8936 : : int err;
8937 : : unsigned long ref_ctr_offset;
8938 : : bool is_retprobe;
8939 : :
8940 : : if (event->attr.type != perf_uprobe.type)
8941 : : return -ENOENT;
8942 : :
8943 : : if (!capable(CAP_SYS_ADMIN))
8944 : : return -EACCES;
8945 : :
8946 : : /*
8947 : : * no branch sampling for probe events
8948 : : */
8949 : : if (has_branch_stack(event))
8950 : : return -EOPNOTSUPP;
8951 : :
8952 : : is_retprobe = event->attr.config & PERF_PROBE_CONFIG_IS_RETPROBE;
8953 : : ref_ctr_offset = event->attr.config >> PERF_UPROBE_REF_CTR_OFFSET_SHIFT;
8954 : : err = perf_uprobe_init(event, ref_ctr_offset, is_retprobe);
8955 : : if (err)
8956 : : return err;
8957 : :
8958 : : event->destroy = perf_uprobe_destroy;
8959 : :
8960 : : return 0;
8961 : : }
8962 : : #endif /* CONFIG_UPROBE_EVENTS */
8963 : :
8964 : 207 : static inline void perf_tp_register(void)
8965 : : {
8966 : 207 : perf_pmu_register(&perf_tracepoint, "tracepoint", PERF_TYPE_TRACEPOINT);
8967 : : #ifdef CONFIG_KPROBE_EVENTS
8968 : 207 : perf_pmu_register(&perf_kprobe, "kprobe", -1);
8969 : : #endif
8970 : : #ifdef CONFIG_UPROBE_EVENTS
8971 : : perf_pmu_register(&perf_uprobe, "uprobe", -1);
8972 : : #endif
8973 : 207 : }
8974 : :
8975 : : static void perf_event_free_filter(struct perf_event *event)
8976 : : {
8977 : 0 : ftrace_profile_free_filter(event);
8978 : : }
8979 : :
8980 : : #ifdef CONFIG_BPF_SYSCALL
8981 : 0 : static void bpf_overflow_handler(struct perf_event *event,
8982 : : struct perf_sample_data *data,
8983 : : struct pt_regs *regs)
8984 : : {
8985 : 0 : struct bpf_perf_event_data_kern ctx = {
8986 : : .data = data,
8987 : : .event = event,
8988 : : };
8989 : : int ret = 0;
8990 : :
8991 : 0 : ctx.regs = perf_arch_bpf_user_pt_regs(regs);
8992 : 0 : preempt_disable();
8993 [ # # ]: 0 : if (unlikely(__this_cpu_inc_return(bpf_prog_active) != 1))
8994 : : goto out;
8995 : : rcu_read_lock();
8996 [ # # ]: 0 : ret = BPF_PROG_RUN(event->prog, &ctx);
8997 : : rcu_read_unlock();
8998 : : out:
8999 : 0 : __this_cpu_dec(bpf_prog_active);
9000 : 0 : preempt_enable();
9001 [ # # ]: 0 : if (!ret)
9002 : 0 : return;
9003 : :
9004 : 0 : event->orig_overflow_handler(event, data, regs);
9005 : : }
9006 : :
9007 : 0 : static int perf_event_set_bpf_handler(struct perf_event *event, u32 prog_fd)
9008 : : {
9009 : : struct bpf_prog *prog;
9010 : :
9011 [ # # ]: 0 : if (event->overflow_handler_context)
9012 : : /* hw breakpoint or kernel counter */
9013 : : return -EINVAL;
9014 : :
9015 [ # # ]: 0 : if (event->prog)
9016 : : return -EEXIST;
9017 : :
9018 : : prog = bpf_prog_get_type(prog_fd, BPF_PROG_TYPE_PERF_EVENT);
9019 [ # # ]: 0 : if (IS_ERR(prog))
9020 : 0 : return PTR_ERR(prog);
9021 : :
9022 : 0 : event->prog = prog;
9023 : 0 : event->orig_overflow_handler = READ_ONCE(event->overflow_handler);
9024 : 0 : WRITE_ONCE(event->overflow_handler, bpf_overflow_handler);
9025 : 0 : return 0;
9026 : : }
9027 : :
9028 : : static void perf_event_free_bpf_handler(struct perf_event *event)
9029 : : {
9030 : 0 : struct bpf_prog *prog = event->prog;
9031 : :
9032 [ # # ]: 0 : if (!prog)
9033 : : return;
9034 : :
9035 : 0 : WRITE_ONCE(event->overflow_handler, event->orig_overflow_handler);
9036 : 0 : event->prog = NULL;
9037 : 0 : bpf_prog_put(prog);
9038 : : }
9039 : : #else
9040 : : static int perf_event_set_bpf_handler(struct perf_event *event, u32 prog_fd)
9041 : : {
9042 : : return -EOPNOTSUPP;
9043 : : }
9044 : : static void perf_event_free_bpf_handler(struct perf_event *event)
9045 : : {
9046 : : }
9047 : : #endif
9048 : :
9049 : : /*
9050 : : * returns true if the event is a tracepoint, or a kprobe/upprobe created
9051 : : * with perf_event_open()
9052 : : */
9053 : : static inline bool perf_event_is_tracing(struct perf_event *event)
9054 : : {
9055 [ # # # # : 0 : if (event->pmu == &perf_tracepoint)
# # ]
9056 : : return true;
9057 : : #ifdef CONFIG_KPROBE_EVENTS
9058 [ # # # # : 0 : if (event->pmu == &perf_kprobe)
# # ]
9059 : : return true;
9060 : : #endif
9061 : : #ifdef CONFIG_UPROBE_EVENTS
9062 : : if (event->pmu == &perf_uprobe)
9063 : : return true;
9064 : : #endif
9065 : : return false;
9066 : : }
9067 : :
9068 : 0 : static int perf_event_set_bpf_prog(struct perf_event *event, u32 prog_fd)
9069 : : {
9070 : : bool is_kprobe, is_tracepoint, is_syscall_tp;
9071 : : struct bpf_prog *prog;
9072 : : int ret;
9073 : :
9074 [ # # ]: 0 : if (!perf_event_is_tracing(event))
9075 : 0 : return perf_event_set_bpf_handler(event, prog_fd);
9076 : :
9077 : 0 : is_kprobe = event->tp_event->flags & TRACE_EVENT_FL_UKPROBE;
9078 : 0 : is_tracepoint = event->tp_event->flags & TRACE_EVENT_FL_TRACEPOINT;
9079 : : is_syscall_tp = is_syscall_trace_event(event->tp_event);
9080 [ # # ]: 0 : if (!is_kprobe && !is_tracepoint && !is_syscall_tp)
9081 : : /* bpf programs can only be attached to u/kprobe or tracepoint */
9082 : : return -EINVAL;
9083 : :
9084 : 0 : prog = bpf_prog_get(prog_fd);
9085 [ # # ]: 0 : if (IS_ERR(prog))
9086 : 0 : return PTR_ERR(prog);
9087 : :
9088 [ # # # # : 0 : if ((is_kprobe && prog->type != BPF_PROG_TYPE_KPROBE) ||
# # ]
9089 [ # # ]: 0 : (is_tracepoint && prog->type != BPF_PROG_TYPE_TRACEPOINT) ||
9090 : : (is_syscall_tp && prog->type != BPF_PROG_TYPE_TRACEPOINT)) {
9091 : : /* valid fd, but invalid bpf program type */
9092 : 0 : bpf_prog_put(prog);
9093 : 0 : return -EINVAL;
9094 : : }
9095 : :
9096 : : /* Kprobe override only works for kprobes, not uprobes. */
9097 [ # # # # ]: 0 : if (prog->kprobe_override &&
9098 : 0 : !(event->tp_event->flags & TRACE_EVENT_FL_KPROBE)) {
9099 : 0 : bpf_prog_put(prog);
9100 : 0 : return -EINVAL;
9101 : : }
9102 : :
9103 [ # # ]: 0 : if (is_tracepoint || is_syscall_tp) {
9104 : 0 : int off = trace_event_get_offsets(event->tp_event);
9105 : :
9106 [ # # ]: 0 : if (prog->aux->max_ctx_offset > off) {
9107 : 0 : bpf_prog_put(prog);
9108 : 0 : return -EACCES;
9109 : : }
9110 : : }
9111 : :
9112 : 0 : ret = perf_event_attach_bpf_prog(event, prog);
9113 [ # # ]: 0 : if (ret)
9114 : 0 : bpf_prog_put(prog);
9115 : 0 : return ret;
9116 : : }
9117 : :
9118 : 0 : static void perf_event_free_bpf_prog(struct perf_event *event)
9119 : : {
9120 [ # # ]: 0 : if (!perf_event_is_tracing(event)) {
9121 : : perf_event_free_bpf_handler(event);
9122 : 0 : return;
9123 : : }
9124 : 0 : perf_event_detach_bpf_prog(event);
9125 : : }
9126 : :
9127 : : #else
9128 : :
9129 : : static inline void perf_tp_register(void)
9130 : : {
9131 : : }
9132 : :
9133 : : static void perf_event_free_filter(struct perf_event *event)
9134 : : {
9135 : : }
9136 : :
9137 : : static int perf_event_set_bpf_prog(struct perf_event *event, u32 prog_fd)
9138 : : {
9139 : : return -ENOENT;
9140 : : }
9141 : :
9142 : : static void perf_event_free_bpf_prog(struct perf_event *event)
9143 : : {
9144 : : }
9145 : : #endif /* CONFIG_EVENT_TRACING */
9146 : :
9147 : : #ifdef CONFIG_HAVE_HW_BREAKPOINT
9148 : 0 : void perf_bp_event(struct perf_event *bp, void *data)
9149 : : {
9150 : : struct perf_sample_data sample;
9151 : : struct pt_regs *regs = data;
9152 : :
9153 : 0 : perf_sample_data_init(&sample, bp->attr.bp_addr, 0);
9154 : :
9155 [ # # # # ]: 0 : if (!bp->hw.state && !perf_exclude_event(bp, regs))
9156 : 0 : perf_swevent_event(bp, 1, &sample, regs);
9157 : 0 : }
9158 : : #endif
9159 : :
9160 : : /*
9161 : : * Allocate a new address filter
9162 : : */
9163 : : static struct perf_addr_filter *
9164 : 0 : perf_addr_filter_new(struct perf_event *event, struct list_head *filters)
9165 : : {
9166 : : int node = cpu_to_node(event->cpu == -1 ? 0 : event->cpu);
9167 : : struct perf_addr_filter *filter;
9168 : :
9169 : 0 : filter = kzalloc_node(sizeof(*filter), GFP_KERNEL, node);
9170 [ # # ]: 0 : if (!filter)
9171 : : return NULL;
9172 : :
9173 : 0 : INIT_LIST_HEAD(&filter->entry);
9174 : : list_add_tail(&filter->entry, filters);
9175 : :
9176 : 0 : return filter;
9177 : : }
9178 : :
9179 : 0 : static void free_filters_list(struct list_head *filters)
9180 : : {
9181 : : struct perf_addr_filter *filter, *iter;
9182 : :
9183 [ # # ]: 0 : list_for_each_entry_safe(filter, iter, filters, entry) {
9184 : 0 : path_put(&filter->path);
9185 : : list_del(&filter->entry);
9186 : 0 : kfree(filter);
9187 : : }
9188 : 0 : }
9189 : :
9190 : : /*
9191 : : * Free existing address filters and optionally install new ones
9192 : : */
9193 : 0 : static void perf_addr_filters_splice(struct perf_event *event,
9194 : : struct list_head *head)
9195 : : {
9196 : : unsigned long flags;
9197 : 0 : LIST_HEAD(list);
9198 : :
9199 [ # # ]: 0 : if (!has_addr_filter(event))
9200 : 0 : return;
9201 : :
9202 : : /* don't bother with children, they don't have their own filters */
9203 [ # # ]: 0 : if (event->parent)
9204 : : return;
9205 : :
9206 : 0 : raw_spin_lock_irqsave(&event->addr_filters.lock, flags);
9207 : :
9208 : 0 : list_splice_init(&event->addr_filters.list, &list);
9209 [ # # ]: 0 : if (head)
9210 : : list_splice(head, &event->addr_filters.list);
9211 : :
9212 : 0 : raw_spin_unlock_irqrestore(&event->addr_filters.lock, flags);
9213 : :
9214 : 0 : free_filters_list(&list);
9215 : : }
9216 : :
9217 : : /*
9218 : : * Scan through mm's vmas and see if one of them matches the
9219 : : * @filter; if so, adjust filter's address range.
9220 : : * Called with mm::mmap_sem down for reading.
9221 : : */
9222 : 0 : static void perf_addr_filter_apply(struct perf_addr_filter *filter,
9223 : : struct mm_struct *mm,
9224 : : struct perf_addr_filter_range *fr)
9225 : : {
9226 : : struct vm_area_struct *vma;
9227 : :
9228 [ # # ]: 0 : for (vma = mm->mmap; vma; vma = vma->vm_next) {
9229 [ # # ]: 0 : if (!vma->vm_file)
9230 : 0 : continue;
9231 : :
9232 [ # # ]: 0 : if (perf_addr_filter_vma_adjust(filter, vma, fr))
9233 : 0 : return;
9234 : : }
9235 : : }
9236 : :
9237 : : /*
9238 : : * Update event's address range filters based on the
9239 : : * task's existing mappings, if any.
9240 : : */
9241 : 0 : static void perf_event_addr_filters_apply(struct perf_event *event)
9242 : : {
9243 : : struct perf_addr_filters_head *ifh = perf_event_addr_filters(event);
9244 : 0 : struct task_struct *task = READ_ONCE(event->ctx->task);
9245 : : struct perf_addr_filter *filter;
9246 : : struct mm_struct *mm = NULL;
9247 : : unsigned int count = 0;
9248 : : unsigned long flags;
9249 : :
9250 : : /*
9251 : : * We may observe TASK_TOMBSTONE, which means that the event tear-down
9252 : : * will stop on the parent's child_mutex that our caller is also holding
9253 : : */
9254 [ # # ]: 0 : if (task == TASK_TOMBSTONE)
9255 : 0 : return;
9256 : :
9257 [ # # ]: 0 : if (ifh->nr_file_filters) {
9258 : 0 : mm = get_task_mm(event->ctx->task);
9259 [ # # ]: 0 : if (!mm)
9260 : : goto restart;
9261 : :
9262 : 0 : down_read(&mm->mmap_sem);
9263 : : }
9264 : :
9265 : 0 : raw_spin_lock_irqsave(&ifh->lock, flags);
9266 [ # # ]: 0 : list_for_each_entry(filter, &ifh->list, entry) {
9267 [ # # ]: 0 : if (filter->path.dentry) {
9268 : : /*
9269 : : * Adjust base offset if the filter is associated to a
9270 : : * binary that needs to be mapped:
9271 : : */
9272 : 0 : event->addr_filter_ranges[count].start = 0;
9273 : 0 : event->addr_filter_ranges[count].size = 0;
9274 : :
9275 : 0 : perf_addr_filter_apply(filter, mm, &event->addr_filter_ranges[count]);
9276 : : } else {
9277 : 0 : event->addr_filter_ranges[count].start = filter->offset;
9278 : 0 : event->addr_filter_ranges[count].size = filter->size;
9279 : : }
9280 : :
9281 : 0 : count++;
9282 : : }
9283 : :
9284 : 0 : event->addr_filters_gen++;
9285 : 0 : raw_spin_unlock_irqrestore(&ifh->lock, flags);
9286 : :
9287 [ # # ]: 0 : if (ifh->nr_file_filters) {
9288 : 0 : up_read(&mm->mmap_sem);
9289 : :
9290 : 0 : mmput(mm);
9291 : : }
9292 : :
9293 : : restart:
9294 : 0 : perf_event_stop(event, 1);
9295 : : }
9296 : :
9297 : : /*
9298 : : * Address range filtering: limiting the data to certain
9299 : : * instruction address ranges. Filters are ioctl()ed to us from
9300 : : * userspace as ascii strings.
9301 : : *
9302 : : * Filter string format:
9303 : : *
9304 : : * ACTION RANGE_SPEC
9305 : : * where ACTION is one of the
9306 : : * * "filter": limit the trace to this region
9307 : : * * "start": start tracing from this address
9308 : : * * "stop": stop tracing at this address/region;
9309 : : * RANGE_SPEC is
9310 : : * * for kernel addresses: <start address>[/<size>]
9311 : : * * for object files: <start address>[/<size>]@</path/to/object/file>
9312 : : *
9313 : : * if <size> is not specified or is zero, the range is treated as a single
9314 : : * address; not valid for ACTION=="filter".
9315 : : */
9316 : : enum {
9317 : : IF_ACT_NONE = -1,
9318 : : IF_ACT_FILTER,
9319 : : IF_ACT_START,
9320 : : IF_ACT_STOP,
9321 : : IF_SRC_FILE,
9322 : : IF_SRC_KERNEL,
9323 : : IF_SRC_FILEADDR,
9324 : : IF_SRC_KERNELADDR,
9325 : : };
9326 : :
9327 : : enum {
9328 : : IF_STATE_ACTION = 0,
9329 : : IF_STATE_SOURCE,
9330 : : IF_STATE_END,
9331 : : };
9332 : :
9333 : : static const match_table_t if_tokens = {
9334 : : { IF_ACT_FILTER, "filter" },
9335 : : { IF_ACT_START, "start" },
9336 : : { IF_ACT_STOP, "stop" },
9337 : : { IF_SRC_FILE, "%u/%u@%s" },
9338 : : { IF_SRC_KERNEL, "%u/%u" },
9339 : : { IF_SRC_FILEADDR, "%u@%s" },
9340 : : { IF_SRC_KERNELADDR, "%u" },
9341 : : { IF_ACT_NONE, NULL },
9342 : : };
9343 : :
9344 : : /*
9345 : : * Address filter string parser
9346 : : */
9347 : : static int
9348 : 0 : perf_event_parse_addr_filter(struct perf_event *event, char *fstr,
9349 : : struct list_head *filters)
9350 : : {
9351 : : struct perf_addr_filter *filter = NULL;
9352 : : char *start, *orig, *filename = NULL;
9353 : : substring_t args[MAX_OPT_ARGS];
9354 : : int state = IF_STATE_ACTION, token;
9355 : : unsigned int kernel = 0;
9356 : : int ret = -EINVAL;
9357 : :
9358 : 0 : orig = fstr = kstrdup(fstr, GFP_KERNEL);
9359 [ # # ]: 0 : if (!fstr)
9360 : : return -ENOMEM;
9361 : :
9362 [ # # ]: 0 : while ((start = strsep(&fstr, " ,\n")) != NULL) {
9363 : : static const enum perf_addr_filter_action_t actions[] = {
9364 : : [IF_ACT_FILTER] = PERF_ADDR_FILTER_ACTION_FILTER,
9365 : : [IF_ACT_START] = PERF_ADDR_FILTER_ACTION_START,
9366 : : [IF_ACT_STOP] = PERF_ADDR_FILTER_ACTION_STOP,
9367 : : };
9368 : : ret = -EINVAL;
9369 : :
9370 [ # # ]: 0 : if (!*start)
9371 : 0 : continue;
9372 : :
9373 : : /* filter definition begins */
9374 [ # # ]: 0 : if (state == IF_STATE_ACTION) {
9375 : 0 : filter = perf_addr_filter_new(event, filters);
9376 [ # # ]: 0 : if (!filter)
9377 : : goto fail;
9378 : : }
9379 : :
9380 : 0 : token = match_token(start, if_tokens, args);
9381 [ # # # # ]: 0 : switch (token) {
9382 : : case IF_ACT_FILTER:
9383 : : case IF_ACT_START:
9384 : : case IF_ACT_STOP:
9385 [ # # ]: 0 : if (state != IF_STATE_ACTION)
9386 : : goto fail;
9387 : :
9388 : 0 : filter->action = actions[token];
9389 : : state = IF_STATE_SOURCE;
9390 : 0 : break;
9391 : :
9392 : : case IF_SRC_KERNELADDR:
9393 : : case IF_SRC_KERNEL:
9394 : : kernel = 1;
9395 : : /* fall through */
9396 : :
9397 : : case IF_SRC_FILEADDR:
9398 : : case IF_SRC_FILE:
9399 [ # # ]: 0 : if (state != IF_STATE_SOURCE)
9400 : : goto fail;
9401 : :
9402 : 0 : *args[0].to = 0;
9403 : 0 : ret = kstrtoul(args[0].from, 0, &filter->offset);
9404 [ # # ]: 0 : if (ret)
9405 : : goto fail;
9406 : :
9407 [ # # ]: 0 : if (token == IF_SRC_KERNEL || token == IF_SRC_FILE) {
9408 : 0 : *args[1].to = 0;
9409 : 0 : ret = kstrtoul(args[1].from, 0, &filter->size);
9410 [ # # ]: 0 : if (ret)
9411 : : goto fail;
9412 : : }
9413 : :
9414 [ # # ]: 0 : if (token == IF_SRC_FILE || token == IF_SRC_FILEADDR) {
9415 [ # # ]: 0 : int fpos = token == IF_SRC_FILE ? 2 : 1;
9416 : :
9417 : 0 : filename = match_strdup(&args[fpos]);
9418 [ # # ]: 0 : if (!filename) {
9419 : : ret = -ENOMEM;
9420 : : goto fail;
9421 : : }
9422 : : }
9423 : :
9424 : : state = IF_STATE_END;
9425 : : break;
9426 : :
9427 : : default:
9428 : : goto fail;
9429 : : }
9430 : :
9431 : : /*
9432 : : * Filter definition is fully parsed, validate and install it.
9433 : : * Make sure that it doesn't contradict itself or the event's
9434 : : * attribute.
9435 : : */
9436 [ # # ]: 0 : if (state == IF_STATE_END) {
9437 : : ret = -EINVAL;
9438 [ # # # # ]: 0 : if (kernel && event->attr.exclude_kernel)
9439 : : goto fail;
9440 : :
9441 : : /*
9442 : : * ACTION "filter" must have a non-zero length region
9443 : : * specified.
9444 : : */
9445 [ # # # # ]: 0 : if (filter->action == PERF_ADDR_FILTER_ACTION_FILTER &&
9446 : 0 : !filter->size)
9447 : : goto fail;
9448 : :
9449 [ # # ]: 0 : if (!kernel) {
9450 [ # # ]: 0 : if (!filename)
9451 : : goto fail;
9452 : :
9453 : : /*
9454 : : * For now, we only support file-based filters
9455 : : * in per-task events; doing so for CPU-wide
9456 : : * events requires additional context switching
9457 : : * trickery, since same object code will be
9458 : : * mapped at different virtual addresses in
9459 : : * different processes.
9460 : : */
9461 : : ret = -EOPNOTSUPP;
9462 [ # # ]: 0 : if (!event->ctx->task)
9463 : : goto fail_free_name;
9464 : :
9465 : : /* look up the path and grab its inode */
9466 : 0 : ret = kern_path(filename, LOOKUP_FOLLOW,
9467 : : &filter->path);
9468 [ # # ]: 0 : if (ret)
9469 : : goto fail_free_name;
9470 : :
9471 : 0 : kfree(filename);
9472 : : filename = NULL;
9473 : :
9474 : : ret = -EINVAL;
9475 [ # # # # ]: 0 : if (!filter->path.dentry ||
9476 : 0 : !S_ISREG(d_inode(filter->path.dentry)
9477 : : ->i_mode))
9478 : : goto fail;
9479 : :
9480 : 0 : event->addr_filters.nr_file_filters++;
9481 : : }
9482 : :
9483 : : /* ready to consume more filters */
9484 : : state = IF_STATE_ACTION;
9485 : : filter = NULL;
9486 : : }
9487 : : }
9488 : :
9489 [ # # ]: 0 : if (state != IF_STATE_ACTION)
9490 : : goto fail;
9491 : :
9492 : 0 : kfree(orig);
9493 : :
9494 : 0 : return 0;
9495 : :
9496 : : fail_free_name:
9497 : 0 : kfree(filename);
9498 : : fail:
9499 : 0 : free_filters_list(filters);
9500 : 0 : kfree(orig);
9501 : :
9502 : 0 : return ret;
9503 : : }
9504 : :
9505 : : static int
9506 : 0 : perf_event_set_addr_filter(struct perf_event *event, char *filter_str)
9507 : : {
9508 : 0 : LIST_HEAD(filters);
9509 : : int ret;
9510 : :
9511 : : /*
9512 : : * Since this is called in perf_ioctl() path, we're already holding
9513 : : * ctx::mutex.
9514 : : */
9515 : : lockdep_assert_held(&event->ctx->mutex);
9516 : :
9517 [ # # # # : 0 : if (WARN_ON_ONCE(event->parent))
# # ]
9518 : : return -EINVAL;
9519 : :
9520 : 0 : ret = perf_event_parse_addr_filter(event, filter_str, &filters);
9521 [ # # ]: 0 : if (ret)
9522 : : goto fail_clear_files;
9523 : :
9524 : 0 : ret = event->pmu->addr_filters_validate(&filters);
9525 [ # # ]: 0 : if (ret)
9526 : : goto fail_free_filters;
9527 : :
9528 : : /* remove existing filters, if any */
9529 : 0 : perf_addr_filters_splice(event, &filters);
9530 : :
9531 : : /* install new filters */
9532 : 0 : perf_event_for_each_child(event, perf_event_addr_filters_apply);
9533 : :
9534 : 0 : return ret;
9535 : :
9536 : : fail_free_filters:
9537 : 0 : free_filters_list(&filters);
9538 : :
9539 : : fail_clear_files:
9540 : 0 : event->addr_filters.nr_file_filters = 0;
9541 : :
9542 : 0 : return ret;
9543 : : }
9544 : :
9545 : 0 : static int perf_event_set_filter(struct perf_event *event, void __user *arg)
9546 : : {
9547 : : int ret = -EINVAL;
9548 : : char *filter_str;
9549 : :
9550 : 0 : filter_str = strndup_user(arg, PAGE_SIZE);
9551 [ # # ]: 0 : if (IS_ERR(filter_str))
9552 : 0 : return PTR_ERR(filter_str);
9553 : :
9554 : : #ifdef CONFIG_EVENT_TRACING
9555 [ # # ]: 0 : if (perf_event_is_tracing(event)) {
9556 : 0 : struct perf_event_context *ctx = event->ctx;
9557 : :
9558 : : /*
9559 : : * Beware, here be dragons!!
9560 : : *
9561 : : * the tracepoint muck will deadlock against ctx->mutex, but
9562 : : * the tracepoint stuff does not actually need it. So
9563 : : * temporarily drop ctx->mutex. As per perf_event_ctx_lock() we
9564 : : * already have a reference on ctx.
9565 : : *
9566 : : * This can result in event getting moved to a different ctx,
9567 : : * but that does not affect the tracepoint state.
9568 : : */
9569 : 0 : mutex_unlock(&ctx->mutex);
9570 : 0 : ret = ftrace_profile_set_filter(event, event->attr.config, filter_str);
9571 : 0 : mutex_lock(&ctx->mutex);
9572 : : } else
9573 : : #endif
9574 [ # # ]: 0 : if (has_addr_filter(event))
9575 : 0 : ret = perf_event_set_addr_filter(event, filter_str);
9576 : :
9577 : 0 : kfree(filter_str);
9578 : 0 : return ret;
9579 : : }
9580 : :
9581 : : /*
9582 : : * hrtimer based swevent callback
9583 : : */
9584 : :
9585 : 0 : static enum hrtimer_restart perf_swevent_hrtimer(struct hrtimer *hrtimer)
9586 : : {
9587 : : enum hrtimer_restart ret = HRTIMER_RESTART;
9588 : : struct perf_sample_data data;
9589 : : struct pt_regs *regs;
9590 : : struct perf_event *event;
9591 : : u64 period;
9592 : :
9593 : 0 : event = container_of(hrtimer, struct perf_event, hw.hrtimer);
9594 : :
9595 [ # # ]: 0 : if (event->state != PERF_EVENT_STATE_ACTIVE)
9596 : : return HRTIMER_NORESTART;
9597 : :
9598 : 0 : event->pmu->read(event);
9599 : :
9600 : 0 : perf_sample_data_init(&data, 0, event->hw.last_period);
9601 : : regs = get_irq_regs();
9602 : :
9603 [ # # # # ]: 0 : if (regs && !perf_exclude_event(event, regs)) {
9604 [ # # # # ]: 0 : if (!(event->attr.exclude_idle && is_idle_task(current)))
9605 [ # # ]: 0 : if (__perf_event_overflow(event, 1, &data, regs))
9606 : : ret = HRTIMER_NORESTART;
9607 : : }
9608 : :
9609 : 0 : period = max_t(u64, 10000, event->hw.sample_period);
9610 : 0 : hrtimer_forward_now(hrtimer, ns_to_ktime(period));
9611 : :
9612 : 0 : return ret;
9613 : : }
9614 : :
9615 : 0 : static void perf_swevent_start_hrtimer(struct perf_event *event)
9616 : : {
9617 : : struct hw_perf_event *hwc = &event->hw;
9618 : : s64 period;
9619 : :
9620 [ # # ]: 0 : if (!is_sampling_event(event))
9621 : 0 : return;
9622 : :
9623 : 0 : period = local64_read(&hwc->period_left);
9624 [ # # ]: 0 : if (period) {
9625 [ # # ]: 0 : if (period < 0)
9626 : : period = 10000;
9627 : :
9628 : : local64_set(&hwc->period_left, 0);
9629 : : } else {
9630 : 0 : period = max_t(u64, 10000, hwc->sample_period);
9631 : : }
9632 : 0 : hrtimer_start(&hwc->hrtimer, ns_to_ktime(period),
9633 : : HRTIMER_MODE_REL_PINNED_HARD);
9634 : : }
9635 : :
9636 : 0 : static void perf_swevent_cancel_hrtimer(struct perf_event *event)
9637 : : {
9638 : : struct hw_perf_event *hwc = &event->hw;
9639 : :
9640 [ # # ]: 0 : if (is_sampling_event(event)) {
9641 : 0 : ktime_t remaining = hrtimer_get_remaining(&hwc->hrtimer);
9642 : 0 : local64_set(&hwc->period_left, ktime_to_ns(remaining));
9643 : :
9644 : 0 : hrtimer_cancel(&hwc->hrtimer);
9645 : : }
9646 : 0 : }
9647 : :
9648 : 0 : static void perf_swevent_init_hrtimer(struct perf_event *event)
9649 : : {
9650 : : struct hw_perf_event *hwc = &event->hw;
9651 : :
9652 [ # # ]: 0 : if (!is_sampling_event(event))
9653 : 0 : return;
9654 : :
9655 : 0 : hrtimer_init(&hwc->hrtimer, CLOCK_MONOTONIC, HRTIMER_MODE_REL_HARD);
9656 : 0 : hwc->hrtimer.function = perf_swevent_hrtimer;
9657 : :
9658 : : /*
9659 : : * Since hrtimers have a fixed rate, we can do a static freq->period
9660 : : * mapping and avoid the whole period adjust feedback stuff.
9661 : : */
9662 [ # # ]: 0 : if (event->attr.freq) {
9663 : 0 : long freq = event->attr.sample_freq;
9664 : :
9665 : 0 : event->attr.sample_period = NSEC_PER_SEC / freq;
9666 : 0 : hwc->sample_period = event->attr.sample_period;
9667 : 0 : local64_set(&hwc->period_left, hwc->sample_period);
9668 : 0 : hwc->last_period = hwc->sample_period;
9669 : 0 : event->attr.freq = 0;
9670 : : }
9671 : : }
9672 : :
9673 : : /*
9674 : : * Software event: cpu wall time clock
9675 : : */
9676 : :
9677 : 0 : static void cpu_clock_event_update(struct perf_event *event)
9678 : : {
9679 : : s64 prev;
9680 : : u64 now;
9681 : :
9682 : : now = local_clock();
9683 : 0 : prev = local64_xchg(&event->hw.prev_count, now);
9684 : 0 : local64_add(now - prev, &event->count);
9685 : 0 : }
9686 : :
9687 : 0 : static void cpu_clock_event_start(struct perf_event *event, int flags)
9688 : : {
9689 : 0 : local64_set(&event->hw.prev_count, local_clock());
9690 : 0 : perf_swevent_start_hrtimer(event);
9691 : 0 : }
9692 : :
9693 : 0 : static void cpu_clock_event_stop(struct perf_event *event, int flags)
9694 : : {
9695 : 0 : perf_swevent_cancel_hrtimer(event);
9696 : 0 : cpu_clock_event_update(event);
9697 : 0 : }
9698 : :
9699 : 0 : static int cpu_clock_event_add(struct perf_event *event, int flags)
9700 : : {
9701 [ # # ]: 0 : if (flags & PERF_EF_START)
9702 : 0 : cpu_clock_event_start(event, flags);
9703 : 0 : perf_event_update_userpage(event);
9704 : :
9705 : 0 : return 0;
9706 : : }
9707 : :
9708 : 0 : static void cpu_clock_event_del(struct perf_event *event, int flags)
9709 : : {
9710 : : cpu_clock_event_stop(event, flags);
9711 : 0 : }
9712 : :
9713 : 0 : static void cpu_clock_event_read(struct perf_event *event)
9714 : : {
9715 : 0 : cpu_clock_event_update(event);
9716 : 0 : }
9717 : :
9718 : 0 : static int cpu_clock_event_init(struct perf_event *event)
9719 : : {
9720 [ # # ]: 0 : if (event->attr.type != PERF_TYPE_SOFTWARE)
9721 : : return -ENOENT;
9722 : :
9723 [ # # ]: 0 : if (event->attr.config != PERF_COUNT_SW_CPU_CLOCK)
9724 : : return -ENOENT;
9725 : :
9726 : : /*
9727 : : * no branch sampling for software events
9728 : : */
9729 [ # # ]: 0 : if (has_branch_stack(event))
9730 : : return -EOPNOTSUPP;
9731 : :
9732 : 0 : perf_swevent_init_hrtimer(event);
9733 : :
9734 : 0 : return 0;
9735 : : }
9736 : :
9737 : : static struct pmu perf_cpu_clock = {
9738 : : .task_ctx_nr = perf_sw_context,
9739 : :
9740 : : .capabilities = PERF_PMU_CAP_NO_NMI,
9741 : :
9742 : : .event_init = cpu_clock_event_init,
9743 : : .add = cpu_clock_event_add,
9744 : : .del = cpu_clock_event_del,
9745 : : .start = cpu_clock_event_start,
9746 : : .stop = cpu_clock_event_stop,
9747 : : .read = cpu_clock_event_read,
9748 : : };
9749 : :
9750 : : /*
9751 : : * Software event: task time clock
9752 : : */
9753 : :
9754 : 0 : static void task_clock_event_update(struct perf_event *event, u64 now)
9755 : : {
9756 : : u64 prev;
9757 : : s64 delta;
9758 : :
9759 : 0 : prev = local64_xchg(&event->hw.prev_count, now);
9760 : 0 : delta = now - prev;
9761 : 0 : local64_add(delta, &event->count);
9762 : 0 : }
9763 : :
9764 : 0 : static void task_clock_event_start(struct perf_event *event, int flags)
9765 : : {
9766 : 0 : local64_set(&event->hw.prev_count, event->ctx->time);
9767 : 0 : perf_swevent_start_hrtimer(event);
9768 : 0 : }
9769 : :
9770 : 0 : static void task_clock_event_stop(struct perf_event *event, int flags)
9771 : : {
9772 : 0 : perf_swevent_cancel_hrtimer(event);
9773 : 0 : task_clock_event_update(event, event->ctx->time);
9774 : 0 : }
9775 : :
9776 : 0 : static int task_clock_event_add(struct perf_event *event, int flags)
9777 : : {
9778 [ # # ]: 0 : if (flags & PERF_EF_START)
9779 : 0 : task_clock_event_start(event, flags);
9780 : 0 : perf_event_update_userpage(event);
9781 : :
9782 : 0 : return 0;
9783 : : }
9784 : :
9785 : 0 : static void task_clock_event_del(struct perf_event *event, int flags)
9786 : : {
9787 : 0 : task_clock_event_stop(event, PERF_EF_UPDATE);
9788 : 0 : }
9789 : :
9790 : 0 : static void task_clock_event_read(struct perf_event *event)
9791 : : {
9792 : : u64 now = perf_clock();
9793 : 0 : u64 delta = now - event->ctx->timestamp;
9794 : 0 : u64 time = event->ctx->time + delta;
9795 : :
9796 : 0 : task_clock_event_update(event, time);
9797 : 0 : }
9798 : :
9799 : 0 : static int task_clock_event_init(struct perf_event *event)
9800 : : {
9801 [ # # ]: 0 : if (event->attr.type != PERF_TYPE_SOFTWARE)
9802 : : return -ENOENT;
9803 : :
9804 [ # # ]: 0 : if (event->attr.config != PERF_COUNT_SW_TASK_CLOCK)
9805 : : return -ENOENT;
9806 : :
9807 : : /*
9808 : : * no branch sampling for software events
9809 : : */
9810 [ # # ]: 0 : if (has_branch_stack(event))
9811 : : return -EOPNOTSUPP;
9812 : :
9813 : 0 : perf_swevent_init_hrtimer(event);
9814 : :
9815 : 0 : return 0;
9816 : : }
9817 : :
9818 : : static struct pmu perf_task_clock = {
9819 : : .task_ctx_nr = perf_sw_context,
9820 : :
9821 : : .capabilities = PERF_PMU_CAP_NO_NMI,
9822 : :
9823 : : .event_init = task_clock_event_init,
9824 : : .add = task_clock_event_add,
9825 : : .del = task_clock_event_del,
9826 : : .start = task_clock_event_start,
9827 : : .stop = task_clock_event_stop,
9828 : : .read = task_clock_event_read,
9829 : : };
9830 : :
9831 : 0 : static void perf_pmu_nop_void(struct pmu *pmu)
9832 : : {
9833 : 0 : }
9834 : :
9835 : 0 : static void perf_pmu_nop_txn(struct pmu *pmu, unsigned int flags)
9836 : : {
9837 : 0 : }
9838 : :
9839 : 0 : static int perf_pmu_nop_int(struct pmu *pmu)
9840 : : {
9841 : 0 : return 0;
9842 : : }
9843 : :
9844 : 0 : static int perf_event_nop_int(struct perf_event *event, u64 value)
9845 : : {
9846 : 0 : return 0;
9847 : : }
9848 : :
9849 : : static DEFINE_PER_CPU(unsigned int, nop_txn_flags);
9850 : :
9851 : 0 : static void perf_pmu_start_txn(struct pmu *pmu, unsigned int flags)
9852 : : {
9853 : 0 : __this_cpu_write(nop_txn_flags, flags);
9854 : :
9855 [ # # ]: 0 : if (flags & ~PERF_PMU_TXN_ADD)
9856 : 0 : return;
9857 : :
9858 : : perf_pmu_disable(pmu);
9859 : : }
9860 : :
9861 : 0 : static int perf_pmu_commit_txn(struct pmu *pmu)
9862 : : {
9863 : 0 : unsigned int flags = __this_cpu_read(nop_txn_flags);
9864 : :
9865 : 0 : __this_cpu_write(nop_txn_flags, 0);
9866 : :
9867 [ # # ]: 0 : if (flags & ~PERF_PMU_TXN_ADD)
9868 : : return 0;
9869 : :
9870 : : perf_pmu_enable(pmu);
9871 : : return 0;
9872 : : }
9873 : :
9874 : 0 : static void perf_pmu_cancel_txn(struct pmu *pmu)
9875 : : {
9876 : 0 : unsigned int flags = __this_cpu_read(nop_txn_flags);
9877 : :
9878 : 0 : __this_cpu_write(nop_txn_flags, 0);
9879 : :
9880 [ # # ]: 0 : if (flags & ~PERF_PMU_TXN_ADD)
9881 : 0 : return;
9882 : :
9883 : : perf_pmu_enable(pmu);
9884 : : }
9885 : :
9886 : 0 : static int perf_event_idx_default(struct perf_event *event)
9887 : : {
9888 : 0 : return 0;
9889 : : }
9890 : :
9891 : : /*
9892 : : * Ensures all contexts with the same task_ctx_nr have the same
9893 : : * pmu_cpu_context too.
9894 : : */
9895 : : static struct perf_cpu_context __percpu *find_pmu_context(int ctxn)
9896 : : {
9897 : : struct pmu *pmu;
9898 : :
9899 [ + - ]: 1449 : if (ctxn < 0)
9900 : : return NULL;
9901 : :
9902 [ + + ]: 2691 : list_for_each_entry(pmu, &pmus, entry) {
9903 [ + + ]: 2277 : if (pmu->task_ctx_nr == ctxn)
9904 : 1035 : return pmu->pmu_cpu_context;
9905 : : }
9906 : :
9907 : : return NULL;
9908 : : }
9909 : :
9910 : : static void free_pmu_context(struct pmu *pmu)
9911 : : {
9912 : : /*
9913 : : * Static contexts such as perf_sw_context have a global lifetime
9914 : : * and may be shared between different PMUs. Avoid freeing them
9915 : : * when a single PMU is going away.
9916 : : */
9917 [ # # ]: 0 : if (pmu->task_ctx_nr > perf_invalid_context)
9918 : : return;
9919 : :
9920 : 0 : free_percpu(pmu->pmu_cpu_context);
9921 : : }
9922 : :
9923 : : /*
9924 : : * Let userspace know that this PMU supports address range filtering:
9925 : : */
9926 : 0 : static ssize_t nr_addr_filters_show(struct device *dev,
9927 : : struct device_attribute *attr,
9928 : : char *page)
9929 : : {
9930 : : struct pmu *pmu = dev_get_drvdata(dev);
9931 : :
9932 : 0 : return snprintf(page, PAGE_SIZE - 1, "%d\n", pmu->nr_addr_filters);
9933 : : }
9934 : : DEVICE_ATTR_RO(nr_addr_filters);
9935 : :
9936 : : static struct idr pmu_idr;
9937 : :
9938 : : static ssize_t
9939 : 0 : type_show(struct device *dev, struct device_attribute *attr, char *page)
9940 : : {
9941 : : struct pmu *pmu = dev_get_drvdata(dev);
9942 : :
9943 : 0 : return snprintf(page, PAGE_SIZE-1, "%d\n", pmu->type);
9944 : : }
9945 : : static DEVICE_ATTR_RO(type);
9946 : :
9947 : : static ssize_t
9948 : 0 : perf_event_mux_interval_ms_show(struct device *dev,
9949 : : struct device_attribute *attr,
9950 : : char *page)
9951 : : {
9952 : : struct pmu *pmu = dev_get_drvdata(dev);
9953 : :
9954 : 0 : return snprintf(page, PAGE_SIZE-1, "%d\n", pmu->hrtimer_interval_ms);
9955 : : }
9956 : :
9957 : : static DEFINE_MUTEX(mux_interval_mutex);
9958 : :
9959 : : static ssize_t
9960 : 0 : perf_event_mux_interval_ms_store(struct device *dev,
9961 : : struct device_attribute *attr,
9962 : : const char *buf, size_t count)
9963 : : {
9964 : : struct pmu *pmu = dev_get_drvdata(dev);
9965 : : int timer, cpu, ret;
9966 : :
9967 : 0 : ret = kstrtoint(buf, 0, &timer);
9968 [ # # ]: 0 : if (ret)
9969 : : return ret;
9970 : :
9971 [ # # ]: 0 : if (timer < 1)
9972 : : return -EINVAL;
9973 : :
9974 : : /* same value, noting to do */
9975 [ # # ]: 0 : if (timer == pmu->hrtimer_interval_ms)
9976 : 0 : return count;
9977 : :
9978 : 0 : mutex_lock(&mux_interval_mutex);
9979 : 0 : pmu->hrtimer_interval_ms = timer;
9980 : :
9981 : : /* update all cpuctx for this PMU */
9982 : : cpus_read_lock();
9983 [ # # ]: 0 : for_each_online_cpu(cpu) {
9984 : : struct perf_cpu_context *cpuctx;
9985 : 0 : cpuctx = per_cpu_ptr(pmu->pmu_cpu_context, cpu);
9986 : 0 : cpuctx->hrtimer_interval = ns_to_ktime(NSEC_PER_MSEC * timer);
9987 : :
9988 : 0 : cpu_function_call(cpu,
9989 : : (remote_function_f)perf_mux_hrtimer_restart, cpuctx);
9990 : : }
9991 : : cpus_read_unlock();
9992 : 0 : mutex_unlock(&mux_interval_mutex);
9993 : :
9994 : 0 : return count;
9995 : : }
9996 : : static DEVICE_ATTR_RW(perf_event_mux_interval_ms);
9997 : :
9998 : : static struct attribute *pmu_dev_attrs[] = {
9999 : : &dev_attr_type.attr,
10000 : : &dev_attr_perf_event_mux_interval_ms.attr,
10001 : : NULL,
10002 : : };
10003 : : ATTRIBUTE_GROUPS(pmu_dev);
10004 : :
10005 : : static int pmu_bus_running;
10006 : : static struct bus_type pmu_bus = {
10007 : : .name = "event_source",
10008 : : .dev_groups = pmu_dev_groups,
10009 : : };
10010 : :
10011 : 0 : static void pmu_dev_release(struct device *dev)
10012 : : {
10013 : 0 : kfree(dev);
10014 : 0 : }
10015 : :
10016 : 1035 : static int pmu_dev_alloc(struct pmu *pmu)
10017 : : {
10018 : : int ret = -ENOMEM;
10019 : :
10020 : 1035 : pmu->dev = kzalloc(sizeof(struct device), GFP_KERNEL);
10021 [ + - ]: 1035 : if (!pmu->dev)
10022 : : goto out;
10023 : :
10024 : 1035 : pmu->dev->groups = pmu->attr_groups;
10025 : 1035 : device_initialize(pmu->dev);
10026 : 1035 : ret = dev_set_name(pmu->dev, "%s", pmu->name);
10027 [ + - ]: 1035 : if (ret)
10028 : : goto free_dev;
10029 : :
10030 : 1035 : dev_set_drvdata(pmu->dev, pmu);
10031 : 1035 : pmu->dev->bus = &pmu_bus;
10032 : 1035 : pmu->dev->release = pmu_dev_release;
10033 : 1035 : ret = device_add(pmu->dev);
10034 [ + - ]: 1035 : if (ret)
10035 : : goto free_dev;
10036 : :
10037 : : /* For PMUs with address filters, throw in an extra attribute: */
10038 [ - + ]: 1035 : if (pmu->nr_addr_filters)
10039 : 0 : ret = device_create_file(pmu->dev, &dev_attr_nr_addr_filters);
10040 : :
10041 [ + - ]: 1035 : if (ret)
10042 : : goto del_dev;
10043 : :
10044 [ - + ]: 1035 : if (pmu->attr_update)
10045 : 0 : ret = sysfs_update_groups(&pmu->dev->kobj, pmu->attr_update);
10046 : :
10047 [ + - ]: 1035 : if (ret)
10048 : : goto del_dev;
10049 : :
10050 : : out:
10051 : 1035 : return ret;
10052 : :
10053 : : del_dev:
10054 : 0 : device_del(pmu->dev);
10055 : :
10056 : : free_dev:
10057 : 0 : put_device(pmu->dev);
10058 : 0 : goto out;
10059 : : }
10060 : :
10061 : : static struct lock_class_key cpuctx_mutex;
10062 : : static struct lock_class_key cpuctx_lock;
10063 : :
10064 : 1449 : int perf_pmu_register(struct pmu *pmu, const char *name, int type)
10065 : : {
10066 : : int cpu, ret;
10067 : :
10068 : 1449 : mutex_lock(&pmus_lock);
10069 : : ret = -ENOMEM;
10070 : 1449 : pmu->pmu_disable_count = alloc_percpu(int);
10071 [ + - ]: 1449 : if (!pmu->pmu_disable_count)
10072 : : goto unlock;
10073 : :
10074 : 1449 : pmu->type = -1;
10075 [ + + ]: 1449 : if (!name)
10076 : : goto skip_type;
10077 : 1035 : pmu->name = name;
10078 : :
10079 [ + + ]: 1035 : if (type < 0) {
10080 : 414 : type = idr_alloc(&pmu_idr, pmu, PERF_TYPE_MAX, 0, GFP_KERNEL);
10081 [ + - ]: 414 : if (type < 0) {
10082 : : ret = type;
10083 : : goto free_pdc;
10084 : : }
10085 : : }
10086 : 1035 : pmu->type = type;
10087 : :
10088 [ - + ]: 1035 : if (pmu_bus_running) {
10089 : 0 : ret = pmu_dev_alloc(pmu);
10090 [ # # ]: 0 : if (ret)
10091 : : goto free_idr;
10092 : : }
10093 : :
10094 : : skip_type:
10095 [ + + ]: 1449 : if (pmu->task_ctx_nr == perf_hw_context) {
10096 : : static int hw_context_taken = 0;
10097 : :
10098 : : /*
10099 : : * Other than systems with heterogeneous CPUs, it never makes
10100 : : * sense for two PMUs to share perf_hw_context. PMUs which are
10101 : : * uncore must use perf_invalid_context.
10102 : : */
10103 [ - + # # : 207 : if (WARN_ON_ONCE(hw_context_taken &&
- + # # -
+ ]
10104 : : !(pmu->capabilities & PERF_PMU_CAP_HETEROGENEOUS_CPUS)))
10105 : 0 : pmu->task_ctx_nr = perf_invalid_context;
10106 : :
10107 : 207 : hw_context_taken = 1;
10108 : : }
10109 : :
10110 : 2898 : pmu->pmu_cpu_context = find_pmu_context(pmu->task_ctx_nr);
10111 [ + + ]: 1449 : if (pmu->pmu_cpu_context)
10112 : : goto got_cpu_context;
10113 : :
10114 : : ret = -ENOMEM;
10115 : 414 : pmu->pmu_cpu_context = alloc_percpu(struct perf_cpu_context);
10116 [ + - ]: 414 : if (!pmu->pmu_cpu_context)
10117 : : goto free_dev;
10118 : :
10119 [ + + ]: 2070 : for_each_possible_cpu(cpu) {
10120 : : struct perf_cpu_context *cpuctx;
10121 : :
10122 : 1656 : cpuctx = per_cpu_ptr(pmu->pmu_cpu_context, cpu);
10123 : 1656 : __perf_event_init_context(&cpuctx->ctx);
10124 : : lockdep_set_class(&cpuctx->ctx.mutex, &cpuctx_mutex);
10125 : : lockdep_set_class(&cpuctx->ctx.lock, &cpuctx_lock);
10126 : 1656 : cpuctx->ctx.pmu = pmu;
10127 : 1656 : cpuctx->online = cpumask_test_cpu(cpu, perf_online_mask);
10128 : :
10129 : 1656 : __perf_mux_hrtimer_init(cpuctx, cpu);
10130 : : }
10131 : :
10132 : : got_cpu_context:
10133 [ + - ]: 1449 : if (!pmu->start_txn) {
10134 [ + + ]: 1449 : if (pmu->pmu_enable) {
10135 : : /*
10136 : : * If we have pmu_enable/pmu_disable calls, install
10137 : : * transaction stubs that use that to try and batch
10138 : : * hardware accesses.
10139 : : */
10140 : 207 : pmu->start_txn = perf_pmu_start_txn;
10141 : 207 : pmu->commit_txn = perf_pmu_commit_txn;
10142 : 207 : pmu->cancel_txn = perf_pmu_cancel_txn;
10143 : : } else {
10144 : 1242 : pmu->start_txn = perf_pmu_nop_txn;
10145 : 1242 : pmu->commit_txn = perf_pmu_nop_int;
10146 : 1242 : pmu->cancel_txn = perf_pmu_nop_void;
10147 : : }
10148 : : }
10149 : :
10150 [ + + ]: 1449 : if (!pmu->pmu_enable) {
10151 : 1242 : pmu->pmu_enable = perf_pmu_nop_void;
10152 : 1242 : pmu->pmu_disable = perf_pmu_nop_void;
10153 : : }
10154 : :
10155 [ + - ]: 1449 : if (!pmu->check_period)
10156 : 1449 : pmu->check_period = perf_event_nop_int;
10157 : :
10158 [ + - ]: 1449 : if (!pmu->event_idx)
10159 : 1449 : pmu->event_idx = perf_event_idx_default;
10160 : :
10161 : 1449 : list_add_rcu(&pmu->entry, &pmus);
10162 : : atomic_set(&pmu->exclusive_cnt, 0);
10163 : : ret = 0;
10164 : : unlock:
10165 : 1449 : mutex_unlock(&pmus_lock);
10166 : :
10167 : 1449 : return ret;
10168 : :
10169 : : free_dev:
10170 : 0 : device_del(pmu->dev);
10171 : 0 : put_device(pmu->dev);
10172 : :
10173 : : free_idr:
10174 [ # # ]: 0 : if (pmu->type >= PERF_TYPE_MAX)
10175 : 0 : idr_remove(&pmu_idr, pmu->type);
10176 : :
10177 : : free_pdc:
10178 : 0 : free_percpu(pmu->pmu_disable_count);
10179 : 0 : goto unlock;
10180 : : }
10181 : : EXPORT_SYMBOL_GPL(perf_pmu_register);
10182 : :
10183 : 0 : void perf_pmu_unregister(struct pmu *pmu)
10184 : : {
10185 : 0 : mutex_lock(&pmus_lock);
10186 : : list_del_rcu(&pmu->entry);
10187 : :
10188 : : /*
10189 : : * We dereference the pmu list under both SRCU and regular RCU, so
10190 : : * synchronize against both of those.
10191 : : */
10192 : 0 : synchronize_srcu(&pmus_srcu);
10193 : 0 : synchronize_rcu();
10194 : :
10195 : 0 : free_percpu(pmu->pmu_disable_count);
10196 [ # # ]: 0 : if (pmu->type >= PERF_TYPE_MAX)
10197 : 0 : idr_remove(&pmu_idr, pmu->type);
10198 [ # # ]: 0 : if (pmu_bus_running) {
10199 [ # # ]: 0 : if (pmu->nr_addr_filters)
10200 : 0 : device_remove_file(pmu->dev, &dev_attr_nr_addr_filters);
10201 : 0 : device_del(pmu->dev);
10202 : 0 : put_device(pmu->dev);
10203 : : }
10204 : : free_pmu_context(pmu);
10205 : 0 : mutex_unlock(&pmus_lock);
10206 : 0 : }
10207 : : EXPORT_SYMBOL_GPL(perf_pmu_unregister);
10208 : :
10209 : : static inline bool has_extended_regs(struct perf_event *event)
10210 : : {
10211 : : return (event->attr.sample_regs_user & PERF_REG_EXTENDED_MASK) ||
10212 : : (event->attr.sample_regs_intr & PERF_REG_EXTENDED_MASK);
10213 : : }
10214 : :
10215 : 0 : static int perf_try_init_event(struct pmu *pmu, struct perf_event *event)
10216 : : {
10217 : : struct perf_event_context *ctx = NULL;
10218 : : int ret;
10219 : :
10220 [ # # ]: 0 : if (!try_module_get(pmu->module))
10221 : : return -ENODEV;
10222 : :
10223 : : /*
10224 : : * A number of pmu->event_init() methods iterate the sibling_list to,
10225 : : * for example, validate if the group fits on the PMU. Therefore,
10226 : : * if this is a sibling event, acquire the ctx->mutex to protect
10227 : : * the sibling_list.
10228 : : */
10229 [ # # # # ]: 0 : if (event->group_leader != event && pmu->task_ctx_nr != perf_sw_context) {
10230 : : /*
10231 : : * This ctx->mutex can nest when we're called through
10232 : : * inheritance. See the perf_event_ctx_lock_nested() comment.
10233 : : */
10234 : 0 : ctx = perf_event_ctx_lock_nested(event->group_leader,
10235 : : SINGLE_DEPTH_NESTING);
10236 [ # # ]: 0 : BUG_ON(!ctx);
10237 : : }
10238 : :
10239 : 0 : event->pmu = pmu;
10240 : 0 : ret = pmu->event_init(event);
10241 : :
10242 [ # # ]: 0 : if (ctx)
10243 : : perf_event_ctx_unlock(event->group_leader, ctx);
10244 : :
10245 [ # # ]: 0 : if (!ret) {
10246 : 0 : if (!(pmu->capabilities & PERF_PMU_CAP_EXTENDED_REGS) &&
10247 : : has_extended_regs(event))
10248 : : ret = -EOPNOTSUPP;
10249 : :
10250 [ # # # # ]: 0 : if (pmu->capabilities & PERF_PMU_CAP_NO_EXCLUDE &&
10251 : : event_has_any_exclude_flag(event))
10252 : : ret = -EINVAL;
10253 : :
10254 [ # # # # ]: 0 : if (ret && event->destroy)
10255 : 0 : event->destroy(event);
10256 : : }
10257 : :
10258 [ # # ]: 0 : if (ret)
10259 : 0 : module_put(pmu->module);
10260 : :
10261 : 0 : return ret;
10262 : : }
10263 : :
10264 : 0 : static struct pmu *perf_init_event(struct perf_event *event)
10265 : : {
10266 : : struct pmu *pmu;
10267 : : int idx;
10268 : : int ret;
10269 : :
10270 : : idx = srcu_read_lock(&pmus_srcu);
10271 : :
10272 : : /* Try parent's PMU first: */
10273 [ # # # # ]: 0 : if (event->parent && event->parent->pmu) {
10274 : : pmu = event->parent->pmu;
10275 : 0 : ret = perf_try_init_event(pmu, event);
10276 [ # # ]: 0 : if (!ret)
10277 : : goto unlock;
10278 : : }
10279 : :
10280 : : rcu_read_lock();
10281 : 0 : pmu = idr_find(&pmu_idr, event->attr.type);
10282 : : rcu_read_unlock();
10283 [ # # ]: 0 : if (pmu) {
10284 : 0 : ret = perf_try_init_event(pmu, event);
10285 [ # # ]: 0 : if (ret)
10286 : : pmu = ERR_PTR(ret);
10287 : : goto unlock;
10288 : : }
10289 : :
10290 [ # # ]: 0 : list_for_each_entry_rcu(pmu, &pmus, entry) {
10291 : 0 : ret = perf_try_init_event(pmu, event);
10292 [ # # ]: 0 : if (!ret)
10293 : : goto unlock;
10294 : :
10295 [ # # ]: 0 : if (ret != -ENOENT) {
10296 : : pmu = ERR_PTR(ret);
10297 : 0 : goto unlock;
10298 : : }
10299 : : }
10300 : : pmu = ERR_PTR(-ENOENT);
10301 : : unlock:
10302 : 0 : srcu_read_unlock(&pmus_srcu, idx);
10303 : :
10304 : 0 : return pmu;
10305 : : }
10306 : :
10307 : 0 : static void attach_sb_event(struct perf_event *event)
10308 : : {
10309 : 0 : struct pmu_event_list *pel = per_cpu_ptr(&pmu_sb_events, event->cpu);
10310 : :
10311 : 0 : raw_spin_lock(&pel->lock);
10312 : 0 : list_add_rcu(&event->sb_list, &pel->list);
10313 : : raw_spin_unlock(&pel->lock);
10314 : 0 : }
10315 : :
10316 : : /*
10317 : : * We keep a list of all !task (and therefore per-cpu) events
10318 : : * that need to receive side-band records.
10319 : : *
10320 : : * This avoids having to scan all the various PMU per-cpu contexts
10321 : : * looking for them.
10322 : : */
10323 : 0 : static void account_pmu_sb_event(struct perf_event *event)
10324 : : {
10325 [ # # ]: 0 : if (is_sb_event(event))
10326 : 0 : attach_sb_event(event);
10327 : 0 : }
10328 : :
10329 : 0 : static void account_event_cpu(struct perf_event *event, int cpu)
10330 : : {
10331 [ # # ]: 0 : if (event->parent)
10332 : 0 : return;
10333 : :
10334 [ # # ]: 0 : if (is_cgroup_event(event))
10335 : 0 : atomic_inc(&per_cpu(perf_cgroup_events, cpu));
10336 : : }
10337 : :
10338 : : /* Freq events need the tick to stay alive (see perf_event_task_tick). */
10339 : : static void account_freq_event_nohz(void)
10340 : : {
10341 : : #ifdef CONFIG_NO_HZ_FULL
10342 : : /* Lock so we don't race with concurrent unaccount */
10343 : : spin_lock(&nr_freq_lock);
10344 : : if (atomic_inc_return(&nr_freq_events) == 1)
10345 : : tick_nohz_dep_set(TICK_DEP_BIT_PERF_EVENTS);
10346 : : spin_unlock(&nr_freq_lock);
10347 : : #endif
10348 : : }
10349 : :
10350 : 0 : static void account_freq_event(void)
10351 : : {
10352 : : if (tick_nohz_full_enabled())
10353 : : account_freq_event_nohz();
10354 : : else
10355 : : atomic_inc(&nr_freq_events);
10356 : 0 : }
10357 : :
10358 : :
10359 : 0 : static void account_event(struct perf_event *event)
10360 : : {
10361 : : bool inc = false;
10362 : :
10363 [ # # ]: 0 : if (event->parent)
10364 : 0 : return;
10365 : :
10366 [ # # ]: 0 : if (event->attach_state & PERF_ATTACH_TASK)
10367 : : inc = true;
10368 [ # # ]: 0 : if (event->attr.mmap || event->attr.mmap_data)
10369 : : atomic_inc(&nr_mmap_events);
10370 [ # # ]: 0 : if (event->attr.comm)
10371 : : atomic_inc(&nr_comm_events);
10372 [ # # ]: 0 : if (event->attr.namespaces)
10373 : : atomic_inc(&nr_namespaces_events);
10374 [ # # ]: 0 : if (event->attr.task)
10375 : : atomic_inc(&nr_task_events);
10376 [ # # ]: 0 : if (event->attr.freq)
10377 : 0 : account_freq_event();
10378 [ # # ]: 0 : if (event->attr.context_switch) {
10379 : : atomic_inc(&nr_switch_events);
10380 : : inc = true;
10381 : : }
10382 [ # # ]: 0 : if (has_branch_stack(event))
10383 : : inc = true;
10384 [ # # ]: 0 : if (is_cgroup_event(event))
10385 : : inc = true;
10386 [ # # ]: 0 : if (event->attr.ksymbol)
10387 : : atomic_inc(&nr_ksymbol_events);
10388 [ # # ]: 0 : if (event->attr.bpf_event)
10389 : : atomic_inc(&nr_bpf_events);
10390 : :
10391 [ # # ]: 0 : if (inc) {
10392 : : /*
10393 : : * We need the mutex here because static_branch_enable()
10394 : : * must complete *before* the perf_sched_count increment
10395 : : * becomes visible.
10396 : : */
10397 [ # # ]: 0 : if (atomic_inc_not_zero(&perf_sched_count))
10398 : : goto enabled;
10399 : :
10400 : 0 : mutex_lock(&perf_sched_mutex);
10401 [ # # ]: 0 : if (!atomic_read(&perf_sched_count)) {
10402 : 0 : static_branch_enable(&perf_sched_events);
10403 : : /*
10404 : : * Guarantee that all CPUs observe they key change and
10405 : : * call the perf scheduling hooks before proceeding to
10406 : : * install events that need them.
10407 : : */
10408 : 0 : synchronize_rcu();
10409 : : }
10410 : : /*
10411 : : * Now that we have waited for the sync_sched(), allow further
10412 : : * increments to by-pass the mutex.
10413 : : */
10414 : : atomic_inc(&perf_sched_count);
10415 : 0 : mutex_unlock(&perf_sched_mutex);
10416 : : }
10417 : : enabled:
10418 : :
10419 : 0 : account_event_cpu(event, event->cpu);
10420 : :
10421 : 0 : account_pmu_sb_event(event);
10422 : : }
10423 : :
10424 : : /*
10425 : : * Allocate and initialize an event structure
10426 : : */
10427 : : static struct perf_event *
10428 : 0 : perf_event_alloc(struct perf_event_attr *attr, int cpu,
10429 : : struct task_struct *task,
10430 : : struct perf_event *group_leader,
10431 : : struct perf_event *parent_event,
10432 : : perf_overflow_handler_t overflow_handler,
10433 : : void *context, int cgroup_fd)
10434 : : {
10435 : : struct pmu *pmu;
10436 : : struct perf_event *event;
10437 : : struct hw_perf_event *hwc;
10438 : : long err = -EINVAL;
10439 : :
10440 [ # # ]: 0 : if ((unsigned)cpu >= nr_cpu_ids) {
10441 [ # # ]: 0 : if (!task || cpu != -1)
10442 : : return ERR_PTR(-EINVAL);
10443 : : }
10444 : :
10445 : 0 : event = kzalloc(sizeof(*event), GFP_KERNEL);
10446 [ # # ]: 0 : if (!event)
10447 : : return ERR_PTR(-ENOMEM);
10448 : :
10449 : : /*
10450 : : * Single events are their own group leaders, with an
10451 : : * empty sibling list:
10452 : : */
10453 [ # # ]: 0 : if (!group_leader)
10454 : : group_leader = event;
10455 : :
10456 : 0 : mutex_init(&event->child_mutex);
10457 : 0 : INIT_LIST_HEAD(&event->child_list);
10458 : :
10459 : 0 : INIT_LIST_HEAD(&event->event_entry);
10460 : 0 : INIT_LIST_HEAD(&event->sibling_list);
10461 : 0 : INIT_LIST_HEAD(&event->active_list);
10462 : : init_event_group(event);
10463 : 0 : INIT_LIST_HEAD(&event->rb_entry);
10464 : 0 : INIT_LIST_HEAD(&event->active_entry);
10465 : 0 : INIT_LIST_HEAD(&event->addr_filters.list);
10466 : : INIT_HLIST_NODE(&event->hlist_entry);
10467 : :
10468 : :
10469 : 0 : init_waitqueue_head(&event->waitq);
10470 : 0 : event->pending_disable = -1;
10471 : : init_irq_work(&event->pending, perf_pending_event);
10472 : :
10473 : 0 : mutex_init(&event->mmap_mutex);
10474 : 0 : raw_spin_lock_init(&event->addr_filters.lock);
10475 : :
10476 : : atomic_long_set(&event->refcount, 1);
10477 : 0 : event->cpu = cpu;
10478 : 0 : event->attr = *attr;
10479 : 0 : event->group_leader = group_leader;
10480 : 0 : event->pmu = NULL;
10481 : 0 : event->oncpu = -1;
10482 : :
10483 : 0 : event->parent = parent_event;
10484 : :
10485 : 0 : event->ns = get_pid_ns(task_active_pid_ns(current));
10486 : 0 : event->id = atomic64_inc_return(&perf_event_id);
10487 : :
10488 : 0 : event->state = PERF_EVENT_STATE_INACTIVE;
10489 : :
10490 [ # # ]: 0 : if (task) {
10491 : 0 : event->attach_state = PERF_ATTACH_TASK;
10492 : : /*
10493 : : * XXX pmu::event_init needs to know what task to account to
10494 : : * and we cannot use the ctx information because we need the
10495 : : * pmu before we get a ctx.
10496 : : */
10497 : 0 : event->hw.target = get_task_struct(task);
10498 : : }
10499 : :
10500 : 0 : event->clock = &local_clock;
10501 [ # # ]: 0 : if (parent_event)
10502 : 0 : event->clock = parent_event->clock;
10503 : :
10504 [ # # ]: 0 : if (!overflow_handler && parent_event) {
10505 : 0 : overflow_handler = parent_event->overflow_handler;
10506 : 0 : context = parent_event->overflow_handler_context;
10507 : : #if defined(CONFIG_BPF_SYSCALL) && defined(CONFIG_EVENT_TRACING)
10508 [ # # ]: 0 : if (overflow_handler == bpf_overflow_handler) {
10509 : 0 : struct bpf_prog *prog = bpf_prog_inc(parent_event->prog);
10510 : :
10511 [ # # ]: 0 : if (IS_ERR(prog)) {
10512 : : err = PTR_ERR(prog);
10513 : 0 : goto err_ns;
10514 : : }
10515 : 0 : event->prog = prog;
10516 : 0 : event->orig_overflow_handler =
10517 : 0 : parent_event->orig_overflow_handler;
10518 : : }
10519 : : #endif
10520 : : }
10521 : :
10522 [ # # ]: 0 : if (overflow_handler) {
10523 : 0 : event->overflow_handler = overflow_handler;
10524 : 0 : event->overflow_handler_context = context;
10525 [ # # ]: 0 : } else if (is_write_backward(event)){
10526 : 0 : event->overflow_handler = perf_event_output_backward;
10527 : 0 : event->overflow_handler_context = NULL;
10528 : : } else {
10529 : 0 : event->overflow_handler = perf_event_output_forward;
10530 : 0 : event->overflow_handler_context = NULL;
10531 : : }
10532 : :
10533 : : perf_event__state_init(event);
10534 : :
10535 : : pmu = NULL;
10536 : :
10537 : : hwc = &event->hw;
10538 : 0 : hwc->sample_period = attr->sample_period;
10539 [ # # # # ]: 0 : if (attr->freq && attr->sample_freq)
10540 : 0 : hwc->sample_period = 1;
10541 : 0 : hwc->last_period = hwc->sample_period;
10542 : :
10543 : 0 : local64_set(&hwc->period_left, hwc->sample_period);
10544 : :
10545 : : /*
10546 : : * We currently do not support PERF_SAMPLE_READ on inherited events.
10547 : : * See perf_output_read().
10548 : : */
10549 [ # # # # ]: 0 : if (attr->inherit && (attr->sample_type & PERF_SAMPLE_READ))
10550 : : goto err_ns;
10551 : :
10552 [ # # ]: 0 : if (!has_branch_stack(event))
10553 : 0 : event->attr.branch_sample_type = 0;
10554 : :
10555 [ # # ]: 0 : if (cgroup_fd != -1) {
10556 : 0 : err = perf_cgroup_connect(cgroup_fd, event, attr, group_leader);
10557 [ # # ]: 0 : if (err)
10558 : : goto err_ns;
10559 : : }
10560 : :
10561 : 0 : pmu = perf_init_event(event);
10562 [ # # ]: 0 : if (IS_ERR(pmu)) {
10563 : : err = PTR_ERR(pmu);
10564 : 0 : goto err_ns;
10565 : : }
10566 : :
10567 : : /*
10568 : : * Disallow uncore-cgroup events, they don't make sense as the cgroup will
10569 : : * be different on other CPUs in the uncore mask.
10570 : : */
10571 [ # # # # ]: 0 : if (pmu->task_ctx_nr == perf_invalid_context && cgroup_fd != -1) {
10572 : : err = -EINVAL;
10573 : : goto err_pmu;
10574 : : }
10575 : :
10576 [ # # # # ]: 0 : if (event->attr.aux_output &&
10577 : 0 : !(pmu->capabilities & PERF_PMU_CAP_AUX_OUTPUT)) {
10578 : : err = -EOPNOTSUPP;
10579 : : goto err_pmu;
10580 : : }
10581 : :
10582 : 0 : err = exclusive_event_init(event);
10583 [ # # ]: 0 : if (err)
10584 : : goto err_pmu;
10585 : :
10586 [ # # ]: 0 : if (has_addr_filter(event)) {
10587 : 0 : event->addr_filter_ranges = kcalloc(pmu->nr_addr_filters,
10588 : : sizeof(struct perf_addr_filter_range),
10589 : : GFP_KERNEL);
10590 [ # # ]: 0 : if (!event->addr_filter_ranges) {
10591 : : err = -ENOMEM;
10592 : : goto err_per_task;
10593 : : }
10594 : :
10595 : : /*
10596 : : * Clone the parent's vma offsets: they are valid until exec()
10597 : : * even if the mm is not shared with the parent.
10598 : : */
10599 [ # # ]: 0 : if (event->parent) {
10600 : : struct perf_addr_filters_head *ifh = perf_event_addr_filters(event);
10601 : :
10602 : 0 : raw_spin_lock_irq(&ifh->lock);
10603 : 0 : memcpy(event->addr_filter_ranges,
10604 : 0 : event->parent->addr_filter_ranges,
10605 : 0 : pmu->nr_addr_filters * sizeof(struct perf_addr_filter_range));
10606 : 0 : raw_spin_unlock_irq(&ifh->lock);
10607 : : }
10608 : :
10609 : : /* force hw sync on the address filters */
10610 : 0 : event->addr_filters_gen = 1;
10611 : : }
10612 : :
10613 [ # # ]: 0 : if (!event->parent) {
10614 [ # # ]: 0 : if (event->attr.sample_type & PERF_SAMPLE_CALLCHAIN) {
10615 : 0 : err = get_callchain_buffers(attr->sample_max_stack);
10616 [ # # ]: 0 : if (err)
10617 : : goto err_addr_filters;
10618 : : }
10619 : : }
10620 : :
10621 : : /* symmetric to unaccount_event() in _free_event() */
10622 : 0 : account_event(event);
10623 : :
10624 : 0 : return event;
10625 : :
10626 : : err_addr_filters:
10627 : 0 : kfree(event->addr_filter_ranges);
10628 : :
10629 : : err_per_task:
10630 : 0 : exclusive_event_destroy(event);
10631 : :
10632 : : err_pmu:
10633 [ # # ]: 0 : if (event->destroy)
10634 : 0 : event->destroy(event);
10635 : 0 : module_put(pmu->module);
10636 : : err_ns:
10637 [ # # ]: 0 : if (is_cgroup_event(event))
10638 : 0 : perf_detach_cgroup(event);
10639 [ # # ]: 0 : if (event->ns)
10640 : 0 : put_pid_ns(event->ns);
10641 [ # # ]: 0 : if (event->hw.target)
10642 : 0 : put_task_struct(event->hw.target);
10643 : 0 : kfree(event);
10644 : :
10645 : 0 : return ERR_PTR(err);
10646 : : }
10647 : :
10648 : 0 : static int perf_copy_attr(struct perf_event_attr __user *uattr,
10649 : : struct perf_event_attr *attr)
10650 : : {
10651 : : u32 size;
10652 : : int ret;
10653 : :
10654 : : /* Zero the full structure, so that a short copy will be nice. */
10655 : 0 : memset(attr, 0, sizeof(*attr));
10656 : :
10657 : 0 : ret = get_user(size, &uattr->size);
10658 [ # # ]: 0 : if (ret)
10659 : : return ret;
10660 : :
10661 : : /* ABI compatibility quirk: */
10662 [ # # ]: 0 : if (!size)
10663 : : size = PERF_ATTR_SIZE_VER0;
10664 [ # # ]: 0 : if (size < PERF_ATTR_SIZE_VER0 || size > PAGE_SIZE)
10665 : : goto err_size;
10666 : :
10667 : : ret = copy_struct_from_user(attr, sizeof(*attr), uattr, size);
10668 [ # # ]: 0 : if (ret) {
10669 [ # # ]: 0 : if (ret == -E2BIG)
10670 : : goto err_size;
10671 : : return ret;
10672 : : }
10673 : :
10674 : 0 : attr->size = size;
10675 : :
10676 [ # # # # ]: 0 : if (attr->__reserved_1 || attr->__reserved_2)
10677 : : return -EINVAL;
10678 : :
10679 [ # # ]: 0 : if (attr->sample_type & ~(PERF_SAMPLE_MAX-1))
10680 : : return -EINVAL;
10681 : :
10682 [ # # ]: 0 : if (attr->read_format & ~(PERF_FORMAT_MAX-1))
10683 : : return -EINVAL;
10684 : :
10685 [ # # ]: 0 : if (attr->sample_type & PERF_SAMPLE_BRANCH_STACK) {
10686 : 0 : u64 mask = attr->branch_sample_type;
10687 : :
10688 : : /* only using defined bits */
10689 [ # # ]: 0 : if (mask & ~(PERF_SAMPLE_BRANCH_MAX-1))
10690 : : return -EINVAL;
10691 : :
10692 : : /* at least one branch bit must be set */
10693 [ # # ]: 0 : if (!(mask & ~PERF_SAMPLE_BRANCH_PLM_ALL))
10694 : : return -EINVAL;
10695 : :
10696 : : /* propagate priv level, when not set for branch */
10697 [ # # ]: 0 : if (!(mask & PERF_SAMPLE_BRANCH_PLM_ALL)) {
10698 : :
10699 : : /* exclude_kernel checked on syscall entry */
10700 [ # # ]: 0 : if (!attr->exclude_kernel)
10701 : 0 : mask |= PERF_SAMPLE_BRANCH_KERNEL;
10702 : :
10703 [ # # ]: 0 : if (!attr->exclude_user)
10704 : 0 : mask |= PERF_SAMPLE_BRANCH_USER;
10705 : :
10706 [ # # ]: 0 : if (!attr->exclude_hv)
10707 : 0 : mask |= PERF_SAMPLE_BRANCH_HV;
10708 : : /*
10709 : : * adjust user setting (for HW filter setup)
10710 : : */
10711 : 0 : attr->branch_sample_type = mask;
10712 : : }
10713 : : /* privileged levels capture (kernel, hv): check permissions */
10714 [ # # ]: 0 : if ((mask & PERF_SAMPLE_BRANCH_PERM_PLM)
10715 [ # # # # ]: 0 : && perf_paranoid_kernel() && !capable(CAP_SYS_ADMIN))
10716 : : return -EACCES;
10717 : : }
10718 : :
10719 [ # # ]: 0 : if (attr->sample_type & PERF_SAMPLE_REGS_USER) {
10720 : 0 : ret = perf_reg_validate(attr->sample_regs_user);
10721 [ # # ]: 0 : if (ret)
10722 : : return ret;
10723 : : }
10724 : :
10725 [ # # ]: 0 : if (attr->sample_type & PERF_SAMPLE_STACK_USER) {
10726 : : if (!arch_perf_have_user_stack_dump())
10727 : : return -ENOSYS;
10728 : :
10729 : : /*
10730 : : * We have __u32 type for the size, but so far
10731 : : * we can only use __u16 as maximum due to the
10732 : : * __u16 sample size limit.
10733 : : */
10734 [ # # ]: 0 : if (attr->sample_stack_user >= USHRT_MAX)
10735 : : return -EINVAL;
10736 [ # # ]: 0 : else if (!IS_ALIGNED(attr->sample_stack_user, sizeof(u64)))
10737 : : return -EINVAL;
10738 : : }
10739 : :
10740 [ # # ]: 0 : if (!attr->sample_max_stack)
10741 : 0 : attr->sample_max_stack = sysctl_perf_event_max_stack;
10742 : :
10743 [ # # ]: 0 : if (attr->sample_type & PERF_SAMPLE_REGS_INTR)
10744 : 0 : ret = perf_reg_validate(attr->sample_regs_intr);
10745 : : out:
10746 : 0 : return ret;
10747 : :
10748 : : err_size:
10749 : 0 : put_user(sizeof(*attr), &uattr->size);
10750 : : ret = -E2BIG;
10751 : 0 : goto out;
10752 : : }
10753 : :
10754 : : static int
10755 : 0 : perf_event_set_output(struct perf_event *event, struct perf_event *output_event)
10756 : : {
10757 : : struct ring_buffer *rb = NULL;
10758 : : int ret = -EINVAL;
10759 : :
10760 [ # # ]: 0 : if (!output_event)
10761 : : goto set;
10762 : :
10763 : : /* don't allow circular references */
10764 [ # # ]: 0 : if (event == output_event)
10765 : : goto out;
10766 : :
10767 : : /*
10768 : : * Don't allow cross-cpu buffers
10769 : : */
10770 [ # # ]: 0 : if (output_event->cpu != event->cpu)
10771 : : goto out;
10772 : :
10773 : : /*
10774 : : * If its not a per-cpu rb, it must be the same task.
10775 : : */
10776 [ # # # # ]: 0 : if (output_event->cpu == -1 && output_event->ctx != event->ctx)
10777 : : goto out;
10778 : :
10779 : : /*
10780 : : * Mixing clocks in the same buffer is trouble you don't need.
10781 : : */
10782 [ # # ]: 0 : if (output_event->clock != event->clock)
10783 : : goto out;
10784 : :
10785 : : /*
10786 : : * Either writing ring buffer from beginning or from end.
10787 : : * Mixing is not allowed.
10788 : : */
10789 [ # # ]: 0 : if (is_write_backward(output_event) != is_write_backward(event))
10790 : : goto out;
10791 : :
10792 : : /*
10793 : : * If both events generate aux data, they must be on the same PMU
10794 : : */
10795 [ # # # # : 0 : if (has_aux(event) && has_aux(output_event) &&
# # ]
10796 : : event->pmu != output_event->pmu)
10797 : : goto out;
10798 : :
10799 : : set:
10800 : 0 : mutex_lock(&event->mmap_mutex);
10801 : : /* Can't redirect output if we've got an active mmap() */
10802 [ # # ]: 0 : if (atomic_read(&event->mmap_count))
10803 : : goto unlock;
10804 : :
10805 [ # # ]: 0 : if (output_event) {
10806 : : /* get the rb we want to redirect to */
10807 : 0 : rb = ring_buffer_get(output_event);
10808 [ # # ]: 0 : if (!rb)
10809 : : goto unlock;
10810 : : }
10811 : :
10812 : 0 : ring_buffer_attach(event, rb);
10813 : :
10814 : : ret = 0;
10815 : : unlock:
10816 : 0 : mutex_unlock(&event->mmap_mutex);
10817 : :
10818 : : out:
10819 : 0 : return ret;
10820 : : }
10821 : :
10822 : : static void mutex_lock_double(struct mutex *a, struct mutex *b)
10823 : : {
10824 [ # # # # ]: 0 : if (b < a)
10825 : : swap(a, b);
10826 : :
10827 : 0 : mutex_lock(a);
10828 : 0 : mutex_lock_nested(b, SINGLE_DEPTH_NESTING);
10829 : : }
10830 : :
10831 : 0 : static int perf_event_set_clock(struct perf_event *event, clockid_t clk_id)
10832 : : {
10833 : : bool nmi_safe = false;
10834 : :
10835 [ # # # # : 0 : switch (clk_id) {
# # ]
10836 : : case CLOCK_MONOTONIC:
10837 : 0 : event->clock = &ktime_get_mono_fast_ns;
10838 : : nmi_safe = true;
10839 : 0 : break;
10840 : :
10841 : : case CLOCK_MONOTONIC_RAW:
10842 : 0 : event->clock = &ktime_get_raw_fast_ns;
10843 : : nmi_safe = true;
10844 : 0 : break;
10845 : :
10846 : : case CLOCK_REALTIME:
10847 : 0 : event->clock = &ktime_get_real_ns;
10848 : 0 : break;
10849 : :
10850 : : case CLOCK_BOOTTIME:
10851 : 0 : event->clock = &ktime_get_boottime_ns;
10852 : 0 : break;
10853 : :
10854 : : case CLOCK_TAI:
10855 : 0 : event->clock = &ktime_get_clocktai_ns;
10856 : 0 : break;
10857 : :
10858 : : default:
10859 : : return -EINVAL;
10860 : : }
10861 : :
10862 [ # # # # ]: 0 : if (!nmi_safe && !(event->pmu->capabilities & PERF_PMU_CAP_NO_NMI))
10863 : : return -EINVAL;
10864 : :
10865 : 0 : return 0;
10866 : : }
10867 : :
10868 : : /*
10869 : : * Variation on perf_event_ctx_lock_nested(), except we take two context
10870 : : * mutexes.
10871 : : */
10872 : : static struct perf_event_context *
10873 : 0 : __perf_event_ctx_lock_double(struct perf_event *group_leader,
10874 : : struct perf_event_context *ctx)
10875 : : {
10876 : : struct perf_event_context *gctx;
10877 : :
10878 : : again:
10879 : : rcu_read_lock();
10880 : 0 : gctx = READ_ONCE(group_leader->ctx);
10881 [ # # ]: 0 : if (!refcount_inc_not_zero(&gctx->refcount)) {
10882 : : rcu_read_unlock();
10883 : : goto again;
10884 : : }
10885 : : rcu_read_unlock();
10886 : :
10887 : 0 : mutex_lock_double(&gctx->mutex, &ctx->mutex);
10888 : :
10889 [ # # ]: 0 : if (group_leader->ctx != gctx) {
10890 : 0 : mutex_unlock(&ctx->mutex);
10891 : 0 : mutex_unlock(&gctx->mutex);
10892 : 0 : put_ctx(gctx);
10893 : 0 : goto again;
10894 : : }
10895 : :
10896 : 0 : return gctx;
10897 : : }
10898 : :
10899 : : /**
10900 : : * sys_perf_event_open - open a performance event, associate it to a task/cpu
10901 : : *
10902 : : * @attr_uptr: event_id type attributes for monitoring/sampling
10903 : : * @pid: target pid
10904 : : * @cpu: target cpu
10905 : : * @group_fd: group leader event fd
10906 : : */
10907 : 0 : SYSCALL_DEFINE5(perf_event_open,
10908 : : struct perf_event_attr __user *, attr_uptr,
10909 : : pid_t, pid, int, cpu, int, group_fd, unsigned long, flags)
10910 : : {
10911 : : struct perf_event *group_leader = NULL, *output_event = NULL;
10912 : : struct perf_event *event, *sibling;
10913 : : struct perf_event_attr attr;
10914 : : struct perf_event_context *ctx, *uninitialized_var(gctx);
10915 : : struct file *event_file = NULL;
10916 : 0 : struct fd group = {NULL, 0};
10917 : : struct task_struct *task = NULL;
10918 : : struct pmu *pmu;
10919 : : int event_fd;
10920 : : int move_group = 0;
10921 : : int err;
10922 : : int f_flags = O_RDWR;
10923 : : int cgroup_fd = -1;
10924 : :
10925 : : /* for future expandability... */
10926 [ # # ]: 0 : if (flags & ~PERF_FLAG_ALL)
10927 : : return -EINVAL;
10928 : :
10929 : 0 : err = perf_copy_attr(attr_uptr, &attr);
10930 [ # # ]: 0 : if (err)
10931 : : return err;
10932 : :
10933 [ # # ]: 0 : if (!attr.exclude_kernel) {
10934 [ # # # # ]: 0 : if (perf_paranoid_kernel() && !capable(CAP_SYS_ADMIN))
10935 : : return -EACCES;
10936 : : }
10937 : :
10938 [ # # ]: 0 : if (attr.namespaces) {
10939 [ # # ]: 0 : if (!capable(CAP_SYS_ADMIN))
10940 : : return -EACCES;
10941 : : }
10942 : :
10943 [ # # ]: 0 : if (attr.freq) {
10944 [ # # ]: 0 : if (attr.sample_freq > sysctl_perf_event_sample_rate)
10945 : : return -EINVAL;
10946 : : } else {
10947 [ # # ]: 0 : if (attr.sample_period & (1ULL << 63))
10948 : : return -EINVAL;
10949 : : }
10950 : :
10951 : : /* Only privileged users can get physical addresses */
10952 [ # # # # ]: 0 : if ((attr.sample_type & PERF_SAMPLE_PHYS_ADDR) &&
10953 [ # # ]: 0 : perf_paranoid_kernel() && !capable(CAP_SYS_ADMIN))
10954 : : return -EACCES;
10955 : :
10956 : 0 : err = security_locked_down(LOCKDOWN_PERF);
10957 [ # # # # ]: 0 : if (err && (attr.sample_type & PERF_SAMPLE_REGS_INTR))
10958 : : /* REGS_INTR can leak data, lockdown must prevent this */
10959 : : return err;
10960 : :
10961 : : err = 0;
10962 : :
10963 : : /*
10964 : : * In cgroup mode, the pid argument is used to pass the fd
10965 : : * opened to the cgroup directory in cgroupfs. The cpu argument
10966 : : * designates the cpu on which to monitor threads from that
10967 : : * cgroup.
10968 : : */
10969 [ # # # # ]: 0 : if ((flags & PERF_FLAG_PID_CGROUP) && (pid == -1 || cpu == -1))
10970 : : return -EINVAL;
10971 : :
10972 [ # # ]: 0 : if (flags & PERF_FLAG_FD_CLOEXEC)
10973 : : f_flags |= O_CLOEXEC;
10974 : :
10975 : 0 : event_fd = get_unused_fd_flags(f_flags);
10976 [ # # ]: 0 : if (event_fd < 0)
10977 : : return event_fd;
10978 : :
10979 [ # # ]: 0 : if (group_fd != -1) {
10980 : 0 : err = perf_fget_light(group_fd, &group);
10981 [ # # ]: 0 : if (err)
10982 : : goto err_fd;
10983 : 0 : group_leader = group.file->private_data;
10984 [ # # ]: 0 : if (flags & PERF_FLAG_FD_OUTPUT)
10985 : : output_event = group_leader;
10986 [ # # ]: 0 : if (flags & PERF_FLAG_FD_NO_GROUP)
10987 : : group_leader = NULL;
10988 : : }
10989 : :
10990 [ # # # # ]: 0 : if (pid != -1 && !(flags & PERF_FLAG_PID_CGROUP)) {
10991 : 0 : task = find_lively_task_by_vpid(pid);
10992 [ # # ]: 0 : if (IS_ERR(task)) {
10993 : : err = PTR_ERR(task);
10994 : 0 : goto err_group_fd;
10995 : : }
10996 : : }
10997 : :
10998 [ # # # # ]: 0 : if (task && group_leader &&
10999 : 0 : group_leader->attr.inherit != attr.inherit) {
11000 : : err = -EINVAL;
11001 : : goto err_task;
11002 : : }
11003 : :
11004 [ # # ]: 0 : if (task) {
11005 : 0 : err = mutex_lock_interruptible(&task->signal->cred_guard_mutex);
11006 [ # # ]: 0 : if (err)
11007 : : goto err_task;
11008 : :
11009 : : /*
11010 : : * Reuse ptrace permission checks for now.
11011 : : *
11012 : : * We must hold cred_guard_mutex across this and any potential
11013 : : * perf_install_in_context() call for this new event to
11014 : : * serialize against exec() altering our credentials (and the
11015 : : * perf_event_exit_task() that could imply).
11016 : : */
11017 : : err = -EACCES;
11018 [ # # ]: 0 : if (!ptrace_may_access(task, PTRACE_MODE_READ_REALCREDS))
11019 : : goto err_cred;
11020 : : }
11021 : :
11022 [ # # ]: 0 : if (flags & PERF_FLAG_PID_CGROUP)
11023 : : cgroup_fd = pid;
11024 : :
11025 : 0 : event = perf_event_alloc(&attr, cpu, task, group_leader, NULL,
11026 : : NULL, NULL, cgroup_fd);
11027 [ # # ]: 0 : if (IS_ERR(event)) {
11028 : : err = PTR_ERR(event);
11029 : 0 : goto err_cred;
11030 : : }
11031 : :
11032 [ # # ]: 0 : if (is_sampling_event(event)) {
11033 [ # # ]: 0 : if (event->pmu->capabilities & PERF_PMU_CAP_NO_INTERRUPT) {
11034 : : err = -EOPNOTSUPP;
11035 : : goto err_alloc;
11036 : : }
11037 : : }
11038 : :
11039 : : /*
11040 : : * Special case software events and allow them to be part of
11041 : : * any hardware group.
11042 : : */
11043 : 0 : pmu = event->pmu;
11044 : :
11045 [ # # ]: 0 : if (attr.use_clockid) {
11046 : 0 : err = perf_event_set_clock(event, attr.clockid);
11047 [ # # ]: 0 : if (err)
11048 : : goto err_alloc;
11049 : : }
11050 : :
11051 [ # # ]: 0 : if (pmu->task_ctx_nr == perf_sw_context)
11052 : 0 : event->event_caps |= PERF_EV_CAP_SOFTWARE;
11053 : :
11054 [ # # ]: 0 : if (group_leader) {
11055 [ # # # # ]: 0 : if (is_software_event(event) &&
11056 : : !in_software_context(group_leader)) {
11057 : : /*
11058 : : * If the event is a sw event, but the group_leader
11059 : : * is on hw context.
11060 : : *
11061 : : * Allow the addition of software events to hw
11062 : : * groups, this is safe because software events
11063 : : * never fail to schedule.
11064 : : */
11065 : : pmu = group_leader->ctx->pmu;
11066 [ # # # # ]: 0 : } else if (!is_software_event(event) &&
11067 [ # # ]: 0 : is_software_event(group_leader) &&
11068 : 0 : (group_leader->group_caps & PERF_EV_CAP_SOFTWARE)) {
11069 : : /*
11070 : : * In case the group is a pure software group, and we
11071 : : * try to add a hardware event, move the whole group to
11072 : : * the hardware context.
11073 : : */
11074 : : move_group = 1;
11075 : : }
11076 : : }
11077 : :
11078 : : /*
11079 : : * Get the target context (task or percpu):
11080 : : */
11081 : 0 : ctx = find_get_context(pmu, task, event);
11082 [ # # ]: 0 : if (IS_ERR(ctx)) {
11083 : : err = PTR_ERR(ctx);
11084 : 0 : goto err_alloc;
11085 : : }
11086 : :
11087 : : /*
11088 : : * Look up the group leader (we will attach this event to it):
11089 : : */
11090 [ # # ]: 0 : if (group_leader) {
11091 : : err = -EINVAL;
11092 : :
11093 : : /*
11094 : : * Do not allow a recursive hierarchy (this new sibling
11095 : : * becoming part of another group-sibling):
11096 : : */
11097 [ # # ]: 0 : if (group_leader->group_leader != group_leader)
11098 : : goto err_context;
11099 : :
11100 : : /* All events in a group should have the same clock */
11101 [ # # ]: 0 : if (group_leader->clock != event->clock)
11102 : : goto err_context;
11103 : :
11104 : : /*
11105 : : * Make sure we're both events for the same CPU;
11106 : : * grouping events for different CPUs is broken; since
11107 : : * you can never concurrently schedule them anyhow.
11108 : : */
11109 [ # # ]: 0 : if (group_leader->cpu != event->cpu)
11110 : : goto err_context;
11111 : :
11112 : : /*
11113 : : * Make sure we're both on the same task, or both
11114 : : * per-CPU events.
11115 : : */
11116 [ # # ]: 0 : if (group_leader->ctx->task != ctx->task)
11117 : : goto err_context;
11118 : :
11119 : : /*
11120 : : * Do not allow to attach to a group in a different task
11121 : : * or CPU context. If we're moving SW events, we'll fix
11122 : : * this up later, so allow that.
11123 : : */
11124 [ # # # # ]: 0 : if (!move_group && group_leader->ctx != ctx)
11125 : : goto err_context;
11126 : :
11127 : : /*
11128 : : * Only a group leader can be exclusive or pinned
11129 : : */
11130 [ # # ]: 0 : if (attr.exclusive || attr.pinned)
11131 : : goto err_context;
11132 : : }
11133 : :
11134 [ # # ]: 0 : if (output_event) {
11135 : 0 : err = perf_event_set_output(event, output_event);
11136 [ # # ]: 0 : if (err)
11137 : : goto err_context;
11138 : : }
11139 : :
11140 : 0 : event_file = anon_inode_getfile("[perf_event]", &perf_fops, event,
11141 : : f_flags);
11142 [ # # ]: 0 : if (IS_ERR(event_file)) {
11143 : : err = PTR_ERR(event_file);
11144 : : event_file = NULL;
11145 : 0 : goto err_context;
11146 : : }
11147 : :
11148 [ # # ]: 0 : if (move_group) {
11149 : 0 : gctx = __perf_event_ctx_lock_double(group_leader, ctx);
11150 : :
11151 [ # # ]: 0 : if (gctx->task == TASK_TOMBSTONE) {
11152 : : err = -ESRCH;
11153 : : goto err_locked;
11154 : : }
11155 : :
11156 : : /*
11157 : : * Check if we raced against another sys_perf_event_open() call
11158 : : * moving the software group underneath us.
11159 : : */
11160 [ # # ]: 0 : if (!(group_leader->group_caps & PERF_EV_CAP_SOFTWARE)) {
11161 : : /*
11162 : : * If someone moved the group out from under us, check
11163 : : * if this new event wound up on the same ctx, if so
11164 : : * its the regular !move_group case, otherwise fail.
11165 : : */
11166 [ # # ]: 0 : if (gctx != ctx) {
11167 : : err = -EINVAL;
11168 : : goto err_locked;
11169 : : } else {
11170 : : perf_event_ctx_unlock(group_leader, gctx);
11171 : : move_group = 0;
11172 : : }
11173 : : }
11174 : :
11175 : : /*
11176 : : * Failure to create exclusive events returns -EBUSY.
11177 : : */
11178 : : err = -EBUSY;
11179 [ # # ]: 0 : if (!exclusive_event_installable(group_leader, ctx))
11180 : : goto err_locked;
11181 : :
11182 [ # # # # ]: 0 : for_each_sibling_event(sibling, group_leader) {
11183 [ # # ]: 0 : if (!exclusive_event_installable(sibling, ctx))
11184 : : goto err_locked;
11185 : : }
11186 : : } else {
11187 : 0 : mutex_lock(&ctx->mutex);
11188 : : }
11189 : :
11190 [ # # ]: 0 : if (ctx->task == TASK_TOMBSTONE) {
11191 : : err = -ESRCH;
11192 : : goto err_locked;
11193 : : }
11194 : :
11195 [ # # ]: 0 : if (!perf_event_validate_size(event)) {
11196 : : err = -E2BIG;
11197 : : goto err_locked;
11198 : : }
11199 : :
11200 [ # # ]: 0 : if (!task) {
11201 : : /*
11202 : : * Check if the @cpu we're creating an event for is online.
11203 : : *
11204 : : * We use the perf_cpu_context::ctx::mutex to serialize against
11205 : : * the hotplug notifiers. See perf_event_{init,exit}_cpu().
11206 : : */
11207 : : struct perf_cpu_context *cpuctx =
11208 : : container_of(ctx, struct perf_cpu_context, ctx);
11209 : :
11210 [ # # ]: 0 : if (!cpuctx->online) {
11211 : : err = -ENODEV;
11212 : : goto err_locked;
11213 : : }
11214 : : }
11215 : :
11216 [ # # # # ]: 0 : if (event->attr.aux_output && !perf_get_aux_event(event, group_leader)) {
11217 : : err = -EINVAL;
11218 : : goto err_locked;
11219 : : }
11220 : :
11221 : : /*
11222 : : * Must be under the same ctx::mutex as perf_install_in_context(),
11223 : : * because we need to serialize with concurrent event creation.
11224 : : */
11225 [ # # ]: 0 : if (!exclusive_event_installable(event, ctx)) {
11226 : : err = -EBUSY;
11227 : : goto err_locked;
11228 : : }
11229 : :
11230 [ # # # # ]: 0 : WARN_ON_ONCE(ctx->parent_ctx);
11231 : :
11232 : : /*
11233 : : * This is the point on no return; we cannot fail hereafter. This is
11234 : : * where we start modifying current state.
11235 : : */
11236 : :
11237 [ # # ]: 0 : if (move_group) {
11238 : : /*
11239 : : * See perf_event_ctx_lock() for comments on the details
11240 : : * of swizzling perf_event::ctx.
11241 : : */
11242 : 0 : perf_remove_from_context(group_leader, 0);
11243 : 0 : put_ctx(gctx);
11244 : :
11245 [ # # # # ]: 0 : for_each_sibling_event(sibling, group_leader) {
11246 : 0 : perf_remove_from_context(sibling, 0);
11247 : 0 : put_ctx(gctx);
11248 : : }
11249 : :
11250 : : /*
11251 : : * Wait for everybody to stop referencing the events through
11252 : : * the old lists, before installing it on new lists.
11253 : : */
11254 : 0 : synchronize_rcu();
11255 : :
11256 : : /*
11257 : : * Install the group siblings before the group leader.
11258 : : *
11259 : : * Because a group leader will try and install the entire group
11260 : : * (through the sibling list, which is still in-tact), we can
11261 : : * end up with siblings installed in the wrong context.
11262 : : *
11263 : : * By installing siblings first we NO-OP because they're not
11264 : : * reachable through the group lists.
11265 : : */
11266 [ # # # # ]: 0 : for_each_sibling_event(sibling, group_leader) {
11267 : : perf_event__state_init(sibling);
11268 : 0 : perf_install_in_context(ctx, sibling, sibling->cpu);
11269 : : get_ctx(ctx);
11270 : : }
11271 : :
11272 : : /*
11273 : : * Removing from the context ends up with disabled
11274 : : * event. What we want here is event in the initial
11275 : : * startup state, ready to be add into new context.
11276 : : */
11277 : : perf_event__state_init(group_leader);
11278 : 0 : perf_install_in_context(ctx, group_leader, group_leader->cpu);
11279 : : get_ctx(ctx);
11280 : : }
11281 : :
11282 : : /*
11283 : : * Precalculate sample_data sizes; do while holding ctx::mutex such
11284 : : * that we're serialized against further additions and before
11285 : : * perf_install_in_context() which is the point the event is active and
11286 : : * can use these values.
11287 : : */
11288 : 0 : perf_event__header_size(event);
11289 : 0 : perf_event__id_header_size(event);
11290 : :
11291 : 0 : event->owner = current;
11292 : :
11293 : 0 : perf_install_in_context(ctx, event, event->cpu);
11294 : 0 : perf_unpin_context(ctx);
11295 : :
11296 [ # # ]: 0 : if (move_group)
11297 : : perf_event_ctx_unlock(group_leader, gctx);
11298 : 0 : mutex_unlock(&ctx->mutex);
11299 : :
11300 [ # # ]: 0 : if (task) {
11301 : 0 : mutex_unlock(&task->signal->cred_guard_mutex);
11302 : 0 : put_task_struct(task);
11303 : : }
11304 : :
11305 : 0 : mutex_lock(¤t->perf_event_mutex);
11306 : 0 : list_add_tail(&event->owner_entry, ¤t->perf_event_list);
11307 : 0 : mutex_unlock(¤t->perf_event_mutex);
11308 : :
11309 : : /*
11310 : : * Drop the reference on the group_event after placing the
11311 : : * new event on the sibling_list. This ensures destruction
11312 : : * of the group leader will find the pointer to itself in
11313 : : * perf_group_detach().
11314 : : */
11315 : : fdput(group);
11316 : 0 : fd_install(event_fd, event_file);
11317 : 0 : return event_fd;
11318 : :
11319 : : err_locked:
11320 [ # # ]: 0 : if (move_group)
11321 : : perf_event_ctx_unlock(group_leader, gctx);
11322 : 0 : mutex_unlock(&ctx->mutex);
11323 : : /* err_file: */
11324 : 0 : fput(event_file);
11325 : : err_context:
11326 : 0 : perf_unpin_context(ctx);
11327 : 0 : put_ctx(ctx);
11328 : : err_alloc:
11329 : : /*
11330 : : * If event_file is set, the fput() above will have called ->release()
11331 : : * and that will take care of freeing the event.
11332 : : */
11333 [ # # ]: 0 : if (!event_file)
11334 : 0 : free_event(event);
11335 : : err_cred:
11336 [ # # ]: 0 : if (task)
11337 : 0 : mutex_unlock(&task->signal->cred_guard_mutex);
11338 : : err_task:
11339 [ # # ]: 0 : if (task)
11340 : 0 : put_task_struct(task);
11341 : : err_group_fd:
11342 : : fdput(group);
11343 : : err_fd:
11344 : 0 : put_unused_fd(event_fd);
11345 : 0 : return err;
11346 : : }
11347 : :
11348 : : /**
11349 : : * perf_event_create_kernel_counter
11350 : : *
11351 : : * @attr: attributes of the counter to create
11352 : : * @cpu: cpu in which the counter is bound
11353 : : * @task: task to profile (NULL for percpu)
11354 : : */
11355 : : struct perf_event *
11356 : 0 : perf_event_create_kernel_counter(struct perf_event_attr *attr, int cpu,
11357 : : struct task_struct *task,
11358 : : perf_overflow_handler_t overflow_handler,
11359 : : void *context)
11360 : : {
11361 : : struct perf_event_context *ctx;
11362 : : struct perf_event *event;
11363 : : int err;
11364 : :
11365 : : /*
11366 : : * Grouping is not supported for kernel events, neither is 'AUX',
11367 : : * make sure the caller's intentions are adjusted.
11368 : : */
11369 [ # # ]: 0 : if (attr->aux_output)
11370 : : return ERR_PTR(-EINVAL);
11371 : :
11372 : 0 : event = perf_event_alloc(attr, cpu, task, NULL, NULL,
11373 : : overflow_handler, context, -1);
11374 [ # # ]: 0 : if (IS_ERR(event)) {
11375 : : err = PTR_ERR(event);
11376 : 0 : goto err;
11377 : : }
11378 : :
11379 : : /* Mark owner so we could distinguish it from user events. */
11380 : 0 : event->owner = TASK_TOMBSTONE;
11381 : :
11382 : : /*
11383 : : * Get the target context (task or percpu):
11384 : : */
11385 : 0 : ctx = find_get_context(event->pmu, task, event);
11386 [ # # ]: 0 : if (IS_ERR(ctx)) {
11387 : : err = PTR_ERR(ctx);
11388 : 0 : goto err_free;
11389 : : }
11390 : :
11391 [ # # # # ]: 0 : WARN_ON_ONCE(ctx->parent_ctx);
11392 : 0 : mutex_lock(&ctx->mutex);
11393 [ # # ]: 0 : if (ctx->task == TASK_TOMBSTONE) {
11394 : : err = -ESRCH;
11395 : : goto err_unlock;
11396 : : }
11397 : :
11398 [ # # ]: 0 : if (!task) {
11399 : : /*
11400 : : * Check if the @cpu we're creating an event for is online.
11401 : : *
11402 : : * We use the perf_cpu_context::ctx::mutex to serialize against
11403 : : * the hotplug notifiers. See perf_event_{init,exit}_cpu().
11404 : : */
11405 : : struct perf_cpu_context *cpuctx =
11406 : : container_of(ctx, struct perf_cpu_context, ctx);
11407 [ # # ]: 0 : if (!cpuctx->online) {
11408 : : err = -ENODEV;
11409 : : goto err_unlock;
11410 : : }
11411 : : }
11412 : :
11413 [ # # ]: 0 : if (!exclusive_event_installable(event, ctx)) {
11414 : : err = -EBUSY;
11415 : : goto err_unlock;
11416 : : }
11417 : :
11418 : 0 : perf_install_in_context(ctx, event, event->cpu);
11419 : 0 : perf_unpin_context(ctx);
11420 : 0 : mutex_unlock(&ctx->mutex);
11421 : :
11422 : 0 : return event;
11423 : :
11424 : : err_unlock:
11425 : 0 : mutex_unlock(&ctx->mutex);
11426 : 0 : perf_unpin_context(ctx);
11427 : 0 : put_ctx(ctx);
11428 : : err_free:
11429 : 0 : free_event(event);
11430 : : err:
11431 : 0 : return ERR_PTR(err);
11432 : : }
11433 : : EXPORT_SYMBOL_GPL(perf_event_create_kernel_counter);
11434 : :
11435 : 0 : void perf_pmu_migrate_context(struct pmu *pmu, int src_cpu, int dst_cpu)
11436 : : {
11437 : : struct perf_event_context *src_ctx;
11438 : : struct perf_event_context *dst_ctx;
11439 : : struct perf_event *event, *tmp;
11440 : 0 : LIST_HEAD(events);
11441 : :
11442 : 0 : src_ctx = &per_cpu_ptr(pmu->pmu_cpu_context, src_cpu)->ctx;
11443 : 0 : dst_ctx = &per_cpu_ptr(pmu->pmu_cpu_context, dst_cpu)->ctx;
11444 : :
11445 : : /*
11446 : : * See perf_event_ctx_lock() for comments on the details
11447 : : * of swizzling perf_event::ctx.
11448 : : */
11449 : 0 : mutex_lock_double(&src_ctx->mutex, &dst_ctx->mutex);
11450 [ # # ]: 0 : list_for_each_entry_safe(event, tmp, &src_ctx->event_list,
11451 : : event_entry) {
11452 : 0 : perf_remove_from_context(event, 0);
11453 : 0 : unaccount_event_cpu(event, src_cpu);
11454 : 0 : put_ctx(src_ctx);
11455 : 0 : list_add(&event->migrate_entry, &events);
11456 : : }
11457 : :
11458 : : /*
11459 : : * Wait for the events to quiesce before re-instating them.
11460 : : */
11461 : 0 : synchronize_rcu();
11462 : :
11463 : : /*
11464 : : * Re-instate events in 2 passes.
11465 : : *
11466 : : * Skip over group leaders and only install siblings on this first
11467 : : * pass, siblings will not get enabled without a leader, however a
11468 : : * leader will enable its siblings, even if those are still on the old
11469 : : * context.
11470 : : */
11471 [ # # ]: 0 : list_for_each_entry_safe(event, tmp, &events, migrate_entry) {
11472 [ # # ]: 0 : if (event->group_leader == event)
11473 : 0 : continue;
11474 : :
11475 : : list_del(&event->migrate_entry);
11476 [ # # ]: 0 : if (event->state >= PERF_EVENT_STATE_OFF)
11477 : 0 : event->state = PERF_EVENT_STATE_INACTIVE;
11478 : 0 : account_event_cpu(event, dst_cpu);
11479 : 0 : perf_install_in_context(dst_ctx, event, dst_cpu);
11480 : : get_ctx(dst_ctx);
11481 : : }
11482 : :
11483 : : /*
11484 : : * Once all the siblings are setup properly, install the group leaders
11485 : : * to make it go.
11486 : : */
11487 [ # # ]: 0 : list_for_each_entry_safe(event, tmp, &events, migrate_entry) {
11488 : : list_del(&event->migrate_entry);
11489 [ # # ]: 0 : if (event->state >= PERF_EVENT_STATE_OFF)
11490 : 0 : event->state = PERF_EVENT_STATE_INACTIVE;
11491 : 0 : account_event_cpu(event, dst_cpu);
11492 : 0 : perf_install_in_context(dst_ctx, event, dst_cpu);
11493 : : get_ctx(dst_ctx);
11494 : : }
11495 : 0 : mutex_unlock(&dst_ctx->mutex);
11496 : 0 : mutex_unlock(&src_ctx->mutex);
11497 : 0 : }
11498 : : EXPORT_SYMBOL_GPL(perf_pmu_migrate_context);
11499 : :
11500 : 0 : static void sync_child_event(struct perf_event *child_event,
11501 : : struct task_struct *child)
11502 : : {
11503 : 0 : struct perf_event *parent_event = child_event->parent;
11504 : : u64 child_val;
11505 : :
11506 [ # # ]: 0 : if (child_event->attr.inherit_stat)
11507 : 0 : perf_event_read_event(child_event, child);
11508 : :
11509 : : child_val = perf_event_count(child_event);
11510 : :
11511 : : /*
11512 : : * Add back the child's count to the parent's count:
11513 : : */
11514 : 0 : atomic64_add(child_val, &parent_event->child_count);
11515 : 0 : atomic64_add(child_event->total_time_enabled,
11516 : : &parent_event->child_total_time_enabled);
11517 : 0 : atomic64_add(child_event->total_time_running,
11518 : : &parent_event->child_total_time_running);
11519 : 0 : }
11520 : :
11521 : : static void
11522 : 0 : perf_event_exit_event(struct perf_event *child_event,
11523 : : struct perf_event_context *child_ctx,
11524 : : struct task_struct *child)
11525 : : {
11526 : 0 : struct perf_event *parent_event = child_event->parent;
11527 : :
11528 : : /*
11529 : : * Do not destroy the 'original' grouping; because of the context
11530 : : * switch optimization the original events could've ended up in a
11531 : : * random child task.
11532 : : *
11533 : : * If we were to destroy the original group, all group related
11534 : : * operations would cease to function properly after this random
11535 : : * child dies.
11536 : : *
11537 : : * Do destroy all inherited groups, we don't care about those
11538 : : * and being thorough is better.
11539 : : */
11540 : 0 : raw_spin_lock_irq(&child_ctx->lock);
11541 [ # # # # ]: 0 : WARN_ON_ONCE(child_ctx->is_active);
11542 : :
11543 [ # # ]: 0 : if (parent_event)
11544 : 0 : perf_group_detach(child_event);
11545 : 0 : list_del_event(child_event, child_ctx);
11546 : 0 : perf_event_set_state(child_event, PERF_EVENT_STATE_EXIT); /* is_event_hup() */
11547 : 0 : raw_spin_unlock_irq(&child_ctx->lock);
11548 : :
11549 : : /*
11550 : : * Parent events are governed by their filedesc, retain them.
11551 : : */
11552 [ # # ]: 0 : if (!parent_event) {
11553 : 0 : perf_event_wakeup(child_event);
11554 : 0 : return;
11555 : : }
11556 : : /*
11557 : : * Child events can be cleaned up.
11558 : : */
11559 : :
11560 : 0 : sync_child_event(child_event, child);
11561 : :
11562 : : /*
11563 : : * Remove this event from the parent's list
11564 : : */
11565 [ # # # # ]: 0 : WARN_ON_ONCE(parent_event->ctx->parent_ctx);
11566 : 0 : mutex_lock(&parent_event->child_mutex);
11567 : 0 : list_del_init(&child_event->child_list);
11568 : 0 : mutex_unlock(&parent_event->child_mutex);
11569 : :
11570 : : /*
11571 : : * Kick perf_poll() for is_event_hup().
11572 : : */
11573 : 0 : perf_event_wakeup(parent_event);
11574 : 0 : free_event(child_event);
11575 : 0 : put_event(parent_event);
11576 : : }
11577 : :
11578 : 511269 : static void perf_event_exit_task_context(struct task_struct *child, int ctxn)
11579 : : {
11580 : : struct perf_event_context *child_ctx, *clone_ctx = NULL;
11581 : : struct perf_event *child_event, *next;
11582 : :
11583 [ - + # # ]: 511269 : WARN_ON_ONCE(child != current);
11584 : :
11585 : 511269 : child_ctx = perf_pin_task_context(child, ctxn);
11586 [ - + ]: 511584 : if (!child_ctx)
11587 : 511584 : return;
11588 : :
11589 : : /*
11590 : : * In order to reduce the amount of tricky in ctx tear-down, we hold
11591 : : * ctx::mutex over the entire thing. This serializes against almost
11592 : : * everything that wants to access the ctx.
11593 : : *
11594 : : * The exception is sys_perf_event_open() /
11595 : : * perf_event_create_kernel_count() which does find_get_context()
11596 : : * without ctx::mutex (it cannot because of the move_group double mutex
11597 : : * lock thing). See the comments in perf_install_in_context().
11598 : : */
11599 : 0 : mutex_lock(&child_ctx->mutex);
11600 : :
11601 : : /*
11602 : : * In a single ctx::lock section, de-schedule the events and detach the
11603 : : * context from the task such that we cannot ever get it scheduled back
11604 : : * in.
11605 : : */
11606 : 0 : raw_spin_lock_irq(&child_ctx->lock);
11607 : 0 : task_ctx_sched_out(__get_cpu_context(child_ctx), child_ctx, EVENT_ALL);
11608 : :
11609 : : /*
11610 : : * Now that the context is inactive, destroy the task <-> ctx relation
11611 : : * and mark the context dead.
11612 : : */
11613 : 0 : RCU_INIT_POINTER(child->perf_event_ctxp[ctxn], NULL);
11614 : 0 : put_ctx(child_ctx); /* cannot be last */
11615 : : WRITE_ONCE(child_ctx->task, TASK_TOMBSTONE);
11616 : 0 : put_task_struct(current); /* cannot be last */
11617 : :
11618 : : clone_ctx = unclone_ctx(child_ctx);
11619 : 0 : raw_spin_unlock_irq(&child_ctx->lock);
11620 : :
11621 [ # # ]: 0 : if (clone_ctx)
11622 : 0 : put_ctx(clone_ctx);
11623 : :
11624 : : /*
11625 : : * Report the task dead after unscheduling the events so that we
11626 : : * won't get any samples after PERF_RECORD_EXIT. We can however still
11627 : : * get a few PERF_RECORD_READ events.
11628 : : */
11629 : 0 : perf_event_task(child, child_ctx, 0);
11630 : :
11631 [ # # ]: 0 : list_for_each_entry_safe(child_event, next, &child_ctx->event_list, event_entry)
11632 : 0 : perf_event_exit_event(child_event, child_ctx, child);
11633 : :
11634 : 0 : mutex_unlock(&child_ctx->mutex);
11635 : :
11636 : 0 : put_ctx(child_ctx);
11637 : : }
11638 : :
11639 : : /*
11640 : : * When a child task exits, feed back event values to parent events.
11641 : : *
11642 : : * Can be called with cred_guard_mutex held when called from
11643 : : * install_exec_creds().
11644 : : */
11645 : 255804 : void perf_event_exit_task(struct task_struct *child)
11646 : : {
11647 : : struct perf_event *event, *tmp;
11648 : : int ctxn;
11649 : :
11650 : 255804 : mutex_lock(&child->perf_event_mutex);
11651 [ - + ]: 255583 : list_for_each_entry_safe(event, tmp, &child->perf_event_list,
11652 : : owner_entry) {
11653 : : list_del_init(&event->owner_entry);
11654 : :
11655 : : /*
11656 : : * Ensure the list deletion is visible before we clear
11657 : : * the owner, closes a race against perf_release() where
11658 : : * we need to serialize on the owner->perf_event_mutex.
11659 : : */
11660 : 0 : smp_store_release(&event->owner, NULL);
11661 : : }
11662 : 255583 : mutex_unlock(&child->perf_event_mutex);
11663 : :
11664 [ + + ]: 767126 : for_each_task_context_nr(ctxn)
11665 : 511317 : perf_event_exit_task_context(child, ctxn);
11666 : :
11667 : : /*
11668 : : * The perf_event_exit_task_context calls perf_event_task
11669 : : * with child's task_ctx, which generates EXIT events for
11670 : : * child contexts and sets child->perf_event_ctxp[] to NULL.
11671 : : * At this point we need to send EXIT events to cpu contexts.
11672 : : */
11673 : 255809 : perf_event_task(child, NULL, 0);
11674 : 255761 : }
11675 : :
11676 : 0 : static void perf_free_event(struct perf_event *event,
11677 : : struct perf_event_context *ctx)
11678 : : {
11679 : 0 : struct perf_event *parent = event->parent;
11680 : :
11681 [ # # # # : 0 : if (WARN_ON_ONCE(!parent))
# # ]
11682 : 0 : return;
11683 : :
11684 : 0 : mutex_lock(&parent->child_mutex);
11685 : 0 : list_del_init(&event->child_list);
11686 : 0 : mutex_unlock(&parent->child_mutex);
11687 : :
11688 : 0 : put_event(parent);
11689 : :
11690 : 0 : raw_spin_lock_irq(&ctx->lock);
11691 : 0 : perf_group_detach(event);
11692 : 0 : list_del_event(event, ctx);
11693 : 0 : raw_spin_unlock_irq(&ctx->lock);
11694 : 0 : free_event(event);
11695 : : }
11696 : :
11697 : : /*
11698 : : * Free a context as created by inheritance by perf_event_init_task() below,
11699 : : * used by fork() in case of fail.
11700 : : *
11701 : : * Even though the task has never lived, the context and events have been
11702 : : * exposed through the child_list, so we must take care tearing it all down.
11703 : : */
11704 : 0 : void perf_event_free_task(struct task_struct *task)
11705 : : {
11706 : : struct perf_event_context *ctx;
11707 : : struct perf_event *event, *tmp;
11708 : : int ctxn;
11709 : :
11710 [ # # ]: 0 : for_each_task_context_nr(ctxn) {
11711 : 0 : ctx = task->perf_event_ctxp[ctxn];
11712 [ # # ]: 0 : if (!ctx)
11713 : 0 : continue;
11714 : :
11715 : 0 : mutex_lock(&ctx->mutex);
11716 : 0 : raw_spin_lock_irq(&ctx->lock);
11717 : : /*
11718 : : * Destroy the task <-> ctx relation and mark the context dead.
11719 : : *
11720 : : * This is important because even though the task hasn't been
11721 : : * exposed yet the context has been (through child_list).
11722 : : */
11723 : 0 : RCU_INIT_POINTER(task->perf_event_ctxp[ctxn], NULL);
11724 : : WRITE_ONCE(ctx->task, TASK_TOMBSTONE);
11725 : 0 : put_task_struct(task); /* cannot be last */
11726 : 0 : raw_spin_unlock_irq(&ctx->lock);
11727 : :
11728 [ # # ]: 0 : list_for_each_entry_safe(event, tmp, &ctx->event_list, event_entry)
11729 : 0 : perf_free_event(event, ctx);
11730 : :
11731 : 0 : mutex_unlock(&ctx->mutex);
11732 : :
11733 : : /*
11734 : : * perf_event_release_kernel() could've stolen some of our
11735 : : * child events and still have them on its free_list. In that
11736 : : * case we must wait for these events to have been freed (in
11737 : : * particular all their references to this task must've been
11738 : : * dropped).
11739 : : *
11740 : : * Without this copy_process() will unconditionally free this
11741 : : * task (irrespective of its reference count) and
11742 : : * _free_event()'s put_task_struct(event->hw.target) will be a
11743 : : * use-after-free.
11744 : : *
11745 : : * Wait for all events to drop their context reference.
11746 : : */
11747 [ # # # # ]: 0 : wait_var_event(&ctx->refcount, refcount_read(&ctx->refcount) == 1);
11748 : 0 : put_ctx(ctx); /* must be last */
11749 : : }
11750 : 0 : }
11751 : :
11752 : 249520 : void perf_event_delayed_put(struct task_struct *task)
11753 : : {
11754 : : int ctxn;
11755 : :
11756 [ + + ]: 756820 : for_each_task_context_nr(ctxn)
11757 [ - + # # ]: 502961 : WARN_ON_ONCE(task->perf_event_ctxp[ctxn]);
11758 : 253859 : }
11759 : :
11760 : 0 : struct file *perf_event_get(unsigned int fd)
11761 : : {
11762 : 0 : struct file *file = fget(fd);
11763 [ # # ]: 0 : if (!file)
11764 : : return ERR_PTR(-EBADF);
11765 : :
11766 [ # # ]: 0 : if (file->f_op != &perf_fops) {
11767 : 0 : fput(file);
11768 : 0 : return ERR_PTR(-EBADF);
11769 : : }
11770 : :
11771 : : return file;
11772 : : }
11773 : :
11774 : 0 : const struct perf_event *perf_get_event(struct file *file)
11775 : : {
11776 [ # # ]: 0 : if (file->f_op != &perf_fops)
11777 : : return ERR_PTR(-EINVAL);
11778 : :
11779 : 0 : return file->private_data;
11780 : : }
11781 : :
11782 : 0 : const struct perf_event_attr *perf_event_attrs(struct perf_event *event)
11783 : : {
11784 [ # # ]: 0 : if (!event)
11785 : : return ERR_PTR(-EINVAL);
11786 : :
11787 : 0 : return &event->attr;
11788 : : }
11789 : :
11790 : : /*
11791 : : * Inherit an event from parent task to child task.
11792 : : *
11793 : : * Returns:
11794 : : * - valid pointer on success
11795 : : * - NULL for orphaned events
11796 : : * - IS_ERR() on error
11797 : : */
11798 : : static struct perf_event *
11799 : 0 : inherit_event(struct perf_event *parent_event,
11800 : : struct task_struct *parent,
11801 : : struct perf_event_context *parent_ctx,
11802 : : struct task_struct *child,
11803 : : struct perf_event *group_leader,
11804 : : struct perf_event_context *child_ctx)
11805 : : {
11806 : 0 : enum perf_event_state parent_state = parent_event->state;
11807 : : struct perf_event *child_event;
11808 : : unsigned long flags;
11809 : :
11810 : : /*
11811 : : * Instead of creating recursive hierarchies of events,
11812 : : * we link inherited events back to the original parent,
11813 : : * which has a filp for sure, which we use as the reference
11814 : : * count:
11815 : : */
11816 [ # # ]: 0 : if (parent_event->parent)
11817 : : parent_event = parent_event->parent;
11818 : :
11819 : 0 : child_event = perf_event_alloc(&parent_event->attr,
11820 : : parent_event->cpu,
11821 : : child,
11822 : : group_leader, parent_event,
11823 : : NULL, NULL, -1);
11824 [ # # ]: 0 : if (IS_ERR(child_event))
11825 : : return child_event;
11826 : :
11827 : :
11828 [ # # # # ]: 0 : if ((child_event->attach_state & PERF_ATTACH_TASK_DATA) &&
11829 : 0 : !child_ctx->task_ctx_data) {
11830 : 0 : struct pmu *pmu = child_event->pmu;
11831 : :
11832 : 0 : child_ctx->task_ctx_data = kzalloc(pmu->task_ctx_size,
11833 : : GFP_KERNEL);
11834 [ # # ]: 0 : if (!child_ctx->task_ctx_data) {
11835 : 0 : free_event(child_event);
11836 : 0 : return ERR_PTR(-ENOMEM);
11837 : : }
11838 : : }
11839 : :
11840 : : /*
11841 : : * is_orphaned_event() and list_add_tail(&parent_event->child_list)
11842 : : * must be under the same lock in order to serialize against
11843 : : * perf_event_release_kernel(), such that either we must observe
11844 : : * is_orphaned_event() or they will observe us on the child_list.
11845 : : */
11846 : 0 : mutex_lock(&parent_event->child_mutex);
11847 [ # # # # ]: 0 : if (is_orphaned_event(parent_event) ||
11848 : 0 : !atomic_long_inc_not_zero(&parent_event->refcount)) {
11849 : 0 : mutex_unlock(&parent_event->child_mutex);
11850 : : /* task_ctx_data is freed with child_ctx */
11851 : 0 : free_event(child_event);
11852 : 0 : return NULL;
11853 : : }
11854 : :
11855 : : get_ctx(child_ctx);
11856 : :
11857 : : /*
11858 : : * Make the child state follow the state of the parent event,
11859 : : * not its attr.disabled bit. We hold the parent's mutex,
11860 : : * so we won't race with perf_event_{en, dis}able_family.
11861 : : */
11862 [ # # ]: 0 : if (parent_state >= PERF_EVENT_STATE_INACTIVE)
11863 : 0 : child_event->state = PERF_EVENT_STATE_INACTIVE;
11864 : : else
11865 : 0 : child_event->state = PERF_EVENT_STATE_OFF;
11866 : :
11867 [ # # ]: 0 : if (parent_event->attr.freq) {
11868 : 0 : u64 sample_period = parent_event->hw.sample_period;
11869 : : struct hw_perf_event *hwc = &child_event->hw;
11870 : :
11871 : 0 : hwc->sample_period = sample_period;
11872 : 0 : hwc->last_period = sample_period;
11873 : :
11874 : 0 : local64_set(&hwc->period_left, sample_period);
11875 : : }
11876 : :
11877 : 0 : child_event->ctx = child_ctx;
11878 : 0 : child_event->overflow_handler = parent_event->overflow_handler;
11879 : : child_event->overflow_handler_context
11880 : 0 : = parent_event->overflow_handler_context;
11881 : :
11882 : : /*
11883 : : * Precalculate sample_data sizes
11884 : : */
11885 : 0 : perf_event__header_size(child_event);
11886 : 0 : perf_event__id_header_size(child_event);
11887 : :
11888 : : /*
11889 : : * Link it up in the child's context:
11890 : : */
11891 : 0 : raw_spin_lock_irqsave(&child_ctx->lock, flags);
11892 : : add_event_to_ctx(child_event, child_ctx);
11893 : 0 : raw_spin_unlock_irqrestore(&child_ctx->lock, flags);
11894 : :
11895 : : /*
11896 : : * Link this into the parent event's child list
11897 : : */
11898 : 0 : list_add_tail(&child_event->child_list, &parent_event->child_list);
11899 : 0 : mutex_unlock(&parent_event->child_mutex);
11900 : :
11901 : 0 : return child_event;
11902 : : }
11903 : :
11904 : : /*
11905 : : * Inherits an event group.
11906 : : *
11907 : : * This will quietly suppress orphaned events; !inherit_event() is not an error.
11908 : : * This matches with perf_event_release_kernel() removing all child events.
11909 : : *
11910 : : * Returns:
11911 : : * - 0 on success
11912 : : * - <0 on error
11913 : : */
11914 : 0 : static int inherit_group(struct perf_event *parent_event,
11915 : : struct task_struct *parent,
11916 : : struct perf_event_context *parent_ctx,
11917 : : struct task_struct *child,
11918 : : struct perf_event_context *child_ctx)
11919 : : {
11920 : : struct perf_event *leader;
11921 : : struct perf_event *sub;
11922 : : struct perf_event *child_ctr;
11923 : :
11924 : 0 : leader = inherit_event(parent_event, parent, parent_ctx,
11925 : : child, NULL, child_ctx);
11926 [ # # ]: 0 : if (IS_ERR(leader))
11927 : 0 : return PTR_ERR(leader);
11928 : : /*
11929 : : * @leader can be NULL here because of is_orphaned_event(). In this
11930 : : * case inherit_event() will create individual events, similar to what
11931 : : * perf_group_detach() would do anyway.
11932 : : */
11933 [ # # # # ]: 0 : for_each_sibling_event(sub, parent_event) {
11934 : 0 : child_ctr = inherit_event(sub, parent, parent_ctx,
11935 : : child, leader, child_ctx);
11936 [ # # ]: 0 : if (IS_ERR(child_ctr))
11937 : 0 : return PTR_ERR(child_ctr);
11938 : :
11939 [ # # # # : 0 : if (sub->aux_event == parent_event && child_ctr &&
# # ]
11940 : 0 : !perf_get_aux_event(child_ctr, leader))
11941 : : return -EINVAL;
11942 : : }
11943 : : return 0;
11944 : : }
11945 : :
11946 : : /*
11947 : : * Creates the child task context and tries to inherit the event-group.
11948 : : *
11949 : : * Clears @inherited_all on !attr.inherited or error. Note that we'll leave
11950 : : * inherited_all set when we 'fail' to inherit an orphaned event; this is
11951 : : * consistent with perf_event_release_kernel() removing all child events.
11952 : : *
11953 : : * Returns:
11954 : : * - 0 on success
11955 : : * - <0 on error
11956 : : */
11957 : : static int
11958 : 0 : inherit_task_group(struct perf_event *event, struct task_struct *parent,
11959 : : struct perf_event_context *parent_ctx,
11960 : : struct task_struct *child, int ctxn,
11961 : : int *inherited_all)
11962 : : {
11963 : : int ret;
11964 : : struct perf_event_context *child_ctx;
11965 : :
11966 [ # # ]: 0 : if (!event->attr.inherit) {
11967 : 0 : *inherited_all = 0;
11968 : 0 : return 0;
11969 : : }
11970 : :
11971 : 0 : child_ctx = child->perf_event_ctxp[ctxn];
11972 [ # # ]: 0 : if (!child_ctx) {
11973 : : /*
11974 : : * This is executed from the parent task context, so
11975 : : * inherit events that have been marked for cloning.
11976 : : * First allocate and initialize a context for the
11977 : : * child.
11978 : : */
11979 : 0 : child_ctx = alloc_perf_context(parent_ctx->pmu, child);
11980 [ # # ]: 0 : if (!child_ctx)
11981 : : return -ENOMEM;
11982 : :
11983 : 0 : child->perf_event_ctxp[ctxn] = child_ctx;
11984 : : }
11985 : :
11986 : 0 : ret = inherit_group(event, parent, parent_ctx,
11987 : : child, child_ctx);
11988 : :
11989 [ # # ]: 0 : if (ret)
11990 : 0 : *inherited_all = 0;
11991 : :
11992 : 0 : return ret;
11993 : : }
11994 : :
11995 : : /*
11996 : : * Initialize the perf_event context in task_struct
11997 : : */
11998 : 587615 : static int perf_event_init_context(struct task_struct *child, int ctxn)
11999 : : {
12000 : : struct perf_event_context *child_ctx, *parent_ctx;
12001 : : struct perf_event_context *cloned_ctx;
12002 : : struct perf_event *event;
12003 : 587615 : struct task_struct *parent = current;
12004 : 587615 : int inherited_all = 1;
12005 : : unsigned long flags;
12006 : : int ret = 0;
12007 : :
12008 [ - + ]: 587615 : if (likely(!parent->perf_event_ctxp[ctxn]))
12009 : : return 0;
12010 : :
12011 : : /*
12012 : : * If the parent's context is a clone, pin it so it won't get
12013 : : * swapped under us.
12014 : : */
12015 : 0 : parent_ctx = perf_pin_task_context(parent, ctxn);
12016 [ # # ]: 0 : if (!parent_ctx)
12017 : : return 0;
12018 : :
12019 : : /*
12020 : : * No need to check if parent_ctx != NULL here; since we saw
12021 : : * it non-NULL earlier, the only reason for it to become NULL
12022 : : * is if we exit, and since we're currently in the middle of
12023 : : * a fork we can't be exiting at the same time.
12024 : : */
12025 : :
12026 : : /*
12027 : : * Lock the parent list. No need to lock the child - not PID
12028 : : * hashed yet and not running, so nobody can access it.
12029 : : */
12030 : 0 : mutex_lock(&parent_ctx->mutex);
12031 : :
12032 : : /*
12033 : : * We dont have to disable NMIs - we are only looking at
12034 : : * the list, not manipulating it:
12035 : : */
12036 [ # # # # : 0 : perf_event_groups_for_each(event, &parent_ctx->pinned_groups) {
# # ]
12037 : 0 : ret = inherit_task_group(event, parent, parent_ctx,
12038 : : child, ctxn, &inherited_all);
12039 [ # # ]: 0 : if (ret)
12040 : : goto out_unlock;
12041 : : }
12042 : :
12043 : : /*
12044 : : * We can't hold ctx->lock when iterating the ->flexible_group list due
12045 : : * to allocations, but we need to prevent rotation because
12046 : : * rotate_ctx() will change the list from interrupt context.
12047 : : */
12048 : 0 : raw_spin_lock_irqsave(&parent_ctx->lock, flags);
12049 : 0 : parent_ctx->rotate_disable = 1;
12050 : 0 : raw_spin_unlock_irqrestore(&parent_ctx->lock, flags);
12051 : :
12052 [ # # # # : 0 : perf_event_groups_for_each(event, &parent_ctx->flexible_groups) {
# # ]
12053 : 0 : ret = inherit_task_group(event, parent, parent_ctx,
12054 : : child, ctxn, &inherited_all);
12055 [ # # ]: 0 : if (ret)
12056 : : goto out_unlock;
12057 : : }
12058 : :
12059 : 0 : raw_spin_lock_irqsave(&parent_ctx->lock, flags);
12060 : 0 : parent_ctx->rotate_disable = 0;
12061 : :
12062 : 0 : child_ctx = child->perf_event_ctxp[ctxn];
12063 : :
12064 [ # # # # ]: 0 : if (child_ctx && inherited_all) {
12065 : : /*
12066 : : * Mark the child context as a clone of the parent
12067 : : * context, or of whatever the parent is a clone of.
12068 : : *
12069 : : * Note that if the parent is a clone, the holding of
12070 : : * parent_ctx->lock avoids it from being uncloned.
12071 : : */
12072 : 0 : cloned_ctx = parent_ctx->parent_ctx;
12073 [ # # ]: 0 : if (cloned_ctx) {
12074 : 0 : child_ctx->parent_ctx = cloned_ctx;
12075 : 0 : child_ctx->parent_gen = parent_ctx->parent_gen;
12076 : : } else {
12077 : 0 : child_ctx->parent_ctx = parent_ctx;
12078 : 0 : child_ctx->parent_gen = parent_ctx->generation;
12079 : : }
12080 : 0 : get_ctx(child_ctx->parent_ctx);
12081 : : }
12082 : :
12083 : 0 : raw_spin_unlock_irqrestore(&parent_ctx->lock, flags);
12084 : : out_unlock:
12085 : 0 : mutex_unlock(&parent_ctx->mutex);
12086 : :
12087 : 0 : perf_unpin_context(parent_ctx);
12088 : 0 : put_ctx(parent_ctx);
12089 : :
12090 : 0 : return ret;
12091 : : }
12092 : :
12093 : : /*
12094 : : * Initialize the perf_event context in task_struct
12095 : : */
12096 : 293658 : int perf_event_init_task(struct task_struct *child)
12097 : : {
12098 : : int ctxn, ret;
12099 : :
12100 : 293658 : memset(child->perf_event_ctxp, 0, sizeof(child->perf_event_ctxp));
12101 : 293658 : mutex_init(&child->perf_event_mutex);
12102 : 293788 : INIT_LIST_HEAD(&child->perf_event_list);
12103 : :
12104 [ + + ]: 881330 : for_each_task_context_nr(ctxn) {
12105 : 587457 : ret = perf_event_init_context(child, ctxn);
12106 [ - + ]: 587542 : if (ret) {
12107 : 0 : perf_event_free_task(child);
12108 : 0 : return ret;
12109 : : }
12110 : : }
12111 : :
12112 : : return 0;
12113 : : }
12114 : :
12115 : 207 : static void __init perf_event_init_all_cpus(void)
12116 : : {
12117 : : struct swevent_htable *swhash;
12118 : : int cpu;
12119 : :
12120 : : zalloc_cpumask_var(&perf_online_mask, GFP_KERNEL);
12121 : :
12122 [ + + ]: 1242 : for_each_possible_cpu(cpu) {
12123 : 828 : swhash = &per_cpu(swevent_htable, cpu);
12124 : 828 : mutex_init(&swhash->hlist_mutex);
12125 : 828 : INIT_LIST_HEAD(&per_cpu(active_ctx_list, cpu));
12126 : :
12127 : 828 : INIT_LIST_HEAD(&per_cpu(pmu_sb_events.list, cpu));
12128 : 828 : raw_spin_lock_init(&per_cpu(pmu_sb_events.lock, cpu));
12129 : :
12130 : : #ifdef CONFIG_CGROUP_PERF
12131 : 828 : INIT_LIST_HEAD(&per_cpu(cgrp_cpuctx_list, cpu));
12132 : : #endif
12133 : 828 : INIT_LIST_HEAD(&per_cpu(sched_cb_list, cpu));
12134 : : }
12135 : 207 : }
12136 : :
12137 : 1449 : static void perf_swevent_init_cpu(unsigned int cpu)
12138 : : {
12139 : 1449 : struct swevent_htable *swhash = &per_cpu(swevent_htable, cpu);
12140 : :
12141 : 1449 : mutex_lock(&swhash->hlist_mutex);
12142 [ - + # # ]: 1449 : if (swhash->hlist_refcount > 0 && !swevent_hlist_deref(swhash)) {
12143 : : struct swevent_hlist *hlist;
12144 : :
12145 : 0 : hlist = kzalloc_node(sizeof(*hlist), GFP_KERNEL, cpu_to_node(cpu));
12146 [ # # ]: 0 : WARN_ON(!hlist);
12147 : 0 : rcu_assign_pointer(swhash->swevent_hlist, hlist);
12148 : : }
12149 : 1449 : mutex_unlock(&swhash->hlist_mutex);
12150 : 1449 : }
12151 : :
12152 : : #if defined CONFIG_HOTPLUG_CPU || defined CONFIG_KEXEC_CORE
12153 : : static void __perf_event_exit_context(void *__info)
12154 : : {
12155 : : struct perf_event_context *ctx = __info;
12156 : : struct perf_cpu_context *cpuctx = __get_cpu_context(ctx);
12157 : : struct perf_event *event;
12158 : :
12159 : : raw_spin_lock(&ctx->lock);
12160 : : ctx_sched_out(ctx, cpuctx, EVENT_TIME);
12161 : : list_for_each_entry(event, &ctx->event_list, event_entry)
12162 : : __perf_remove_from_context(event, cpuctx, ctx, (void *)DETACH_GROUP);
12163 : : raw_spin_unlock(&ctx->lock);
12164 : : }
12165 : :
12166 : : static void perf_event_exit_cpu_context(int cpu)
12167 : : {
12168 : : struct perf_cpu_context *cpuctx;
12169 : : struct perf_event_context *ctx;
12170 : : struct pmu *pmu;
12171 : :
12172 : : mutex_lock(&pmus_lock);
12173 : : list_for_each_entry(pmu, &pmus, entry) {
12174 : : cpuctx = per_cpu_ptr(pmu->pmu_cpu_context, cpu);
12175 : : ctx = &cpuctx->ctx;
12176 : :
12177 : : mutex_lock(&ctx->mutex);
12178 : : smp_call_function_single(cpu, __perf_event_exit_context, ctx, 1);
12179 : : cpuctx->online = 0;
12180 : : mutex_unlock(&ctx->mutex);
12181 : : }
12182 : : cpumask_clear_cpu(cpu, perf_online_mask);
12183 : : mutex_unlock(&pmus_lock);
12184 : : }
12185 : : #else
12186 : :
12187 : : static void perf_event_exit_cpu_context(int cpu) { }
12188 : :
12189 : : #endif
12190 : :
12191 : 1449 : int perf_event_init_cpu(unsigned int cpu)
12192 : : {
12193 : : struct perf_cpu_context *cpuctx;
12194 : : struct perf_event_context *ctx;
12195 : : struct pmu *pmu;
12196 : :
12197 : 1449 : perf_swevent_init_cpu(cpu);
12198 : :
12199 : 1449 : mutex_lock(&pmus_lock);
12200 : : cpumask_set_cpu(cpu, perf_online_mask);
12201 [ + + ]: 9936 : list_for_each_entry(pmu, &pmus, entry) {
12202 : 8487 : cpuctx = per_cpu_ptr(pmu->pmu_cpu_context, cpu);
12203 : : ctx = &cpuctx->ctx;
12204 : :
12205 : 8487 : mutex_lock(&ctx->mutex);
12206 : 8487 : cpuctx->online = 1;
12207 : 8487 : mutex_unlock(&ctx->mutex);
12208 : : }
12209 : 1449 : mutex_unlock(&pmus_lock);
12210 : :
12211 : 1449 : return 0;
12212 : : }
12213 : :
12214 : 0 : int perf_event_exit_cpu(unsigned int cpu)
12215 : : {
12216 : : perf_event_exit_cpu_context(cpu);
12217 : 0 : return 0;
12218 : : }
12219 : :
12220 : : static int
12221 : 0 : perf_reboot(struct notifier_block *notifier, unsigned long val, void *v)
12222 : : {
12223 : : int cpu;
12224 : :
12225 [ # # ]: 0 : for_each_online_cpu(cpu)
12226 : : perf_event_exit_cpu(cpu);
12227 : :
12228 : 0 : return NOTIFY_OK;
12229 : : }
12230 : :
12231 : : /*
12232 : : * Run the perf reboot notifier at the very last possible moment so that
12233 : : * the generic watchdog code runs as long as possible.
12234 : : */
12235 : : static struct notifier_block perf_reboot_notifier = {
12236 : : .notifier_call = perf_reboot,
12237 : : .priority = INT_MIN,
12238 : : };
12239 : :
12240 : 207 : void __init perf_event_init(void)
12241 : : {
12242 : : int ret;
12243 : :
12244 : : idr_init(&pmu_idr);
12245 : :
12246 : 207 : perf_event_init_all_cpus();
12247 : 207 : init_srcu_struct(&pmus_srcu);
12248 : 207 : perf_pmu_register(&perf_swevent, "software", PERF_TYPE_SOFTWARE);
12249 : 207 : perf_pmu_register(&perf_cpu_clock, NULL, -1);
12250 : 207 : perf_pmu_register(&perf_task_clock, NULL, -1);
12251 : 207 : perf_tp_register();
12252 : 207 : perf_event_init_cpu(smp_processor_id());
12253 : 207 : register_reboot_notifier(&perf_reboot_notifier);
12254 : :
12255 : 207 : ret = init_hw_breakpoint();
12256 [ - + ]: 207 : WARN(ret, "hw_breakpoint initialization failed with: %d", ret);
12257 : :
12258 : : /*
12259 : : * Build time assertion that we keep the data_head at the intended
12260 : : * location. IOW, validation we got the __reserved[] size right.
12261 : : */
12262 : : BUILD_BUG_ON((offsetof(struct perf_event_mmap_page, data_head))
12263 : : != 1024);
12264 : 207 : }
12265 : :
12266 : 0 : ssize_t perf_event_sysfs_show(struct device *dev, struct device_attribute *attr,
12267 : : char *page)
12268 : : {
12269 : : struct perf_pmu_events_attr *pmu_attr =
12270 : : container_of(attr, struct perf_pmu_events_attr, attr);
12271 : :
12272 [ # # ]: 0 : if (pmu_attr->event_str)
12273 : 0 : return sprintf(page, "%s\n", pmu_attr->event_str);
12274 : :
12275 : : return 0;
12276 : : }
12277 : : EXPORT_SYMBOL_GPL(perf_event_sysfs_show);
12278 : :
12279 : 207 : static int __init perf_event_sysfs_init(void)
12280 : : {
12281 : : struct pmu *pmu;
12282 : : int ret;
12283 : :
12284 : 207 : mutex_lock(&pmus_lock);
12285 : :
12286 : 207 : ret = bus_register(&pmu_bus);
12287 [ + - ]: 207 : if (ret)
12288 : : goto unlock;
12289 : :
12290 [ + + ]: 1656 : list_for_each_entry(pmu, &pmus, entry) {
12291 [ + + - + ]: 1449 : if (!pmu->name || pmu->type < 0)
12292 : 414 : continue;
12293 : :
12294 : 1035 : ret = pmu_dev_alloc(pmu);
12295 [ - + ]: 1035 : WARN(ret, "Failed to register pmu: %s, reason %d\n", pmu->name, ret);
12296 : : }
12297 : 207 : pmu_bus_running = 1;
12298 : : ret = 0;
12299 : :
12300 : : unlock:
12301 : 207 : mutex_unlock(&pmus_lock);
12302 : :
12303 : 207 : return ret;
12304 : : }
12305 : : device_initcall(perf_event_sysfs_init);
12306 : :
12307 : : #ifdef CONFIG_CGROUP_PERF
12308 : : static struct cgroup_subsys_state *
12309 : 207 : perf_cgroup_css_alloc(struct cgroup_subsys_state *parent_css)
12310 : : {
12311 : : struct perf_cgroup *jc;
12312 : :
12313 : 207 : jc = kzalloc(sizeof(*jc), GFP_KERNEL);
12314 [ + - ]: 207 : if (!jc)
12315 : : return ERR_PTR(-ENOMEM);
12316 : :
12317 : 207 : jc->info = alloc_percpu(struct perf_cgroup_info);
12318 [ - + ]: 207 : if (!jc->info) {
12319 : 0 : kfree(jc);
12320 : 0 : return ERR_PTR(-ENOMEM);
12321 : : }
12322 : :
12323 : 207 : return &jc->css;
12324 : : }
12325 : :
12326 : 0 : static void perf_cgroup_css_free(struct cgroup_subsys_state *css)
12327 : : {
12328 : : struct perf_cgroup *jc = container_of(css, struct perf_cgroup, css);
12329 : :
12330 : 0 : free_percpu(jc->info);
12331 : 0 : kfree(jc);
12332 : 0 : }
12333 : :
12334 : 0 : static int __perf_cgroup_move(void *info)
12335 : : {
12336 : : struct task_struct *task = info;
12337 : : rcu_read_lock();
12338 : 0 : perf_cgroup_switch(task, PERF_CGROUP_SWOUT | PERF_CGROUP_SWIN);
12339 : : rcu_read_unlock();
12340 : 0 : return 0;
12341 : : }
12342 : :
12343 : 0 : static void perf_cgroup_attach(struct cgroup_taskset *tset)
12344 : : {
12345 : : struct task_struct *task;
12346 : : struct cgroup_subsys_state *css;
12347 : :
12348 [ # # ]: 0 : cgroup_taskset_for_each(task, css, tset)
12349 : 0 : task_function_call(task, __perf_cgroup_move, task);
12350 : 0 : }
12351 : :
12352 : : struct cgroup_subsys perf_event_cgrp_subsys = {
12353 : : .css_alloc = perf_cgroup_css_alloc,
12354 : : .css_free = perf_cgroup_css_free,
12355 : : .attach = perf_cgroup_attach,
12356 : : /*
12357 : : * Implicitly enable on dfl hierarchy so that perf events can
12358 : : * always be filtered by cgroup2 path as long as perf_event
12359 : : * controller is not mounted on a legacy hierarchy.
12360 : : */
12361 : : .implicit_on_dfl = true,
12362 : : .threaded = true,
12363 : : };
12364 : : #endif /* CONFIG_CGROUP_PERF */
|
