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 : 0 : 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
97 : : *
98 : : * returns: @func return value, or
99 : : * -ESRCH - when the process isn't running
100 : : * -EAGAIN - when the process moved away
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 : 0 : int ret;
112 : :
113 : 0 : do {
114 : 0 : ret = smp_call_function_single(task_cpu(p), remote_function, &data, 1);
115 [ # # ]: 0 : if (!ret)
116 : 0 : ret = data.ret;
117 [ # # ]: 0 : } while (ret == -EAGAIN);
118 : :
119 : 0 : return ret;
120 : : }
121 : :
122 : : /**
123 : : * cpu_function_call - call a function on the cpu
124 : : * @func: the function to be called
125 : : * @info: the function call argument
126 : : *
127 : : * Calls the function @func on the remote cpu.
128 : : *
129 : : * returns: @func return value or -ENXIO when the cpu is offline
130 : : */
131 : 0 : static int cpu_function_call(int cpu, remote_function_f func, void *info)
132 : : {
133 : 0 : struct remote_function_call data = {
134 : : .p = NULL,
135 : : .func = func,
136 : : .info = info,
137 : : .ret = -ENXIO, /* No such CPU */
138 : : };
139 : :
140 : 0 : smp_call_function_single(cpu, remote_function, &data, 1);
141 : :
142 : 0 : return data.ret;
143 : : }
144 : :
145 : : static inline struct perf_cpu_context *
146 : 0 : __get_cpu_context(struct perf_event_context *ctx)
147 : : {
148 : 0 : return this_cpu_ptr(ctx->pmu->pmu_cpu_context);
149 : : }
150 : :
151 : 0 : static void perf_ctx_lock(struct perf_cpu_context *cpuctx,
152 : : struct perf_event_context *ctx)
153 : : {
154 : 0 : raw_spin_lock(&cpuctx->ctx.lock);
155 [ # # # # : 0 : if (ctx)
# # # # #
# ]
156 : 0 : raw_spin_lock(&ctx->lock);
157 : : }
158 : :
159 : 0 : static void perf_ctx_unlock(struct perf_cpu_context *cpuctx,
160 : : struct perf_event_context *ctx)
161 : : {
162 : 0 : if (ctx)
163 : 0 : raw_spin_unlock(&ctx->lock);
164 : 0 : raw_spin_unlock(&cpuctx->ctx.lock);
165 : 0 : }
166 : :
167 : : #define TASK_TOMBSTONE ((void *)-1L)
168 : :
169 : 0 : static bool is_kernel_event(struct perf_event *event)
170 : : {
171 : 0 : return READ_ONCE(event->owner) == TASK_TOMBSTONE;
172 : : }
173 : :
174 : : /*
175 : : * On task ctx scheduling...
176 : : *
177 : : * When !ctx->nr_events a task context will not be scheduled. This means
178 : : * we can disable the scheduler hooks (for performance) without leaving
179 : : * pending task ctx state.
180 : : *
181 : : * This however results in two special cases:
182 : : *
183 : : * - removing the last event from a task ctx; this is relatively straight
184 : : * forward and is done in __perf_remove_from_context.
185 : : *
186 : : * - adding the first event to a task ctx; this is tricky because we cannot
187 : : * rely on ctx->is_active and therefore cannot use event_function_call().
188 : : * See perf_install_in_context().
189 : : *
190 : : * If ctx->nr_events, then ctx->is_active and cpuctx->task_ctx are set.
191 : : */
192 : :
193 : : typedef void (*event_f)(struct perf_event *, struct perf_cpu_context *,
194 : : struct perf_event_context *, void *);
195 : :
196 : : struct event_function_struct {
197 : : struct perf_event *event;
198 : : event_f func;
199 : : void *data;
200 : : };
201 : :
202 : 0 : static int event_function(void *info)
203 : : {
204 : 0 : struct event_function_struct *efs = info;
205 : 0 : struct perf_event *event = efs->event;
206 : 0 : struct perf_event_context *ctx = event->ctx;
207 : 0 : struct perf_cpu_context *cpuctx = __get_cpu_context(ctx);
208 : 0 : struct perf_event_context *task_ctx = cpuctx->task_ctx;
209 : 0 : int ret = 0;
210 : :
211 : 0 : lockdep_assert_irqs_disabled();
212 : :
213 : 0 : perf_ctx_lock(cpuctx, task_ctx);
214 : : /*
215 : : * Since we do the IPI call without holding ctx->lock things can have
216 : : * changed, double check we hit the task we set out to hit.
217 : : */
218 [ # # ]: 0 : if (ctx->task) {
219 [ # # ]: 0 : if (ctx->task != current) {
220 : 0 : ret = -ESRCH;
221 : 0 : goto unlock;
222 : : }
223 : :
224 : : /*
225 : : * We only use event_function_call() on established contexts,
226 : : * and event_function() is only ever called when active (or
227 : : * rather, we'll have bailed in task_function_call() or the
228 : : * above ctx->task != current test), therefore we must have
229 : : * ctx->is_active here.
230 : : */
231 [ # # ]: 0 : WARN_ON_ONCE(!ctx->is_active);
232 : : /*
233 : : * And since we have ctx->is_active, cpuctx->task_ctx must
234 : : * match.
235 : : */
236 [ # # ]: 0 : WARN_ON_ONCE(task_ctx != ctx);
237 : : } else {
238 [ # # ]: 0 : WARN_ON_ONCE(&cpuctx->ctx != ctx);
239 : : }
240 : :
241 : 0 : efs->func(event, cpuctx, ctx, efs->data);
242 : 0 : unlock:
243 [ # # ]: 0 : perf_ctx_unlock(cpuctx, task_ctx);
244 : :
245 : 0 : return ret;
246 : : }
247 : :
248 : 0 : static void event_function_call(struct perf_event *event, event_f func, void *data)
249 : : {
250 : 0 : struct perf_event_context *ctx = event->ctx;
251 [ # # ]: 0 : struct task_struct *task = READ_ONCE(ctx->task); /* verified in event_function */
252 : 0 : struct event_function_struct efs = {
253 : : .event = event,
254 : : .func = func,
255 : : .data = data,
256 : : };
257 : :
258 : 0 : if (!event->parent) {
259 : : /*
260 : : * If this is a !child event, we must hold ctx::mutex to
261 : : * stabilize the the event->ctx relation. See
262 : : * perf_event_ctx_lock().
263 : : */
264 : 0 : lockdep_assert_held(&ctx->mutex);
265 : : }
266 : :
267 [ # # ]: 0 : if (!task) {
268 : 0 : cpu_function_call(event->cpu, event_function, &efs);
269 : 0 : return;
270 : : }
271 : :
272 [ # # ]: 0 : if (task == TASK_TOMBSTONE)
273 : : return;
274 : :
275 : 0 : again:
276 [ # # ]: 0 : if (!task_function_call(task, event_function, &efs))
277 : : return;
278 : :
279 : 0 : raw_spin_lock_irq(&ctx->lock);
280 : : /*
281 : : * Reload the task pointer, it might have been changed by
282 : : * a concurrent perf_event_context_sched_out().
283 : : */
284 : 0 : task = ctx->task;
285 [ # # ]: 0 : if (task == TASK_TOMBSTONE) {
286 : 0 : raw_spin_unlock_irq(&ctx->lock);
287 : 0 : return;
288 : : }
289 [ # # ]: 0 : if (ctx->is_active) {
290 : 0 : raw_spin_unlock_irq(&ctx->lock);
291 : 0 : goto again;
292 : : }
293 : 0 : func(event, NULL, ctx, data);
294 : 0 : raw_spin_unlock_irq(&ctx->lock);
295 : : }
296 : :
297 : : /*
298 : : * Similar to event_function_call() + event_function(), but hard assumes IRQs
299 : : * are already disabled and we're on the right CPU.
300 : : */
301 : 0 : static void event_function_local(struct perf_event *event, event_f func, void *data)
302 : : {
303 : 0 : struct perf_event_context *ctx = event->ctx;
304 : 0 : struct perf_cpu_context *cpuctx = __get_cpu_context(ctx);
305 [ # # ]: 0 : struct task_struct *task = READ_ONCE(ctx->task);
306 : 0 : struct perf_event_context *task_ctx = NULL;
307 : :
308 : 0 : lockdep_assert_irqs_disabled();
309 : :
310 [ # # ]: 0 : if (task) {
311 [ # # ]: 0 : if (task == TASK_TOMBSTONE)
312 : : return;
313 : :
314 : : task_ctx = ctx;
315 : : }
316 : :
317 : 0 : perf_ctx_lock(cpuctx, task_ctx);
318 : :
319 : 0 : task = ctx->task;
320 [ # # ]: 0 : if (task == TASK_TOMBSTONE)
321 : 0 : goto unlock;
322 : :
323 [ # # ]: 0 : if (task) {
324 : : /*
325 : : * We must be either inactive or active and the right task,
326 : : * otherwise we're screwed, since we cannot IPI to somewhere
327 : : * else.
328 : : */
329 [ # # ]: 0 : if (ctx->is_active) {
330 [ # # # # ]: 0 : if (WARN_ON_ONCE(task != current))
331 : 0 : goto unlock;
332 : :
333 [ # # # # ]: 0 : if (WARN_ON_ONCE(cpuctx->task_ctx != ctx))
334 : 0 : goto unlock;
335 : : }
336 : : } else {
337 [ # # ]: 0 : WARN_ON_ONCE(&cpuctx->ctx != ctx);
338 : : }
339 : :
340 : 0 : func(event, cpuctx, ctx, data);
341 : 0 : unlock:
342 [ # # ]: 0 : perf_ctx_unlock(cpuctx, task_ctx);
343 : : }
344 : :
345 : : #define PERF_FLAG_ALL (PERF_FLAG_FD_NO_GROUP |\
346 : : PERF_FLAG_FD_OUTPUT |\
347 : : PERF_FLAG_PID_CGROUP |\
348 : : PERF_FLAG_FD_CLOEXEC)
349 : :
350 : : /*
351 : : * branch priv levels that need permission checks
352 : : */
353 : : #define PERF_SAMPLE_BRANCH_PERM_PLM \
354 : : (PERF_SAMPLE_BRANCH_KERNEL |\
355 : : PERF_SAMPLE_BRANCH_HV)
356 : :
357 : : enum event_type_t {
358 : : EVENT_FLEXIBLE = 0x1,
359 : : EVENT_PINNED = 0x2,
360 : : EVENT_TIME = 0x4,
361 : : /* see ctx_resched() for details */
362 : : EVENT_CPU = 0x8,
363 : : EVENT_ALL = EVENT_FLEXIBLE | EVENT_PINNED,
364 : : };
365 : :
366 : : /*
367 : : * perf_sched_events : >0 events exist
368 : : * perf_cgroup_events: >0 per-cpu cgroup events exist on this cpu
369 : : */
370 : :
371 : : static void perf_sched_delayed(struct work_struct *work);
372 : : DEFINE_STATIC_KEY_FALSE(perf_sched_events);
373 : : static DECLARE_DELAYED_WORK(perf_sched_work, perf_sched_delayed);
374 : : static DEFINE_MUTEX(perf_sched_mutex);
375 : : static atomic_t perf_sched_count;
376 : :
377 : : static DEFINE_PER_CPU(atomic_t, perf_cgroup_events);
378 : : static DEFINE_PER_CPU(int, perf_sched_cb_usages);
379 : : static DEFINE_PER_CPU(struct pmu_event_list, pmu_sb_events);
380 : :
381 : : static atomic_t nr_mmap_events __read_mostly;
382 : : static atomic_t nr_comm_events __read_mostly;
383 : : static atomic_t nr_namespaces_events __read_mostly;
384 : : static atomic_t nr_task_events __read_mostly;
385 : : static atomic_t nr_freq_events __read_mostly;
386 : : static atomic_t nr_switch_events __read_mostly;
387 : : static atomic_t nr_ksymbol_events __read_mostly;
388 : : static atomic_t nr_bpf_events __read_mostly;
389 : :
390 : : static LIST_HEAD(pmus);
391 : : static DEFINE_MUTEX(pmus_lock);
392 : : static struct srcu_struct pmus_srcu;
393 : : static cpumask_var_t perf_online_mask;
394 : :
395 : : /*
396 : : * perf event paranoia level:
397 : : * -1 - not paranoid at all
398 : : * 0 - disallow raw tracepoint access for unpriv
399 : : * 1 - disallow cpu events for unpriv
400 : : * 2 - disallow kernel profiling for unpriv
401 : : */
402 : : int sysctl_perf_event_paranoid __read_mostly = 2;
403 : :
404 : : /* Minimum for 512 kiB + 1 user control page */
405 : : int sysctl_perf_event_mlock __read_mostly = 512 + (PAGE_SIZE / 1024); /* 'free' kiB per user */
406 : :
407 : : /*
408 : : * max perf event sample rate
409 : : */
410 : : #define DEFAULT_MAX_SAMPLE_RATE 100000
411 : : #define DEFAULT_SAMPLE_PERIOD_NS (NSEC_PER_SEC / DEFAULT_MAX_SAMPLE_RATE)
412 : : #define DEFAULT_CPU_TIME_MAX_PERCENT 25
413 : :
414 : : int sysctl_perf_event_sample_rate __read_mostly = DEFAULT_MAX_SAMPLE_RATE;
415 : :
416 : : static int max_samples_per_tick __read_mostly = DIV_ROUND_UP(DEFAULT_MAX_SAMPLE_RATE, HZ);
417 : : static int perf_sample_period_ns __read_mostly = DEFAULT_SAMPLE_PERIOD_NS;
418 : :
419 : : static int perf_sample_allowed_ns __read_mostly =
420 : : DEFAULT_SAMPLE_PERIOD_NS * DEFAULT_CPU_TIME_MAX_PERCENT / 100;
421 : :
422 : 0 : static void update_perf_cpu_limits(void)
423 : : {
424 : 0 : u64 tmp = perf_sample_period_ns;
425 : :
426 : 0 : tmp *= sysctl_perf_cpu_time_max_percent;
427 : 0 : tmp = div_u64(tmp, 100);
428 [ # # # # ]: 0 : if (!tmp)
429 : 0 : tmp = 1;
430 : :
431 : 0 : WRITE_ONCE(perf_sample_allowed_ns, tmp);
432 : 0 : }
433 : :
434 : : static bool perf_rotate_context(struct perf_cpu_context *cpuctx);
435 : :
436 : 0 : int perf_proc_update_handler(struct ctl_table *table, int write,
437 : : void __user *buffer, size_t *lenp,
438 : : loff_t *ppos)
439 : : {
440 : 0 : int ret;
441 : 0 : int perf_cpu = sysctl_perf_cpu_time_max_percent;
442 : : /*
443 : : * If throttling is disabled don't allow the write:
444 : : */
445 [ # # # # ]: 0 : if (write && (perf_cpu == 100 || perf_cpu == 0))
446 : : return -EINVAL;
447 : :
448 : 0 : ret = proc_dointvec_minmax(table, write, buffer, lenp, ppos);
449 [ # # ]: 0 : if (ret || !write)
450 : : return ret;
451 : :
452 : 0 : max_samples_per_tick = DIV_ROUND_UP(sysctl_perf_event_sample_rate, HZ);
453 : 0 : perf_sample_period_ns = NSEC_PER_SEC / sysctl_perf_event_sample_rate;
454 [ # # ]: 0 : update_perf_cpu_limits();
455 : :
456 : 0 : return 0;
457 : : }
458 : :
459 : : int sysctl_perf_cpu_time_max_percent __read_mostly = DEFAULT_CPU_TIME_MAX_PERCENT;
460 : :
461 : 0 : int perf_cpu_time_max_percent_handler(struct ctl_table *table, int write,
462 : : void __user *buffer, size_t *lenp,
463 : : loff_t *ppos)
464 : : {
465 : 0 : int ret = proc_dointvec_minmax(table, write, buffer, lenp, ppos);
466 : :
467 [ # # ]: 0 : if (ret || !write)
468 : : return ret;
469 : :
470 [ # # ]: 0 : if (sysctl_perf_cpu_time_max_percent == 100 ||
471 : : sysctl_perf_cpu_time_max_percent == 0) {
472 : 0 : printk(KERN_WARNING
473 : : "perf: Dynamic interrupt throttling disabled, can hang your system!\n");
474 : 0 : WRITE_ONCE(perf_sample_allowed_ns, 0);
475 : : } else {
476 [ # # ]: 0 : update_perf_cpu_limits();
477 : : }
478 : :
479 : : return 0;
480 : : }
481 : :
482 : : /*
483 : : * perf samples are done in some very critical code paths (NMIs).
484 : : * If they take too much CPU time, the system can lock up and not
485 : : * get any real work done. This will drop the sample rate when
486 : : * we detect that events are taking too long.
487 : : */
488 : : #define NR_ACCUMULATED_SAMPLES 128
489 : : static DEFINE_PER_CPU(u64, running_sample_length);
490 : :
491 : : static u64 __report_avg;
492 : : static u64 __report_allowed;
493 : :
494 : 0 : static void perf_duration_warn(struct irq_work *w)
495 : : {
496 [ # # ]: 0 : printk_ratelimited(KERN_INFO
497 : : "perf: interrupt took too long (%lld > %lld), lowering "
498 : : "kernel.perf_event_max_sample_rate to %d\n",
499 : : __report_avg, __report_allowed,
500 : : sysctl_perf_event_sample_rate);
501 : 0 : }
502 : :
503 : : static DEFINE_IRQ_WORK(perf_duration_work, perf_duration_warn);
504 : :
505 : 0 : void perf_sample_event_took(u64 sample_len_ns)
506 : : {
507 [ # # ]: 0 : u64 max_len = READ_ONCE(perf_sample_allowed_ns);
508 : 0 : u64 running_len;
509 : 0 : u64 avg_len;
510 : 0 : u32 max;
511 : :
512 [ # # ]: 0 : if (max_len == 0)
513 : : return;
514 : :
515 : : /* Decay the counter by 1 average sample. */
516 [ # # ]: 0 : running_len = __this_cpu_read(running_sample_length);
517 : 0 : running_len -= running_len/NR_ACCUMULATED_SAMPLES;
518 : 0 : running_len += sample_len_ns;
519 : 0 : __this_cpu_write(running_sample_length, running_len);
520 : :
521 : : /*
522 : : * Note: this will be biased artifically low until we have
523 : : * seen NR_ACCUMULATED_SAMPLES. Doing it this way keeps us
524 : : * from having to maintain a count.
525 : : */
526 : 0 : avg_len = running_len/NR_ACCUMULATED_SAMPLES;
527 [ # # ]: 0 : if (avg_len <= max_len)
528 : : return;
529 : :
530 : 0 : __report_avg = avg_len;
531 : 0 : __report_allowed = max_len;
532 : :
533 : : /*
534 : : * Compute a throttle threshold 25% below the current duration.
535 : : */
536 : 0 : avg_len += avg_len / 4;
537 : 0 : max = (TICK_NSEC / 100) * sysctl_perf_cpu_time_max_percent;
538 [ # # ]: 0 : if (avg_len < max)
539 : 0 : max /= (u32)avg_len;
540 : : else
541 : : max = 1;
542 : :
543 : 0 : WRITE_ONCE(perf_sample_allowed_ns, avg_len);
544 : 0 : WRITE_ONCE(max_samples_per_tick, max);
545 : :
546 : 0 : sysctl_perf_event_sample_rate = max * HZ;
547 : 0 : perf_sample_period_ns = NSEC_PER_SEC / sysctl_perf_event_sample_rate;
548 : :
549 [ # # ]: 0 : if (!irq_work_queue(&perf_duration_work)) {
550 : 0 : early_printk("perf: interrupt took too long (%lld > %lld), lowering "
551 : : "kernel.perf_event_max_sample_rate to %d\n",
552 : : __report_avg, __report_allowed,
553 : : sysctl_perf_event_sample_rate);
554 : : }
555 : : }
556 : :
557 : : static atomic64_t perf_event_id;
558 : :
559 : : static void cpu_ctx_sched_out(struct perf_cpu_context *cpuctx,
560 : : enum event_type_t event_type);
561 : :
562 : : static void cpu_ctx_sched_in(struct perf_cpu_context *cpuctx,
563 : : enum event_type_t event_type,
564 : : struct task_struct *task);
565 : :
566 : : static void update_context_time(struct perf_event_context *ctx);
567 : : static u64 perf_event_time(struct perf_event *event);
568 : :
569 : 0 : void __weak perf_event_print_debug(void) { }
570 : :
571 : 0 : extern __weak const char *perf_pmu_name(void)
572 : : {
573 : 0 : return "pmu";
574 : : }
575 : :
576 : 0 : static inline u64 perf_clock(void)
577 : : {
578 : 0 : return local_clock();
579 : : }
580 : :
581 : 0 : static inline u64 perf_event_clock(struct perf_event *event)
582 : : {
583 : 0 : return event->clock();
584 : : }
585 : :
586 : : /*
587 : : * State based event timekeeping...
588 : : *
589 : : * The basic idea is to use event->state to determine which (if any) time
590 : : * fields to increment with the current delta. This means we only need to
591 : : * update timestamps when we change state or when they are explicitly requested
592 : : * (read).
593 : : *
594 : : * Event groups make things a little more complicated, but not terribly so. The
595 : : * rules for a group are that if the group leader is OFF the entire group is
596 : : * OFF, irrespecive of what the group member states are. This results in
597 : : * __perf_effective_state().
598 : : *
599 : : * A futher ramification is that when a group leader flips between OFF and
600 : : * !OFF, we need to update all group member times.
601 : : *
602 : : *
603 : : * NOTE: perf_event_time() is based on the (cgroup) context time, and thus we
604 : : * need to make sure the relevant context time is updated before we try and
605 : : * update our timestamps.
606 : : */
607 : :
608 : : static __always_inline enum perf_event_state
609 : 0 : __perf_effective_state(struct perf_event *event)
610 : : {
611 : 0 : struct perf_event *leader = event->group_leader;
612 : :
613 : 0 : if (leader->state <= PERF_EVENT_STATE_OFF)
614 : : return leader->state;
615 : :
616 : 0 : return event->state;
617 : : }
618 : :
619 : : static __always_inline void
620 : 0 : __perf_update_times(struct perf_event *event, u64 now, u64 *enabled, u64 *running)
621 : : {
622 : 0 : enum perf_event_state state = __perf_effective_state(event);
623 : 0 : u64 delta = now - event->tstamp;
624 : :
625 : 0 : *enabled = event->total_time_enabled;
626 [ # # # # : 0 : if (state >= PERF_EVENT_STATE_INACTIVE)
# # ]
627 : 0 : *enabled += delta;
628 : :
629 : 0 : *running = event->total_time_running;
630 [ # # # # : 0 : if (state >= PERF_EVENT_STATE_ACTIVE)
# # ]
631 : 0 : *running += delta;
632 : : }
633 : :
634 : 0 : static void perf_event_update_time(struct perf_event *event)
635 : : {
636 : 0 : u64 now = perf_event_time(event);
637 : :
638 [ # # ]: 0 : __perf_update_times(event, now, &event->total_time_enabled,
639 : : &event->total_time_running);
640 : 0 : event->tstamp = now;
641 : 0 : }
642 : :
643 : 0 : static void perf_event_update_sibling_time(struct perf_event *leader)
644 : : {
645 : 0 : struct perf_event *sibling;
646 : :
647 [ # # # # ]: 0 : for_each_sibling_event(sibling, leader)
648 : 0 : perf_event_update_time(sibling);
649 : 0 : }
650 : :
651 : : static void
652 : 0 : perf_event_set_state(struct perf_event *event, enum perf_event_state state)
653 : : {
654 [ # # ]: 0 : if (event->state == state)
655 : : return;
656 : :
657 : 0 : perf_event_update_time(event);
658 : : /*
659 : : * If a group leader gets enabled/disabled all its siblings
660 : : * are affected too.
661 : : */
662 [ # # ]: 0 : if ((event->state < 0) ^ (state < 0))
663 : 0 : perf_event_update_sibling_time(event);
664 : :
665 : 0 : WRITE_ONCE(event->state, state);
666 : : }
667 : :
668 : : #ifdef CONFIG_CGROUP_PERF
669 : :
670 : : static inline bool
671 : : perf_cgroup_match(struct perf_event *event)
672 : : {
673 : : struct perf_event_context *ctx = event->ctx;
674 : : struct perf_cpu_context *cpuctx = __get_cpu_context(ctx);
675 : :
676 : : /* @event doesn't care about cgroup */
677 : : if (!event->cgrp)
678 : : return true;
679 : :
680 : : /* wants specific cgroup scope but @cpuctx isn't associated with any */
681 : : if (!cpuctx->cgrp)
682 : : return false;
683 : :
684 : : /*
685 : : * Cgroup scoping is recursive. An event enabled for a cgroup is
686 : : * also enabled for all its descendant cgroups. If @cpuctx's
687 : : * cgroup is a descendant of @event's (the test covers identity
688 : : * case), it's a match.
689 : : */
690 : : return cgroup_is_descendant(cpuctx->cgrp->css.cgroup,
691 : : event->cgrp->css.cgroup);
692 : : }
693 : :
694 : : static inline void perf_detach_cgroup(struct perf_event *event)
695 : : {
696 : : css_put(&event->cgrp->css);
697 : : event->cgrp = NULL;
698 : : }
699 : :
700 : : static inline int is_cgroup_event(struct perf_event *event)
701 : : {
702 : : return event->cgrp != NULL;
703 : : }
704 : :
705 : : static inline u64 perf_cgroup_event_time(struct perf_event *event)
706 : : {
707 : : struct perf_cgroup_info *t;
708 : :
709 : : t = per_cpu_ptr(event->cgrp->info, event->cpu);
710 : : return t->time;
711 : : }
712 : :
713 : : static inline void __update_cgrp_time(struct perf_cgroup *cgrp)
714 : : {
715 : : struct perf_cgroup_info *info;
716 : : u64 now;
717 : :
718 : : now = perf_clock();
719 : :
720 : : info = this_cpu_ptr(cgrp->info);
721 : :
722 : : info->time += now - info->timestamp;
723 : : info->timestamp = now;
724 : : }
725 : :
726 : : static inline void update_cgrp_time_from_cpuctx(struct perf_cpu_context *cpuctx)
727 : : {
728 : : struct perf_cgroup *cgrp = cpuctx->cgrp;
729 : : struct cgroup_subsys_state *css;
730 : :
731 : : if (cgrp) {
732 : : for (css = &cgrp->css; css; css = css->parent) {
733 : : cgrp = container_of(css, struct perf_cgroup, css);
734 : : __update_cgrp_time(cgrp);
735 : : }
736 : : }
737 : : }
738 : :
739 : : static inline void update_cgrp_time_from_event(struct perf_event *event)
740 : : {
741 : : struct perf_cgroup *cgrp;
742 : :
743 : : /*
744 : : * ensure we access cgroup data only when needed and
745 : : * when we know the cgroup is pinned (css_get)
746 : : */
747 : : if (!is_cgroup_event(event))
748 : : return;
749 : :
750 : : cgrp = perf_cgroup_from_task(current, event->ctx);
751 : : /*
752 : : * Do not update time when cgroup is not active
753 : : */
754 : : if (cgroup_is_descendant(cgrp->css.cgroup, event->cgrp->css.cgroup))
755 : : __update_cgrp_time(event->cgrp);
756 : : }
757 : :
758 : : static inline void
759 : : perf_cgroup_set_timestamp(struct task_struct *task,
760 : : struct perf_event_context *ctx)
761 : : {
762 : : struct perf_cgroup *cgrp;
763 : : struct perf_cgroup_info *info;
764 : : struct cgroup_subsys_state *css;
765 : :
766 : : /*
767 : : * ctx->lock held by caller
768 : : * ensure we do not access cgroup data
769 : : * unless we have the cgroup pinned (css_get)
770 : : */
771 : : if (!task || !ctx->nr_cgroups)
772 : : return;
773 : :
774 : : cgrp = perf_cgroup_from_task(task, ctx);
775 : :
776 : : for (css = &cgrp->css; css; css = css->parent) {
777 : : cgrp = container_of(css, struct perf_cgroup, css);
778 : : info = this_cpu_ptr(cgrp->info);
779 : : info->timestamp = ctx->timestamp;
780 : : }
781 : : }
782 : :
783 : : static DEFINE_PER_CPU(struct list_head, cgrp_cpuctx_list);
784 : :
785 : : #define PERF_CGROUP_SWOUT 0x1 /* cgroup switch out every event */
786 : : #define PERF_CGROUP_SWIN 0x2 /* cgroup switch in events based on task */
787 : :
788 : : /*
789 : : * reschedule events based on the cgroup constraint of task.
790 : : *
791 : : * mode SWOUT : schedule out everything
792 : : * mode SWIN : schedule in based on cgroup for next
793 : : */
794 : : static void perf_cgroup_switch(struct task_struct *task, int mode)
795 : : {
796 : : struct perf_cpu_context *cpuctx;
797 : : struct list_head *list;
798 : : unsigned long flags;
799 : :
800 : : /*
801 : : * Disable interrupts and preemption to avoid this CPU's
802 : : * cgrp_cpuctx_entry to change under us.
803 : : */
804 : : local_irq_save(flags);
805 : :
806 : : list = this_cpu_ptr(&cgrp_cpuctx_list);
807 : : list_for_each_entry(cpuctx, list, cgrp_cpuctx_entry) {
808 : : WARN_ON_ONCE(cpuctx->ctx.nr_cgroups == 0);
809 : :
810 : : perf_ctx_lock(cpuctx, cpuctx->task_ctx);
811 : : perf_pmu_disable(cpuctx->ctx.pmu);
812 : :
813 : : if (mode & PERF_CGROUP_SWOUT) {
814 : : cpu_ctx_sched_out(cpuctx, EVENT_ALL);
815 : : /*
816 : : * must not be done before ctxswout due
817 : : * to event_filter_match() in event_sched_out()
818 : : */
819 : : cpuctx->cgrp = NULL;
820 : : }
821 : :
822 : : if (mode & PERF_CGROUP_SWIN) {
823 : : WARN_ON_ONCE(cpuctx->cgrp);
824 : : /*
825 : : * set cgrp before ctxsw in to allow
826 : : * event_filter_match() to not have to pass
827 : : * task around
828 : : * we pass the cpuctx->ctx to perf_cgroup_from_task()
829 : : * because cgorup events are only per-cpu
830 : : */
831 : : cpuctx->cgrp = perf_cgroup_from_task(task,
832 : : &cpuctx->ctx);
833 : : cpu_ctx_sched_in(cpuctx, EVENT_ALL, task);
834 : : }
835 : : perf_pmu_enable(cpuctx->ctx.pmu);
836 : : perf_ctx_unlock(cpuctx, cpuctx->task_ctx);
837 : : }
838 : :
839 : : local_irq_restore(flags);
840 : : }
841 : :
842 : : static inline void perf_cgroup_sched_out(struct task_struct *task,
843 : : struct task_struct *next)
844 : : {
845 : : struct perf_cgroup *cgrp1;
846 : : struct perf_cgroup *cgrp2 = NULL;
847 : :
848 : : rcu_read_lock();
849 : : /*
850 : : * we come here when we know perf_cgroup_events > 0
851 : : * we do not need to pass the ctx here because we know
852 : : * we are holding the rcu lock
853 : : */
854 : : cgrp1 = perf_cgroup_from_task(task, NULL);
855 : : cgrp2 = perf_cgroup_from_task(next, NULL);
856 : :
857 : : /*
858 : : * only schedule out current cgroup events if we know
859 : : * that we are switching to a different cgroup. Otherwise,
860 : : * do no touch the cgroup events.
861 : : */
862 : : if (cgrp1 != cgrp2)
863 : : perf_cgroup_switch(task, PERF_CGROUP_SWOUT);
864 : :
865 : : rcu_read_unlock();
866 : : }
867 : :
868 : : static inline void perf_cgroup_sched_in(struct task_struct *prev,
869 : : struct task_struct *task)
870 : : {
871 : : struct perf_cgroup *cgrp1;
872 : : struct perf_cgroup *cgrp2 = NULL;
873 : :
874 : : rcu_read_lock();
875 : : /*
876 : : * we come here when we know perf_cgroup_events > 0
877 : : * we do not need to pass the ctx here because we know
878 : : * we are holding the rcu lock
879 : : */
880 : : cgrp1 = perf_cgroup_from_task(task, NULL);
881 : : cgrp2 = perf_cgroup_from_task(prev, NULL);
882 : :
883 : : /*
884 : : * only need to schedule in cgroup events if we are changing
885 : : * cgroup during ctxsw. Cgroup events were not scheduled
886 : : * out of ctxsw out if that was not the case.
887 : : */
888 : : if (cgrp1 != cgrp2)
889 : : perf_cgroup_switch(task, PERF_CGROUP_SWIN);
890 : :
891 : : rcu_read_unlock();
892 : : }
893 : :
894 : : static inline int perf_cgroup_connect(int fd, struct perf_event *event,
895 : : struct perf_event_attr *attr,
896 : : struct perf_event *group_leader)
897 : : {
898 : : struct perf_cgroup *cgrp;
899 : : struct cgroup_subsys_state *css;
900 : : struct fd f = fdget(fd);
901 : : int ret = 0;
902 : :
903 : : if (!f.file)
904 : : return -EBADF;
905 : :
906 : : css = css_tryget_online_from_dir(f.file->f_path.dentry,
907 : : &perf_event_cgrp_subsys);
908 : : if (IS_ERR(css)) {
909 : : ret = PTR_ERR(css);
910 : : goto out;
911 : : }
912 : :
913 : : cgrp = container_of(css, struct perf_cgroup, css);
914 : : event->cgrp = cgrp;
915 : :
916 : : /*
917 : : * all events in a group must monitor
918 : : * the same cgroup because a task belongs
919 : : * to only one perf cgroup at a time
920 : : */
921 : : if (group_leader && group_leader->cgrp != cgrp) {
922 : : perf_detach_cgroup(event);
923 : : ret = -EINVAL;
924 : : }
925 : : out:
926 : : fdput(f);
927 : : return ret;
928 : : }
929 : :
930 : : static inline void
931 : : perf_cgroup_set_shadow_time(struct perf_event *event, u64 now)
932 : : {
933 : : struct perf_cgroup_info *t;
934 : : t = per_cpu_ptr(event->cgrp->info, event->cpu);
935 : : event->shadow_ctx_time = now - t->timestamp;
936 : : }
937 : :
938 : : /*
939 : : * Update cpuctx->cgrp so that it is set when first cgroup event is added and
940 : : * cleared when last cgroup event is removed.
941 : : */
942 : : static inline void
943 : : list_update_cgroup_event(struct perf_event *event,
944 : : struct perf_event_context *ctx, bool add)
945 : : {
946 : : struct perf_cpu_context *cpuctx;
947 : : struct list_head *cpuctx_entry;
948 : :
949 : : if (!is_cgroup_event(event))
950 : : return;
951 : :
952 : : /*
953 : : * Because cgroup events are always per-cpu events,
954 : : * @ctx == &cpuctx->ctx.
955 : : */
956 : : cpuctx = container_of(ctx, struct perf_cpu_context, ctx);
957 : :
958 : : /*
959 : : * Since setting cpuctx->cgrp is conditional on the current @cgrp
960 : : * matching the event's cgroup, we must do this for every new event,
961 : : * because if the first would mismatch, the second would not try again
962 : : * and we would leave cpuctx->cgrp unset.
963 : : */
964 : : if (add && !cpuctx->cgrp) {
965 : : struct perf_cgroup *cgrp = perf_cgroup_from_task(current, ctx);
966 : :
967 : : if (cgroup_is_descendant(cgrp->css.cgroup, event->cgrp->css.cgroup))
968 : : cpuctx->cgrp = cgrp;
969 : : }
970 : :
971 : : if (add && ctx->nr_cgroups++)
972 : : return;
973 : : else if (!add && --ctx->nr_cgroups)
974 : : return;
975 : :
976 : : /* no cgroup running */
977 : : if (!add)
978 : : cpuctx->cgrp = NULL;
979 : :
980 : : cpuctx_entry = &cpuctx->cgrp_cpuctx_entry;
981 : : if (add)
982 : : list_add(cpuctx_entry,
983 : : per_cpu_ptr(&cgrp_cpuctx_list, event->cpu));
984 : : else
985 : : list_del(cpuctx_entry);
986 : : }
987 : :
988 : : #else /* !CONFIG_CGROUP_PERF */
989 : :
990 : : static inline bool
991 : 0 : perf_cgroup_match(struct perf_event *event)
992 : : {
993 : 0 : return true;
994 : : }
995 : :
996 : : static inline void perf_detach_cgroup(struct perf_event *event)
997 : : {}
998 : :
999 : 0 : static inline int is_cgroup_event(struct perf_event *event)
1000 : : {
1001 : 0 : return 0;
1002 : : }
1003 : :
1004 : : static inline void update_cgrp_time_from_event(struct perf_event *event)
1005 : : {
1006 : : }
1007 : :
1008 : : static inline void update_cgrp_time_from_cpuctx(struct perf_cpu_context *cpuctx)
1009 : : {
1010 : : }
1011 : :
1012 : : static inline void perf_cgroup_sched_out(struct task_struct *task,
1013 : : struct task_struct *next)
1014 : : {
1015 : : }
1016 : :
1017 : : static inline void perf_cgroup_sched_in(struct task_struct *prev,
1018 : : struct task_struct *task)
1019 : : {
1020 : : }
1021 : :
1022 : 0 : static inline int perf_cgroup_connect(pid_t pid, struct perf_event *event,
1023 : : struct perf_event_attr *attr,
1024 : : struct perf_event *group_leader)
1025 : : {
1026 : 0 : return -EINVAL;
1027 : : }
1028 : :
1029 : : static inline void
1030 : : perf_cgroup_set_timestamp(struct task_struct *task,
1031 : : struct perf_event_context *ctx)
1032 : : {
1033 : : }
1034 : :
1035 : : static inline void
1036 : : perf_cgroup_switch(struct task_struct *task, struct task_struct *next)
1037 : : {
1038 : : }
1039 : :
1040 : : static inline void
1041 : : perf_cgroup_set_shadow_time(struct perf_event *event, u64 now)
1042 : : {
1043 : : }
1044 : :
1045 : : static inline u64 perf_cgroup_event_time(struct perf_event *event)
1046 : : {
1047 : : return 0;
1048 : : }
1049 : :
1050 : : static inline void
1051 : 0 : list_update_cgroup_event(struct perf_event *event,
1052 : : struct perf_event_context *ctx, bool add)
1053 : : {
1054 : 0 : }
1055 : :
1056 : : #endif
1057 : :
1058 : : /*
1059 : : * set default to be dependent on timer tick just
1060 : : * like original code
1061 : : */
1062 : : #define PERF_CPU_HRTIMER (1000 / HZ)
1063 : : /*
1064 : : * function must be called with interrupts disabled
1065 : : */
1066 : 0 : static enum hrtimer_restart perf_mux_hrtimer_handler(struct hrtimer *hr)
1067 : : {
1068 : 0 : struct perf_cpu_context *cpuctx;
1069 : 0 : bool rotations;
1070 : :
1071 : 0 : lockdep_assert_irqs_disabled();
1072 : :
1073 : 0 : cpuctx = container_of(hr, struct perf_cpu_context, hrtimer);
1074 : 0 : rotations = perf_rotate_context(cpuctx);
1075 : :
1076 : 0 : raw_spin_lock(&cpuctx->hrtimer_lock);
1077 [ # # ]: 0 : if (rotations)
1078 : 0 : hrtimer_forward_now(hr, cpuctx->hrtimer_interval);
1079 : : else
1080 : 0 : cpuctx->hrtimer_active = 0;
1081 : 0 : raw_spin_unlock(&cpuctx->hrtimer_lock);
1082 : :
1083 : 0 : return rotations ? HRTIMER_RESTART : HRTIMER_NORESTART;
1084 : : }
1085 : :
1086 : : static void __perf_mux_hrtimer_init(struct perf_cpu_context *cpuctx, int cpu)
1087 : : {
1088 : : struct hrtimer *timer = &cpuctx->hrtimer;
1089 : : struct pmu *pmu = cpuctx->ctx.pmu;
1090 : : u64 interval;
1091 : :
1092 : : /* no multiplexing needed for SW PMU */
1093 : : if (pmu->task_ctx_nr == perf_sw_context)
1094 : : return;
1095 : :
1096 : : /*
1097 : : * check default is sane, if not set then force to
1098 : : * default interval (1/tick)
1099 : : */
1100 : : interval = pmu->hrtimer_interval_ms;
1101 : : if (interval < 1)
1102 : : interval = pmu->hrtimer_interval_ms = PERF_CPU_HRTIMER;
1103 : :
1104 : : cpuctx->hrtimer_interval = ns_to_ktime(NSEC_PER_MSEC * interval);
1105 : :
1106 : : raw_spin_lock_init(&cpuctx->hrtimer_lock);
1107 : : hrtimer_init(timer, CLOCK_MONOTONIC, HRTIMER_MODE_ABS_PINNED_HARD);
1108 : : timer->function = perf_mux_hrtimer_handler;
1109 : : }
1110 : :
1111 : 0 : static int perf_mux_hrtimer_restart(struct perf_cpu_context *cpuctx)
1112 : : {
1113 : 0 : struct hrtimer *timer = &cpuctx->hrtimer;
1114 : 0 : struct pmu *pmu = cpuctx->ctx.pmu;
1115 : 0 : unsigned long flags;
1116 : :
1117 : : /* not for SW PMU */
1118 [ # # ]: 0 : if (pmu->task_ctx_nr == perf_sw_context)
1119 : : return 0;
1120 : :
1121 : 0 : raw_spin_lock_irqsave(&cpuctx->hrtimer_lock, flags);
1122 [ # # ]: 0 : if (!cpuctx->hrtimer_active) {
1123 : 0 : cpuctx->hrtimer_active = 1;
1124 : 0 : hrtimer_forward_now(timer, cpuctx->hrtimer_interval);
1125 : 0 : hrtimer_start_expires(timer, HRTIMER_MODE_ABS_PINNED_HARD);
1126 : : }
1127 : 0 : raw_spin_unlock_irqrestore(&cpuctx->hrtimer_lock, flags);
1128 : :
1129 : 0 : return 0;
1130 : : }
1131 : :
1132 : 0 : void perf_pmu_disable(struct pmu *pmu)
1133 : : {
1134 : 0 : int *count = this_cpu_ptr(pmu->pmu_disable_count);
1135 [ # # # # : 0 : if (!(*count)++)
# # # # #
# # # # #
# # # # #
# ]
1136 : 0 : pmu->pmu_disable(pmu);
1137 : 0 : }
1138 : :
1139 : 0 : void perf_pmu_enable(struct pmu *pmu)
1140 : : {
1141 : 0 : int *count = this_cpu_ptr(pmu->pmu_disable_count);
1142 [ # # # # : 0 : if (!--(*count))
# # # # #
# # # # #
# # # # #
# # # ]
1143 : 0 : pmu->pmu_enable(pmu);
1144 : 0 : }
1145 : :
1146 : : static DEFINE_PER_CPU(struct list_head, active_ctx_list);
1147 : :
1148 : : /*
1149 : : * perf_event_ctx_activate(), perf_event_ctx_deactivate(), and
1150 : : * perf_event_task_tick() are fully serialized because they're strictly cpu
1151 : : * affine and perf_event_ctx{activate,deactivate} are called with IRQs
1152 : : * disabled, while perf_event_task_tick is called from IRQ context.
1153 : : */
1154 : : static void perf_event_ctx_activate(struct perf_event_context *ctx)
1155 : : {
1156 : : struct list_head *head = this_cpu_ptr(&active_ctx_list);
1157 : :
1158 : : lockdep_assert_irqs_disabled();
1159 : :
1160 : : WARN_ON(!list_empty(&ctx->active_ctx_list));
1161 : :
1162 : : list_add(&ctx->active_ctx_list, head);
1163 : : }
1164 : :
1165 : : static void perf_event_ctx_deactivate(struct perf_event_context *ctx)
1166 : : {
1167 : : lockdep_assert_irqs_disabled();
1168 : :
1169 : : WARN_ON(list_empty(&ctx->active_ctx_list));
1170 : :
1171 : : list_del_init(&ctx->active_ctx_list);
1172 : : }
1173 : :
1174 : 0 : static void get_ctx(struct perf_event_context *ctx)
1175 : : {
1176 : 0 : refcount_inc(&ctx->refcount);
1177 : 0 : }
1178 : :
1179 : 0 : static void free_ctx(struct rcu_head *head)
1180 : : {
1181 : 0 : struct perf_event_context *ctx;
1182 : :
1183 : 0 : ctx = container_of(head, struct perf_event_context, rcu_head);
1184 : 0 : kfree(ctx->task_ctx_data);
1185 : 0 : kfree(ctx);
1186 : 0 : }
1187 : :
1188 : 0 : static void put_ctx(struct perf_event_context *ctx)
1189 : : {
1190 [ # # ]: 0 : if (refcount_dec_and_test(&ctx->refcount)) {
1191 [ # # ]: 0 : if (ctx->parent_ctx)
1192 : 0 : put_ctx(ctx->parent_ctx);
1193 [ # # ]: 0 : if (ctx->task && ctx->task != TASK_TOMBSTONE)
1194 : 0 : put_task_struct(ctx->task);
1195 : 0 : call_rcu(&ctx->rcu_head, free_ctx);
1196 : : }
1197 : 0 : }
1198 : :
1199 : : /*
1200 : : * Because of perf_event::ctx migration in sys_perf_event_open::move_group and
1201 : : * perf_pmu_migrate_context() we need some magic.
1202 : : *
1203 : : * Those places that change perf_event::ctx will hold both
1204 : : * perf_event_ctx::mutex of the 'old' and 'new' ctx value.
1205 : : *
1206 : : * Lock ordering is by mutex address. There are two other sites where
1207 : : * perf_event_context::mutex nests and those are:
1208 : : *
1209 : : * - perf_event_exit_task_context() [ child , 0 ]
1210 : : * perf_event_exit_event()
1211 : : * put_event() [ parent, 1 ]
1212 : : *
1213 : : * - perf_event_init_context() [ parent, 0 ]
1214 : : * inherit_task_group()
1215 : : * inherit_group()
1216 : : * inherit_event()
1217 : : * perf_event_alloc()
1218 : : * perf_init_event()
1219 : : * perf_try_init_event() [ child , 1 ]
1220 : : *
1221 : : * While it appears there is an obvious deadlock here -- the parent and child
1222 : : * nesting levels are inverted between the two. This is in fact safe because
1223 : : * life-time rules separate them. That is an exiting task cannot fork, and a
1224 : : * spawning task cannot (yet) exit.
1225 : : *
1226 : : * But remember that that these are parent<->child context relations, and
1227 : : * migration does not affect children, therefore these two orderings should not
1228 : : * interact.
1229 : : *
1230 : : * The change in perf_event::ctx does not affect children (as claimed above)
1231 : : * because the sys_perf_event_open() case will install a new event and break
1232 : : * the ctx parent<->child relation, and perf_pmu_migrate_context() is only
1233 : : * concerned with cpuctx and that doesn't have children.
1234 : : *
1235 : : * The places that change perf_event::ctx will issue:
1236 : : *
1237 : : * perf_remove_from_context();
1238 : : * synchronize_rcu();
1239 : : * perf_install_in_context();
1240 : : *
1241 : : * to affect the change. The remove_from_context() + synchronize_rcu() should
1242 : : * quiesce the event, after which we can install it in the new location. This
1243 : : * means that only external vectors (perf_fops, prctl) can perturb the event
1244 : : * while in transit. Therefore all such accessors should also acquire
1245 : : * perf_event_context::mutex to serialize against this.
1246 : : *
1247 : : * However; because event->ctx can change while we're waiting to acquire
1248 : : * ctx->mutex we must be careful and use the below perf_event_ctx_lock()
1249 : : * function.
1250 : : *
1251 : : * Lock order:
1252 : : * cred_guard_mutex
1253 : : * task_struct::perf_event_mutex
1254 : : * perf_event_context::mutex
1255 : : * perf_event::child_mutex;
1256 : : * perf_event_context::lock
1257 : : * perf_event::mmap_mutex
1258 : : * mmap_sem
1259 : : * perf_addr_filters_head::lock
1260 : : *
1261 : : * cpu_hotplug_lock
1262 : : * pmus_lock
1263 : : * cpuctx->mutex / perf_event_context::mutex
1264 : : */
1265 : : static struct perf_event_context *
1266 : : perf_event_ctx_lock_nested(struct perf_event *event, int nesting)
1267 : : {
1268 : : struct perf_event_context *ctx;
1269 : :
1270 : : again:
1271 : : rcu_read_lock();
1272 : : ctx = READ_ONCE(event->ctx);
1273 : : if (!refcount_inc_not_zero(&ctx->refcount)) {
1274 : : rcu_read_unlock();
1275 : : goto again;
1276 : : }
1277 : : rcu_read_unlock();
1278 : :
1279 : : mutex_lock_nested(&ctx->mutex, nesting);
1280 : : if (event->ctx != ctx) {
1281 : : mutex_unlock(&ctx->mutex);
1282 : : put_ctx(ctx);
1283 : : goto again;
1284 : : }
1285 : :
1286 : : return ctx;
1287 : : }
1288 : :
1289 : : static inline struct perf_event_context *
1290 : 0 : perf_event_ctx_lock(struct perf_event *event)
1291 : : {
1292 : 0 : return perf_event_ctx_lock_nested(event, 0);
1293 : : }
1294 : :
1295 : 0 : static void perf_event_ctx_unlock(struct perf_event *event,
1296 : : struct perf_event_context *ctx)
1297 : : {
1298 : 0 : mutex_unlock(&ctx->mutex);
1299 : 0 : put_ctx(ctx);
1300 : 0 : }
1301 : :
1302 : : /*
1303 : : * This must be done under the ctx->lock, such as to serialize against
1304 : : * context_equiv(), therefore we cannot call put_ctx() since that might end up
1305 : : * calling scheduler related locks and ctx->lock nests inside those.
1306 : : */
1307 : : static __must_check struct perf_event_context *
1308 : 0 : unclone_ctx(struct perf_event_context *ctx)
1309 : : {
1310 : 0 : struct perf_event_context *parent_ctx = ctx->parent_ctx;
1311 : :
1312 : 0 : lockdep_assert_held(&ctx->lock);
1313 : :
1314 : 0 : if (parent_ctx)
1315 : 0 : ctx->parent_ctx = NULL;
1316 : 0 : ctx->generation++;
1317 : :
1318 : 0 : return parent_ctx;
1319 : : }
1320 : :
1321 : 0 : static u32 perf_event_pid_type(struct perf_event *event, struct task_struct *p,
1322 : : enum pid_type type)
1323 : : {
1324 : 0 : u32 nr;
1325 : : /*
1326 : : * only top level events have the pid namespace they were created in
1327 : : */
1328 [ # # ]: 0 : if (event->parent)
1329 : 0 : event = event->parent;
1330 : :
1331 : 0 : nr = __task_pid_nr_ns(p, type, event->ns);
1332 : : /* avoid -1 if it is idle thread or runs in another ns */
1333 [ # # # # ]: 0 : if (!nr && !pid_alive(p))
1334 : 0 : nr = -1;
1335 : 0 : return nr;
1336 : : }
1337 : :
1338 : 0 : static u32 perf_event_pid(struct perf_event *event, struct task_struct *p)
1339 : : {
1340 : 0 : return perf_event_pid_type(event, p, PIDTYPE_TGID);
1341 : : }
1342 : :
1343 : 0 : static u32 perf_event_tid(struct perf_event *event, struct task_struct *p)
1344 : : {
1345 : 0 : return perf_event_pid_type(event, p, PIDTYPE_PID);
1346 : : }
1347 : :
1348 : : /*
1349 : : * If we inherit events we want to return the parent event id
1350 : : * to userspace.
1351 : : */
1352 : 0 : static u64 primary_event_id(struct perf_event *event)
1353 : : {
1354 : 0 : u64 id = event->id;
1355 : :
1356 : 0 : if (event->parent)
1357 : 0 : id = event->parent->id;
1358 : :
1359 : 0 : return id;
1360 : : }
1361 : :
1362 : : /*
1363 : : * Get the perf_event_context for a task and lock it.
1364 : : *
1365 : : * This has to cope with with the fact that until it is locked,
1366 : : * the context could get moved to another task.
1367 : : */
1368 : : static struct perf_event_context *
1369 : 20384 : perf_lock_task_context(struct task_struct *task, int ctxn, unsigned long *flags)
1370 : : {
1371 : 20384 : struct perf_event_context *ctx;
1372 : :
1373 : 20384 : retry:
1374 : : /*
1375 : : * One of the few rules of preemptible RCU is that one cannot do
1376 : : * rcu_read_unlock() while holding a scheduler (or nested) lock when
1377 : : * part of the read side critical section was irqs-enabled -- see
1378 : : * rcu_read_unlock_special().
1379 : : *
1380 : : * Since ctx->lock nests under rq->lock we must ensure the entire read
1381 : : * side critical section has interrupts disabled.
1382 : : */
1383 : 20384 : local_irq_save(*flags);
1384 : 20384 : rcu_read_lock();
1385 [ - + ]: 20384 : ctx = rcu_dereference(task->perf_event_ctxp[ctxn]);
1386 [ - + ]: 20384 : if (ctx) {
1387 : : /*
1388 : : * If this context is a clone of another, it might
1389 : : * get swapped for another underneath us by
1390 : : * perf_event_task_sched_out, though the
1391 : : * rcu_read_lock() protects us from any context
1392 : : * getting freed. Lock the context and check if it
1393 : : * got swapped before we could get the lock, and retry
1394 : : * if so. If we locked the right context, then it
1395 : : * can't get swapped on us any more.
1396 : : */
1397 : 0 : raw_spin_lock(&ctx->lock);
1398 [ # # ]: 0 : if (ctx != rcu_dereference(task->perf_event_ctxp[ctxn])) {
1399 : 0 : raw_spin_unlock(&ctx->lock);
1400 : 0 : rcu_read_unlock();
1401 : 0 : local_irq_restore(*flags);
1402 : 0 : goto retry;
1403 : : }
1404 : :
1405 [ # # # # ]: 0 : if (ctx->task == TASK_TOMBSTONE ||
1406 : 0 : !refcount_inc_not_zero(&ctx->refcount)) {
1407 : 0 : raw_spin_unlock(&ctx->lock);
1408 : 0 : ctx = NULL;
1409 : : } else {
1410 [ # # ]: 0 : WARN_ON_ONCE(ctx->task != task);
1411 : : }
1412 : : }
1413 : 20384 : rcu_read_unlock();
1414 [ + - ]: 20384 : if (!ctx)
1415 : 20384 : local_irq_restore(*flags);
1416 : 20384 : return ctx;
1417 : : }
1418 : :
1419 : : /*
1420 : : * Get the context for a task and increment its pin_count so it
1421 : : * can't get swapped to another task. This also increments its
1422 : : * reference count so that the context can't get freed.
1423 : : */
1424 : : static struct perf_event_context *
1425 : 20384 : perf_pin_task_context(struct task_struct *task, int ctxn)
1426 : : {
1427 : 20384 : struct perf_event_context *ctx;
1428 : 20384 : unsigned long flags;
1429 : :
1430 : 20384 : ctx = perf_lock_task_context(task, ctxn, &flags);
1431 [ - + ]: 20384 : if (ctx) {
1432 : 0 : ++ctx->pin_count;
1433 : 0 : raw_spin_unlock_irqrestore(&ctx->lock, flags);
1434 : : }
1435 : 20384 : return ctx;
1436 : : }
1437 : :
1438 : 0 : static void perf_unpin_context(struct perf_event_context *ctx)
1439 : : {
1440 : 0 : unsigned long flags;
1441 : :
1442 : 0 : raw_spin_lock_irqsave(&ctx->lock, flags);
1443 : 0 : --ctx->pin_count;
1444 : 0 : raw_spin_unlock_irqrestore(&ctx->lock, flags);
1445 : 0 : }
1446 : :
1447 : : /*
1448 : : * Update the record of the current time in a context.
1449 : : */
1450 : 0 : static void update_context_time(struct perf_event_context *ctx)
1451 : : {
1452 : 0 : u64 now = perf_clock();
1453 : :
1454 : 0 : ctx->time += now - ctx->timestamp;
1455 : 0 : ctx->timestamp = now;
1456 : 0 : }
1457 : :
1458 : 0 : static u64 perf_event_time(struct perf_event *event)
1459 : : {
1460 : 0 : struct perf_event_context *ctx = event->ctx;
1461 : :
1462 : 0 : if (is_cgroup_event(event))
1463 : : return perf_cgroup_event_time(event);
1464 : :
1465 [ # # ]: 0 : return ctx ? ctx->time : 0;
1466 : : }
1467 : :
1468 : 0 : static enum event_type_t get_event_type(struct perf_event *event)
1469 : : {
1470 : 0 : struct perf_event_context *ctx = event->ctx;
1471 : 0 : enum event_type_t event_type;
1472 : :
1473 : 0 : lockdep_assert_held(&ctx->lock);
1474 : :
1475 : : /*
1476 : : * It's 'group type', really, because if our group leader is
1477 : : * pinned, so are we.
1478 : : */
1479 : 0 : if (event->group_leader != event)
1480 : 0 : event = event->group_leader;
1481 : :
1482 [ # # # # : 0 : event_type = event->attr.pinned ? EVENT_PINNED : EVENT_FLEXIBLE;
# # ]
1483 [ # # # # : 0 : if (!ctx->task)
# # ]
1484 : 0 : event_type |= EVENT_CPU;
1485 : :
1486 : 0 : return event_type;
1487 : : }
1488 : :
1489 : : /*
1490 : : * Helper function to initialize event group nodes.
1491 : : */
1492 : 0 : static void init_event_group(struct perf_event *event)
1493 : : {
1494 : 0 : RB_CLEAR_NODE(&event->group_node);
1495 : 0 : event->group_index = 0;
1496 : : }
1497 : :
1498 : : /*
1499 : : * Extract pinned or flexible groups from the context
1500 : : * based on event attrs bits.
1501 : : */
1502 : : static struct perf_event_groups *
1503 : 0 : get_event_groups(struct perf_event *event, struct perf_event_context *ctx)
1504 : : {
1505 : 0 : if (event->attr.pinned)
1506 : 0 : return &ctx->pinned_groups;
1507 : : else
1508 : 0 : return &ctx->flexible_groups;
1509 : : }
1510 : :
1511 : : /*
1512 : : * Helper function to initializes perf_event_group trees.
1513 : : */
1514 : 26 : static void perf_event_groups_init(struct perf_event_groups *groups)
1515 : : {
1516 : 26 : groups->tree = RB_ROOT;
1517 : 26 : groups->index = 0;
1518 : : }
1519 : :
1520 : : /*
1521 : : * Compare function for event groups;
1522 : : *
1523 : : * Implements complex key that first sorts by CPU and then by virtual index
1524 : : * which provides ordering when rotating groups for the same CPU.
1525 : : */
1526 : : static bool
1527 : 0 : perf_event_groups_less(struct perf_event *left, struct perf_event *right)
1528 : : {
1529 : 0 : if (left->cpu < right->cpu)
1530 : : return true;
1531 [ # # ]: 0 : if (left->cpu > right->cpu)
1532 : : return false;
1533 : :
1534 [ # # ]: 0 : if (left->group_index < right->group_index)
1535 : : return true;
1536 : : if (left->group_index > right->group_index)
1537 : : return false;
1538 : :
1539 : : return false;
1540 : : }
1541 : :
1542 : : /*
1543 : : * Insert @event into @groups' tree; using {@event->cpu, ++@groups->index} for
1544 : : * key (see perf_event_groups_less). This places it last inside the CPU
1545 : : * subtree.
1546 : : */
1547 : : static void
1548 : 0 : perf_event_groups_insert(struct perf_event_groups *groups,
1549 : : struct perf_event *event)
1550 : : {
1551 : 0 : struct perf_event *node_event;
1552 : 0 : struct rb_node *parent;
1553 : 0 : struct rb_node **node;
1554 : :
1555 : 0 : event->group_index = ++groups->index;
1556 : :
1557 : 0 : node = &groups->tree.rb_node;
1558 : 0 : parent = *node;
1559 : :
1560 [ # # ]: 0 : while (*node) {
1561 : 0 : parent = *node;
1562 : 0 : node_event = container_of(*node, struct perf_event, group_node);
1563 : :
1564 [ # # ]: 0 : if (perf_event_groups_less(event, node_event))
1565 : 0 : node = &parent->rb_left;
1566 : : else
1567 : 0 : node = &parent->rb_right;
1568 : : }
1569 : :
1570 : 0 : rb_link_node(&event->group_node, parent, node);
1571 : 0 : rb_insert_color(&event->group_node, &groups->tree);
1572 : 0 : }
1573 : :
1574 : : /*
1575 : : * Helper function to insert event into the pinned or flexible groups.
1576 : : */
1577 : : static void
1578 : 0 : add_event_to_groups(struct perf_event *event, struct perf_event_context *ctx)
1579 : : {
1580 : 0 : struct perf_event_groups *groups;
1581 : :
1582 : 0 : groups = get_event_groups(event, ctx);
1583 : 0 : perf_event_groups_insert(groups, event);
1584 : 0 : }
1585 : :
1586 : : /*
1587 : : * Delete a group from a tree.
1588 : : */
1589 : : static void
1590 : 0 : perf_event_groups_delete(struct perf_event_groups *groups,
1591 : : struct perf_event *event)
1592 : : {
1593 [ # # # # : 0 : WARN_ON_ONCE(RB_EMPTY_NODE(&event->group_node) ||
# # ]
1594 : : RB_EMPTY_ROOT(&groups->tree));
1595 : :
1596 : 0 : rb_erase(&event->group_node, &groups->tree);
1597 : 0 : init_event_group(event);
1598 : 0 : }
1599 : :
1600 : : /*
1601 : : * Helper function to delete event from its groups.
1602 : : */
1603 : : static void
1604 : 0 : del_event_from_groups(struct perf_event *event, struct perf_event_context *ctx)
1605 : : {
1606 : 0 : struct perf_event_groups *groups;
1607 : :
1608 : 0 : groups = get_event_groups(event, ctx);
1609 : 0 : perf_event_groups_delete(groups, event);
1610 : 0 : }
1611 : :
1612 : : /*
1613 : : * Get the leftmost event in the @cpu subtree.
1614 : : */
1615 : : static struct perf_event *
1616 : 0 : perf_event_groups_first(struct perf_event_groups *groups, int cpu)
1617 : : {
1618 : 0 : struct perf_event *node_event = NULL, *match = NULL;
1619 : 0 : struct rb_node *node = groups->tree.rb_node;
1620 : :
1621 [ # # # # ]: 0 : while (node) {
1622 : 0 : node_event = container_of(node, struct perf_event, group_node);
1623 : :
1624 [ # # # # ]: 0 : if (cpu < node_event->cpu) {
1625 : 0 : node = node->rb_left;
1626 [ # # # # ]: 0 : } else if (cpu > node_event->cpu) {
1627 : 0 : node = node->rb_right;
1628 : : } else {
1629 : 0 : match = node_event;
1630 : 0 : node = node->rb_left;
1631 : : }
1632 : : }
1633 : :
1634 : 0 : return match;
1635 : : }
1636 : :
1637 : : /*
1638 : : * Like rb_entry_next_safe() for the @cpu subtree.
1639 : : */
1640 : : static struct perf_event *
1641 : 0 : perf_event_groups_next(struct perf_event *event)
1642 : : {
1643 : 0 : struct perf_event *next;
1644 : :
1645 [ # # ]: 0 : next = rb_entry_safe(rb_next(&event->group_node), typeof(*event), group_node);
1646 [ # # # # ]: 0 : if (next && next->cpu == event->cpu)
1647 : 0 : return next;
1648 : :
1649 : : return NULL;
1650 : : }
1651 : :
1652 : : /*
1653 : : * Iterate through the whole groups tree.
1654 : : */
1655 : : #define perf_event_groups_for_each(event, groups) \
1656 : : for (event = rb_entry_safe(rb_first(&((groups)->tree)), \
1657 : : typeof(*event), group_node); event; \
1658 : : event = rb_entry_safe(rb_next(&event->group_node), \
1659 : : typeof(*event), group_node))
1660 : :
1661 : : /*
1662 : : * Add an event from the lists for its context.
1663 : : * Must be called with ctx->mutex and ctx->lock held.
1664 : : */
1665 : : static void
1666 : 0 : list_add_event(struct perf_event *event, struct perf_event_context *ctx)
1667 : : {
1668 : 0 : lockdep_assert_held(&ctx->lock);
1669 : :
1670 [ # # ]: 0 : WARN_ON_ONCE(event->attach_state & PERF_ATTACH_CONTEXT);
1671 : 0 : event->attach_state |= PERF_ATTACH_CONTEXT;
1672 : :
1673 [ # # ]: 0 : event->tstamp = perf_event_time(event);
1674 : :
1675 : : /*
1676 : : * If we're a stand alone event or group leader, we go to the context
1677 : : * list, group events are kept attached to the group so that
1678 : : * perf_group_detach can, at all times, locate all siblings.
1679 : : */
1680 [ # # ]: 0 : if (event->group_leader == event) {
1681 : 0 : event->group_caps = event->event_caps;
1682 [ # # ]: 0 : add_event_to_groups(event, ctx);
1683 : : }
1684 : :
1685 : 0 : list_update_cgroup_event(event, ctx, true);
1686 : :
1687 : 0 : list_add_rcu(&event->event_entry, &ctx->event_list);
1688 : 0 : ctx->nr_events++;
1689 [ # # ]: 0 : if (event->attr.inherit_stat)
1690 : 0 : ctx->nr_stat++;
1691 : :
1692 : 0 : ctx->generation++;
1693 : 0 : }
1694 : :
1695 : : /*
1696 : : * Initialize event state based on the perf_event_attr::disabled.
1697 : : */
1698 : 0 : static inline void perf_event__state_init(struct perf_event *event)
1699 : : {
1700 : 0 : event->state = event->attr.disabled ? PERF_EVENT_STATE_OFF :
1701 : : PERF_EVENT_STATE_INACTIVE;
1702 : : }
1703 : :
1704 : 0 : static void __perf_event_read_size(struct perf_event *event, int nr_siblings)
1705 : : {
1706 : 0 : int entry = sizeof(u64); /* value */
1707 : 0 : int size = 0;
1708 : 0 : int nr = 1;
1709 : :
1710 : 0 : if (event->attr.read_format & PERF_FORMAT_TOTAL_TIME_ENABLED)
1711 : 0 : size += sizeof(u64);
1712 : :
1713 [ # # # # ]: 0 : if (event->attr.read_format & PERF_FORMAT_TOTAL_TIME_RUNNING)
1714 : 0 : size += sizeof(u64);
1715 : :
1716 [ # # # # ]: 0 : if (event->attr.read_format & PERF_FORMAT_ID)
1717 : 0 : entry += sizeof(u64);
1718 : :
1719 [ # # # # ]: 0 : if (event->attr.read_format & PERF_FORMAT_GROUP) {
1720 : 0 : nr += nr_siblings;
1721 : 0 : size += sizeof(u64);
1722 : : }
1723 : :
1724 : 0 : size += entry * nr;
1725 : 0 : event->read_size = size;
1726 : : }
1727 : :
1728 : : static void __perf_event_header_size(struct perf_event *event, u64 sample_type)
1729 : : {
1730 : : struct perf_sample_data *data;
1731 : : u16 size = 0;
1732 : :
1733 : : if (sample_type & PERF_SAMPLE_IP)
1734 : : size += sizeof(data->ip);
1735 : :
1736 : : if (sample_type & PERF_SAMPLE_ADDR)
1737 : : size += sizeof(data->addr);
1738 : :
1739 : : if (sample_type & PERF_SAMPLE_PERIOD)
1740 : : size += sizeof(data->period);
1741 : :
1742 : : if (sample_type & PERF_SAMPLE_WEIGHT)
1743 : : size += sizeof(data->weight);
1744 : :
1745 : : if (sample_type & PERF_SAMPLE_READ)
1746 : : size += event->read_size;
1747 : :
1748 : : if (sample_type & PERF_SAMPLE_DATA_SRC)
1749 : : size += sizeof(data->data_src.val);
1750 : :
1751 : : if (sample_type & PERF_SAMPLE_TRANSACTION)
1752 : : size += sizeof(data->txn);
1753 : :
1754 : : if (sample_type & PERF_SAMPLE_PHYS_ADDR)
1755 : : size += sizeof(data->phys_addr);
1756 : :
1757 : : event->header_size = size;
1758 : : }
1759 : :
1760 : : /*
1761 : : * Called at perf_event creation and when events are attached/detached from a
1762 : : * group.
1763 : : */
1764 : 0 : static void perf_event__header_size(struct perf_event *event)
1765 : : {
1766 : 0 : __perf_event_read_size(event,
1767 [ # # ]: 0 : event->group_leader->nr_siblings);
1768 : 0 : __perf_event_header_size(event, event->attr.sample_type);
1769 : 0 : }
1770 : :
1771 : : static void perf_event__id_header_size(struct perf_event *event)
1772 : : {
1773 : : struct perf_sample_data *data;
1774 : : u64 sample_type = event->attr.sample_type;
1775 : : u16 size = 0;
1776 : :
1777 : : if (sample_type & PERF_SAMPLE_TID)
1778 : : size += sizeof(data->tid_entry);
1779 : :
1780 : : if (sample_type & PERF_SAMPLE_TIME)
1781 : : size += sizeof(data->time);
1782 : :
1783 : : if (sample_type & PERF_SAMPLE_IDENTIFIER)
1784 : : size += sizeof(data->id);
1785 : :
1786 : : if (sample_type & PERF_SAMPLE_ID)
1787 : : size += sizeof(data->id);
1788 : :
1789 : : if (sample_type & PERF_SAMPLE_STREAM_ID)
1790 : : size += sizeof(data->stream_id);
1791 : :
1792 : : if (sample_type & PERF_SAMPLE_CPU)
1793 : : size += sizeof(data->cpu_entry);
1794 : :
1795 : : event->id_header_size = size;
1796 : : }
1797 : :
1798 : 0 : static bool perf_event_validate_size(struct perf_event *event)
1799 : : {
1800 : : /*
1801 : : * The values computed here will be over-written when we actually
1802 : : * attach the event.
1803 : : */
1804 [ # # ]: 0 : __perf_event_read_size(event, event->group_leader->nr_siblings + 1);
1805 : 0 : __perf_event_header_size(event, event->attr.sample_type & ~PERF_SAMPLE_READ);
1806 : 0 : perf_event__id_header_size(event);
1807 : :
1808 : : /*
1809 : : * Sum the lot; should not exceed the 64k limit we have on records.
1810 : : * Conservative limit to allow for callchains and other variable fields.
1811 : : */
1812 : 0 : if (event->read_size + event->header_size +
1813 [ # # ]: 0 : event->id_header_size + sizeof(struct perf_event_header) >= 16*1024)
1814 : 0 : return false;
1815 : :
1816 : : return true;
1817 : : }
1818 : :
1819 : 0 : static void perf_group_attach(struct perf_event *event)
1820 : : {
1821 : 0 : struct perf_event *group_leader = event->group_leader, *pos;
1822 : :
1823 : 0 : lockdep_assert_held(&event->ctx->lock);
1824 : :
1825 : : /*
1826 : : * We can have double attach due to group movement in perf_event_open.
1827 : : */
1828 [ # # ]: 0 : if (event->attach_state & PERF_ATTACH_GROUP)
1829 : : return;
1830 : :
1831 : 0 : event->attach_state |= PERF_ATTACH_GROUP;
1832 : :
1833 [ # # ]: 0 : if (group_leader == event)
1834 : : return;
1835 : :
1836 [ # # ]: 0 : WARN_ON_ONCE(group_leader->ctx != event->ctx);
1837 : :
1838 : 0 : group_leader->group_caps &= event->event_caps;
1839 : :
1840 : 0 : list_add_tail(&event->sibling_list, &group_leader->sibling_list);
1841 : 0 : group_leader->nr_siblings++;
1842 : :
1843 : 0 : perf_event__header_size(group_leader);
1844 : :
1845 [ # # # # ]: 0 : for_each_sibling_event(pos, group_leader)
1846 : 0 : perf_event__header_size(pos);
1847 : : }
1848 : :
1849 : : /*
1850 : : * Remove an event from the lists for its context.
1851 : : * Must be called with ctx->mutex and ctx->lock held.
1852 : : */
1853 : : static void
1854 : 0 : list_del_event(struct perf_event *event, struct perf_event_context *ctx)
1855 : : {
1856 [ # # ]: 0 : WARN_ON_ONCE(event->ctx != ctx);
1857 : 0 : lockdep_assert_held(&ctx->lock);
1858 : :
1859 : : /*
1860 : : * We can have double detach due to exit/hot-unplug + close.
1861 : : */
1862 [ # # ]: 0 : if (!(event->attach_state & PERF_ATTACH_CONTEXT))
1863 : : return;
1864 : :
1865 : 0 : event->attach_state &= ~PERF_ATTACH_CONTEXT;
1866 : :
1867 : 0 : list_update_cgroup_event(event, ctx, false);
1868 : :
1869 : 0 : ctx->nr_events--;
1870 [ # # ]: 0 : if (event->attr.inherit_stat)
1871 : 0 : ctx->nr_stat--;
1872 : :
1873 [ # # ]: 0 : list_del_rcu(&event->event_entry);
1874 : :
1875 [ # # ]: 0 : if (event->group_leader == event)
1876 [ # # ]: 0 : del_event_from_groups(event, ctx);
1877 : :
1878 : : /*
1879 : : * If event was in error state, then keep it
1880 : : * that way, otherwise bogus counts will be
1881 : : * returned on read(). The only way to get out
1882 : : * of error state is by explicit re-enabling
1883 : : * of the event
1884 : : */
1885 [ # # ]: 0 : if (event->state > PERF_EVENT_STATE_OFF)
1886 : 0 : perf_event_set_state(event, PERF_EVENT_STATE_OFF);
1887 : :
1888 : 0 : ctx->generation++;
1889 : : }
1890 : :
1891 : : static int
1892 : 0 : perf_aux_output_match(struct perf_event *event, struct perf_event *aux_event)
1893 : : {
1894 [ # # ]: 0 : if (!has_aux(aux_event))
1895 : : return 0;
1896 : :
1897 [ # # ]: 0 : if (!event->pmu->aux_output_match)
1898 : : return 0;
1899 : :
1900 : 0 : return event->pmu->aux_output_match(aux_event);
1901 : : }
1902 : :
1903 : : static void put_event(struct perf_event *event);
1904 : : static void event_sched_out(struct perf_event *event,
1905 : : struct perf_cpu_context *cpuctx,
1906 : : struct perf_event_context *ctx);
1907 : :
1908 : 0 : static void perf_put_aux_event(struct perf_event *event)
1909 : : {
1910 : 0 : struct perf_event_context *ctx = event->ctx;
1911 : 0 : struct perf_cpu_context *cpuctx = __get_cpu_context(ctx);
1912 : 0 : struct perf_event *iter;
1913 : :
1914 : : /*
1915 : : * If event uses aux_event tear down the link
1916 : : */
1917 [ # # ]: 0 : if (event->aux_event) {
1918 : 0 : iter = event->aux_event;
1919 : 0 : event->aux_event = NULL;
1920 : 0 : put_event(iter);
1921 : 0 : return;
1922 : : }
1923 : :
1924 : : /*
1925 : : * If the event is an aux_event, tear down all links to
1926 : : * it from other events.
1927 : : */
1928 [ # # # # ]: 0 : for_each_sibling_event(iter, event->group_leader) {
1929 [ # # ]: 0 : if (iter->aux_event != event)
1930 : 0 : continue;
1931 : :
1932 : 0 : iter->aux_event = NULL;
1933 : 0 : put_event(event);
1934 : :
1935 : : /*
1936 : : * If it's ACTIVE, schedule it out and put it into ERROR
1937 : : * state so that we don't try to schedule it again. Note
1938 : : * that perf_event_enable() will clear the ERROR status.
1939 : : */
1940 : 0 : event_sched_out(iter, cpuctx, ctx);
1941 : 0 : perf_event_set_state(event, PERF_EVENT_STATE_ERROR);
1942 : : }
1943 : : }
1944 : :
1945 : 0 : static bool perf_need_aux_event(struct perf_event *event)
1946 : : {
1947 [ # # ]: 0 : return !!event->attr.aux_output || !!event->attr.aux_sample_size;
1948 : : }
1949 : :
1950 : 0 : static int perf_get_aux_event(struct perf_event *event,
1951 : : struct perf_event *group_leader)
1952 : : {
1953 : : /*
1954 : : * Our group leader must be an aux event if we want to be
1955 : : * an aux_output. This way, the aux event will precede its
1956 : : * aux_output events in the group, and therefore will always
1957 : : * schedule first.
1958 : : */
1959 [ # # ]: 0 : if (!group_leader)
1960 : : return 0;
1961 : :
1962 : : /*
1963 : : * aux_output and aux_sample_size are mutually exclusive.
1964 : : */
1965 [ # # # # ]: 0 : if (event->attr.aux_output && event->attr.aux_sample_size)
1966 : : return 0;
1967 : :
1968 [ # # # # ]: 0 : if (event->attr.aux_output &&
1969 : : !perf_aux_output_match(event, group_leader))
1970 : 0 : return 0;
1971 : :
1972 [ # # # # ]: 0 : if (event->attr.aux_sample_size && !group_leader->pmu->snapshot_aux)
1973 : : return 0;
1974 : :
1975 [ # # ]: 0 : if (!atomic_long_inc_not_zero(&group_leader->refcount))
1976 : : return 0;
1977 : :
1978 : : /*
1979 : : * Link aux_outputs to their aux event; this is undone in
1980 : : * perf_group_detach() by perf_put_aux_event(). When the
1981 : : * group in torn down, the aux_output events loose their
1982 : : * link to the aux_event and can't schedule any more.
1983 : : */
1984 : 0 : event->aux_event = group_leader;
1985 : :
1986 : 0 : return 1;
1987 : : }
1988 : :
1989 : 0 : static void perf_group_detach(struct perf_event *event)
1990 : : {
1991 : 0 : struct perf_event *sibling, *tmp;
1992 : 0 : struct perf_event_context *ctx = event->ctx;
1993 : :
1994 : 0 : lockdep_assert_held(&ctx->lock);
1995 : :
1996 : : /*
1997 : : * We can have double detach due to exit/hot-unplug + close.
1998 : : */
1999 [ # # ]: 0 : if (!(event->attach_state & PERF_ATTACH_GROUP))
2000 : : return;
2001 : :
2002 : 0 : event->attach_state &= ~PERF_ATTACH_GROUP;
2003 : :
2004 : 0 : perf_put_aux_event(event);
2005 : :
2006 : : /*
2007 : : * If this is a sibling, remove it from its group.
2008 : : */
2009 [ # # ]: 0 : if (event->group_leader != event) {
2010 : 0 : list_del_init(&event->sibling_list);
2011 : 0 : event->group_leader->nr_siblings--;
2012 : 0 : goto out;
2013 : : }
2014 : :
2015 : : /*
2016 : : * If this was a group event with sibling events then
2017 : : * upgrade the siblings to singleton events by adding them
2018 : : * to whatever list we are on.
2019 : : */
2020 [ # # ]: 0 : list_for_each_entry_safe(sibling, tmp, &event->sibling_list, sibling_list) {
2021 : :
2022 : 0 : sibling->group_leader = sibling;
2023 [ # # ]: 0 : list_del_init(&sibling->sibling_list);
2024 : :
2025 : : /* Inherit group flags from the previous leader */
2026 : 0 : sibling->group_caps = event->group_caps;
2027 : :
2028 [ # # ]: 0 : if (!RB_EMPTY_NODE(&event->group_node)) {
2029 [ # # ]: 0 : add_event_to_groups(sibling, event->ctx);
2030 : :
2031 [ # # ]: 0 : if (sibling->state == PERF_EVENT_STATE_ACTIVE) {
2032 : 0 : struct list_head *list = sibling->attr.pinned ?
2033 [ # # ]: 0 : &ctx->pinned_active : &ctx->flexible_active;
2034 : :
2035 : 0 : list_add_tail(&sibling->active_list, list);
2036 : : }
2037 : : }
2038 : :
2039 [ # # ]: 0 : WARN_ON_ONCE(sibling->ctx != event->ctx);
2040 : : }
2041 : :
2042 : 0 : out:
2043 : 0 : perf_event__header_size(event->group_leader);
2044 : :
2045 [ # # # # ]: 0 : for_each_sibling_event(tmp, event->group_leader)
2046 : 0 : perf_event__header_size(tmp);
2047 : : }
2048 : :
2049 : : static bool is_orphaned_event(struct perf_event *event)
2050 : : {
2051 : : return event->state == PERF_EVENT_STATE_DEAD;
2052 : : }
2053 : :
2054 : 0 : static inline int __pmu_filter_match(struct perf_event *event)
2055 : : {
2056 : 0 : struct pmu *pmu = event->pmu;
2057 : 0 : return pmu->filter_match ? pmu->filter_match(event) : 1;
2058 : : }
2059 : :
2060 : : /*
2061 : : * Check whether we should attempt to schedule an event group based on
2062 : : * PMU-specific filtering. An event group can consist of HW and SW events,
2063 : : * potentially with a SW leader, so we must check all the filters, to
2064 : : * determine whether a group is schedulable:
2065 : : */
2066 : 0 : static inline int pmu_filter_match(struct perf_event *event)
2067 : : {
2068 : 0 : struct perf_event *sibling;
2069 : :
2070 [ # # # # ]: 0 : if (!__pmu_filter_match(event))
2071 : : return 0;
2072 : :
2073 [ # # # # ]: 0 : for_each_sibling_event(sibling, event) {
2074 [ # # # # ]: 0 : if (!__pmu_filter_match(sibling))
2075 : : return 0;
2076 : : }
2077 : :
2078 : : return 1;
2079 : : }
2080 : :
2081 : : static inline int
2082 : 0 : event_filter_match(struct perf_event *event)
2083 : : {
2084 [ # # ]: 0 : return (event->cpu == -1 || event->cpu == smp_processor_id()) &&
2085 [ # # # # ]: 0 : perf_cgroup_match(event) && pmu_filter_match(event);
2086 : : }
2087 : :
2088 : : static void
2089 : : event_sched_out(struct perf_event *event,
2090 : : struct perf_cpu_context *cpuctx,
2091 : : struct perf_event_context *ctx)
2092 : : {
2093 : : enum perf_event_state state = PERF_EVENT_STATE_INACTIVE;
2094 : :
2095 : : WARN_ON_ONCE(event->ctx != ctx);
2096 : : lockdep_assert_held(&ctx->lock);
2097 : :
2098 : : if (event->state != PERF_EVENT_STATE_ACTIVE)
2099 : : return;
2100 : :
2101 : : /*
2102 : : * Asymmetry; we only schedule events _IN_ through ctx_sched_in(), but
2103 : : * we can schedule events _OUT_ individually through things like
2104 : : * __perf_remove_from_context().
2105 : : */
2106 : : list_del_init(&event->active_list);
2107 : :
2108 : : perf_pmu_disable(event->pmu);
2109 : :
2110 : : event->pmu->del(event, 0);
2111 : : event->oncpu = -1;
2112 : :
2113 : : if (READ_ONCE(event->pending_disable) >= 0) {
2114 : : WRITE_ONCE(event->pending_disable, -1);
2115 : : state = PERF_EVENT_STATE_OFF;
2116 : : }
2117 : : perf_event_set_state(event, state);
2118 : :
2119 : : if (!is_software_event(event))
2120 : : cpuctx->active_oncpu--;
2121 : : if (!--ctx->nr_active)
2122 : : perf_event_ctx_deactivate(ctx);
2123 : : if (event->attr.freq && event->attr.sample_freq)
2124 : : ctx->nr_freq--;
2125 : : if (event->attr.exclusive || !cpuctx->active_oncpu)
2126 : : cpuctx->exclusive = 0;
2127 : :
2128 : : perf_pmu_enable(event->pmu);
2129 : : }
2130 : :
2131 : : static void
2132 : 0 : group_sched_out(struct perf_event *group_event,
2133 : : struct perf_cpu_context *cpuctx,
2134 : : struct perf_event_context *ctx)
2135 : : {
2136 : 0 : struct perf_event *event;
2137 : :
2138 [ # # ]: 0 : if (group_event->state != PERF_EVENT_STATE_ACTIVE)
2139 : : return;
2140 : :
2141 : 0 : perf_pmu_disable(ctx->pmu);
2142 : :
2143 : 0 : event_sched_out(group_event, cpuctx, ctx);
2144 : :
2145 : : /*
2146 : : * Schedule out siblings (if any):
2147 : : */
2148 [ # # # # ]: 0 : for_each_sibling_event(event, group_event)
2149 : 0 : event_sched_out(event, cpuctx, ctx);
2150 : :
2151 : 0 : perf_pmu_enable(ctx->pmu);
2152 : :
2153 [ # # ]: 0 : if (group_event->attr.exclusive)
2154 : 0 : cpuctx->exclusive = 0;
2155 : : }
2156 : :
2157 : : #define DETACH_GROUP 0x01UL
2158 : :
2159 : : /*
2160 : : * Cross CPU call to remove a performance event
2161 : : *
2162 : : * We disable the event on the hardware level first. After that we
2163 : : * remove it from the context list.
2164 : : */
2165 : : static void
2166 : 0 : __perf_remove_from_context(struct perf_event *event,
2167 : : struct perf_cpu_context *cpuctx,
2168 : : struct perf_event_context *ctx,
2169 : : void *info)
2170 : : {
2171 : 0 : unsigned long flags = (unsigned long)info;
2172 : :
2173 [ # # ]: 0 : if (ctx->is_active & EVENT_TIME) {
2174 : 0 : update_context_time(ctx);
2175 : : update_cgrp_time_from_cpuctx(cpuctx);
2176 : : }
2177 : :
2178 : 0 : event_sched_out(event, cpuctx, ctx);
2179 [ # # ]: 0 : if (flags & DETACH_GROUP)
2180 : 0 : perf_group_detach(event);
2181 : 0 : list_del_event(event, ctx);
2182 : :
2183 [ # # # # ]: 0 : if (!ctx->nr_events && ctx->is_active) {
2184 : 0 : ctx->is_active = 0;
2185 [ # # ]: 0 : if (ctx->task) {
2186 [ # # ]: 0 : WARN_ON_ONCE(cpuctx->task_ctx != ctx);
2187 : 0 : cpuctx->task_ctx = NULL;
2188 : : }
2189 : : }
2190 : 0 : }
2191 : :
2192 : : /*
2193 : : * Remove the event from a task's (or a CPU's) list of events.
2194 : : *
2195 : : * If event->ctx is a cloned context, callers must make sure that
2196 : : * every task struct that event->ctx->task could possibly point to
2197 : : * remains valid. This is OK when called from perf_release since
2198 : : * that only calls us on the top-level context, which can't be a clone.
2199 : : * When called from perf_event_exit_task, it's OK because the
2200 : : * context has been detached from its task.
2201 : : */
2202 : 0 : static void perf_remove_from_context(struct perf_event *event, unsigned long flags)
2203 : : {
2204 : 0 : struct perf_event_context *ctx = event->ctx;
2205 : :
2206 : 0 : lockdep_assert_held(&ctx->mutex);
2207 : :
2208 : 0 : event_function_call(event, __perf_remove_from_context, (void *)flags);
2209 : :
2210 : : /*
2211 : : * The above event_function_call() can NO-OP when it hits
2212 : : * TASK_TOMBSTONE. In that case we must already have been detached
2213 : : * from the context (by perf_event_exit_event()) but the grouping
2214 : : * might still be in-tact.
2215 : : */
2216 [ # # ]: 0 : WARN_ON_ONCE(event->attach_state & PERF_ATTACH_CONTEXT);
2217 [ # # ]: 0 : if ((flags & DETACH_GROUP) &&
2218 [ # # ]: 0 : (event->attach_state & PERF_ATTACH_GROUP)) {
2219 : : /*
2220 : : * Since in that case we cannot possibly be scheduled, simply
2221 : : * detach now.
2222 : : */
2223 : 0 : raw_spin_lock_irq(&ctx->lock);
2224 : 0 : perf_group_detach(event);
2225 : 0 : raw_spin_unlock_irq(&ctx->lock);
2226 : : }
2227 : 0 : }
2228 : :
2229 : : /*
2230 : : * Cross CPU call to disable a performance event
2231 : : */
2232 : 0 : static void __perf_event_disable(struct perf_event *event,
2233 : : struct perf_cpu_context *cpuctx,
2234 : : struct perf_event_context *ctx,
2235 : : void *info)
2236 : : {
2237 [ # # ]: 0 : if (event->state < PERF_EVENT_STATE_INACTIVE)
2238 : : return;
2239 : :
2240 [ # # ]: 0 : if (ctx->is_active & EVENT_TIME) {
2241 : 0 : update_context_time(ctx);
2242 : : update_cgrp_time_from_event(event);
2243 : : }
2244 : :
2245 [ # # ]: 0 : if (event == event->group_leader)
2246 : 0 : group_sched_out(event, cpuctx, ctx);
2247 : : else
2248 : 0 : event_sched_out(event, cpuctx, ctx);
2249 : :
2250 : 0 : perf_event_set_state(event, PERF_EVENT_STATE_OFF);
2251 : : }
2252 : :
2253 : : /*
2254 : : * Disable an event.
2255 : : *
2256 : : * If event->ctx is a cloned context, callers must make sure that
2257 : : * every task struct that event->ctx->task could possibly point to
2258 : : * remains valid. This condition is satisfied when called through
2259 : : * perf_event_for_each_child or perf_event_for_each because they
2260 : : * hold the top-level event's child_mutex, so any descendant that
2261 : : * goes to exit will block in perf_event_exit_event().
2262 : : *
2263 : : * When called from perf_pending_event it's OK because event->ctx
2264 : : * is the current context on this CPU and preemption is disabled,
2265 : : * hence we can't get into perf_event_task_sched_out for this context.
2266 : : */
2267 : 0 : static void _perf_event_disable(struct perf_event *event)
2268 : : {
2269 : 0 : struct perf_event_context *ctx = event->ctx;
2270 : :
2271 : 0 : raw_spin_lock_irq(&ctx->lock);
2272 [ # # ]: 0 : if (event->state <= PERF_EVENT_STATE_OFF) {
2273 : 0 : raw_spin_unlock_irq(&ctx->lock);
2274 : 0 : return;
2275 : : }
2276 : 0 : raw_spin_unlock_irq(&ctx->lock);
2277 : :
2278 : 0 : event_function_call(event, __perf_event_disable, NULL);
2279 : : }
2280 : :
2281 : 0 : void perf_event_disable_local(struct perf_event *event)
2282 : : {
2283 : 0 : event_function_local(event, __perf_event_disable, NULL);
2284 : 0 : }
2285 : :
2286 : : /*
2287 : : * Strictly speaking kernel users cannot create groups and therefore this
2288 : : * interface does not need the perf_event_ctx_lock() magic.
2289 : : */
2290 : 0 : void perf_event_disable(struct perf_event *event)
2291 : : {
2292 : 0 : struct perf_event_context *ctx;
2293 : :
2294 : 0 : ctx = perf_event_ctx_lock(event);
2295 : 0 : _perf_event_disable(event);
2296 : 0 : perf_event_ctx_unlock(event, ctx);
2297 : 0 : }
2298 : : EXPORT_SYMBOL_GPL(perf_event_disable);
2299 : :
2300 : 0 : void perf_event_disable_inatomic(struct perf_event *event)
2301 : : {
2302 : 0 : WRITE_ONCE(event->pending_disable, smp_processor_id());
2303 : : /* can fail, see perf_pending_event_disable() */
2304 : 0 : irq_work_queue(&event->pending);
2305 : 0 : }
2306 : :
2307 : : static void perf_set_shadow_time(struct perf_event *event,
2308 : : struct perf_event_context *ctx)
2309 : : {
2310 : : /*
2311 : : * use the correct time source for the time snapshot
2312 : : *
2313 : : * We could get by without this by leveraging the
2314 : : * fact that to get to this function, the caller
2315 : : * has most likely already called update_context_time()
2316 : : * and update_cgrp_time_xx() and thus both timestamp
2317 : : * are identical (or very close). Given that tstamp is,
2318 : : * already adjusted for cgroup, we could say that:
2319 : : * tstamp - ctx->timestamp
2320 : : * is equivalent to
2321 : : * tstamp - cgrp->timestamp.
2322 : : *
2323 : : * Then, in perf_output_read(), the calculation would
2324 : : * work with no changes because:
2325 : : * - event is guaranteed scheduled in
2326 : : * - no scheduled out in between
2327 : : * - thus the timestamp would be the same
2328 : : *
2329 : : * But this is a bit hairy.
2330 : : *
2331 : : * So instead, we have an explicit cgroup call to remain
2332 : : * within the time time source all along. We believe it
2333 : : * is cleaner and simpler to understand.
2334 : : */
2335 : : if (is_cgroup_event(event))
2336 : : perf_cgroup_set_shadow_time(event, event->tstamp);
2337 : : else
2338 : : event->shadow_ctx_time = event->tstamp - ctx->timestamp;
2339 : : }
2340 : :
2341 : : #define MAX_INTERRUPTS (~0ULL)
2342 : :
2343 : : static void perf_log_throttle(struct perf_event *event, int enable);
2344 : : static void perf_log_itrace_start(struct perf_event *event);
2345 : :
2346 : : static int
2347 : : event_sched_in(struct perf_event *event,
2348 : : struct perf_cpu_context *cpuctx,
2349 : : struct perf_event_context *ctx)
2350 : : {
2351 : : int ret = 0;
2352 : :
2353 : : lockdep_assert_held(&ctx->lock);
2354 : :
2355 : : if (event->state <= PERF_EVENT_STATE_OFF)
2356 : : return 0;
2357 : :
2358 : : WRITE_ONCE(event->oncpu, smp_processor_id());
2359 : : /*
2360 : : * Order event::oncpu write to happen before the ACTIVE state is
2361 : : * visible. This allows perf_event_{stop,read}() to observe the correct
2362 : : * ->oncpu if it sees ACTIVE.
2363 : : */
2364 : : smp_wmb();
2365 : : perf_event_set_state(event, PERF_EVENT_STATE_ACTIVE);
2366 : :
2367 : : /*
2368 : : * Unthrottle events, since we scheduled we might have missed several
2369 : : * ticks already, also for a heavily scheduling task there is little
2370 : : * guarantee it'll get a tick in a timely manner.
2371 : : */
2372 : : if (unlikely(event->hw.interrupts == MAX_INTERRUPTS)) {
2373 : : perf_log_throttle(event, 1);
2374 : : event->hw.interrupts = 0;
2375 : : }
2376 : :
2377 : : perf_pmu_disable(event->pmu);
2378 : :
2379 : : perf_set_shadow_time(event, ctx);
2380 : :
2381 : : perf_log_itrace_start(event);
2382 : :
2383 : : if (event->pmu->add(event, PERF_EF_START)) {
2384 : : perf_event_set_state(event, PERF_EVENT_STATE_INACTIVE);
2385 : : event->oncpu = -1;
2386 : : ret = -EAGAIN;
2387 : : goto out;
2388 : : }
2389 : :
2390 : : if (!is_software_event(event))
2391 : : cpuctx->active_oncpu++;
2392 : : if (!ctx->nr_active++)
2393 : : perf_event_ctx_activate(ctx);
2394 : : if (event->attr.freq && event->attr.sample_freq)
2395 : : ctx->nr_freq++;
2396 : :
2397 : : if (event->attr.exclusive)
2398 : : cpuctx->exclusive = 1;
2399 : :
2400 : : out:
2401 : : perf_pmu_enable(event->pmu);
2402 : :
2403 : : return ret;
2404 : : }
2405 : :
2406 : : static int
2407 : 0 : group_sched_in(struct perf_event *group_event,
2408 : : struct perf_cpu_context *cpuctx,
2409 : : struct perf_event_context *ctx)
2410 : : {
2411 : 0 : struct perf_event *event, *partial_group = NULL;
2412 : 0 : struct pmu *pmu = ctx->pmu;
2413 : :
2414 [ # # ]: 0 : if (group_event->state == PERF_EVENT_STATE_OFF)
2415 : : return 0;
2416 : :
2417 : 0 : pmu->start_txn(pmu, PERF_PMU_TXN_ADD);
2418 : :
2419 [ # # ]: 0 : if (event_sched_in(group_event, cpuctx, ctx)) {
2420 : 0 : pmu->cancel_txn(pmu);
2421 : 0 : perf_mux_hrtimer_restart(cpuctx);
2422 : 0 : return -EAGAIN;
2423 : : }
2424 : :
2425 : : /*
2426 : : * Schedule in siblings as one group (if any):
2427 : : */
2428 [ # # # # ]: 0 : for_each_sibling_event(event, group_event) {
2429 [ # # ]: 0 : if (event_sched_in(event, cpuctx, ctx)) {
2430 : 0 : partial_group = event;
2431 : 0 : goto group_error;
2432 : : }
2433 : : }
2434 : :
2435 [ # # ]: 0 : if (!pmu->commit_txn(pmu))
2436 : : return 0;
2437 : :
2438 : 0 : group_error:
2439 : : /*
2440 : : * Groups can be scheduled in as one unit only, so undo any
2441 : : * partial group before returning:
2442 : : * The events up to the failed event are scheduled out normally.
2443 : : */
2444 [ # # # # ]: 0 : for_each_sibling_event(event, group_event) {
2445 [ # # ]: 0 : if (event == partial_group)
2446 : : break;
2447 : :
2448 : 0 : event_sched_out(event, cpuctx, ctx);
2449 : : }
2450 : 0 : event_sched_out(group_event, cpuctx, ctx);
2451 : :
2452 : 0 : pmu->cancel_txn(pmu);
2453 : :
2454 : 0 : perf_mux_hrtimer_restart(cpuctx);
2455 : :
2456 : 0 : return -EAGAIN;
2457 : : }
2458 : :
2459 : : /*
2460 : : * Work out whether we can put this event group on the CPU now.
2461 : : */
2462 : 0 : static int group_can_go_on(struct perf_event *event,
2463 : : struct perf_cpu_context *cpuctx,
2464 : : int can_add_hw)
2465 : : {
2466 : : /*
2467 : : * Groups consisting entirely of software events can always go on.
2468 : : */
2469 : 0 : if (event->group_caps & PERF_EV_CAP_SOFTWARE)
2470 : : return 1;
2471 : : /*
2472 : : * If an exclusive group is already on, no other hardware
2473 : : * events can go on.
2474 : : */
2475 [ # # # # ]: 0 : if (cpuctx->exclusive)
2476 : : return 0;
2477 : : /*
2478 : : * If this group is exclusive and there are already
2479 : : * events on the CPU, it can't go on.
2480 : : */
2481 [ # # # # : 0 : if (event->attr.exclusive && cpuctx->active_oncpu)
# # # # ]
2482 : : return 0;
2483 : : /*
2484 : : * Otherwise, try to add it if all previous groups were able
2485 : : * to go on.
2486 : : */
2487 : : return can_add_hw;
2488 : : }
2489 : :
2490 : 0 : static void add_event_to_ctx(struct perf_event *event,
2491 : : struct perf_event_context *ctx)
2492 : : {
2493 : 0 : list_add_event(event, ctx);
2494 : 0 : perf_group_attach(event);
2495 : 0 : }
2496 : :
2497 : : static void ctx_sched_out(struct perf_event_context *ctx,
2498 : : struct perf_cpu_context *cpuctx,
2499 : : enum event_type_t event_type);
2500 : : static void
2501 : : ctx_sched_in(struct perf_event_context *ctx,
2502 : : struct perf_cpu_context *cpuctx,
2503 : : enum event_type_t event_type,
2504 : : struct task_struct *task);
2505 : :
2506 : 0 : static void task_ctx_sched_out(struct perf_cpu_context *cpuctx,
2507 : : struct perf_event_context *ctx,
2508 : : enum event_type_t event_type)
2509 : : {
2510 [ # # ]: 0 : if (!cpuctx->task_ctx)
2511 : : return;
2512 : :
2513 [ # # # # ]: 0 : if (WARN_ON_ONCE(ctx != cpuctx->task_ctx))
2514 : : return;
2515 : :
2516 : 0 : ctx_sched_out(ctx, cpuctx, event_type);
2517 : : }
2518 : :
2519 : : static void perf_event_sched_in(struct perf_cpu_context *cpuctx,
2520 : : struct perf_event_context *ctx,
2521 : : struct task_struct *task)
2522 : : {
2523 : : cpu_ctx_sched_in(cpuctx, EVENT_PINNED, task);
2524 : : if (ctx)
2525 : : ctx_sched_in(ctx, cpuctx, EVENT_PINNED, task);
2526 : : cpu_ctx_sched_in(cpuctx, EVENT_FLEXIBLE, task);
2527 : : if (ctx)
2528 : : ctx_sched_in(ctx, cpuctx, EVENT_FLEXIBLE, task);
2529 : : }
2530 : :
2531 : : /*
2532 : : * We want to maintain the following priority of scheduling:
2533 : : * - CPU pinned (EVENT_CPU | EVENT_PINNED)
2534 : : * - task pinned (EVENT_PINNED)
2535 : : * - CPU flexible (EVENT_CPU | EVENT_FLEXIBLE)
2536 : : * - task flexible (EVENT_FLEXIBLE).
2537 : : *
2538 : : * In order to avoid unscheduling and scheduling back in everything every
2539 : : * time an event is added, only do it for the groups of equal priority and
2540 : : * below.
2541 : : *
2542 : : * This can be called after a batch operation on task events, in which case
2543 : : * event_type is a bit mask of the types of events involved. For CPU events,
2544 : : * event_type is only either EVENT_PINNED or EVENT_FLEXIBLE.
2545 : : */
2546 : 0 : static void ctx_resched(struct perf_cpu_context *cpuctx,
2547 : : struct perf_event_context *task_ctx,
2548 : : enum event_type_t event_type)
2549 : : {
2550 : 0 : enum event_type_t ctx_event_type;
2551 : 0 : bool cpu_event = !!(event_type & EVENT_CPU);
2552 : :
2553 : : /*
2554 : : * If pinned groups are involved, flexible groups also need to be
2555 : : * scheduled out.
2556 : : */
2557 [ # # ]: 0 : if (event_type & EVENT_PINNED)
2558 : 0 : event_type |= EVENT_FLEXIBLE;
2559 : :
2560 : 0 : ctx_event_type = event_type & EVENT_ALL;
2561 : :
2562 : 0 : perf_pmu_disable(cpuctx->ctx.pmu);
2563 [ # # ]: 0 : if (task_ctx)
2564 : 0 : task_ctx_sched_out(cpuctx, task_ctx, event_type);
2565 : :
2566 : : /*
2567 : : * Decide which cpu ctx groups to schedule out based on the types
2568 : : * of events that caused rescheduling:
2569 : : * - EVENT_CPU: schedule out corresponding groups;
2570 : : * - EVENT_PINNED task events: schedule out EVENT_FLEXIBLE groups;
2571 : : * - otherwise, do nothing more.
2572 : : */
2573 [ # # ]: 0 : if (cpu_event)
2574 : 0 : cpu_ctx_sched_out(cpuctx, ctx_event_type);
2575 [ # # ]: 0 : else if (ctx_event_type & EVENT_PINNED)
2576 : 0 : cpu_ctx_sched_out(cpuctx, EVENT_FLEXIBLE);
2577 : :
2578 : 0 : perf_event_sched_in(cpuctx, task_ctx, current);
2579 : 0 : perf_pmu_enable(cpuctx->ctx.pmu);
2580 : 0 : }
2581 : :
2582 : 0 : void perf_pmu_resched(struct pmu *pmu)
2583 : : {
2584 : 0 : struct perf_cpu_context *cpuctx = this_cpu_ptr(pmu->pmu_cpu_context);
2585 : 0 : struct perf_event_context *task_ctx = cpuctx->task_ctx;
2586 : :
2587 : 0 : perf_ctx_lock(cpuctx, task_ctx);
2588 : 0 : ctx_resched(cpuctx, task_ctx, EVENT_ALL|EVENT_CPU);
2589 [ # # ]: 0 : perf_ctx_unlock(cpuctx, task_ctx);
2590 : 0 : }
2591 : :
2592 : : /*
2593 : : * Cross CPU call to install and enable a performance event
2594 : : *
2595 : : * Very similar to remote_function() + event_function() but cannot assume that
2596 : : * things like ctx->is_active and cpuctx->task_ctx are set.
2597 : : */
2598 : 0 : static int __perf_install_in_context(void *info)
2599 : : {
2600 : 0 : struct perf_event *event = info;
2601 : 0 : struct perf_event_context *ctx = event->ctx;
2602 : 0 : struct perf_cpu_context *cpuctx = __get_cpu_context(ctx);
2603 : 0 : struct perf_event_context *task_ctx = cpuctx->task_ctx;
2604 : 0 : bool reprogram = true;
2605 : 0 : int ret = 0;
2606 : :
2607 : 0 : raw_spin_lock(&cpuctx->ctx.lock);
2608 [ # # ]: 0 : if (ctx->task) {
2609 : 0 : raw_spin_lock(&ctx->lock);
2610 : 0 : task_ctx = ctx;
2611 : :
2612 : 0 : reprogram = (ctx->task == current);
2613 : :
2614 : : /*
2615 : : * If the task is running, it must be running on this CPU,
2616 : : * otherwise we cannot reprogram things.
2617 : : *
2618 : : * If its not running, we don't care, ctx->lock will
2619 : : * serialize against it becoming runnable.
2620 : : */
2621 [ # # # # ]: 0 : if (task_curr(ctx->task) && !reprogram) {
2622 : 0 : ret = -ESRCH;
2623 : 0 : goto unlock;
2624 : : }
2625 : :
2626 [ # # # # : 0 : WARN_ON_ONCE(reprogram && cpuctx->task_ctx && cpuctx->task_ctx != ctx);
# # # # ]
2627 [ # # ]: 0 : } else if (task_ctx) {
2628 : 0 : raw_spin_lock(&task_ctx->lock);
2629 : : }
2630 : :
2631 : : #ifdef CONFIG_CGROUP_PERF
2632 : : if (is_cgroup_event(event)) {
2633 : : /*
2634 : : * If the current cgroup doesn't match the event's
2635 : : * cgroup, we should not try to schedule it.
2636 : : */
2637 : : struct perf_cgroup *cgrp = perf_cgroup_from_task(current, ctx);
2638 : : reprogram = cgroup_is_descendant(cgrp->css.cgroup,
2639 : : event->cgrp->css.cgroup);
2640 : : }
2641 : : #endif
2642 : :
2643 [ # # ]: 0 : if (reprogram) {
2644 : 0 : ctx_sched_out(ctx, cpuctx, EVENT_TIME);
2645 : 0 : add_event_to_ctx(event, ctx);
2646 [ # # ]: 0 : ctx_resched(cpuctx, task_ctx, get_event_type(event));
2647 : : } else {
2648 : 0 : add_event_to_ctx(event, ctx);
2649 : : }
2650 : :
2651 : 0 : unlock:
2652 [ # # ]: 0 : perf_ctx_unlock(cpuctx, task_ctx);
2653 : :
2654 : 0 : return ret;
2655 : : }
2656 : :
2657 : : static bool exclusive_event_installable(struct perf_event *event,
2658 : : struct perf_event_context *ctx);
2659 : :
2660 : : /*
2661 : : * Attach a performance event to a context.
2662 : : *
2663 : : * Very similar to event_function_call, see comment there.
2664 : : */
2665 : : static void
2666 : 0 : perf_install_in_context(struct perf_event_context *ctx,
2667 : : struct perf_event *event,
2668 : : int cpu)
2669 : : {
2670 : 0 : struct task_struct *task = READ_ONCE(ctx->task);
2671 : :
2672 : 0 : lockdep_assert_held(&ctx->mutex);
2673 : :
2674 [ # # ]: 0 : WARN_ON_ONCE(!exclusive_event_installable(event, ctx));
2675 : :
2676 [ # # ]: 0 : if (event->cpu != -1)
2677 : 0 : event->cpu = cpu;
2678 : :
2679 : : /*
2680 : : * Ensures that if we can observe event->ctx, both the event and ctx
2681 : : * will be 'complete'. See perf_iterate_sb_cpu().
2682 : : */
2683 [ # # ]: 0 : smp_store_release(&event->ctx, ctx);
2684 : :
2685 : : /*
2686 : : * perf_event_attr::disabled events will not run and can be initialized
2687 : : * without IPI. Except when this is the first event for the context, in
2688 : : * that case we need the magic of the IPI to set ctx->is_active.
2689 : : *
2690 : : * The IOC_ENABLE that is sure to follow the creation of a disabled
2691 : : * event will issue the IPI and reprogram the hardware.
2692 : : */
2693 [ # # # # : 0 : if (__perf_effective_state(event) == PERF_EVENT_STATE_OFF && ctx->nr_events) {
# # ]
2694 : 0 : raw_spin_lock_irq(&ctx->lock);
2695 [ # # ]: 0 : if (ctx->task == TASK_TOMBSTONE) {
2696 : 0 : raw_spin_unlock_irq(&ctx->lock);
2697 : 0 : return;
2698 : : }
2699 : 0 : add_event_to_ctx(event, ctx);
2700 : 0 : raw_spin_unlock_irq(&ctx->lock);
2701 : 0 : return;
2702 : : }
2703 : :
2704 [ # # ]: 0 : if (!task) {
2705 : 0 : cpu_function_call(cpu, __perf_install_in_context, event);
2706 : 0 : return;
2707 : : }
2708 : :
2709 : : /*
2710 : : * Should not happen, we validate the ctx is still alive before calling.
2711 : : */
2712 [ # # # # ]: 0 : if (WARN_ON_ONCE(task == TASK_TOMBSTONE))
2713 : : return;
2714 : :
2715 : : /*
2716 : : * Installing events is tricky because we cannot rely on ctx->is_active
2717 : : * to be set in case this is the nr_events 0 -> 1 transition.
2718 : : *
2719 : : * Instead we use task_curr(), which tells us if the task is running.
2720 : : * However, since we use task_curr() outside of rq::lock, we can race
2721 : : * against the actual state. This means the result can be wrong.
2722 : : *
2723 : : * If we get a false positive, we retry, this is harmless.
2724 : : *
2725 : : * If we get a false negative, things are complicated. If we are after
2726 : : * perf_event_context_sched_in() ctx::lock will serialize us, and the
2727 : : * value must be correct. If we're before, it doesn't matter since
2728 : : * perf_event_context_sched_in() will program the counter.
2729 : : *
2730 : : * However, this hinges on the remote context switch having observed
2731 : : * our task->perf_event_ctxp[] store, such that it will in fact take
2732 : : * ctx::lock in perf_event_context_sched_in().
2733 : : *
2734 : : * We do this by task_function_call(), if the IPI fails to hit the task
2735 : : * we know any future context switch of task must see the
2736 : : * perf_event_ctpx[] store.
2737 : : */
2738 : :
2739 : : /*
2740 : : * This smp_mb() orders the task->perf_event_ctxp[] store with the
2741 : : * task_cpu() load, such that if the IPI then does not find the task
2742 : : * running, a future context switch of that task must observe the
2743 : : * store.
2744 : : */
2745 : 0 : smp_mb();
2746 : 0 : again:
2747 [ # # ]: 0 : if (!task_function_call(task, __perf_install_in_context, event))
2748 : : return;
2749 : :
2750 : 0 : raw_spin_lock_irq(&ctx->lock);
2751 : 0 : task = ctx->task;
2752 [ # # # # ]: 0 : if (WARN_ON_ONCE(task == TASK_TOMBSTONE)) {
2753 : : /*
2754 : : * Cannot happen because we already checked above (which also
2755 : : * cannot happen), and we hold ctx->mutex, which serializes us
2756 : : * against perf_event_exit_task_context().
2757 : : */
2758 : 0 : raw_spin_unlock_irq(&ctx->lock);
2759 : 0 : return;
2760 : : }
2761 : : /*
2762 : : * If the task is not running, ctx->lock will avoid it becoming so,
2763 : : * thus we can safely install the event.
2764 : : */
2765 [ # # ]: 0 : if (task_curr(task)) {
2766 : 0 : raw_spin_unlock_irq(&ctx->lock);
2767 : 0 : goto again;
2768 : : }
2769 : 0 : add_event_to_ctx(event, ctx);
2770 : 0 : raw_spin_unlock_irq(&ctx->lock);
2771 : : }
2772 : :
2773 : : /*
2774 : : * Cross CPU call to enable a performance event
2775 : : */
2776 : 0 : static void __perf_event_enable(struct perf_event *event,
2777 : : struct perf_cpu_context *cpuctx,
2778 : : struct perf_event_context *ctx,
2779 : : void *info)
2780 : : {
2781 : 0 : struct perf_event *leader = event->group_leader;
2782 : 0 : struct perf_event_context *task_ctx;
2783 : :
2784 [ # # ]: 0 : if (event->state >= PERF_EVENT_STATE_INACTIVE ||
2785 : : event->state <= PERF_EVENT_STATE_ERROR)
2786 : : return;
2787 : :
2788 [ # # ]: 0 : if (ctx->is_active)
2789 : 0 : ctx_sched_out(ctx, cpuctx, EVENT_TIME);
2790 : :
2791 : 0 : perf_event_set_state(event, PERF_EVENT_STATE_INACTIVE);
2792 : :
2793 [ # # ]: 0 : if (!ctx->is_active)
2794 : : return;
2795 : :
2796 [ # # ]: 0 : if (!event_filter_match(event)) {
2797 : 0 : ctx_sched_in(ctx, cpuctx, EVENT_TIME, current);
2798 : 0 : return;
2799 : : }
2800 : :
2801 : : /*
2802 : : * If the event is in a group and isn't the group leader,
2803 : : * then don't put it on unless the group is on.
2804 : : */
2805 [ # # # # ]: 0 : if (leader != event && leader->state != PERF_EVENT_STATE_ACTIVE) {
2806 : 0 : ctx_sched_in(ctx, cpuctx, EVENT_TIME, current);
2807 : 0 : return;
2808 : : }
2809 : :
2810 : 0 : task_ctx = cpuctx->task_ctx;
2811 [ # # ]: 0 : if (ctx->task)
2812 [ # # ]: 0 : WARN_ON_ONCE(task_ctx != ctx);
2813 : :
2814 [ # # ]: 0 : ctx_resched(cpuctx, task_ctx, get_event_type(event));
2815 : : }
2816 : :
2817 : : /*
2818 : : * Enable an event.
2819 : : *
2820 : : * If event->ctx is a cloned context, callers must make sure that
2821 : : * every task struct that event->ctx->task could possibly point to
2822 : : * remains valid. This condition is satisfied when called through
2823 : : * perf_event_for_each_child or perf_event_for_each as described
2824 : : * for perf_event_disable.
2825 : : */
2826 : 0 : static void _perf_event_enable(struct perf_event *event)
2827 : : {
2828 : 0 : struct perf_event_context *ctx = event->ctx;
2829 : :
2830 : 0 : raw_spin_lock_irq(&ctx->lock);
2831 [ # # ]: 0 : if (event->state >= PERF_EVENT_STATE_INACTIVE ||
2832 : : event->state < PERF_EVENT_STATE_ERROR) {
2833 : 0 : raw_spin_unlock_irq(&ctx->lock);
2834 : 0 : return;
2835 : : }
2836 : :
2837 : : /*
2838 : : * If the event is in error state, clear that first.
2839 : : *
2840 : : * That way, if we see the event in error state below, we know that it
2841 : : * has gone back into error state, as distinct from the task having
2842 : : * been scheduled away before the cross-call arrived.
2843 : : */
2844 [ # # ]: 0 : if (event->state == PERF_EVENT_STATE_ERROR)
2845 : 0 : event->state = PERF_EVENT_STATE_OFF;
2846 : 0 : raw_spin_unlock_irq(&ctx->lock);
2847 : :
2848 : 0 : event_function_call(event, __perf_event_enable, NULL);
2849 : : }
2850 : :
2851 : : /*
2852 : : * See perf_event_disable();
2853 : : */
2854 : 0 : void perf_event_enable(struct perf_event *event)
2855 : : {
2856 : 0 : struct perf_event_context *ctx;
2857 : :
2858 : 0 : ctx = perf_event_ctx_lock(event);
2859 : 0 : _perf_event_enable(event);
2860 : 0 : perf_event_ctx_unlock(event, ctx);
2861 : 0 : }
2862 : : EXPORT_SYMBOL_GPL(perf_event_enable);
2863 : :
2864 : : struct stop_event_data {
2865 : : struct perf_event *event;
2866 : : unsigned int restart;
2867 : : };
2868 : :
2869 : 0 : static int __perf_event_stop(void *info)
2870 : : {
2871 : 0 : struct stop_event_data *sd = info;
2872 : 0 : struct perf_event *event = sd->event;
2873 : :
2874 : : /* if it's already INACTIVE, do nothing */
2875 [ # # ]: 0 : if (READ_ONCE(event->state) != PERF_EVENT_STATE_ACTIVE)
2876 : : return 0;
2877 : :
2878 : : /* matches smp_wmb() in event_sched_in() */
2879 : 0 : smp_rmb();
2880 : :
2881 : : /*
2882 : : * There is a window with interrupts enabled before we get here,
2883 : : * so we need to check again lest we try to stop another CPU's event.
2884 : : */
2885 [ # # ]: 0 : if (READ_ONCE(event->oncpu) != smp_processor_id())
2886 : : return -EAGAIN;
2887 : :
2888 : 0 : event->pmu->stop(event, PERF_EF_UPDATE);
2889 : :
2890 : : /*
2891 : : * May race with the actual stop (through perf_pmu_output_stop()),
2892 : : * but it is only used for events with AUX ring buffer, and such
2893 : : * events will refuse to restart because of rb::aux_mmap_count==0,
2894 : : * see comments in perf_aux_output_begin().
2895 : : *
2896 : : * Since this is happening on an event-local CPU, no trace is lost
2897 : : * while restarting.
2898 : : */
2899 [ # # ]: 0 : if (sd->restart)
2900 : 0 : event->pmu->start(event, 0);
2901 : :
2902 : : return 0;
2903 : : }
2904 : :
2905 : 0 : static int perf_event_stop(struct perf_event *event, int restart)
2906 : : {
2907 : 0 : struct stop_event_data sd = {
2908 : : .event = event,
2909 : : .restart = restart,
2910 : : };
2911 : 0 : int ret = 0;
2912 : :
2913 : 0 : do {
2914 [ # # ]: 0 : if (READ_ONCE(event->state) != PERF_EVENT_STATE_ACTIVE)
2915 : : return 0;
2916 : :
2917 : : /* matches smp_wmb() in event_sched_in() */
2918 : 0 : smp_rmb();
2919 : :
2920 : : /*
2921 : : * We only want to restart ACTIVE events, so if the event goes
2922 : : * inactive here (event->oncpu==-1), there's nothing more to do;
2923 : : * fall through with ret==-ENXIO.
2924 : : */
2925 : 0 : ret = cpu_function_call(READ_ONCE(event->oncpu),
2926 : : __perf_event_stop, &sd);
2927 [ # # ]: 0 : } while (ret == -EAGAIN);
2928 : :
2929 : : return ret;
2930 : : }
2931 : :
2932 : : /*
2933 : : * In order to contain the amount of racy and tricky in the address filter
2934 : : * configuration management, it is a two part process:
2935 : : *
2936 : : * (p1) when userspace mappings change as a result of (1) or (2) or (3) below,
2937 : : * we update the addresses of corresponding vmas in
2938 : : * event::addr_filter_ranges array and bump the event::addr_filters_gen;
2939 : : * (p2) when an event is scheduled in (pmu::add), it calls
2940 : : * perf_event_addr_filters_sync() which calls pmu::addr_filters_sync()
2941 : : * if the generation has changed since the previous call.
2942 : : *
2943 : : * If (p1) happens while the event is active, we restart it to force (p2).
2944 : : *
2945 : : * (1) perf_addr_filters_apply(): adjusting filters' offsets based on
2946 : : * pre-existing mappings, called once when new filters arrive via SET_FILTER
2947 : : * ioctl;
2948 : : * (2) perf_addr_filters_adjust(): adjusting filters' offsets based on newly
2949 : : * registered mapping, called for every new mmap(), with mm::mmap_sem down
2950 : : * for reading;
2951 : : * (3) perf_event_addr_filters_exec(): clearing filters' offsets in the process
2952 : : * of exec.
2953 : : */
2954 : 0 : void perf_event_addr_filters_sync(struct perf_event *event)
2955 : : {
2956 [ # # ]: 0 : struct perf_addr_filters_head *ifh = perf_event_addr_filters(event);
2957 : :
2958 [ # # ]: 0 : if (!has_addr_filter(event))
2959 : : return;
2960 : :
2961 : 0 : raw_spin_lock(&ifh->lock);
2962 [ # # ]: 0 : if (event->addr_filters_gen != event->hw.addr_filters_gen) {
2963 : 0 : event->pmu->addr_filters_sync(event);
2964 : 0 : event->hw.addr_filters_gen = event->addr_filters_gen;
2965 : : }
2966 : 0 : raw_spin_unlock(&ifh->lock);
2967 : : }
2968 : : EXPORT_SYMBOL_GPL(perf_event_addr_filters_sync);
2969 : :
2970 : 0 : static int _perf_event_refresh(struct perf_event *event, int refresh)
2971 : : {
2972 : : /*
2973 : : * not supported on inherited events
2974 : : */
2975 [ # # # # ]: 0 : if (event->attr.inherit || !is_sampling_event(event))
2976 : : return -EINVAL;
2977 : :
2978 : 0 : atomic_add(refresh, &event->event_limit);
2979 : 0 : _perf_event_enable(event);
2980 : :
2981 : 0 : return 0;
2982 : : }
2983 : :
2984 : : /*
2985 : : * See perf_event_disable()
2986 : : */
2987 : 0 : int perf_event_refresh(struct perf_event *event, int refresh)
2988 : : {
2989 : 0 : struct perf_event_context *ctx;
2990 : 0 : int ret;
2991 : :
2992 : 0 : ctx = perf_event_ctx_lock(event);
2993 : 0 : ret = _perf_event_refresh(event, refresh);
2994 : 0 : perf_event_ctx_unlock(event, ctx);
2995 : :
2996 : 0 : return ret;
2997 : : }
2998 : : EXPORT_SYMBOL_GPL(perf_event_refresh);
2999 : :
3000 : 0 : static int perf_event_modify_breakpoint(struct perf_event *bp,
3001 : : struct perf_event_attr *attr)
3002 : : {
3003 : 0 : int err;
3004 : :
3005 : 0 : _perf_event_disable(bp);
3006 : :
3007 : 0 : err = modify_user_hw_breakpoint_check(bp, attr, true);
3008 : :
3009 [ # # ]: 0 : if (!bp->attr.disabled)
3010 : 0 : _perf_event_enable(bp);
3011 : :
3012 : 0 : return err;
3013 : : }
3014 : :
3015 : 0 : static int perf_event_modify_attr(struct perf_event *event,
3016 : : struct perf_event_attr *attr)
3017 : : {
3018 : 0 : if (event->attr.type != attr->type)
3019 : : return -EINVAL;
3020 : :
3021 [ # # ]: 0 : switch (event->attr.type) {
3022 : 0 : case PERF_TYPE_BREAKPOINT:
3023 : 0 : return perf_event_modify_breakpoint(event, attr);
3024 : : default:
3025 : : /* Place holder for future additions. */
3026 : : return -EOPNOTSUPP;
3027 : : }
3028 : : }
3029 : :
3030 : 0 : static void ctx_sched_out(struct perf_event_context *ctx,
3031 : : struct perf_cpu_context *cpuctx,
3032 : : enum event_type_t event_type)
3033 : : {
3034 : 0 : struct perf_event *event, *tmp;
3035 : 0 : int is_active = ctx->is_active;
3036 : :
3037 : 0 : lockdep_assert_held(&ctx->lock);
3038 : :
3039 [ # # ]: 0 : if (likely(!ctx->nr_events)) {
3040 : : /*
3041 : : * See __perf_remove_from_context().
3042 : : */
3043 [ # # ]: 0 : WARN_ON_ONCE(ctx->is_active);
3044 [ # # ]: 0 : if (ctx->task)
3045 [ # # ]: 0 : WARN_ON_ONCE(cpuctx->task_ctx);
3046 : : return;
3047 : : }
3048 : :
3049 : 0 : ctx->is_active &= ~event_type;
3050 [ # # ]: 0 : if (!(ctx->is_active & EVENT_ALL))
3051 : 0 : ctx->is_active = 0;
3052 : :
3053 [ # # ]: 0 : if (ctx->task) {
3054 [ # # ]: 0 : WARN_ON_ONCE(cpuctx->task_ctx != ctx);
3055 [ # # ]: 0 : if (!ctx->is_active)
3056 : 0 : cpuctx->task_ctx = NULL;
3057 : : }
3058 : :
3059 : : /*
3060 : : * Always update time if it was set; not only when it changes.
3061 : : * Otherwise we can 'forget' to update time for any but the last
3062 : : * context we sched out. For example:
3063 : : *
3064 : : * ctx_sched_out(.event_type = EVENT_FLEXIBLE)
3065 : : * ctx_sched_out(.event_type = EVENT_PINNED)
3066 : : *
3067 : : * would only update time for the pinned events.
3068 : : */
3069 [ # # ]: 0 : if (is_active & EVENT_TIME) {
3070 : : /* update (and stop) ctx time */
3071 : 0 : update_context_time(ctx);
3072 : : update_cgrp_time_from_cpuctx(cpuctx);
3073 : : }
3074 : :
3075 : 0 : is_active ^= ctx->is_active; /* changed bits */
3076 : :
3077 [ # # # # ]: 0 : if (!ctx->nr_active || !(is_active & EVENT_ALL))
3078 : : return;
3079 : :
3080 : : /*
3081 : : * If we had been multiplexing, no rotations are necessary, now no events
3082 : : * are active.
3083 : : */
3084 : 0 : ctx->rotate_necessary = 0;
3085 : :
3086 : 0 : perf_pmu_disable(ctx->pmu);
3087 [ # # ]: 0 : if (is_active & EVENT_PINNED) {
3088 [ # # ]: 0 : list_for_each_entry_safe(event, tmp, &ctx->pinned_active, active_list)
3089 : 0 : group_sched_out(event, cpuctx, ctx);
3090 : : }
3091 : :
3092 [ # # ]: 0 : if (is_active & EVENT_FLEXIBLE) {
3093 [ # # ]: 0 : list_for_each_entry_safe(event, tmp, &ctx->flexible_active, active_list)
3094 : 0 : group_sched_out(event, cpuctx, ctx);
3095 : : }
3096 : 0 : perf_pmu_enable(ctx->pmu);
3097 : : }
3098 : :
3099 : : /*
3100 : : * Test whether two contexts are equivalent, i.e. whether they have both been
3101 : : * cloned from the same version of the same context.
3102 : : *
3103 : : * Equivalence is measured using a generation number in the context that is
3104 : : * incremented on each modification to it; see unclone_ctx(), list_add_event()
3105 : : * and list_del_event().
3106 : : */
3107 : 0 : static int context_equiv(struct perf_event_context *ctx1,
3108 : : struct perf_event_context *ctx2)
3109 : : {
3110 : 0 : lockdep_assert_held(&ctx1->lock);
3111 : 0 : lockdep_assert_held(&ctx2->lock);
3112 : :
3113 : : /* Pinning disables the swap optimization */
3114 [ # # # # ]: 0 : if (ctx1->pin_count || ctx2->pin_count)
3115 : : return 0;
3116 : :
3117 : : /* If ctx1 is the parent of ctx2 */
3118 [ # # # # ]: 0 : if (ctx1 == ctx2->parent_ctx && ctx1->generation == ctx2->parent_gen)
3119 : : return 1;
3120 : :
3121 : : /* If ctx2 is the parent of ctx1 */
3122 [ # # # # ]: 0 : if (ctx1->parent_ctx == ctx2 && ctx1->parent_gen == ctx2->generation)
3123 : : return 1;
3124 : :
3125 : : /*
3126 : : * If ctx1 and ctx2 have the same parent; we flatten the parent
3127 : : * hierarchy, see perf_event_init_context().
3128 : : */
3129 [ # # # # ]: 0 : if (ctx1->parent_ctx && ctx1->parent_ctx == ctx2->parent_ctx &&
3130 [ # # ]: 0 : ctx1->parent_gen == ctx2->parent_gen)
3131 : 0 : return 1;
3132 : :
3133 : : /* Unmatched */
3134 : : return 0;
3135 : : }
3136 : :
3137 : 0 : static void __perf_event_sync_stat(struct perf_event *event,
3138 : : struct perf_event *next_event)
3139 : : {
3140 : 0 : u64 value;
3141 : :
3142 [ # # ]: 0 : if (!event->attr.inherit_stat)
3143 : : return;
3144 : :
3145 : : /*
3146 : : * Update the event value, we cannot use perf_event_read()
3147 : : * because we're in the middle of a context switch and have IRQs
3148 : : * disabled, which upsets smp_call_function_single(), however
3149 : : * we know the event must be on the current CPU, therefore we
3150 : : * don't need to use it.
3151 : : */
3152 [ # # ]: 0 : if (event->state == PERF_EVENT_STATE_ACTIVE)
3153 : 0 : event->pmu->read(event);
3154 : :
3155 : 0 : perf_event_update_time(event);
3156 : :
3157 : : /*
3158 : : * In order to keep per-task stats reliable we need to flip the event
3159 : : * values when we flip the contexts.
3160 : : */
3161 : 0 : value = local64_read(&next_event->count);
3162 : 0 : value = local64_xchg(&event->count, value);
3163 : 0 : local64_set(&next_event->count, value);
3164 : :
3165 : 0 : swap(event->total_time_enabled, next_event->total_time_enabled);
3166 : 0 : swap(event->total_time_running, next_event->total_time_running);
3167 : :
3168 : : /*
3169 : : * Since we swizzled the values, update the user visible data too.
3170 : : */
3171 : 0 : perf_event_update_userpage(event);
3172 : 0 : perf_event_update_userpage(next_event);
3173 : : }
3174 : :
3175 : 0 : static void perf_event_sync_stat(struct perf_event_context *ctx,
3176 : : struct perf_event_context *next_ctx)
3177 : : {
3178 : 0 : struct perf_event *event, *next_event;
3179 : :
3180 [ # # ]: 0 : if (!ctx->nr_stat)
3181 : : return;
3182 : :
3183 : 0 : update_context_time(ctx);
3184 : :
3185 : 0 : event = list_first_entry(&ctx->event_list,
3186 : : struct perf_event, event_entry);
3187 : :
3188 : 0 : next_event = list_first_entry(&next_ctx->event_list,
3189 : : struct perf_event, event_entry);
3190 : :
3191 [ # # ]: 0 : while (&event->event_entry != &ctx->event_list &&
3192 [ # # ]: 0 : &next_event->event_entry != &next_ctx->event_list) {
3193 : :
3194 : 0 : __perf_event_sync_stat(event, next_event);
3195 : :
3196 : 0 : event = list_next_entry(event, event_entry);
3197 : 0 : next_event = list_next_entry(next_event, event_entry);
3198 : : }
3199 : : }
3200 : :
3201 : 0 : static void perf_event_context_sched_out(struct task_struct *task, int ctxn,
3202 : : struct task_struct *next)
3203 : : {
3204 : 0 : struct perf_event_context *ctx = task->perf_event_ctxp[ctxn];
3205 : 0 : struct perf_event_context *next_ctx;
3206 : 0 : struct perf_event_context *parent, *next_parent;
3207 : 0 : struct perf_cpu_context *cpuctx;
3208 : 0 : int do_switch = 1;
3209 : :
3210 [ # # ]: 0 : if (likely(!ctx))
3211 : : return;
3212 : :
3213 : 0 : cpuctx = __get_cpu_context(ctx);
3214 [ # # ]: 0 : if (!cpuctx->task_ctx)
3215 : : return;
3216 : :
3217 : 0 : rcu_read_lock();
3218 : 0 : next_ctx = next->perf_event_ctxp[ctxn];
3219 [ # # ]: 0 : if (!next_ctx)
3220 : 0 : goto unlock;
3221 : :
3222 [ # # ]: 0 : parent = rcu_dereference(ctx->parent_ctx);
3223 : 0 : next_parent = rcu_dereference(next_ctx->parent_ctx);
3224 : :
3225 : : /* If neither context have a parent context; they cannot be clones. */
3226 [ # # ]: 0 : if (!parent && !next_parent)
3227 : 0 : goto unlock;
3228 : :
3229 [ # # # # ]: 0 : if (next_parent == ctx || next_ctx == parent || next_parent == parent) {
3230 : : /*
3231 : : * Looks like the two contexts are clones, so we might be
3232 : : * able to optimize the context switch. We lock both
3233 : : * contexts and check that they are clones under the
3234 : : * lock (including re-checking that neither has been
3235 : : * uncloned in the meantime). It doesn't matter which
3236 : : * order we take the locks because no other cpu could
3237 : : * be trying to lock both of these tasks.
3238 : : */
3239 : 0 : raw_spin_lock(&ctx->lock);
3240 : 0 : raw_spin_lock_nested(&next_ctx->lock, SINGLE_DEPTH_NESTING);
3241 [ # # ]: 0 : if (context_equiv(ctx, next_ctx)) {
3242 : 0 : struct pmu *pmu = ctx->pmu;
3243 : :
3244 [ # # ]: 0 : WRITE_ONCE(ctx->task, next);
3245 : 0 : WRITE_ONCE(next_ctx->task, task);
3246 : :
3247 : : /*
3248 : : * PMU specific parts of task perf context can require
3249 : : * additional synchronization. As an example of such
3250 : : * synchronization see implementation details of Intel
3251 : : * LBR call stack data profiling;
3252 : : */
3253 [ # # ]: 0 : if (pmu->swap_task_ctx)
3254 : 0 : pmu->swap_task_ctx(ctx, next_ctx);
3255 : : else
3256 : 0 : swap(ctx->task_ctx_data, next_ctx->task_ctx_data);
3257 : :
3258 : : /*
3259 : : * RCU_INIT_POINTER here is safe because we've not
3260 : : * modified the ctx and the above modification of
3261 : : * ctx->task and ctx->task_ctx_data are immaterial
3262 : : * since those values are always verified under
3263 : : * ctx->lock which we're now holding.
3264 : : */
3265 : 0 : RCU_INIT_POINTER(task->perf_event_ctxp[ctxn], next_ctx);
3266 : 0 : RCU_INIT_POINTER(next->perf_event_ctxp[ctxn], ctx);
3267 : :
3268 : 0 : do_switch = 0;
3269 : :
3270 : 0 : perf_event_sync_stat(ctx, next_ctx);
3271 : : }
3272 : 0 : raw_spin_unlock(&next_ctx->lock);
3273 : 0 : raw_spin_unlock(&ctx->lock);
3274 : : }
3275 : 0 : unlock:
3276 : 0 : rcu_read_unlock();
3277 : :
3278 [ # # ]: 0 : if (do_switch) {
3279 : 0 : raw_spin_lock(&ctx->lock);
3280 : 0 : task_ctx_sched_out(cpuctx, ctx, EVENT_ALL);
3281 : 0 : raw_spin_unlock(&ctx->lock);
3282 : : }
3283 : : }
3284 : :
3285 : : static DEFINE_PER_CPU(struct list_head, sched_cb_list);
3286 : :
3287 : 0 : void perf_sched_cb_dec(struct pmu *pmu)
3288 : : {
3289 : 0 : struct perf_cpu_context *cpuctx = this_cpu_ptr(pmu->pmu_cpu_context);
3290 : :
3291 : 0 : this_cpu_dec(perf_sched_cb_usages);
3292 : :
3293 [ # # ]: 0 : if (!--cpuctx->sched_cb_usage)
3294 : 0 : list_del(&cpuctx->sched_cb_entry);
3295 : 0 : }
3296 : :
3297 : :
3298 : 0 : void perf_sched_cb_inc(struct pmu *pmu)
3299 : : {
3300 : 0 : struct perf_cpu_context *cpuctx = this_cpu_ptr(pmu->pmu_cpu_context);
3301 : :
3302 [ # # ]: 0 : if (!cpuctx->sched_cb_usage++)
3303 : 0 : list_add(&cpuctx->sched_cb_entry, this_cpu_ptr(&sched_cb_list));
3304 : :
3305 : 0 : this_cpu_inc(perf_sched_cb_usages);
3306 : 0 : }
3307 : :
3308 : : /*
3309 : : * This function provides the context switch callback to the lower code
3310 : : * layer. It is invoked ONLY when the context switch callback is enabled.
3311 : : *
3312 : : * This callback is relevant even to per-cpu events; for example multi event
3313 : : * PEBS requires this to provide PID/TID information. This requires we flush
3314 : : * all queued PEBS records before we context switch to a new task.
3315 : : */
3316 : 0 : static void perf_pmu_sched_task(struct task_struct *prev,
3317 : : struct task_struct *next,
3318 : : bool sched_in)
3319 : : {
3320 : 0 : struct perf_cpu_context *cpuctx;
3321 : 0 : struct pmu *pmu;
3322 : :
3323 [ # # ]: 0 : if (prev == next)
3324 : : return;
3325 : :
3326 [ # # ]: 0 : list_for_each_entry(cpuctx, this_cpu_ptr(&sched_cb_list), sched_cb_entry) {
3327 : 0 : pmu = cpuctx->ctx.pmu; /* software PMUs will not have sched_task */
3328 : :
3329 [ # # # # ]: 0 : if (WARN_ON_ONCE(!pmu->sched_task))
3330 : 0 : continue;
3331 : :
3332 : 0 : perf_ctx_lock(cpuctx, cpuctx->task_ctx);
3333 : 0 : perf_pmu_disable(pmu);
3334 : :
3335 : 0 : pmu->sched_task(cpuctx->task_ctx, sched_in);
3336 : :
3337 : 0 : perf_pmu_enable(pmu);
3338 [ # # ]: 0 : perf_ctx_unlock(cpuctx, cpuctx->task_ctx);
3339 : : }
3340 : : }
3341 : :
3342 : : static void perf_event_switch(struct task_struct *task,
3343 : : struct task_struct *next_prev, bool sched_in);
3344 : :
3345 : : #define for_each_task_context_nr(ctxn) \
3346 : : for ((ctxn) = 0; (ctxn) < perf_nr_task_contexts; (ctxn)++)
3347 : :
3348 : : /*
3349 : : * Called from scheduler to remove the events of the current task,
3350 : : * with interrupts disabled.
3351 : : *
3352 : : * We stop each event and update the event value in event->count.
3353 : : *
3354 : : * This does not protect us against NMI, but disable()
3355 : : * sets the disabled bit in the control field of event _before_
3356 : : * accessing the event control register. If a NMI hits, then it will
3357 : : * not restart the event.
3358 : : */
3359 : 0 : void __perf_event_task_sched_out(struct task_struct *task,
3360 : : struct task_struct *next)
3361 : : {
3362 : 0 : int ctxn;
3363 : :
3364 [ # # ]: 0 : if (__this_cpu_read(perf_sched_cb_usages))
3365 : 0 : perf_pmu_sched_task(task, next, false);
3366 : :
3367 [ # # ]: 0 : if (atomic_read(&nr_switch_events))
3368 : 0 : perf_event_switch(task, next, false);
3369 : :
3370 [ # # ]: 0 : for_each_task_context_nr(ctxn)
3371 : 0 : perf_event_context_sched_out(task, ctxn, next);
3372 : :
3373 : : /*
3374 : : * if cgroup events exist on this CPU, then we need
3375 : : * to check if we have to switch out PMU state.
3376 : : * cgroup event are system-wide mode only
3377 : : */
3378 : 0 : if (atomic_read(this_cpu_ptr(&perf_cgroup_events)))
3379 : : perf_cgroup_sched_out(task, next);
3380 : 0 : }
3381 : :
3382 : : /*
3383 : : * Called with IRQs disabled
3384 : : */
3385 : 0 : static void cpu_ctx_sched_out(struct perf_cpu_context *cpuctx,
3386 : : enum event_type_t event_type)
3387 : : {
3388 : 0 : ctx_sched_out(&cpuctx->ctx, cpuctx, event_type);
3389 : 0 : }
3390 : :
3391 : 0 : static int visit_groups_merge(struct perf_event_groups *groups, int cpu,
3392 : : int (*func)(struct perf_event *, void *), void *data)
3393 : : {
3394 : 0 : struct perf_event **evt, *evt1, *evt2;
3395 : 0 : int ret;
3396 : :
3397 : 0 : evt1 = perf_event_groups_first(groups, -1);
3398 : 0 : evt2 = perf_event_groups_first(groups, cpu);
3399 : :
3400 [ # # ]: 0 : while (evt1 || evt2) {
3401 [ # # ]: 0 : if (evt1 && evt2) {
3402 [ # # ]: 0 : if (evt1->group_index < evt2->group_index)
3403 : : evt = &evt1;
3404 : : else
3405 : 0 : evt = &evt2;
3406 [ # # ]: 0 : } else if (evt1) {
3407 : : evt = &evt1;
3408 : : } else {
3409 : 0 : evt = &evt2;
3410 : : }
3411 : :
3412 : 0 : ret = func(*evt, data);
3413 [ # # ]: 0 : if (ret)
3414 : 0 : return ret;
3415 : :
3416 : 0 : *evt = perf_event_groups_next(*evt);
3417 : : }
3418 : :
3419 : : return 0;
3420 : : }
3421 : :
3422 : : struct sched_in_data {
3423 : : struct perf_event_context *ctx;
3424 : : struct perf_cpu_context *cpuctx;
3425 : : int can_add_hw;
3426 : : };
3427 : :
3428 : 0 : static int pinned_sched_in(struct perf_event *event, void *data)
3429 : : {
3430 : 0 : struct sched_in_data *sid = data;
3431 : :
3432 [ # # ]: 0 : if (event->state <= PERF_EVENT_STATE_OFF)
3433 : : return 0;
3434 : :
3435 [ # # ]: 0 : if (!event_filter_match(event))
3436 : : return 0;
3437 : :
3438 [ # # # # ]: 0 : if (group_can_go_on(event, sid->cpuctx, sid->can_add_hw)) {
3439 [ # # ]: 0 : if (!group_sched_in(event, sid->cpuctx, sid->ctx))
3440 : 0 : list_add_tail(&event->active_list, &sid->ctx->pinned_active);
3441 : : }
3442 : :
3443 : : /*
3444 : : * If this pinned group hasn't been scheduled,
3445 : : * put it in error state.
3446 : : */
3447 [ # # ]: 0 : if (event->state == PERF_EVENT_STATE_INACTIVE)
3448 : 0 : perf_event_set_state(event, PERF_EVENT_STATE_ERROR);
3449 : :
3450 : : return 0;
3451 : : }
3452 : :
3453 : 0 : static int flexible_sched_in(struct perf_event *event, void *data)
3454 : : {
3455 : 0 : struct sched_in_data *sid = data;
3456 : :
3457 [ # # ]: 0 : if (event->state <= PERF_EVENT_STATE_OFF)
3458 : : return 0;
3459 : :
3460 [ # # ]: 0 : if (!event_filter_match(event))
3461 : : return 0;
3462 : :
3463 [ # # # # ]: 0 : if (group_can_go_on(event, sid->cpuctx, sid->can_add_hw)) {
3464 : 0 : int ret = group_sched_in(event, sid->cpuctx, sid->ctx);
3465 [ # # ]: 0 : if (ret) {
3466 : 0 : sid->can_add_hw = 0;
3467 : 0 : sid->ctx->rotate_necessary = 1;
3468 : 0 : return 0;
3469 : : }
3470 : 0 : list_add_tail(&event->active_list, &sid->ctx->flexible_active);
3471 : : }
3472 : :
3473 : : return 0;
3474 : : }
3475 : :
3476 : : static void
3477 : : ctx_pinned_sched_in(struct perf_event_context *ctx,
3478 : : struct perf_cpu_context *cpuctx)
3479 : : {
3480 : : struct sched_in_data sid = {
3481 : : .ctx = ctx,
3482 : : .cpuctx = cpuctx,
3483 : : .can_add_hw = 1,
3484 : : };
3485 : :
3486 : : visit_groups_merge(&ctx->pinned_groups,
3487 : : smp_processor_id(),
3488 : : pinned_sched_in, &sid);
3489 : : }
3490 : :
3491 : : static void
3492 : : ctx_flexible_sched_in(struct perf_event_context *ctx,
3493 : : struct perf_cpu_context *cpuctx)
3494 : : {
3495 : : struct sched_in_data sid = {
3496 : : .ctx = ctx,
3497 : : .cpuctx = cpuctx,
3498 : : .can_add_hw = 1,
3499 : : };
3500 : :
3501 : : visit_groups_merge(&ctx->flexible_groups,
3502 : : smp_processor_id(),
3503 : : flexible_sched_in, &sid);
3504 : : }
3505 : :
3506 : : static void
3507 : : ctx_sched_in(struct perf_event_context *ctx,
3508 : : struct perf_cpu_context *cpuctx,
3509 : : enum event_type_t event_type,
3510 : : struct task_struct *task)
3511 : : {
3512 : : int is_active = ctx->is_active;
3513 : : u64 now;
3514 : :
3515 : : lockdep_assert_held(&ctx->lock);
3516 : :
3517 : : if (likely(!ctx->nr_events))
3518 : : return;
3519 : :
3520 : : ctx->is_active |= (event_type | EVENT_TIME);
3521 : : if (ctx->task) {
3522 : : if (!is_active)
3523 : : cpuctx->task_ctx = ctx;
3524 : : else
3525 : : WARN_ON_ONCE(cpuctx->task_ctx != ctx);
3526 : : }
3527 : :
3528 : : is_active ^= ctx->is_active; /* changed bits */
3529 : :
3530 : : if (is_active & EVENT_TIME) {
3531 : : /* start ctx time */
3532 : : now = perf_clock();
3533 : : ctx->timestamp = now;
3534 : : perf_cgroup_set_timestamp(task, ctx);
3535 : : }
3536 : :
3537 : : /*
3538 : : * First go through the list and put on any pinned groups
3539 : : * in order to give them the best chance of going on.
3540 : : */
3541 : : if (is_active & EVENT_PINNED)
3542 : : ctx_pinned_sched_in(ctx, cpuctx);
3543 : :
3544 : : /* Then walk through the lower prio flexible groups */
3545 : : if (is_active & EVENT_FLEXIBLE)
3546 : : ctx_flexible_sched_in(ctx, cpuctx);
3547 : : }
3548 : :
3549 : : static void cpu_ctx_sched_in(struct perf_cpu_context *cpuctx,
3550 : : enum event_type_t event_type,
3551 : : struct task_struct *task)
3552 : : {
3553 : : struct perf_event_context *ctx = &cpuctx->ctx;
3554 : :
3555 : : ctx_sched_in(ctx, cpuctx, event_type, task);
3556 : : }
3557 : :
3558 : : static void perf_event_context_sched_in(struct perf_event_context *ctx,
3559 : : struct task_struct *task)
3560 : : {
3561 : : struct perf_cpu_context *cpuctx;
3562 : :
3563 : : cpuctx = __get_cpu_context(ctx);
3564 : : if (cpuctx->task_ctx == ctx)
3565 : : return;
3566 : :
3567 : : perf_ctx_lock(cpuctx, ctx);
3568 : : /*
3569 : : * We must check ctx->nr_events while holding ctx->lock, such
3570 : : * that we serialize against perf_install_in_context().
3571 : : */
3572 : : if (!ctx->nr_events)
3573 : : goto unlock;
3574 : :
3575 : : perf_pmu_disable(ctx->pmu);
3576 : : /*
3577 : : * We want to keep the following priority order:
3578 : : * cpu pinned (that don't need to move), task pinned,
3579 : : * cpu flexible, task flexible.
3580 : : *
3581 : : * However, if task's ctx is not carrying any pinned
3582 : : * events, no need to flip the cpuctx's events around.
3583 : : */
3584 : : if (!RB_EMPTY_ROOT(&ctx->pinned_groups.tree))
3585 : : cpu_ctx_sched_out(cpuctx, EVENT_FLEXIBLE);
3586 : : perf_event_sched_in(cpuctx, ctx, task);
3587 : : perf_pmu_enable(ctx->pmu);
3588 : :
3589 : : unlock:
3590 : : perf_ctx_unlock(cpuctx, ctx);
3591 : : }
3592 : :
3593 : : /*
3594 : : * Called from scheduler to add the events of the current task
3595 : : * with interrupts disabled.
3596 : : *
3597 : : * We restore the event value and then enable it.
3598 : : *
3599 : : * This does not protect us against NMI, but enable()
3600 : : * sets the enabled bit in the control field of event _before_
3601 : : * accessing the event control register. If a NMI hits, then it will
3602 : : * keep the event running.
3603 : : */
3604 : 0 : void __perf_event_task_sched_in(struct task_struct *prev,
3605 : : struct task_struct *task)
3606 : : {
3607 : 0 : struct perf_event_context *ctx;
3608 : 0 : int ctxn;
3609 : :
3610 : : /*
3611 : : * If cgroup events exist on this CPU, then we need to check if we have
3612 : : * to switch in PMU state; cgroup event are system-wide mode only.
3613 : : *
3614 : : * Since cgroup events are CPU events, we must schedule these in before
3615 : : * we schedule in the task events.
3616 : : */
3617 : 0 : if (atomic_read(this_cpu_ptr(&perf_cgroup_events)))
3618 : : perf_cgroup_sched_in(prev, task);
3619 : :
3620 [ # # ]: 0 : for_each_task_context_nr(ctxn) {
3621 : 0 : ctx = task->perf_event_ctxp[ctxn];
3622 [ # # ]: 0 : if (likely(!ctx))
3623 : 0 : continue;
3624 : :
3625 : 0 : perf_event_context_sched_in(ctx, task);
3626 : : }
3627 : :
3628 [ # # ]: 0 : if (atomic_read(&nr_switch_events))
3629 : 0 : perf_event_switch(task, prev, true);
3630 : :
3631 [ # # ]: 0 : if (__this_cpu_read(perf_sched_cb_usages))
3632 : 0 : perf_pmu_sched_task(prev, task, true);
3633 : 0 : }
3634 : :
3635 : : static u64 perf_calculate_period(struct perf_event *event, u64 nsec, u64 count)
3636 : : {
3637 : : u64 frequency = event->attr.sample_freq;
3638 : : u64 sec = NSEC_PER_SEC;
3639 : : u64 divisor, dividend;
3640 : :
3641 : : int count_fls, nsec_fls, frequency_fls, sec_fls;
3642 : :
3643 : : count_fls = fls64(count);
3644 : : nsec_fls = fls64(nsec);
3645 : : frequency_fls = fls64(frequency);
3646 : : sec_fls = 30;
3647 : :
3648 : : /*
3649 : : * We got @count in @nsec, with a target of sample_freq HZ
3650 : : * the target period becomes:
3651 : : *
3652 : : * @count * 10^9
3653 : : * period = -------------------
3654 : : * @nsec * sample_freq
3655 : : *
3656 : : */
3657 : :
3658 : : /*
3659 : : * Reduce accuracy by one bit such that @a and @b converge
3660 : : * to a similar magnitude.
3661 : : */
3662 : : #define REDUCE_FLS(a, b) \
3663 : : do { \
3664 : : if (a##_fls > b##_fls) { \
3665 : : a >>= 1; \
3666 : : a##_fls--; \
3667 : : } else { \
3668 : : b >>= 1; \
3669 : : b##_fls--; \
3670 : : } \
3671 : : } while (0)
3672 : :
3673 : : /*
3674 : : * Reduce accuracy until either term fits in a u64, then proceed with
3675 : : * the other, so that finally we can do a u64/u64 division.
3676 : : */
3677 : : while (count_fls + sec_fls > 64 && nsec_fls + frequency_fls > 64) {
3678 : : REDUCE_FLS(nsec, frequency);
3679 : : REDUCE_FLS(sec, count);
3680 : : }
3681 : :
3682 : : if (count_fls + sec_fls > 64) {
3683 : : divisor = nsec * frequency;
3684 : :
3685 : : while (count_fls + sec_fls > 64) {
3686 : : REDUCE_FLS(count, sec);
3687 : : divisor >>= 1;
3688 : : }
3689 : :
3690 : : dividend = count * sec;
3691 : : } else {
3692 : : dividend = count * sec;
3693 : :
3694 : : while (nsec_fls + frequency_fls > 64) {
3695 : : REDUCE_FLS(nsec, frequency);
3696 : : dividend >>= 1;
3697 : : }
3698 : :
3699 : : divisor = nsec * frequency;
3700 : : }
3701 : :
3702 : : if (!divisor)
3703 : : return dividend;
3704 : :
3705 : : return div64_u64(dividend, divisor);
3706 : : }
3707 : :
3708 : : static DEFINE_PER_CPU(int, perf_throttled_count);
3709 : : static DEFINE_PER_CPU(u64, perf_throttled_seq);
3710 : :
3711 : 0 : static void perf_adjust_period(struct perf_event *event, u64 nsec, u64 count, bool disable)
3712 : : {
3713 : 0 : struct hw_perf_event *hwc = &event->hw;
3714 : 0 : s64 period, sample_period;
3715 : 0 : s64 delta;
3716 : :
3717 : 0 : period = perf_calculate_period(event, nsec, count);
3718 : :
3719 : 0 : delta = (s64)(period - hwc->sample_period);
3720 : 0 : delta = (delta + 7) / 8; /* low pass filter */
3721 : :
3722 : 0 : sample_period = hwc->sample_period + delta;
3723 : :
3724 [ # # ]: 0 : if (!sample_period)
3725 : 0 : sample_period = 1;
3726 : :
3727 : 0 : hwc->sample_period = sample_period;
3728 : :
3729 [ # # ]: 0 : if (local64_read(&hwc->period_left) > 8*sample_period) {
3730 [ # # ]: 0 : if (disable)
3731 : 0 : event->pmu->stop(event, PERF_EF_UPDATE);
3732 : :
3733 : 0 : local64_set(&hwc->period_left, 0);
3734 : :
3735 [ # # ]: 0 : if (disable)
3736 : 0 : event->pmu->start(event, PERF_EF_RELOAD);
3737 : : }
3738 : 0 : }
3739 : :
3740 : : /*
3741 : : * combine freq adjustment with unthrottling to avoid two passes over the
3742 : : * events. At the same time, make sure, having freq events does not change
3743 : : * the rate of unthrottling as that would introduce bias.
3744 : : */
3745 : 0 : static void perf_adjust_freq_unthr_context(struct perf_event_context *ctx,
3746 : : int needs_unthr)
3747 : : {
3748 : 0 : struct perf_event *event;
3749 : 0 : struct hw_perf_event *hwc;
3750 : 0 : u64 now, period = TICK_NSEC;
3751 : 0 : s64 delta;
3752 : :
3753 : : /*
3754 : : * only need to iterate over all events iff:
3755 : : * - context have events in frequency mode (needs freq adjust)
3756 : : * - there are events to unthrottle on this cpu
3757 : : */
3758 [ # # ]: 0 : if (!(ctx->nr_freq || needs_unthr))
3759 : : return;
3760 : :
3761 : 0 : raw_spin_lock(&ctx->lock);
3762 : 0 : perf_pmu_disable(ctx->pmu);
3763 : :
3764 [ # # ]: 0 : list_for_each_entry_rcu(event, &ctx->event_list, event_entry) {
3765 [ # # ]: 0 : if (event->state != PERF_EVENT_STATE_ACTIVE)
3766 : 0 : continue;
3767 : :
3768 [ # # ]: 0 : if (!event_filter_match(event))
3769 : 0 : continue;
3770 : :
3771 : 0 : perf_pmu_disable(event->pmu);
3772 : :
3773 : 0 : hwc = &event->hw;
3774 : :
3775 [ # # ]: 0 : if (hwc->interrupts == MAX_INTERRUPTS) {
3776 : 0 : hwc->interrupts = 0;
3777 : 0 : perf_log_throttle(event, 1);
3778 : 0 : event->pmu->start(event, 0);
3779 : : }
3780 : :
3781 [ # # # # ]: 0 : if (!event->attr.freq || !event->attr.sample_freq)
3782 : 0 : goto next;
3783 : :
3784 : : /*
3785 : : * stop the event and update event->count
3786 : : */
3787 : 0 : event->pmu->stop(event, PERF_EF_UPDATE);
3788 : :
3789 : 0 : now = local64_read(&event->count);
3790 : 0 : delta = now - hwc->freq_count_stamp;
3791 : 0 : hwc->freq_count_stamp = now;
3792 : :
3793 : : /*
3794 : : * restart the event
3795 : : * reload only if value has changed
3796 : : * we have stopped the event so tell that
3797 : : * to perf_adjust_period() to avoid stopping it
3798 : : * twice.
3799 : : */
3800 [ # # ]: 0 : if (delta > 0)
3801 : 0 : perf_adjust_period(event, period, delta, false);
3802 : :
3803 [ # # ]: 0 : event->pmu->start(event, delta > 0 ? PERF_EF_RELOAD : 0);
3804 : 0 : next:
3805 : 0 : perf_pmu_enable(event->pmu);
3806 : : }
3807 : :
3808 : 0 : perf_pmu_enable(ctx->pmu);
3809 : 0 : raw_spin_unlock(&ctx->lock);
3810 : : }
3811 : :
3812 : : /*
3813 : : * Move @event to the tail of the @ctx's elegible events.
3814 : : */
3815 : 0 : static void rotate_ctx(struct perf_event_context *ctx, struct perf_event *event)
3816 : : {
3817 : : /*
3818 : : * Rotate the first entry last of non-pinned groups. Rotation might be
3819 : : * disabled by the inheritance code.
3820 : : */
3821 [ # # ]: 0 : if (ctx->rotate_disable)
3822 : : return;
3823 : :
3824 : 0 : perf_event_groups_delete(&ctx->flexible_groups, event);
3825 : 0 : perf_event_groups_insert(&ctx->flexible_groups, event);
3826 : : }
3827 : :
3828 : : /* pick an event from the flexible_groups to rotate */
3829 : : static inline struct perf_event *
3830 : 0 : ctx_event_to_rotate(struct perf_event_context *ctx)
3831 : : {
3832 : 0 : struct perf_event *event;
3833 : :
3834 : : /* pick the first active flexible event */
3835 [ # # ]: 0 : event = list_first_entry_or_null(&ctx->flexible_active,
3836 : : struct perf_event, active_list);
3837 : :
3838 : : /* if no active flexible event, pick the first event */
3839 [ # # ]: 0 : if (!event) {
3840 [ # # ]: 0 : event = rb_entry_safe(rb_first(&ctx->flexible_groups.tree),
3841 : : typeof(*event), group_node);
3842 : : }
3843 : :
3844 : 0 : return event;
3845 : : }
3846 : :
3847 : 0 : static bool perf_rotate_context(struct perf_cpu_context *cpuctx)
3848 : : {
3849 : 0 : struct perf_event *cpu_event = NULL, *task_event = NULL;
3850 : 0 : struct perf_event_context *task_ctx = NULL;
3851 : 0 : int cpu_rotate, task_rotate;
3852 : :
3853 : : /*
3854 : : * Since we run this from IRQ context, nobody can install new
3855 : : * events, thus the event count values are stable.
3856 : : */
3857 : :
3858 : 0 : cpu_rotate = cpuctx->ctx.rotate_necessary;
3859 : 0 : task_ctx = cpuctx->task_ctx;
3860 [ # # ]: 0 : task_rotate = task_ctx ? task_ctx->rotate_necessary : 0;
3861 : :
3862 [ # # ]: 0 : if (!(cpu_rotate || task_rotate))
3863 : : return false;
3864 : :
3865 : 0 : perf_ctx_lock(cpuctx, cpuctx->task_ctx);
3866 : 0 : perf_pmu_disable(cpuctx->ctx.pmu);
3867 : :
3868 [ # # ]: 0 : if (task_rotate)
3869 : 0 : task_event = ctx_event_to_rotate(task_ctx);
3870 [ # # ]: 0 : if (cpu_rotate)
3871 : 0 : cpu_event = ctx_event_to_rotate(&cpuctx->ctx);
3872 : :
3873 : : /*
3874 : : * As per the order given at ctx_resched() first 'pop' task flexible
3875 : : * and then, if needed CPU flexible.
3876 : : */
3877 [ # # # # ]: 0 : if (task_event || (task_ctx && cpu_event))
3878 : 0 : ctx_sched_out(task_ctx, cpuctx, EVENT_FLEXIBLE);
3879 [ # # ]: 0 : if (cpu_event)
3880 : 0 : cpu_ctx_sched_out(cpuctx, EVENT_FLEXIBLE);
3881 : :
3882 [ # # ]: 0 : if (task_event)
3883 : 0 : rotate_ctx(task_ctx, task_event);
3884 [ # # ]: 0 : if (cpu_event)
3885 : 0 : rotate_ctx(&cpuctx->ctx, cpu_event);
3886 : :
3887 : 0 : perf_event_sched_in(cpuctx, task_ctx, current);
3888 : :
3889 : 0 : perf_pmu_enable(cpuctx->ctx.pmu);
3890 [ # # ]: 0 : perf_ctx_unlock(cpuctx, cpuctx->task_ctx);
3891 : :
3892 : 0 : return true;
3893 : : }
3894 : :
3895 : 34686 : void perf_event_task_tick(void)
3896 : : {
3897 : 34686 : struct list_head *head = this_cpu_ptr(&active_ctx_list);
3898 : 34686 : struct perf_event_context *ctx, *tmp;
3899 : 34686 : int throttled;
3900 : :
3901 : 34686 : lockdep_assert_irqs_disabled();
3902 : :
3903 : 34686 : __this_cpu_inc(perf_throttled_seq);
3904 : 34686 : throttled = __this_cpu_xchg(perf_throttled_count, 0);
3905 : 34686 : tick_dep_clear_cpu(smp_processor_id(), TICK_DEP_BIT_PERF_EVENTS);
3906 : :
3907 [ - + ]: 34686 : list_for_each_entry_safe(ctx, tmp, head, active_ctx_list)
3908 : 0 : perf_adjust_freq_unthr_context(ctx, throttled);
3909 : 34686 : }
3910 : :
3911 : 0 : static int event_enable_on_exec(struct perf_event *event,
3912 : : struct perf_event_context *ctx)
3913 : : {
3914 : 0 : if (!event->attr.enable_on_exec)
3915 : : return 0;
3916 : :
3917 : 0 : event->attr.enable_on_exec = 0;
3918 [ # # ]: 0 : if (event->state >= PERF_EVENT_STATE_INACTIVE)
3919 : : return 0;
3920 : :
3921 : 0 : perf_event_set_state(event, PERF_EVENT_STATE_INACTIVE);
3922 : :
3923 : 0 : return 1;
3924 : : }
3925 : :
3926 : : /*
3927 : : * Enable all of a task's events that have been marked enable-on-exec.
3928 : : * This expects task == current.
3929 : : */
3930 : 0 : static void perf_event_enable_on_exec(int ctxn)
3931 : : {
3932 : 0 : struct perf_event_context *ctx, *clone_ctx = NULL;
3933 : 0 : enum event_type_t event_type = 0;
3934 : 0 : struct perf_cpu_context *cpuctx;
3935 : 0 : struct perf_event *event;
3936 : 0 : unsigned long flags;
3937 : 0 : int enabled = 0;
3938 : :
3939 : 0 : local_irq_save(flags);
3940 [ # # ]: 0 : ctx = current->perf_event_ctxp[ctxn];
3941 [ # # # # ]: 0 : if (!ctx || !ctx->nr_events)
3942 : 0 : goto out;
3943 : :
3944 : 0 : cpuctx = __get_cpu_context(ctx);
3945 : 0 : perf_ctx_lock(cpuctx, ctx);
3946 : 0 : ctx_sched_out(ctx, cpuctx, EVENT_TIME);
3947 [ # # ]: 0 : list_for_each_entry(event, &ctx->event_list, event_entry) {
3948 [ # # ]: 0 : enabled |= event_enable_on_exec(event, ctx);
3949 [ # # ]: 0 : event_type |= get_event_type(event);
3950 : : }
3951 : :
3952 : : /*
3953 : : * Unclone and reschedule this context if we enabled any event.
3954 : : */
3955 [ # # ]: 0 : if (enabled) {
3956 [ # # ]: 0 : clone_ctx = unclone_ctx(ctx);
3957 : 0 : ctx_resched(cpuctx, ctx, event_type);
3958 : : } else {
3959 : 0 : ctx_sched_in(ctx, cpuctx, EVENT_TIME, current);
3960 : : }
3961 : 0 : perf_ctx_unlock(cpuctx, ctx);
3962 : :
3963 : 0 : out:
3964 : 0 : local_irq_restore(flags);
3965 : :
3966 [ # # ]: 0 : if (clone_ctx)
3967 : 0 : put_ctx(clone_ctx);
3968 : 0 : }
3969 : :
3970 : : struct perf_read_data {
3971 : : struct perf_event *event;
3972 : : bool group;
3973 : : int ret;
3974 : : };
3975 : :
3976 : 0 : static int __perf_event_read_cpu(struct perf_event *event, int event_cpu)
3977 : : {
3978 : 0 : u16 local_pkg, event_pkg;
3979 : :
3980 : 0 : if (event->group_caps & PERF_EV_CAP_READ_ACTIVE_PKG) {
3981 [ # # ]: 0 : int local_cpu = smp_processor_id();
3982 : :
3983 : 0 : event_pkg = topology_physical_package_id(event_cpu);
3984 : 0 : local_pkg = topology_physical_package_id(local_cpu);
3985 : :
3986 [ # # ]: 0 : if (event_pkg == local_pkg)
3987 : 0 : return local_cpu;
3988 : : }
3989 : :
3990 : : return event_cpu;
3991 : : }
3992 : :
3993 : : /*
3994 : : * Cross CPU call to read the hardware event
3995 : : */
3996 : 0 : static void __perf_event_read(void *info)
3997 : : {
3998 : 0 : struct perf_read_data *data = info;
3999 : 0 : struct perf_event *sub, *event = data->event;
4000 : 0 : struct perf_event_context *ctx = event->ctx;
4001 : 0 : struct perf_cpu_context *cpuctx = __get_cpu_context(ctx);
4002 : 0 : struct pmu *pmu = event->pmu;
4003 : :
4004 : : /*
4005 : : * If this is a task context, we need to check whether it is
4006 : : * the current task context of this cpu. If not it has been
4007 : : * scheduled out before the smp call arrived. In that case
4008 : : * event->count would have been updated to a recent sample
4009 : : * when the event was scheduled out.
4010 : : */
4011 [ # # # # ]: 0 : if (ctx->task && cpuctx->task_ctx != ctx)
4012 : : return;
4013 : :
4014 : 0 : raw_spin_lock(&ctx->lock);
4015 [ # # ]: 0 : if (ctx->is_active & EVENT_TIME) {
4016 : 0 : update_context_time(ctx);
4017 : : update_cgrp_time_from_event(event);
4018 : : }
4019 : :
4020 : 0 : perf_event_update_time(event);
4021 [ # # ]: 0 : if (data->group)
4022 : 0 : perf_event_update_sibling_time(event);
4023 : :
4024 [ # # ]: 0 : if (event->state != PERF_EVENT_STATE_ACTIVE)
4025 : 0 : goto unlock;
4026 : :
4027 [ # # ]: 0 : if (!data->group) {
4028 : 0 : pmu->read(event);
4029 : 0 : data->ret = 0;
4030 : 0 : goto unlock;
4031 : : }
4032 : :
4033 : 0 : pmu->start_txn(pmu, PERF_PMU_TXN_READ);
4034 : :
4035 : 0 : pmu->read(event);
4036 : :
4037 [ # # # # ]: 0 : for_each_sibling_event(sub, event) {
4038 [ # # ]: 0 : if (sub->state == PERF_EVENT_STATE_ACTIVE) {
4039 : : /*
4040 : : * Use sibling's PMU rather than @event's since
4041 : : * sibling could be on different (eg: software) PMU.
4042 : : */
4043 : 0 : sub->pmu->read(sub);
4044 : : }
4045 : : }
4046 : :
4047 : 0 : data->ret = pmu->commit_txn(pmu);
4048 : :
4049 : 0 : unlock:
4050 : 0 : raw_spin_unlock(&ctx->lock);
4051 : : }
4052 : :
4053 : 0 : static inline u64 perf_event_count(struct perf_event *event)
4054 : : {
4055 : 0 : return local64_read(&event->count) + atomic64_read(&event->child_count);
4056 : : }
4057 : :
4058 : : /*
4059 : : * NMI-safe method to read a local event, that is an event that
4060 : : * is:
4061 : : * - either for the current task, or for this CPU
4062 : : * - does not have inherit set, for inherited task events
4063 : : * will not be local and we cannot read them atomically
4064 : : * - must not have a pmu::count method
4065 : : */
4066 : 0 : int perf_event_read_local(struct perf_event *event, u64 *value,
4067 : : u64 *enabled, u64 *running)
4068 : : {
4069 : 0 : unsigned long flags;
4070 : 0 : int ret = 0;
4071 : :
4072 : : /*
4073 : : * Disabling interrupts avoids all counter scheduling (context
4074 : : * switches, timer based rotation and IPIs).
4075 : : */
4076 : 0 : local_irq_save(flags);
4077 : :
4078 : : /*
4079 : : * It must not be an event with inherit set, we cannot read
4080 : : * all child counters from atomic context.
4081 : : */
4082 [ # # ]: 0 : if (event->attr.inherit) {
4083 : 0 : ret = -EOPNOTSUPP;
4084 : 0 : goto out;
4085 : : }
4086 : :
4087 : : /* If this is a per-task event, it must be for current */
4088 [ # # # # ]: 0 : if ((event->attach_state & PERF_ATTACH_TASK) &&
4089 [ # # ]: 0 : event->hw.target != current) {
4090 : 0 : ret = -EINVAL;
4091 : 0 : goto out;
4092 : : }
4093 : :
4094 : : /* If this is a per-CPU event, it must be for this CPU */
4095 [ # # # # ]: 0 : if (!(event->attach_state & PERF_ATTACH_TASK) &&
4096 [ # # ]: 0 : event->cpu != smp_processor_id()) {
4097 : 0 : ret = -EINVAL;
4098 : 0 : goto out;
4099 : : }
4100 : :
4101 : : /* If this is a pinned event it must be running on this CPU */
4102 [ # # # # ]: 0 : if (event->attr.pinned && event->oncpu != smp_processor_id()) {
4103 : 0 : ret = -EBUSY;
4104 : 0 : goto out;
4105 : : }
4106 : :
4107 : : /*
4108 : : * If the event is currently on this CPU, its either a per-task event,
4109 : : * or local to this CPU. Furthermore it means its ACTIVE (otherwise
4110 : : * oncpu == -1).
4111 : : */
4112 [ # # ]: 0 : if (event->oncpu == smp_processor_id())
4113 : 0 : event->pmu->read(event);
4114 : :
4115 : 0 : *value = local64_read(&event->count);
4116 [ # # ]: 0 : if (enabled || running) {
4117 : 0 : u64 now = event->shadow_ctx_time + perf_clock();
4118 : 0 : u64 __enabled, __running;
4119 : :
4120 [ # # ]: 0 : __perf_update_times(event, now, &__enabled, &__running);
4121 [ # # ]: 0 : if (enabled)
4122 : 0 : *enabled = __enabled;
4123 [ # # ]: 0 : if (running)
4124 : 0 : *running = __running;
4125 : : }
4126 : 0 : out:
4127 : 0 : local_irq_restore(flags);
4128 : :
4129 : 0 : return ret;
4130 : : }
4131 : :
4132 : 0 : static int perf_event_read(struct perf_event *event, bool group)
4133 : : {
4134 : 0 : enum perf_event_state state = READ_ONCE(event->state);
4135 : 0 : int event_cpu, ret = 0;
4136 : :
4137 : : /*
4138 : : * If event is enabled and currently active on a CPU, update the
4139 : : * value in the event structure:
4140 : : */
4141 : 0 : again:
4142 [ # # ]: 0 : if (state == PERF_EVENT_STATE_ACTIVE) {
4143 : 0 : struct perf_read_data data;
4144 : :
4145 : : /*
4146 : : * Orders the ->state and ->oncpu loads such that if we see
4147 : : * ACTIVE we must also see the right ->oncpu.
4148 : : *
4149 : : * Matches the smp_wmb() from event_sched_in().
4150 : : */
4151 : 0 : smp_rmb();
4152 : :
4153 [ # # ]: 0 : event_cpu = READ_ONCE(event->oncpu);
4154 [ # # ]: 0 : if ((unsigned)event_cpu >= nr_cpu_ids)
4155 : 0 : return 0;
4156 : :
4157 : 0 : data = (struct perf_read_data){
4158 : : .event = event,
4159 : : .group = group,
4160 : : .ret = 0,
4161 : : };
4162 : :
4163 : 0 : preempt_disable();
4164 [ # # ]: 0 : event_cpu = __perf_event_read_cpu(event, event_cpu);
4165 : :
4166 : : /*
4167 : : * Purposely ignore the smp_call_function_single() return
4168 : : * value.
4169 : : *
4170 : : * If event_cpu isn't a valid CPU it means the event got
4171 : : * scheduled out and that will have updated the event count.
4172 : : *
4173 : : * Therefore, either way, we'll have an up-to-date event count
4174 : : * after this.
4175 : : */
4176 : 0 : (void)smp_call_function_single(event_cpu, __perf_event_read, &data, 1);
4177 : 0 : preempt_enable();
4178 : 0 : ret = data.ret;
4179 : :
4180 [ # # ]: 0 : } else if (state == PERF_EVENT_STATE_INACTIVE) {
4181 : 0 : struct perf_event_context *ctx = event->ctx;
4182 : 0 : unsigned long flags;
4183 : :
4184 : 0 : raw_spin_lock_irqsave(&ctx->lock, flags);
4185 : 0 : state = event->state;
4186 [ # # ]: 0 : if (state != PERF_EVENT_STATE_INACTIVE) {
4187 : 0 : raw_spin_unlock_irqrestore(&ctx->lock, flags);
4188 : 0 : goto again;
4189 : : }
4190 : :
4191 : : /*
4192 : : * May read while context is not active (e.g., thread is
4193 : : * blocked), in that case we cannot update context time
4194 : : */
4195 [ # # ]: 0 : if (ctx->is_active & EVENT_TIME) {
4196 : 0 : update_context_time(ctx);
4197 : : update_cgrp_time_from_event(event);
4198 : : }
4199 : :
4200 : 0 : perf_event_update_time(event);
4201 [ # # ]: 0 : if (group)
4202 : 0 : perf_event_update_sibling_time(event);
4203 : 0 : raw_spin_unlock_irqrestore(&ctx->lock, flags);
4204 : : }
4205 : :
4206 : : return ret;
4207 : : }
4208 : :
4209 : : /*
4210 : : * Initialize the perf_event context in a task_struct:
4211 : : */
4212 : 26 : static void __perf_event_init_context(struct perf_event_context *ctx)
4213 : : {
4214 : 26 : raw_spin_lock_init(&ctx->lock);
4215 : 26 : mutex_init(&ctx->mutex);
4216 : 26 : INIT_LIST_HEAD(&ctx->active_ctx_list);
4217 : 26 : perf_event_groups_init(&ctx->pinned_groups);
4218 : 26 : perf_event_groups_init(&ctx->flexible_groups);
4219 : 26 : INIT_LIST_HEAD(&ctx->event_list);
4220 : 26 : INIT_LIST_HEAD(&ctx->pinned_active);
4221 : 26 : INIT_LIST_HEAD(&ctx->flexible_active);
4222 : 26 : refcount_set(&ctx->refcount, 1);
4223 : 26 : }
4224 : :
4225 : : static struct perf_event_context *
4226 : 0 : alloc_perf_context(struct pmu *pmu, struct task_struct *task)
4227 : : {
4228 : 0 : struct perf_event_context *ctx;
4229 : :
4230 : 0 : ctx = kzalloc(sizeof(struct perf_event_context), GFP_KERNEL);
4231 [ # # ]: 0 : if (!ctx)
4232 : : return NULL;
4233 : :
4234 : 0 : __perf_event_init_context(ctx);
4235 [ # # ]: 0 : if (task)
4236 : 0 : ctx->task = get_task_struct(task);
4237 : 0 : ctx->pmu = pmu;
4238 : :
4239 : 0 : return ctx;
4240 : : }
4241 : :
4242 : : static struct task_struct *
4243 : 0 : find_lively_task_by_vpid(pid_t vpid)
4244 : : {
4245 : 0 : struct task_struct *task;
4246 : :
4247 : 0 : rcu_read_lock();
4248 [ # # ]: 0 : if (!vpid)
4249 : 0 : task = current;
4250 : : else
4251 : 0 : task = find_task_by_vpid(vpid);
4252 [ # # ]: 0 : if (task)
4253 : 0 : get_task_struct(task);
4254 : 0 : rcu_read_unlock();
4255 : :
4256 [ # # ]: 0 : if (!task)
4257 : 0 : return ERR_PTR(-ESRCH);
4258 : :
4259 : : return task;
4260 : : }
4261 : :
4262 : : /*
4263 : : * Returns a matching context with refcount and pincount.
4264 : : */
4265 : : static struct perf_event_context *
4266 : 0 : find_get_context(struct pmu *pmu, struct task_struct *task,
4267 : : struct perf_event *event)
4268 : : {
4269 : 0 : struct perf_event_context *ctx, *clone_ctx = NULL;
4270 : 0 : struct perf_cpu_context *cpuctx;
4271 : 0 : void *task_ctx_data = NULL;
4272 : 0 : unsigned long flags;
4273 : 0 : int ctxn, err;
4274 : 0 : int cpu = event->cpu;
4275 : :
4276 [ # # ]: 0 : if (!task) {
4277 : : /* Must be root to operate on a CPU event: */
4278 : 0 : err = perf_allow_cpu(&event->attr);
4279 [ # # ]: 0 : if (err)
4280 : 0 : return ERR_PTR(err);
4281 : :
4282 : 0 : cpuctx = per_cpu_ptr(pmu->pmu_cpu_context, cpu);
4283 : 0 : ctx = &cpuctx->ctx;
4284 : 0 : get_ctx(ctx);
4285 : 0 : ++ctx->pin_count;
4286 : :
4287 : 0 : return ctx;
4288 : : }
4289 : :
4290 : 0 : err = -EINVAL;
4291 : 0 : ctxn = pmu->task_ctx_nr;
4292 [ # # ]: 0 : if (ctxn < 0)
4293 : 0 : goto errout;
4294 : :
4295 [ # # ]: 0 : if (event->attach_state & PERF_ATTACH_TASK_DATA) {
4296 : 0 : task_ctx_data = kzalloc(pmu->task_ctx_size, GFP_KERNEL);
4297 [ # # ]: 0 : if (!task_ctx_data) {
4298 : 0 : err = -ENOMEM;
4299 : 0 : goto errout;
4300 : : }
4301 : : }
4302 : :
4303 : 0 : retry:
4304 : 0 : ctx = perf_lock_task_context(task, ctxn, &flags);
4305 [ # # ]: 0 : if (ctx) {
4306 [ # # ]: 0 : clone_ctx = unclone_ctx(ctx);
4307 : 0 : ++ctx->pin_count;
4308 : :
4309 [ # # # # ]: 0 : if (task_ctx_data && !ctx->task_ctx_data) {
4310 : 0 : ctx->task_ctx_data = task_ctx_data;
4311 : 0 : task_ctx_data = NULL;
4312 : : }
4313 : 0 : raw_spin_unlock_irqrestore(&ctx->lock, flags);
4314 : :
4315 [ # # ]: 0 : if (clone_ctx)
4316 : 0 : put_ctx(clone_ctx);
4317 : : } else {
4318 : 0 : ctx = alloc_perf_context(pmu, task);
4319 : 0 : err = -ENOMEM;
4320 [ # # ]: 0 : if (!ctx)
4321 : 0 : goto errout;
4322 : :
4323 [ # # ]: 0 : if (task_ctx_data) {
4324 : 0 : ctx->task_ctx_data = task_ctx_data;
4325 : 0 : task_ctx_data = NULL;
4326 : : }
4327 : :
4328 : 0 : err = 0;
4329 : 0 : mutex_lock(&task->perf_event_mutex);
4330 : : /*
4331 : : * If it has already passed perf_event_exit_task().
4332 : : * we must see PF_EXITING, it takes this mutex too.
4333 : : */
4334 [ # # ]: 0 : if (task->flags & PF_EXITING)
4335 : : err = -ESRCH;
4336 [ # # ]: 0 : else if (task->perf_event_ctxp[ctxn])
4337 : : err = -EAGAIN;
4338 : : else {
4339 : 0 : get_ctx(ctx);
4340 : 0 : ++ctx->pin_count;
4341 : 0 : rcu_assign_pointer(task->perf_event_ctxp[ctxn], ctx);
4342 : : }
4343 : 0 : mutex_unlock(&task->perf_event_mutex);
4344 : :
4345 [ # # ]: 0 : if (unlikely(err)) {
4346 : 0 : put_ctx(ctx);
4347 : :
4348 [ # # ]: 0 : if (err == -EAGAIN)
4349 : 0 : goto retry;
4350 : 0 : goto errout;
4351 : : }
4352 : : }
4353 : :
4354 : 0 : kfree(task_ctx_data);
4355 : 0 : return ctx;
4356 : :
4357 : 0 : errout:
4358 : 0 : kfree(task_ctx_data);
4359 : 0 : return ERR_PTR(err);
4360 : : }
4361 : :
4362 : : static void perf_event_free_filter(struct perf_event *event);
4363 : : static void perf_event_free_bpf_prog(struct perf_event *event);
4364 : :
4365 : 0 : static void free_event_rcu(struct rcu_head *head)
4366 : : {
4367 : 0 : struct perf_event *event;
4368 : :
4369 : 0 : event = container_of(head, struct perf_event, rcu_head);
4370 [ # # ]: 0 : if (event->ns)
4371 : 0 : put_pid_ns(event->ns);
4372 : 0 : perf_event_free_filter(event);
4373 : 0 : kfree(event);
4374 : 0 : }
4375 : :
4376 : : static void ring_buffer_attach(struct perf_event *event,
4377 : : struct perf_buffer *rb);
4378 : :
4379 : 0 : static void detach_sb_event(struct perf_event *event)
4380 : : {
4381 : 0 : struct pmu_event_list *pel = per_cpu_ptr(&pmu_sb_events, event->cpu);
4382 : :
4383 : 0 : raw_spin_lock(&pel->lock);
4384 : 0 : list_del_rcu(&event->sb_list);
4385 : 0 : raw_spin_unlock(&pel->lock);
4386 : 0 : }
4387 : :
4388 : 0 : static bool is_sb_event(struct perf_event *event)
4389 : : {
4390 : 0 : struct perf_event_attr *attr = &event->attr;
4391 : :
4392 : 0 : if (event->parent)
4393 : : return false;
4394 : :
4395 [ # # # # ]: 0 : if (event->attach_state & PERF_ATTACH_TASK)
4396 : : return false;
4397 : :
4398 : 0 : if (attr->mmap || attr->mmap_data || attr->mmap2 ||
4399 : : attr->comm || attr->comm_exec ||
4400 : : attr->task || attr->ksymbol ||
4401 [ # # # # ]: 0 : attr->context_switch ||
4402 : : attr->bpf_event)
4403 : 0 : return true;
4404 : : return false;
4405 : : }
4406 : :
4407 : 0 : static void unaccount_pmu_sb_event(struct perf_event *event)
4408 : : {
4409 [ # # ]: 0 : if (is_sb_event(event))
4410 : 0 : detach_sb_event(event);
4411 : 0 : }
4412 : :
4413 : 0 : static void unaccount_event_cpu(struct perf_event *event, int cpu)
4414 : : {
4415 : 0 : if (event->parent)
4416 : : return;
4417 : :
4418 : : if (is_cgroup_event(event))
4419 : : atomic_dec(&per_cpu(perf_cgroup_events, cpu));
4420 : : }
4421 : :
4422 : : #ifdef CONFIG_NO_HZ_FULL
4423 : : static DEFINE_SPINLOCK(nr_freq_lock);
4424 : : #endif
4425 : :
4426 : : static void unaccount_freq_event_nohz(void)
4427 : : {
4428 : : #ifdef CONFIG_NO_HZ_FULL
4429 : : spin_lock(&nr_freq_lock);
4430 : : if (atomic_dec_and_test(&nr_freq_events))
4431 : : tick_nohz_dep_clear(TICK_DEP_BIT_PERF_EVENTS);
4432 : : spin_unlock(&nr_freq_lock);
4433 : : #endif
4434 : : }
4435 : :
4436 : 0 : static void unaccount_freq_event(void)
4437 : : {
4438 : 0 : if (tick_nohz_full_enabled())
4439 : : unaccount_freq_event_nohz();
4440 : : else
4441 : 0 : atomic_dec(&nr_freq_events);
4442 : 0 : }
4443 : :
4444 : 0 : static void unaccount_event(struct perf_event *event)
4445 : : {
4446 : 0 : bool dec = false;
4447 : :
4448 [ # # ]: 0 : if (event->parent)
4449 : : return;
4450 : :
4451 [ # # ]: 0 : if (event->attach_state & PERF_ATTACH_TASK)
4452 : 0 : dec = true;
4453 [ # # ]: 0 : if (event->attr.mmap || event->attr.mmap_data)
4454 : 0 : atomic_dec(&nr_mmap_events);
4455 [ # # ]: 0 : if (event->attr.comm)
4456 : 0 : atomic_dec(&nr_comm_events);
4457 [ # # ]: 0 : if (event->attr.namespaces)
4458 : 0 : atomic_dec(&nr_namespaces_events);
4459 [ # # ]: 0 : if (event->attr.task)
4460 : 0 : atomic_dec(&nr_task_events);
4461 [ # # ]: 0 : if (event->attr.freq)
4462 : 0 : unaccount_freq_event();
4463 [ # # ]: 0 : if (event->attr.context_switch) {
4464 : 0 : dec = true;
4465 : 0 : atomic_dec(&nr_switch_events);
4466 : : }
4467 : 0 : if (is_cgroup_event(event))
4468 : : dec = true;
4469 [ # # ]: 0 : if (has_branch_stack(event))
4470 : 0 : dec = true;
4471 [ # # ]: 0 : if (event->attr.ksymbol)
4472 : 0 : atomic_dec(&nr_ksymbol_events);
4473 [ # # ]: 0 : if (event->attr.bpf_event)
4474 : 0 : atomic_dec(&nr_bpf_events);
4475 : :
4476 [ # # ]: 0 : if (dec) {
4477 [ # # ]: 0 : if (!atomic_add_unless(&perf_sched_count, -1, 1))
4478 : 0 : schedule_delayed_work(&perf_sched_work, HZ);
4479 : : }
4480 : :
4481 : 0 : unaccount_event_cpu(event, event->cpu);
4482 : :
4483 : 0 : unaccount_pmu_sb_event(event);
4484 : : }
4485 : :
4486 : 0 : static void perf_sched_delayed(struct work_struct *work)
4487 : : {
4488 : 0 : mutex_lock(&perf_sched_mutex);
4489 [ # # ]: 0 : if (atomic_dec_and_test(&perf_sched_count))
4490 : 0 : static_branch_disable(&perf_sched_events);
4491 : 0 : mutex_unlock(&perf_sched_mutex);
4492 : 0 : }
4493 : :
4494 : : /*
4495 : : * The following implement mutual exclusion of events on "exclusive" pmus
4496 : : * (PERF_PMU_CAP_EXCLUSIVE). Such pmus can only have one event scheduled
4497 : : * at a time, so we disallow creating events that might conflict, namely:
4498 : : *
4499 : : * 1) cpu-wide events in the presence of per-task events,
4500 : : * 2) per-task events in the presence of cpu-wide events,
4501 : : * 3) two matching events on the same context.
4502 : : *
4503 : : * The former two cases are handled in the allocation path (perf_event_alloc(),
4504 : : * _free_event()), the latter -- before the first perf_install_in_context().
4505 : : */
4506 : : static int exclusive_event_init(struct perf_event *event)
4507 : : {
4508 : : struct pmu *pmu = event->pmu;
4509 : :
4510 : : if (!is_exclusive_pmu(pmu))
4511 : : return 0;
4512 : :
4513 : : /*
4514 : : * Prevent co-existence of per-task and cpu-wide events on the
4515 : : * same exclusive pmu.
4516 : : *
4517 : : * Negative pmu::exclusive_cnt means there are cpu-wide
4518 : : * events on this "exclusive" pmu, positive means there are
4519 : : * per-task events.
4520 : : *
4521 : : * Since this is called in perf_event_alloc() path, event::ctx
4522 : : * doesn't exist yet; it is, however, safe to use PERF_ATTACH_TASK
4523 : : * to mean "per-task event", because unlike other attach states it
4524 : : * never gets cleared.
4525 : : */
4526 : : if (event->attach_state & PERF_ATTACH_TASK) {
4527 : : if (!atomic_inc_unless_negative(&pmu->exclusive_cnt))
4528 : : return -EBUSY;
4529 : : } else {
4530 : : if (!atomic_dec_unless_positive(&pmu->exclusive_cnt))
4531 : : return -EBUSY;
4532 : : }
4533 : :
4534 : : return 0;
4535 : : }
4536 : :
4537 : : static void exclusive_event_destroy(struct perf_event *event)
4538 : : {
4539 : : struct pmu *pmu = event->pmu;
4540 : :
4541 : : if (!is_exclusive_pmu(pmu))
4542 : : return;
4543 : :
4544 : : /* see comment in exclusive_event_init() */
4545 : : if (event->attach_state & PERF_ATTACH_TASK)
4546 : : atomic_dec(&pmu->exclusive_cnt);
4547 : : else
4548 : : atomic_inc(&pmu->exclusive_cnt);
4549 : : }
4550 : :
4551 : 0 : static bool exclusive_event_match(struct perf_event *e1, struct perf_event *e2)
4552 : : {
4553 : 0 : if ((e1->pmu == e2->pmu) &&
4554 [ # # # # ]: 0 : (e1->cpu == e2->cpu ||
4555 [ # # ]: 0 : e1->cpu == -1 ||
4556 : : e2->cpu == -1))
4557 : : return true;
4558 : : return false;
4559 : : }
4560 : :
4561 : 0 : static bool exclusive_event_installable(struct perf_event *event,
4562 : : struct perf_event_context *ctx)
4563 : : {
4564 : 0 : struct perf_event *iter_event;
4565 : 0 : struct pmu *pmu = event->pmu;
4566 : :
4567 : 0 : lockdep_assert_held(&ctx->mutex);
4568 : :
4569 [ # # ]: 0 : if (!is_exclusive_pmu(pmu))
4570 : : return true;
4571 : :
4572 [ # # ]: 0 : list_for_each_entry(iter_event, &ctx->event_list, event_entry) {
4573 [ # # ]: 0 : if (exclusive_event_match(iter_event, event))
4574 : : return false;
4575 : : }
4576 : :
4577 : : return true;
4578 : : }
4579 : :
4580 : : static void perf_addr_filters_splice(struct perf_event *event,
4581 : : struct list_head *head);
4582 : :
4583 : 0 : static void _free_event(struct perf_event *event)
4584 : : {
4585 : 0 : irq_work_sync(&event->pending);
4586 : :
4587 : 0 : unaccount_event(event);
4588 : :
4589 : 0 : security_perf_event_free(event);
4590 : :
4591 [ # # ]: 0 : if (event->rb) {
4592 : : /*
4593 : : * Can happen when we close an event with re-directed output.
4594 : : *
4595 : : * Since we have a 0 refcount, perf_mmap_close() will skip
4596 : : * over us; possibly making our ring_buffer_put() the last.
4597 : : */
4598 : 0 : mutex_lock(&event->mmap_mutex);
4599 : 0 : ring_buffer_attach(event, NULL);
4600 : 0 : mutex_unlock(&event->mmap_mutex);
4601 : : }
4602 : :
4603 : 0 : if (is_cgroup_event(event))
4604 : : perf_detach_cgroup(event);
4605 : :
4606 [ # # ]: 0 : if (!event->parent) {
4607 [ # # ]: 0 : if (event->attr.sample_type & PERF_SAMPLE_CALLCHAIN)
4608 : 0 : put_callchain_buffers();
4609 : : }
4610 : :
4611 : 0 : perf_event_free_bpf_prog(event);
4612 : 0 : perf_addr_filters_splice(event, NULL);
4613 : 0 : kfree(event->addr_filter_ranges);
4614 : :
4615 [ # # ]: 0 : if (event->destroy)
4616 : 0 : event->destroy(event);
4617 : :
4618 : : /*
4619 : : * Must be after ->destroy(), due to uprobe_perf_close() using
4620 : : * hw.target.
4621 : : */
4622 [ # # ]: 0 : if (event->hw.target)
4623 : 0 : put_task_struct(event->hw.target);
4624 : :
4625 : : /*
4626 : : * perf_event_free_task() relies on put_ctx() being 'last', in particular
4627 : : * all task references must be cleaned up.
4628 : : */
4629 [ # # ]: 0 : if (event->ctx)
4630 : 0 : put_ctx(event->ctx);
4631 : :
4632 : 0 : exclusive_event_destroy(event);
4633 : 0 : module_put(event->pmu->module);
4634 : :
4635 : 0 : call_rcu(&event->rcu_head, free_event_rcu);
4636 : 0 : }
4637 : :
4638 : : /*
4639 : : * Used to free events which have a known refcount of 1, such as in error paths
4640 : : * where the event isn't exposed yet and inherited events.
4641 : : */
4642 : 0 : static void free_event(struct perf_event *event)
4643 : : {
4644 [ # # # # ]: 0 : if (WARN(atomic_long_cmpxchg(&event->refcount, 1, 0) != 1,
4645 : : "unexpected event refcount: %ld; ptr=%p\n",
4646 : : atomic_long_read(&event->refcount), event)) {
4647 : : /* leak to avoid use-after-free */
4648 : : return;
4649 : : }
4650 : :
4651 : 0 : _free_event(event);
4652 : : }
4653 : :
4654 : : /*
4655 : : * Remove user event from the owner task.
4656 : : */
4657 : 0 : static void perf_remove_from_owner(struct perf_event *event)
4658 : : {
4659 : 0 : struct task_struct *owner;
4660 : :
4661 : 0 : rcu_read_lock();
4662 : : /*
4663 : : * Matches the smp_store_release() in perf_event_exit_task(). If we
4664 : : * observe !owner it means the list deletion is complete and we can
4665 : : * indeed free this event, otherwise we need to serialize on
4666 : : * owner->perf_event_mutex.
4667 : : */
4668 [ # # ]: 0 : owner = READ_ONCE(event->owner);
4669 [ # # ]: 0 : if (owner) {
4670 : : /*
4671 : : * Since delayed_put_task_struct() also drops the last
4672 : : * task reference we can safely take a new reference
4673 : : * while holding the rcu_read_lock().
4674 : : */
4675 : 0 : get_task_struct(owner);
4676 : : }
4677 : 0 : rcu_read_unlock();
4678 : :
4679 [ # # ]: 0 : if (owner) {
4680 : : /*
4681 : : * If we're here through perf_event_exit_task() we're already
4682 : : * holding ctx->mutex which would be an inversion wrt. the
4683 : : * normal lock order.
4684 : : *
4685 : : * However we can safely take this lock because its the child
4686 : : * ctx->mutex.
4687 : : */
4688 : 0 : mutex_lock_nested(&owner->perf_event_mutex, SINGLE_DEPTH_NESTING);
4689 : :
4690 : : /*
4691 : : * We have to re-check the event->owner field, if it is cleared
4692 : : * we raced with perf_event_exit_task(), acquiring the mutex
4693 : : * ensured they're done, and we can proceed with freeing the
4694 : : * event.
4695 : : */
4696 [ # # ]: 0 : if (event->owner) {
4697 : 0 : list_del_init(&event->owner_entry);
4698 : 0 : smp_store_release(&event->owner, NULL);
4699 : : }
4700 : 0 : mutex_unlock(&owner->perf_event_mutex);
4701 : 0 : put_task_struct(owner);
4702 : : }
4703 : 0 : }
4704 : :
4705 : 0 : static void put_event(struct perf_event *event)
4706 : : {
4707 [ # # ]: 0 : if (!atomic_long_dec_and_test(&event->refcount))
4708 : : return;
4709 : :
4710 : 0 : _free_event(event);
4711 : : }
4712 : :
4713 : : /*
4714 : : * Kill an event dead; while event:refcount will preserve the event
4715 : : * object, it will not preserve its functionality. Once the last 'user'
4716 : : * gives up the object, we'll destroy the thing.
4717 : : */
4718 : 0 : int perf_event_release_kernel(struct perf_event *event)
4719 : : {
4720 : 0 : struct perf_event_context *ctx = event->ctx;
4721 : 0 : struct perf_event *child, *tmp;
4722 : 0 : LIST_HEAD(free_list);
4723 : :
4724 : : /*
4725 : : * If we got here through err_file: fput(event_file); we will not have
4726 : : * attached to a context yet.
4727 : : */
4728 [ # # ]: 0 : if (!ctx) {
4729 [ # # ]: 0 : WARN_ON_ONCE(event->attach_state &
4730 : : (PERF_ATTACH_CONTEXT|PERF_ATTACH_GROUP));
4731 : 0 : goto no_ctx;
4732 : : }
4733 : :
4734 [ # # ]: 0 : if (!is_kernel_event(event))
4735 : 0 : perf_remove_from_owner(event);
4736 : :
4737 : 0 : ctx = perf_event_ctx_lock(event);
4738 [ # # ]: 0 : WARN_ON_ONCE(ctx->parent_ctx);
4739 : 0 : perf_remove_from_context(event, DETACH_GROUP);
4740 : :
4741 : 0 : raw_spin_lock_irq(&ctx->lock);
4742 : : /*
4743 : : * Mark this event as STATE_DEAD, there is no external reference to it
4744 : : * anymore.
4745 : : *
4746 : : * Anybody acquiring event->child_mutex after the below loop _must_
4747 : : * also see this, most importantly inherit_event() which will avoid
4748 : : * placing more children on the list.
4749 : : *
4750 : : * Thus this guarantees that we will in fact observe and kill _ALL_
4751 : : * child events.
4752 : : */
4753 : 0 : event->state = PERF_EVENT_STATE_DEAD;
4754 : 0 : raw_spin_unlock_irq(&ctx->lock);
4755 : :
4756 : 0 : perf_event_ctx_unlock(event, ctx);
4757 : :
4758 : 0 : again:
4759 : 0 : mutex_lock(&event->child_mutex);
4760 [ # # ]: 0 : list_for_each_entry(child, &event->child_list, child_list) {
4761 : :
4762 : : /*
4763 : : * Cannot change, child events are not migrated, see the
4764 : : * comment with perf_event_ctx_lock_nested().
4765 : : */
4766 : 0 : ctx = READ_ONCE(child->ctx);
4767 : : /*
4768 : : * Since child_mutex nests inside ctx::mutex, we must jump
4769 : : * through hoops. We start by grabbing a reference on the ctx.
4770 : : *
4771 : : * Since the event cannot get freed while we hold the
4772 : : * child_mutex, the context must also exist and have a !0
4773 : : * reference count.
4774 : : */
4775 : 0 : get_ctx(ctx);
4776 : :
4777 : : /*
4778 : : * Now that we have a ctx ref, we can drop child_mutex, and
4779 : : * acquire ctx::mutex without fear of it going away. Then we
4780 : : * can re-acquire child_mutex.
4781 : : */
4782 : 0 : mutex_unlock(&event->child_mutex);
4783 : 0 : mutex_lock(&ctx->mutex);
4784 : 0 : mutex_lock(&event->child_mutex);
4785 : :
4786 : : /*
4787 : : * Now that we hold ctx::mutex and child_mutex, revalidate our
4788 : : * state, if child is still the first entry, it didn't get freed
4789 : : * and we can continue doing so.
4790 : : */
4791 [ # # ]: 0 : tmp = list_first_entry_or_null(&event->child_list,
4792 : : struct perf_event, child_list);
4793 [ # # ]: 0 : if (tmp == child) {
4794 : 0 : perf_remove_from_context(child, DETACH_GROUP);
4795 : 0 : list_move(&child->child_list, &free_list);
4796 : : /*
4797 : : * This matches the refcount bump in inherit_event();
4798 : : * this can't be the last reference.
4799 : : */
4800 : 0 : put_event(event);
4801 : : }
4802 : :
4803 : 0 : mutex_unlock(&event->child_mutex);
4804 : 0 : mutex_unlock(&ctx->mutex);
4805 : 0 : put_ctx(ctx);
4806 : 0 : goto again;
4807 : : }
4808 : 0 : mutex_unlock(&event->child_mutex);
4809 : :
4810 [ # # ]: 0 : list_for_each_entry_safe(child, tmp, &free_list, child_list) {
4811 : 0 : void *var = &child->ctx->refcount;
4812 : :
4813 : 0 : list_del(&child->child_list);
4814 : 0 : free_event(child);
4815 : :
4816 : : /*
4817 : : * Wake any perf_event_free_task() waiting for this event to be
4818 : : * freed.
4819 : : */
4820 : 0 : smp_mb(); /* pairs with wait_var_event() */
4821 : 0 : wake_up_var(var);
4822 : : }
4823 : :
4824 : 0 : no_ctx:
4825 : 0 : put_event(event); /* Must be the 'last' reference */
4826 : 0 : return 0;
4827 : : }
4828 : : EXPORT_SYMBOL_GPL(perf_event_release_kernel);
4829 : :
4830 : : /*
4831 : : * Called when the last reference to the file is gone.
4832 : : */
4833 : 0 : static int perf_release(struct inode *inode, struct file *file)
4834 : : {
4835 : 0 : perf_event_release_kernel(file->private_data);
4836 : 0 : return 0;
4837 : : }
4838 : :
4839 : 0 : static u64 __perf_event_read_value(struct perf_event *event, u64 *enabled, u64 *running)
4840 : : {
4841 : 0 : struct perf_event *child;
4842 : 0 : u64 total = 0;
4843 : :
4844 : 0 : *enabled = 0;
4845 : 0 : *running = 0;
4846 : :
4847 : 0 : mutex_lock(&event->child_mutex);
4848 : :
4849 : 0 : (void)perf_event_read(event, false);
4850 : 0 : total += perf_event_count(event);
4851 : :
4852 : 0 : *enabled += event->total_time_enabled +
4853 : 0 : atomic64_read(&event->child_total_time_enabled);
4854 : 0 : *running += event->total_time_running +
4855 : 0 : atomic64_read(&event->child_total_time_running);
4856 : :
4857 [ # # ]: 0 : list_for_each_entry(child, &event->child_list, child_list) {
4858 : 0 : (void)perf_event_read(child, false);
4859 : 0 : total += perf_event_count(child);
4860 : 0 : *enabled += child->total_time_enabled;
4861 : 0 : *running += child->total_time_running;
4862 : : }
4863 : 0 : mutex_unlock(&event->child_mutex);
4864 : :
4865 : 0 : return total;
4866 : : }
4867 : :
4868 : 0 : u64 perf_event_read_value(struct perf_event *event, u64 *enabled, u64 *running)
4869 : : {
4870 : 0 : struct perf_event_context *ctx;
4871 : 0 : u64 count;
4872 : :
4873 : 0 : ctx = perf_event_ctx_lock(event);
4874 : 0 : count = __perf_event_read_value(event, enabled, running);
4875 : 0 : perf_event_ctx_unlock(event, ctx);
4876 : :
4877 : 0 : return count;
4878 : : }
4879 : : EXPORT_SYMBOL_GPL(perf_event_read_value);
4880 : :
4881 : 0 : static int __perf_read_group_add(struct perf_event *leader,
4882 : : u64 read_format, u64 *values)
4883 : : {
4884 : 0 : struct perf_event_context *ctx = leader->ctx;
4885 : 0 : struct perf_event *sub;
4886 : 0 : unsigned long flags;
4887 : 0 : int n = 1; /* skip @nr */
4888 : 0 : int ret;
4889 : :
4890 : 0 : ret = perf_event_read(leader, true);
4891 [ # # ]: 0 : if (ret)
4892 : : return ret;
4893 : :
4894 : 0 : raw_spin_lock_irqsave(&ctx->lock, flags);
4895 : :
4896 : : /*
4897 : : * Since we co-schedule groups, {enabled,running} times of siblings
4898 : : * will be identical to those of the leader, so we only publish one
4899 : : * set.
4900 : : */
4901 [ # # ]: 0 : if (read_format & PERF_FORMAT_TOTAL_TIME_ENABLED) {
4902 : 0 : values[n++] += leader->total_time_enabled +
4903 : 0 : atomic64_read(&leader->child_total_time_enabled);
4904 : : }
4905 : :
4906 [ # # ]: 0 : if (read_format & PERF_FORMAT_TOTAL_TIME_RUNNING) {
4907 : 0 : values[n++] += leader->total_time_running +
4908 : 0 : atomic64_read(&leader->child_total_time_running);
4909 : : }
4910 : :
4911 : : /*
4912 : : * Write {count,id} tuples for every sibling.
4913 : : */
4914 : 0 : values[n++] += perf_event_count(leader);
4915 [ # # ]: 0 : if (read_format & PERF_FORMAT_ID)
4916 [ # # ]: 0 : values[n++] = primary_event_id(leader);
4917 : :
4918 [ # # # # ]: 0 : for_each_sibling_event(sub, leader) {
4919 : 0 : values[n++] += perf_event_count(sub);
4920 [ # # ]: 0 : if (read_format & PERF_FORMAT_ID)
4921 [ # # ]: 0 : values[n++] = primary_event_id(sub);
4922 : : }
4923 : :
4924 : 0 : raw_spin_unlock_irqrestore(&ctx->lock, flags);
4925 : 0 : return 0;
4926 : : }
4927 : :
4928 : : static int perf_read_group(struct perf_event *event,
4929 : : u64 read_format, char __user *buf)
4930 : : {
4931 : : struct perf_event *leader = event->group_leader, *child;
4932 : : struct perf_event_context *ctx = leader->ctx;
4933 : : int ret;
4934 : : u64 *values;
4935 : :
4936 : : lockdep_assert_held(&ctx->mutex);
4937 : :
4938 : : values = kzalloc(event->read_size, GFP_KERNEL);
4939 : : if (!values)
4940 : : return -ENOMEM;
4941 : :
4942 : : values[0] = 1 + leader->nr_siblings;
4943 : :
4944 : : /*
4945 : : * By locking the child_mutex of the leader we effectively
4946 : : * lock the child list of all siblings.. XXX explain how.
4947 : : */
4948 : : mutex_lock(&leader->child_mutex);
4949 : :
4950 : : ret = __perf_read_group_add(leader, read_format, values);
4951 : : if (ret)
4952 : : goto unlock;
4953 : :
4954 : : list_for_each_entry(child, &leader->child_list, child_list) {
4955 : : ret = __perf_read_group_add(child, read_format, values);
4956 : : if (ret)
4957 : : goto unlock;
4958 : : }
4959 : :
4960 : : mutex_unlock(&leader->child_mutex);
4961 : :
4962 : : ret = event->read_size;
4963 : : if (copy_to_user(buf, values, event->read_size))
4964 : : ret = -EFAULT;
4965 : : goto out;
4966 : :
4967 : : unlock:
4968 : : mutex_unlock(&leader->child_mutex);
4969 : : out:
4970 : : kfree(values);
4971 : : return ret;
4972 : : }
4973 : :
4974 : 0 : static int perf_read_one(struct perf_event *event,
4975 : : u64 read_format, char __user *buf)
4976 : : {
4977 : 0 : u64 enabled, running;
4978 : 0 : u64 values[4];
4979 : 0 : int n = 0;
4980 : :
4981 : 0 : values[n++] = __perf_event_read_value(event, &enabled, &running);
4982 [ # # ]: 0 : if (read_format & PERF_FORMAT_TOTAL_TIME_ENABLED)
4983 : 0 : values[n++] = enabled;
4984 [ # # ]: 0 : if (read_format & PERF_FORMAT_TOTAL_TIME_RUNNING)
4985 : 0 : values[n++] = running;
4986 [ # # ]: 0 : if (read_format & PERF_FORMAT_ID)
4987 [ # # ]: 0 : values[n++] = primary_event_id(event);
4988 : :
4989 [ # # # # ]: 0 : if (copy_to_user(buf, values, n * sizeof(u64)))
4990 : : return -EFAULT;
4991 : :
4992 : 0 : return n * sizeof(u64);
4993 : : }
4994 : :
4995 : 0 : static bool is_event_hup(struct perf_event *event)
4996 : : {
4997 : 0 : bool no_children;
4998 : :
4999 [ # # ]: 0 : if (event->state > PERF_EVENT_STATE_EXIT)
5000 : : return false;
5001 : :
5002 : 0 : mutex_lock(&event->child_mutex);
5003 : 0 : no_children = list_empty(&event->child_list);
5004 : 0 : mutex_unlock(&event->child_mutex);
5005 : 0 : return no_children;
5006 : : }
5007 : :
5008 : : /*
5009 : : * Read the performance event - simple non blocking version for now
5010 : : */
5011 : : static ssize_t
5012 : 0 : __perf_read(struct perf_event *event, char __user *buf, size_t count)
5013 : : {
5014 : 0 : u64 read_format = event->attr.read_format;
5015 : 0 : int ret;
5016 : :
5017 : : /*
5018 : : * Return end-of-file for a read on an event that is in
5019 : : * error state (i.e. because it was pinned but it couldn't be
5020 : : * scheduled on to the CPU at some point).
5021 : : */
5022 [ # # ]: 0 : if (event->state == PERF_EVENT_STATE_ERROR)
5023 : : return 0;
5024 : :
5025 [ # # ]: 0 : if (count < event->read_size)
5026 : : return -ENOSPC;
5027 : :
5028 [ # # ]: 0 : WARN_ON_ONCE(event->ctx->parent_ctx);
5029 [ # # ]: 0 : if (read_format & PERF_FORMAT_GROUP)
5030 : 0 : ret = perf_read_group(event, read_format, buf);
5031 : : else
5032 : 0 : ret = perf_read_one(event, read_format, buf);
5033 : :
5034 : 0 : return ret;
5035 : : }
5036 : :
5037 : : static ssize_t
5038 : 0 : perf_read(struct file *file, char __user *buf, size_t count, loff_t *ppos)
5039 : : {
5040 : 0 : struct perf_event *event = file->private_data;
5041 : 0 : struct perf_event_context *ctx;
5042 : 0 : int ret;
5043 : :
5044 : 0 : ret = security_perf_event_read(event);
5045 [ # # ]: 0 : if (ret)
5046 : 0 : return ret;
5047 : :
5048 : 0 : ctx = perf_event_ctx_lock(event);
5049 : 0 : ret = __perf_read(event, buf, count);
5050 : 0 : perf_event_ctx_unlock(event, ctx);
5051 : :
5052 : 0 : return ret;
5053 : : }
5054 : :
5055 : 0 : static __poll_t perf_poll(struct file *file, poll_table *wait)
5056 : : {
5057 : 0 : struct perf_event *event = file->private_data;
5058 : 0 : struct perf_buffer *rb;
5059 : 0 : __poll_t events = EPOLLHUP;
5060 : :
5061 [ # # ]: 0 : poll_wait(file, &event->waitq, wait);
5062 : :
5063 [ # # ]: 0 : if (is_event_hup(event))
5064 : : return events;
5065 : :
5066 : : /*
5067 : : * Pin the event->rb by taking event->mmap_mutex; otherwise
5068 : : * perf_event_set_output() can swizzle our rb and make us miss wakeups.
5069 : : */
5070 : 0 : mutex_lock(&event->mmap_mutex);
5071 : 0 : rb = event->rb;
5072 [ # # ]: 0 : if (rb)
5073 : 0 : events = atomic_xchg(&rb->poll, 0);
5074 : 0 : mutex_unlock(&event->mmap_mutex);
5075 : 0 : return events;
5076 : : }
5077 : :
5078 : 0 : static void _perf_event_reset(struct perf_event *event)
5079 : : {
5080 : 0 : (void)perf_event_read(event, false);
5081 : 0 : local64_set(&event->count, 0);
5082 : 0 : perf_event_update_userpage(event);
5083 : 0 : }
5084 : :
5085 : : /* Assume it's not an event with inherit set. */
5086 : 0 : u64 perf_event_pause(struct perf_event *event, bool reset)
5087 : : {
5088 : 0 : struct perf_event_context *ctx;
5089 : 0 : u64 count;
5090 : :
5091 : 0 : ctx = perf_event_ctx_lock(event);
5092 [ # # ]: 0 : WARN_ON_ONCE(event->attr.inherit);
5093 : 0 : _perf_event_disable(event);
5094 : 0 : count = local64_read(&event->count);
5095 [ # # ]: 0 : if (reset)
5096 : 0 : local64_set(&event->count, 0);
5097 : 0 : perf_event_ctx_unlock(event, ctx);
5098 : :
5099 : 0 : return count;
5100 : : }
5101 : : EXPORT_SYMBOL_GPL(perf_event_pause);
5102 : :
5103 : : /*
5104 : : * Holding the top-level event's child_mutex means that any
5105 : : * descendant process that has inherited this event will block
5106 : : * in perf_event_exit_event() if it goes to exit, thus satisfying the
5107 : : * task existence requirements of perf_event_enable/disable.
5108 : : */
5109 : 0 : static void perf_event_for_each_child(struct perf_event *event,
5110 : : void (*func)(struct perf_event *))
5111 : : {
5112 : 0 : struct perf_event *child;
5113 : :
5114 [ # # ]: 0 : WARN_ON_ONCE(event->ctx->parent_ctx);
5115 : :
5116 : 0 : mutex_lock(&event->child_mutex);
5117 : 0 : func(event);
5118 [ # # ]: 0 : list_for_each_entry(child, &event->child_list, child_list)
5119 : 0 : func(child);
5120 : 0 : mutex_unlock(&event->child_mutex);
5121 : 0 : }
5122 : :
5123 : : static void perf_event_for_each(struct perf_event *event,
5124 : : void (*func)(struct perf_event *))
5125 : : {
5126 : : struct perf_event_context *ctx = event->ctx;
5127 : : struct perf_event *sibling;
5128 : :
5129 : : lockdep_assert_held(&ctx->mutex);
5130 : :
5131 : : event = event->group_leader;
5132 : :
5133 : : perf_event_for_each_child(event, func);
5134 : : for_each_sibling_event(sibling, event)
5135 : : perf_event_for_each_child(sibling, func);
5136 : : }
5137 : :
5138 : 0 : static void __perf_event_period(struct perf_event *event,
5139 : : struct perf_cpu_context *cpuctx,
5140 : : struct perf_event_context *ctx,
5141 : : void *info)
5142 : : {
5143 : 0 : u64 value = *((u64 *)info);
5144 : 0 : bool active;
5145 : :
5146 [ # # ]: 0 : if (event->attr.freq) {
5147 : 0 : event->attr.sample_freq = value;
5148 : : } else {
5149 : 0 : event->attr.sample_period = value;
5150 : 0 : event->hw.sample_period = value;
5151 : : }
5152 : :
5153 : 0 : active = (event->state == PERF_EVENT_STATE_ACTIVE);
5154 [ # # ]: 0 : if (active) {
5155 : 0 : perf_pmu_disable(ctx->pmu);
5156 : : /*
5157 : : * We could be throttled; unthrottle now to avoid the tick
5158 : : * trying to unthrottle while we already re-started the event.
5159 : : */
5160 [ # # ]: 0 : if (event->hw.interrupts == MAX_INTERRUPTS) {
5161 : 0 : event->hw.interrupts = 0;
5162 : 0 : perf_log_throttle(event, 1);
5163 : : }
5164 : 0 : event->pmu->stop(event, PERF_EF_UPDATE);
5165 : : }
5166 : :
5167 : 0 : local64_set(&event->hw.period_left, 0);
5168 : :
5169 [ # # ]: 0 : if (active) {
5170 : 0 : event->pmu->start(event, PERF_EF_RELOAD);
5171 : 0 : perf_pmu_enable(ctx->pmu);
5172 : : }
5173 : 0 : }
5174 : :
5175 : 0 : static int perf_event_check_period(struct perf_event *event, u64 value)
5176 : : {
5177 : 0 : return event->pmu->check_period(event, value);
5178 : : }
5179 : :
5180 : 0 : static int _perf_event_period(struct perf_event *event, u64 value)
5181 : : {
5182 [ # # ]: 0 : if (!is_sampling_event(event))
5183 : : return -EINVAL;
5184 : :
5185 [ # # ]: 0 : if (!value)
5186 : : return -EINVAL;
5187 : :
5188 [ # # # # ]: 0 : if (event->attr.freq && value > sysctl_perf_event_sample_rate)
5189 : : return -EINVAL;
5190 : :
5191 [ # # ]: 0 : if (perf_event_check_period(event, value))
5192 : : return -EINVAL;
5193 : :
5194 [ # # # # ]: 0 : if (!event->attr.freq && (value & (1ULL << 63)))
5195 : : return -EINVAL;
5196 : :
5197 : 0 : event_function_call(event, __perf_event_period, &value);
5198 : :
5199 : 0 : return 0;
5200 : : }
5201 : :
5202 : 0 : int perf_event_period(struct perf_event *event, u64 value)
5203 : : {
5204 : 0 : struct perf_event_context *ctx;
5205 : 0 : int ret;
5206 : :
5207 : 0 : ctx = perf_event_ctx_lock(event);
5208 : 0 : ret = _perf_event_period(event, value);
5209 : 0 : perf_event_ctx_unlock(event, ctx);
5210 : :
5211 : 0 : return ret;
5212 : : }
5213 : : EXPORT_SYMBOL_GPL(perf_event_period);
5214 : :
5215 : : static const struct file_operations perf_fops;
5216 : :
5217 : 0 : static inline int perf_fget_light(int fd, struct fd *p)
5218 : : {
5219 : 0 : struct fd f = fdget(fd);
5220 [ # # ]: 0 : if (!f.file)
5221 : : return -EBADF;
5222 : :
5223 [ # # ]: 0 : if (f.file->f_op != &perf_fops) {
5224 [ # # ]: 0 : fdput(f);
5225 : 0 : return -EBADF;
5226 : : }
5227 : 0 : *p = f;
5228 : 0 : return 0;
5229 : : }
5230 : :
5231 : : static int perf_event_set_output(struct perf_event *event,
5232 : : struct perf_event *output_event);
5233 : : static int perf_event_set_filter(struct perf_event *event, void __user *arg);
5234 : : static int perf_event_set_bpf_prog(struct perf_event *event, u32 prog_fd);
5235 : : static int perf_copy_attr(struct perf_event_attr __user *uattr,
5236 : : struct perf_event_attr *attr);
5237 : :
5238 : 0 : static long _perf_ioctl(struct perf_event *event, unsigned int cmd, unsigned long arg)
5239 : : {
5240 : 0 : void (*func)(struct perf_event *);
5241 : 0 : u32 flags = arg;
5242 : :
5243 [ # # # # : 0 : switch (cmd) {
# # # # #
# # # # ]
5244 : : case PERF_EVENT_IOC_ENABLE:
5245 : : func = _perf_event_enable;
5246 : : break;
5247 : 0 : case PERF_EVENT_IOC_DISABLE:
5248 : 0 : func = _perf_event_disable;
5249 : 0 : break;
5250 : 0 : case PERF_EVENT_IOC_RESET:
5251 : 0 : func = _perf_event_reset;
5252 : 0 : break;
5253 : :
5254 : 0 : case PERF_EVENT_IOC_REFRESH:
5255 : 0 : return _perf_event_refresh(event, arg);
5256 : :
5257 : 0 : case PERF_EVENT_IOC_PERIOD:
5258 : : {
5259 : 0 : u64 value;
5260 : :
5261 [ # # ]: 0 : if (copy_from_user(&value, (u64 __user *)arg, sizeof(value)))
5262 : : return -EFAULT;
5263 : :
5264 : 0 : return _perf_event_period(event, value);
5265 : : }
5266 : 0 : case PERF_EVENT_IOC_ID:
5267 : : {
5268 [ # # ]: 0 : u64 id = primary_event_id(event);
5269 : :
5270 [ # # ]: 0 : if (copy_to_user((void __user *)arg, &id, sizeof(id)))
5271 : 0 : return -EFAULT;
5272 : : return 0;
5273 : : }
5274 : :
5275 : 0 : case PERF_EVENT_IOC_SET_OUTPUT:
5276 : : {
5277 : 0 : int ret;
5278 [ # # ]: 0 : if (arg != -1) {
5279 : 0 : struct perf_event *output_event;
5280 : 0 : struct fd output;
5281 : 0 : ret = perf_fget_light(arg, &output);
5282 [ # # ]: 0 : if (ret)
5283 : 0 : return ret;
5284 : 0 : output_event = output.file->private_data;
5285 : 0 : ret = perf_event_set_output(event, output_event);
5286 [ # # ]: 0 : fdput(output);
5287 : : } else {
5288 : 0 : ret = perf_event_set_output(event, NULL);
5289 : : }
5290 : 0 : return ret;
5291 : : }
5292 : :
5293 : 0 : case PERF_EVENT_IOC_SET_FILTER:
5294 : 0 : return perf_event_set_filter(event, (void __user *)arg);
5295 : :
5296 : 0 : case PERF_EVENT_IOC_SET_BPF:
5297 : 0 : return perf_event_set_bpf_prog(event, arg);
5298 : :
5299 : : case PERF_EVENT_IOC_PAUSE_OUTPUT: {
5300 : 0 : struct perf_buffer *rb;
5301 : :
5302 : 0 : rcu_read_lock();
5303 [ # # ]: 0 : rb = rcu_dereference(event->rb);
5304 [ # # # # ]: 0 : if (!rb || !rb->nr_pages) {
5305 : 0 : rcu_read_unlock();
5306 : 0 : return -EINVAL;
5307 : : }
5308 [ # # ]: 0 : rb_toggle_paused(rb, !!arg);
5309 : 0 : rcu_read_unlock();
5310 : 0 : return 0;
5311 : : }
5312 : :
5313 : 0 : case PERF_EVENT_IOC_QUERY_BPF:
5314 : 0 : return perf_event_query_prog_array(event, (void __user *)arg);
5315 : :
5316 : 0 : case PERF_EVENT_IOC_MODIFY_ATTRIBUTES: {
5317 : 0 : struct perf_event_attr new_attr;
5318 : 0 : int err = perf_copy_attr((struct perf_event_attr __user *)arg,
5319 : : &new_attr);
5320 : :
5321 [ # # ]: 0 : if (err)
5322 : 0 : return err;
5323 : :
5324 [ # # ]: 0 : return perf_event_modify_attr(event, &new_attr);
5325 : : }
5326 : : default:
5327 : : return -ENOTTY;
5328 : : }
5329 : :
5330 [ # # ]: 0 : if (flags & PERF_IOC_FLAG_GROUP)
5331 : 0 : perf_event_for_each(event, func);
5332 : : else
5333 : 0 : perf_event_for_each_child(event, func);
5334 : :
5335 : : return 0;
5336 : : }
5337 : :
5338 : 0 : static long perf_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
5339 : : {
5340 : 0 : struct perf_event *event = file->private_data;
5341 : 0 : struct perf_event_context *ctx;
5342 : 0 : long ret;
5343 : :
5344 : : /* Treat ioctl like writes as it is likely a mutating operation. */
5345 : 0 : ret = security_perf_event_write(event);
5346 [ # # ]: 0 : if (ret)
5347 : : return ret;
5348 : :
5349 : 0 : ctx = perf_event_ctx_lock(event);
5350 : 0 : ret = _perf_ioctl(event, cmd, arg);
5351 : 0 : perf_event_ctx_unlock(event, ctx);
5352 : :
5353 : 0 : return ret;
5354 : : }
5355 : :
5356 : : #ifdef CONFIG_COMPAT
5357 : 0 : static long perf_compat_ioctl(struct file *file, unsigned int cmd,
5358 : : unsigned long arg)
5359 : : {
5360 [ # # ]: 0 : switch (_IOC_NR(cmd)) {
5361 : 0 : case _IOC_NR(PERF_EVENT_IOC_SET_FILTER):
5362 : : case _IOC_NR(PERF_EVENT_IOC_ID):
5363 : : case _IOC_NR(PERF_EVENT_IOC_QUERY_BPF):
5364 : : case _IOC_NR(PERF_EVENT_IOC_MODIFY_ATTRIBUTES):
5365 : : /* Fix up pointer size (usually 4 -> 8 in 32-on-64-bit case */
5366 [ # # ]: 0 : if (_IOC_SIZE(cmd) == sizeof(compat_uptr_t)) {
5367 : 0 : cmd &= ~IOCSIZE_MASK;
5368 : 0 : cmd |= sizeof(void *) << IOCSIZE_SHIFT;
5369 : : }
5370 : : break;
5371 : : }
5372 : 0 : return perf_ioctl(file, cmd, arg);
5373 : : }
5374 : : #else
5375 : : # define perf_compat_ioctl NULL
5376 : : #endif
5377 : :
5378 : 0 : int perf_event_task_enable(void)
5379 : : {
5380 : 0 : struct perf_event_context *ctx;
5381 : 0 : struct perf_event *event;
5382 : :
5383 : 0 : mutex_lock(¤t->perf_event_mutex);
5384 [ # # ]: 0 : list_for_each_entry(event, ¤t->perf_event_list, owner_entry) {
5385 : 0 : ctx = perf_event_ctx_lock(event);
5386 : 0 : perf_event_for_each_child(event, _perf_event_enable);
5387 : 0 : perf_event_ctx_unlock(event, ctx);
5388 : : }
5389 : 0 : mutex_unlock(¤t->perf_event_mutex);
5390 : :
5391 : 0 : return 0;
5392 : : }
5393 : :
5394 : 0 : int perf_event_task_disable(void)
5395 : : {
5396 : 0 : struct perf_event_context *ctx;
5397 : 0 : struct perf_event *event;
5398 : :
5399 : 0 : mutex_lock(¤t->perf_event_mutex);
5400 [ # # ]: 0 : list_for_each_entry(event, ¤t->perf_event_list, owner_entry) {
5401 : 0 : ctx = perf_event_ctx_lock(event);
5402 : 0 : perf_event_for_each_child(event, _perf_event_disable);
5403 : 0 : perf_event_ctx_unlock(event, ctx);
5404 : : }
5405 : 0 : mutex_unlock(¤t->perf_event_mutex);
5406 : :
5407 : 0 : return 0;
5408 : : }
5409 : :
5410 : 0 : static int perf_event_index(struct perf_event *event)
5411 : : {
5412 : 0 : if (event->hw.state & PERF_HES_STOPPED)
5413 : : return 0;
5414 : :
5415 [ # # ]: 0 : if (event->state != PERF_EVENT_STATE_ACTIVE)
5416 : : return 0;
5417 : :
5418 : 0 : return event->pmu->event_idx(event);
5419 : : }
5420 : :
5421 : 0 : static void calc_timer_values(struct perf_event *event,
5422 : : u64 *now,
5423 : : u64 *enabled,
5424 : : u64 *running)
5425 : : {
5426 : 0 : u64 ctx_time;
5427 : :
5428 : 0 : *now = perf_clock();
5429 : 0 : ctx_time = event->shadow_ctx_time + *now;
5430 [ # # ]: 0 : __perf_update_times(event, ctx_time, enabled, running);
5431 : 0 : }
5432 : :
5433 : 0 : static void perf_event_init_userpage(struct perf_event *event)
5434 : : {
5435 : 0 : struct perf_event_mmap_page *userpg;
5436 : 0 : struct perf_buffer *rb;
5437 : :
5438 : 0 : rcu_read_lock();
5439 [ # # ]: 0 : rb = rcu_dereference(event->rb);
5440 [ # # ]: 0 : if (!rb)
5441 : 0 : goto unlock;
5442 : :
5443 : 0 : userpg = rb->user_page;
5444 : :
5445 : : /* Allow new userspace to detect that bit 0 is deprecated */
5446 : 0 : userpg->cap_bit0_is_deprecated = 1;
5447 : 0 : userpg->size = offsetof(struct perf_event_mmap_page, __reserved);
5448 : 0 : userpg->data_offset = PAGE_SIZE;
5449 : 0 : userpg->data_size = perf_data_size(rb);
5450 : :
5451 : 0 : unlock:
5452 : 0 : rcu_read_unlock();
5453 : : }
5454 : :
5455 : 0 : void __weak arch_perf_update_userpage(
5456 : : struct perf_event *event, struct perf_event_mmap_page *userpg, u64 now)
5457 : : {
5458 : 0 : }
5459 : :
5460 : : /*
5461 : : * Callers need to ensure there can be no nesting of this function, otherwise
5462 : : * the seqlock logic goes bad. We can not serialize this because the arch
5463 : : * code calls this from NMI context.
5464 : : */
5465 : 0 : void perf_event_update_userpage(struct perf_event *event)
5466 : : {
5467 : 0 : struct perf_event_mmap_page *userpg;
5468 : 0 : struct perf_buffer *rb;
5469 : 0 : u64 enabled, running, now;
5470 : :
5471 : 0 : rcu_read_lock();
5472 [ # # ]: 0 : rb = rcu_dereference(event->rb);
5473 [ # # ]: 0 : if (!rb)
5474 : 0 : goto unlock;
5475 : :
5476 : : /*
5477 : : * compute total_time_enabled, total_time_running
5478 : : * based on snapshot values taken when the event
5479 : : * was last scheduled in.
5480 : : *
5481 : : * we cannot simply called update_context_time()
5482 : : * because of locking issue as we can be called in
5483 : : * NMI context
5484 : : */
5485 : 0 : calc_timer_values(event, &now, &enabled, &running);
5486 : :
5487 : 0 : userpg = rb->user_page;
5488 : : /*
5489 : : * Disable preemption to guarantee consistent time stamps are stored to
5490 : : * the user page.
5491 : : */
5492 : 0 : preempt_disable();
5493 : 0 : ++userpg->lock;
5494 : 0 : barrier();
5495 [ # # ]: 0 : userpg->index = perf_event_index(event);
5496 : 0 : userpg->offset = perf_event_count(event);
5497 [ # # ]: 0 : if (userpg->index)
5498 : 0 : userpg->offset -= local64_read(&event->hw.prev_count);
5499 : :
5500 : 0 : userpg->time_enabled = enabled +
5501 : 0 : atomic64_read(&event->child_total_time_enabled);
5502 : :
5503 : 0 : userpg->time_running = running +
5504 : 0 : atomic64_read(&event->child_total_time_running);
5505 : :
5506 : 0 : arch_perf_update_userpage(event, userpg, now);
5507 : :
5508 : 0 : barrier();
5509 : 0 : ++userpg->lock;
5510 : 0 : preempt_enable();
5511 : 0 : unlock:
5512 : 0 : rcu_read_unlock();
5513 : 0 : }
5514 : : EXPORT_SYMBOL_GPL(perf_event_update_userpage);
5515 : :
5516 : 0 : static vm_fault_t perf_mmap_fault(struct vm_fault *vmf)
5517 : : {
5518 : 0 : struct perf_event *event = vmf->vma->vm_file->private_data;
5519 : 0 : struct perf_buffer *rb;
5520 : 0 : vm_fault_t ret = VM_FAULT_SIGBUS;
5521 : :
5522 [ # # ]: 0 : if (vmf->flags & FAULT_FLAG_MKWRITE) {
5523 [ # # ]: 0 : if (vmf->pgoff == 0)
5524 : 0 : ret = 0;
5525 : 0 : return ret;
5526 : : }
5527 : :
5528 : 0 : rcu_read_lock();
5529 [ # # ]: 0 : rb = rcu_dereference(event->rb);
5530 [ # # ]: 0 : if (!rb)
5531 : 0 : goto unlock;
5532 : :
5533 [ # # # # ]: 0 : if (vmf->pgoff && (vmf->flags & FAULT_FLAG_WRITE))
5534 : 0 : goto unlock;
5535 : :
5536 : 0 : vmf->page = perf_mmap_to_page(rb, vmf->pgoff);
5537 [ # # ]: 0 : if (!vmf->page)
5538 : 0 : goto unlock;
5539 : :
5540 [ # # ]: 0 : get_page(vmf->page);
5541 : 0 : vmf->page->mapping = vmf->vma->vm_file->f_mapping;
5542 : 0 : vmf->page->index = vmf->pgoff;
5543 : :
5544 : 0 : ret = 0;
5545 : 0 : unlock:
5546 : 0 : rcu_read_unlock();
5547 : :
5548 : 0 : return ret;
5549 : : }
5550 : :
5551 : 0 : static void ring_buffer_attach(struct perf_event *event,
5552 : : struct perf_buffer *rb)
5553 : : {
5554 : 0 : struct perf_buffer *old_rb = NULL;
5555 : 0 : unsigned long flags;
5556 : :
5557 [ # # ]: 0 : if (event->rb) {
5558 : : /*
5559 : : * Should be impossible, we set this when removing
5560 : : * event->rb_entry and wait/clear when adding event->rb_entry.
5561 : : */
5562 [ # # ]: 0 : WARN_ON_ONCE(event->rcu_pending);
5563 : :
5564 : 0 : old_rb = event->rb;
5565 : 0 : spin_lock_irqsave(&old_rb->event_lock, flags);
5566 : 0 : list_del_rcu(&event->rb_entry);
5567 : 0 : spin_unlock_irqrestore(&old_rb->event_lock, flags);
5568 : :
5569 : 0 : event->rcu_batches = get_state_synchronize_rcu();
5570 : 0 : event->rcu_pending = 1;
5571 : : }
5572 : :
5573 [ # # ]: 0 : if (rb) {
5574 [ # # ]: 0 : if (event->rcu_pending) {
5575 : 0 : cond_synchronize_rcu(event->rcu_batches);
5576 : 0 : event->rcu_pending = 0;
5577 : : }
5578 : :
5579 : 0 : spin_lock_irqsave(&rb->event_lock, flags);
5580 : 0 : list_add_rcu(&event->rb_entry, &rb->event_list);
5581 : 0 : spin_unlock_irqrestore(&rb->event_lock, flags);
5582 : : }
5583 : :
5584 : : /*
5585 : : * Avoid racing with perf_mmap_close(AUX): stop the event
5586 : : * before swizzling the event::rb pointer; if it's getting
5587 : : * unmapped, its aux_mmap_count will be 0 and it won't
5588 : : * restart. See the comment in __perf_pmu_output_stop().
5589 : : *
5590 : : * Data will inevitably be lost when set_output is done in
5591 : : * mid-air, but then again, whoever does it like this is
5592 : : * not in for the data anyway.
5593 : : */
5594 [ # # ]: 0 : if (has_aux(event))
5595 : 0 : perf_event_stop(event, 0);
5596 : :
5597 [ # # ]: 0 : rcu_assign_pointer(event->rb, rb);
5598 : :
5599 [ # # ]: 0 : if (old_rb) {
5600 : 0 : ring_buffer_put(old_rb);
5601 : : /*
5602 : : * Since we detached before setting the new rb, so that we
5603 : : * could attach the new rb, we could have missed a wakeup.
5604 : : * Provide it now.
5605 : : */
5606 : 0 : wake_up_all(&event->waitq);
5607 : : }
5608 : 0 : }
5609 : :
5610 : 0 : static void ring_buffer_wakeup(struct perf_event *event)
5611 : : {
5612 : 0 : struct perf_buffer *rb;
5613 : :
5614 : 0 : rcu_read_lock();
5615 [ # # ]: 0 : rb = rcu_dereference(event->rb);
5616 [ # # ]: 0 : if (rb) {
5617 [ # # ]: 0 : list_for_each_entry_rcu(event, &rb->event_list, rb_entry)
5618 : 0 : wake_up_all(&event->waitq);
5619 : : }
5620 : 0 : rcu_read_unlock();
5621 : 0 : }
5622 : :
5623 : 0 : struct perf_buffer *ring_buffer_get(struct perf_event *event)
5624 : : {
5625 : 0 : struct perf_buffer *rb;
5626 : :
5627 : 0 : rcu_read_lock();
5628 [ # # ]: 0 : rb = rcu_dereference(event->rb);
5629 [ # # ]: 0 : if (rb) {
5630 [ # # ]: 0 : if (!refcount_inc_not_zero(&rb->refcount))
5631 : 0 : rb = NULL;
5632 : : }
5633 : 0 : rcu_read_unlock();
5634 : :
5635 : 0 : return rb;
5636 : : }
5637 : :
5638 : 0 : void ring_buffer_put(struct perf_buffer *rb)
5639 : : {
5640 [ # # ]: 0 : if (!refcount_dec_and_test(&rb->refcount))
5641 : : return;
5642 : :
5643 [ # # ]: 0 : WARN_ON_ONCE(!list_empty(&rb->event_list));
5644 : :
5645 : 0 : call_rcu(&rb->rcu_head, rb_free_rcu);
5646 : : }
5647 : :
5648 : 0 : static void perf_mmap_open(struct vm_area_struct *vma)
5649 : : {
5650 : 0 : struct perf_event *event = vma->vm_file->private_data;
5651 : :
5652 : 0 : atomic_inc(&event->mmap_count);
5653 : 0 : atomic_inc(&event->rb->mmap_count);
5654 : :
5655 [ # # ]: 0 : if (vma->vm_pgoff)
5656 : 0 : atomic_inc(&event->rb->aux_mmap_count);
5657 : :
5658 [ # # ]: 0 : if (event->pmu->event_mapped)
5659 : 0 : event->pmu->event_mapped(event, vma->vm_mm);
5660 : 0 : }
5661 : :
5662 : : static void perf_pmu_output_stop(struct perf_event *event);
5663 : :
5664 : : /*
5665 : : * A buffer can be mmap()ed multiple times; either directly through the same
5666 : : * event, or through other events by use of perf_event_set_output().
5667 : : *
5668 : : * In order to undo the VM accounting done by perf_mmap() we need to destroy
5669 : : * the buffer here, where we still have a VM context. This means we need
5670 : : * to detach all events redirecting to us.
5671 : : */
5672 : 0 : static void perf_mmap_close(struct vm_area_struct *vma)
5673 : : {
5674 : 0 : struct perf_event *event = vma->vm_file->private_data;
5675 : :
5676 : 0 : struct perf_buffer *rb = ring_buffer_get(event);
5677 : 0 : struct user_struct *mmap_user = rb->mmap_user;
5678 : 0 : int mmap_locked = rb->mmap_locked;
5679 [ # # ]: 0 : unsigned long size = perf_data_size(rb);
5680 : :
5681 [ # # ]: 0 : if (event->pmu->event_unmapped)
5682 : 0 : event->pmu->event_unmapped(event, vma->vm_mm);
5683 : :
5684 : : /*
5685 : : * rb->aux_mmap_count will always drop before rb->mmap_count and
5686 : : * event->mmap_count, so it is ok to use event->mmap_mutex to
5687 : : * serialize with perf_mmap here.
5688 : : */
5689 [ # # # # : 0 : if (rb_has_aux(rb) && vma->vm_pgoff == rb->aux_pgoff &&
# # ]
5690 : 0 : atomic_dec_and_mutex_lock(&rb->aux_mmap_count, &event->mmap_mutex)) {
5691 : : /*
5692 : : * Stop all AUX events that are writing to this buffer,
5693 : : * so that we can free its AUX pages and corresponding PMU
5694 : : * data. Note that after rb::aux_mmap_count dropped to zero,
5695 : : * they won't start any more (see perf_aux_output_begin()).
5696 : : */
5697 : 0 : perf_pmu_output_stop(event);
5698 : :
5699 : : /* now it's safe to free the pages */
5700 : 0 : atomic_long_sub(rb->aux_nr_pages - rb->aux_mmap_locked, &mmap_user->locked_vm);
5701 : 0 : atomic64_sub(rb->aux_mmap_locked, &vma->vm_mm->pinned_vm);
5702 : :
5703 : : /* this has to be the last one */
5704 : 0 : rb_free_aux(rb);
5705 [ # # ]: 0 : WARN_ON_ONCE(refcount_read(&rb->aux_refcount));
5706 : :
5707 : 0 : mutex_unlock(&event->mmap_mutex);
5708 : : }
5709 : :
5710 : 0 : atomic_dec(&rb->mmap_count);
5711 : :
5712 [ # # ]: 0 : if (!atomic_dec_and_mutex_lock(&event->mmap_count, &event->mmap_mutex))
5713 : 0 : goto out_put;
5714 : :
5715 : 0 : ring_buffer_attach(event, NULL);
5716 : 0 : mutex_unlock(&event->mmap_mutex);
5717 : :
5718 : : /* If there's still other mmap()s of this buffer, we're done. */
5719 [ # # ]: 0 : if (atomic_read(&rb->mmap_count))
5720 : 0 : goto out_put;
5721 : :
5722 : : /*
5723 : : * No other mmap()s, detach from all other events that might redirect
5724 : : * into the now unreachable buffer. Somewhat complicated by the
5725 : : * fact that rb::event_lock otherwise nests inside mmap_mutex.
5726 : : */
5727 : 0 : again:
5728 : 0 : rcu_read_lock();
5729 [ # # ]: 0 : list_for_each_entry_rcu(event, &rb->event_list, rb_entry) {
5730 [ # # ]: 0 : if (!atomic_long_inc_not_zero(&event->refcount)) {
5731 : : /*
5732 : : * This event is en-route to free_event() which will
5733 : : * detach it and remove it from the list.
5734 : : */
5735 : 0 : continue;
5736 : : }
5737 : 0 : rcu_read_unlock();
5738 : :
5739 : 0 : mutex_lock(&event->mmap_mutex);
5740 : : /*
5741 : : * Check we didn't race with perf_event_set_output() which can
5742 : : * swizzle the rb from under us while we were waiting to
5743 : : * acquire mmap_mutex.
5744 : : *
5745 : : * If we find a different rb; ignore this event, a next
5746 : : * iteration will no longer find it on the list. We have to
5747 : : * still restart the iteration to make sure we're not now
5748 : : * iterating the wrong list.
5749 : : */
5750 [ # # ]: 0 : if (event->rb == rb)
5751 : 0 : ring_buffer_attach(event, NULL);
5752 : :
5753 : 0 : mutex_unlock(&event->mmap_mutex);
5754 : 0 : put_event(event);
5755 : :
5756 : : /*
5757 : : * Restart the iteration; either we're on the wrong list or
5758 : : * destroyed its integrity by doing a deletion.
5759 : : */
5760 : 0 : goto again;
5761 : : }
5762 : 0 : rcu_read_unlock();
5763 : :
5764 : : /*
5765 : : * It could be there's still a few 0-ref events on the list; they'll
5766 : : * get cleaned up by free_event() -- they'll also still have their
5767 : : * ref on the rb and will free it whenever they are done with it.
5768 : : *
5769 : : * Aside from that, this buffer is 'fully' detached and unmapped,
5770 : : * undo the VM accounting.
5771 : : */
5772 : :
5773 : 0 : atomic_long_sub((size >> PAGE_SHIFT) + 1 - mmap_locked,
5774 : : &mmap_user->locked_vm);
5775 : 0 : atomic64_sub(mmap_locked, &vma->vm_mm->pinned_vm);
5776 : 0 : free_uid(mmap_user);
5777 : :
5778 : 0 : out_put:
5779 : 0 : ring_buffer_put(rb); /* could be last */
5780 : 0 : }
5781 : :
5782 : : static const struct vm_operations_struct perf_mmap_vmops = {
5783 : : .open = perf_mmap_open,
5784 : : .close = perf_mmap_close, /* non mergeable */
5785 : : .fault = perf_mmap_fault,
5786 : : .page_mkwrite = perf_mmap_fault,
5787 : : };
5788 : :
5789 : 0 : static int perf_mmap(struct file *file, struct vm_area_struct *vma)
5790 : : {
5791 : 0 : struct perf_event *event = file->private_data;
5792 : 0 : unsigned long user_locked, user_lock_limit;
5793 [ # # ]: 0 : struct user_struct *user = current_user();
5794 : 0 : struct perf_buffer *rb = NULL;
5795 : 0 : unsigned long locked, lock_limit;
5796 : 0 : unsigned long vma_size;
5797 : 0 : unsigned long nr_pages;
5798 : 0 : long user_extra = 0, extra = 0;
5799 : 0 : int ret = 0, flags = 0;
5800 : :
5801 : : /*
5802 : : * Don't allow mmap() of inherited per-task counters. This would
5803 : : * create a performance issue due to all children writing to the
5804 : : * same rb.
5805 : : */
5806 [ # # # # ]: 0 : if (event->cpu == -1 && event->attr.inherit)
5807 : : return -EINVAL;
5808 : :
5809 [ # # ]: 0 : if (!(vma->vm_flags & VM_SHARED))
5810 : : return -EINVAL;
5811 : :
5812 : 0 : ret = security_perf_event_read(event);
5813 [ # # ]: 0 : if (ret)
5814 : : return ret;
5815 : :
5816 : 0 : vma_size = vma->vm_end - vma->vm_start;
5817 : :
5818 [ # # ]: 0 : if (vma->vm_pgoff == 0) {
5819 : 0 : nr_pages = (vma_size / PAGE_SIZE) - 1;
5820 : : } else {
5821 : : /*
5822 : : * AUX area mapping: if rb->aux_nr_pages != 0, it's already
5823 : : * mapped, all subsequent mappings should have the same size
5824 : : * and offset. Must be above the normal perf buffer.
5825 : : */
5826 : 0 : u64 aux_offset, aux_size;
5827 : :
5828 [ # # ]: 0 : if (!event->rb)
5829 : : return -EINVAL;
5830 : :
5831 : 0 : nr_pages = vma_size / PAGE_SIZE;
5832 : :
5833 : 0 : mutex_lock(&event->mmap_mutex);
5834 : 0 : ret = -EINVAL;
5835 : :
5836 : 0 : rb = event->rb;
5837 [ # # ]: 0 : if (!rb)
5838 : 0 : goto aux_unlock;
5839 : :
5840 [ # # ]: 0 : aux_offset = READ_ONCE(rb->user_page->aux_offset);
5841 : 0 : aux_size = READ_ONCE(rb->user_page->aux_size);
5842 : :
5843 [ # # ]: 0 : if (aux_offset < perf_data_size(rb) + PAGE_SIZE)
5844 : 0 : goto aux_unlock;
5845 : :
5846 [ # # ]: 0 : if (aux_offset != vma->vm_pgoff << PAGE_SHIFT)
5847 : 0 : goto aux_unlock;
5848 : :
5849 : : /* already mapped with a different offset */
5850 [ # # # # ]: 0 : if (rb_has_aux(rb) && rb->aux_pgoff != vma->vm_pgoff)
5851 : 0 : goto aux_unlock;
5852 : :
5853 [ # # # # ]: 0 : if (aux_size != vma_size || aux_size != nr_pages * PAGE_SIZE)
5854 : 0 : goto aux_unlock;
5855 : :
5856 : : /* already mapped with a different size */
5857 [ # # # # ]: 0 : if (rb_has_aux(rb) && rb->aux_nr_pages != nr_pages)
5858 : 0 : goto aux_unlock;
5859 : :
5860 [ # # # # ]: 0 : if (!is_power_of_2(nr_pages))
5861 : 0 : goto aux_unlock;
5862 : :
5863 [ # # ]: 0 : if (!atomic_inc_not_zero(&rb->mmap_count))
5864 : 0 : goto aux_unlock;
5865 : :
5866 [ # # ]: 0 : if (rb_has_aux(rb)) {
5867 : 0 : atomic_inc(&rb->aux_mmap_count);
5868 : 0 : ret = 0;
5869 : 0 : goto unlock;
5870 : : }
5871 : :
5872 : 0 : atomic_set(&rb->aux_mmap_count, 1);
5873 : 0 : user_extra = nr_pages;
5874 : :
5875 : 0 : goto accounting;
5876 : : }
5877 : :
5878 : : /*
5879 : : * If we have rb pages ensure they're a power-of-two number, so we
5880 : : * can do bitmasks instead of modulo.
5881 : : */
5882 [ # # # # ]: 0 : if (nr_pages != 0 && !is_power_of_2(nr_pages))
5883 : : return -EINVAL;
5884 : :
5885 [ # # ]: 0 : if (vma_size != PAGE_SIZE * (1 + nr_pages))
5886 : : return -EINVAL;
5887 : :
5888 [ # # ]: 0 : WARN_ON_ONCE(event->ctx->parent_ctx);
5889 : : again:
5890 : 0 : mutex_lock(&event->mmap_mutex);
5891 [ # # ]: 0 : if (event->rb) {
5892 [ # # ]: 0 : if (event->rb->nr_pages != nr_pages) {
5893 : 0 : ret = -EINVAL;
5894 : 0 : goto unlock;
5895 : : }
5896 : :
5897 [ # # ]: 0 : if (!atomic_inc_not_zero(&event->rb->mmap_count)) {
5898 : : /*
5899 : : * Raced against perf_mmap_close() through
5900 : : * perf_event_set_output(). Try again, hope for better
5901 : : * luck.
5902 : : */
5903 : 0 : mutex_unlock(&event->mmap_mutex);
5904 : 0 : goto again;
5905 : : }
5906 : :
5907 : 0 : goto unlock;
5908 : : }
5909 : :
5910 : 0 : user_extra = nr_pages + 1;
5911 : :
5912 : 0 : accounting:
5913 : 0 : user_lock_limit = sysctl_perf_event_mlock >> (PAGE_SHIFT - 10);
5914 : :
5915 : : /*
5916 : : * Increase the limit linearly with more CPUs:
5917 : : */
5918 : 0 : user_lock_limit *= num_online_cpus();
5919 : :
5920 : 0 : user_locked = atomic_long_read(&user->locked_vm);
5921 : :
5922 : : /*
5923 : : * sysctl_perf_event_mlock may have changed, so that
5924 : : * user->locked_vm > user_lock_limit
5925 : : */
5926 : 0 : if (user_locked > user_lock_limit)
5927 : : user_locked = user_lock_limit;
5928 : 0 : user_locked += user_extra;
5929 : :
5930 [ # # ]: 0 : if (user_locked > user_lock_limit) {
5931 : : /*
5932 : : * charge locked_vm until it hits user_lock_limit;
5933 : : * charge the rest from pinned_vm
5934 : : */
5935 : 0 : extra = user_locked - user_lock_limit;
5936 : 0 : user_extra -= extra;
5937 : : }
5938 : :
5939 : 0 : lock_limit = rlimit(RLIMIT_MEMLOCK);
5940 : 0 : lock_limit >>= PAGE_SHIFT;
5941 : 0 : locked = atomic64_read(&vma->vm_mm->pinned_vm) + extra;
5942 : :
5943 [ # # # # : 0 : if ((locked > lock_limit) && perf_is_paranoid() &&
# # ]
5944 : 0 : !capable(CAP_IPC_LOCK)) {
5945 : 0 : ret = -EPERM;
5946 : 0 : goto unlock;
5947 : : }
5948 : :
5949 [ # # # # : 0 : WARN_ON(!rb && event->rb);
# # ]
5950 : :
5951 [ # # ]: 0 : if (vma->vm_flags & VM_WRITE)
5952 : 0 : flags |= RING_BUFFER_WRITABLE;
5953 : :
5954 [ # # ]: 0 : if (!rb) {
5955 : 0 : rb = rb_alloc(nr_pages,
5956 [ # # ]: 0 : event->attr.watermark ? event->attr.wakeup_watermark : 0,
5957 : : event->cpu, flags);
5958 : :
5959 [ # # ]: 0 : if (!rb) {
5960 : 0 : ret = -ENOMEM;
5961 : 0 : goto unlock;
5962 : : }
5963 : :
5964 : 0 : atomic_set(&rb->mmap_count, 1);
5965 : 0 : rb->mmap_user = get_current_user();
5966 : 0 : rb->mmap_locked = extra;
5967 : :
5968 : 0 : ring_buffer_attach(event, rb);
5969 : :
5970 : 0 : perf_event_init_userpage(event);
5971 : 0 : perf_event_update_userpage(event);
5972 : : } else {
5973 : 0 : ret = rb_alloc_aux(rb, event, vma->vm_pgoff, nr_pages,
5974 : 0 : event->attr.aux_watermark, flags);
5975 [ # # ]: 0 : if (!ret)
5976 : 0 : rb->aux_mmap_locked = extra;
5977 : : }
5978 : :
5979 : 0 : unlock:
5980 [ # # ]: 0 : if (!ret) {
5981 : 0 : atomic_long_add(user_extra, &user->locked_vm);
5982 : 0 : atomic64_add(extra, &vma->vm_mm->pinned_vm);
5983 : :
5984 : 0 : atomic_inc(&event->mmap_count);
5985 [ # # ]: 0 : } else if (rb) {
5986 : 0 : atomic_dec(&rb->mmap_count);
5987 : : }
5988 : 0 : aux_unlock:
5989 : 0 : mutex_unlock(&event->mmap_mutex);
5990 : :
5991 : : /*
5992 : : * Since pinned accounting is per vm we cannot allow fork() to copy our
5993 : : * vma.
5994 : : */
5995 : 0 : vma->vm_flags |= VM_DONTCOPY | VM_DONTEXPAND | VM_DONTDUMP;
5996 : 0 : vma->vm_ops = &perf_mmap_vmops;
5997 : :
5998 [ # # ]: 0 : if (event->pmu->event_mapped)
5999 : 0 : event->pmu->event_mapped(event, vma->vm_mm);
6000 : :
6001 : : return ret;
6002 : : }
6003 : :
6004 : 0 : static int perf_fasync(int fd, struct file *filp, int on)
6005 : : {
6006 : 0 : struct inode *inode = file_inode(filp);
6007 : 0 : struct perf_event *event = filp->private_data;
6008 : 0 : int retval;
6009 : :
6010 : 0 : inode_lock(inode);
6011 : 0 : retval = fasync_helper(fd, filp, on, &event->fasync);
6012 : 0 : inode_unlock(inode);
6013 : :
6014 : 0 : if (retval < 0)
6015 : : return retval;
6016 : :
6017 : : return 0;
6018 : : }
6019 : :
6020 : : static const struct file_operations perf_fops = {
6021 : : .llseek = no_llseek,
6022 : : .release = perf_release,
6023 : : .read = perf_read,
6024 : : .poll = perf_poll,
6025 : : .unlocked_ioctl = perf_ioctl,
6026 : : .compat_ioctl = perf_compat_ioctl,
6027 : : .mmap = perf_mmap,
6028 : : .fasync = perf_fasync,
6029 : : };
6030 : :
6031 : : /*
6032 : : * Perf event wakeup
6033 : : *
6034 : : * If there's data, ensure we set the poll() state and publish everything
6035 : : * to user-space before waking everybody up.
6036 : : */
6037 : :
6038 : 0 : static inline struct fasync_struct **perf_event_fasync(struct perf_event *event)
6039 : : {
6040 : : /* only the parent has fasync state */
6041 : 0 : if (event->parent)
6042 : 0 : event = event->parent;
6043 : 0 : return &event->fasync;
6044 : : }
6045 : :
6046 : 0 : void perf_event_wakeup(struct perf_event *event)
6047 : : {
6048 : 0 : ring_buffer_wakeup(event);
6049 : :
6050 [ # # ]: 0 : if (event->pending_kill) {
6051 [ # # ]: 0 : kill_fasync(perf_event_fasync(event), SIGIO, event->pending_kill);
6052 : 0 : event->pending_kill = 0;
6053 : : }
6054 : 0 : }
6055 : :
6056 : 0 : static void perf_pending_event_disable(struct perf_event *event)
6057 : : {
6058 [ # # ]: 0 : int cpu = READ_ONCE(event->pending_disable);
6059 : :
6060 [ # # ]: 0 : if (cpu < 0)
6061 : : return;
6062 : :
6063 [ # # ]: 0 : if (cpu == smp_processor_id()) {
6064 : 0 : WRITE_ONCE(event->pending_disable, -1);
6065 : 0 : perf_event_disable_local(event);
6066 : 0 : return;
6067 : : }
6068 : :
6069 : : /*
6070 : : * CPU-A CPU-B
6071 : : *
6072 : : * perf_event_disable_inatomic()
6073 : : * @pending_disable = CPU-A;
6074 : : * irq_work_queue();
6075 : : *
6076 : : * sched-out
6077 : : * @pending_disable = -1;
6078 : : *
6079 : : * sched-in
6080 : : * perf_event_disable_inatomic()
6081 : : * @pending_disable = CPU-B;
6082 : : * irq_work_queue(); // FAILS
6083 : : *
6084 : : * irq_work_run()
6085 : : * perf_pending_event()
6086 : : *
6087 : : * But the event runs on CPU-B and wants disabling there.
6088 : : */
6089 : 0 : irq_work_queue_on(&event->pending, cpu);
6090 : : }
6091 : :
6092 : 0 : static void perf_pending_event(struct irq_work *entry)
6093 : : {
6094 : 0 : struct perf_event *event = container_of(entry, struct perf_event, pending);
6095 : 0 : int rctx;
6096 : :
6097 : 0 : rctx = perf_swevent_get_recursion_context();
6098 : : /*
6099 : : * If we 'fail' here, that's OK, it means recursion is already disabled
6100 : : * and we won't recurse 'further'.
6101 : : */
6102 : :
6103 : 0 : perf_pending_event_disable(event);
6104 : :
6105 [ # # ]: 0 : if (event->pending_wakeup) {
6106 : 0 : event->pending_wakeup = 0;
6107 : 0 : perf_event_wakeup(event);
6108 : : }
6109 : :
6110 [ # # ]: 0 : if (rctx >= 0)
6111 : 0 : perf_swevent_put_recursion_context(rctx);
6112 : 0 : }
6113 : :
6114 : : /*
6115 : : * We assume there is only KVM supporting the callbacks.
6116 : : * Later on, we might change it to a list if there is
6117 : : * another virtualization implementation supporting the callbacks.
6118 : : */
6119 : : struct perf_guest_info_callbacks *perf_guest_cbs;
6120 : :
6121 : 0 : int perf_register_guest_info_callbacks(struct perf_guest_info_callbacks *cbs)
6122 : : {
6123 : 0 : perf_guest_cbs = cbs;
6124 : 0 : return 0;
6125 : : }
6126 : : EXPORT_SYMBOL_GPL(perf_register_guest_info_callbacks);
6127 : :
6128 : 0 : int perf_unregister_guest_info_callbacks(struct perf_guest_info_callbacks *cbs)
6129 : : {
6130 : 0 : perf_guest_cbs = NULL;
6131 : 0 : return 0;
6132 : : }
6133 : : EXPORT_SYMBOL_GPL(perf_unregister_guest_info_callbacks);
6134 : :
6135 : : static void
6136 : 0 : perf_output_sample_regs(struct perf_output_handle *handle,
6137 : : struct pt_regs *regs, u64 mask)
6138 : : {
6139 : 0 : int bit;
6140 : 0 : DECLARE_BITMAP(_mask, 64);
6141 : :
6142 : 0 : bitmap_from_u64(_mask, mask);
6143 [ # # ]: 0 : for_each_set_bit(bit, _mask, sizeof(mask) * BITS_PER_BYTE) {
6144 : 0 : u64 val;
6145 : :
6146 : 0 : val = perf_reg_value(regs, bit);
6147 : 0 : perf_output_put(handle, val);
6148 : : }
6149 : 0 : }
6150 : :
6151 : 0 : static void perf_sample_regs_user(struct perf_regs *regs_user,
6152 : : struct pt_regs *regs,
6153 : : struct pt_regs *regs_user_copy)
6154 : : {
6155 [ # # ]: 0 : if (user_mode(regs)) {
6156 : 0 : regs_user->abi = perf_reg_abi(current);
6157 : 0 : regs_user->regs = regs;
6158 [ # # ]: 0 : } else if (!(current->flags & PF_KTHREAD)) {
6159 : 0 : perf_get_regs_user(regs_user, regs, regs_user_copy);
6160 : : } else {
6161 : 0 : regs_user->abi = PERF_SAMPLE_REGS_ABI_NONE;
6162 : 0 : regs_user->regs = NULL;
6163 : : }
6164 : 0 : }
6165 : :
6166 : 0 : static void perf_sample_regs_intr(struct perf_regs *regs_intr,
6167 : : struct pt_regs *regs)
6168 : : {
6169 : 0 : regs_intr->regs = regs;
6170 : 0 : regs_intr->abi = perf_reg_abi(current);
6171 : : }
6172 : :
6173 : :
6174 : : /*
6175 : : * Get remaining task size from user stack pointer.
6176 : : *
6177 : : * It'd be better to take stack vma map and limit this more
6178 : : * precisely, but there's no way to get it safely under interrupt,
6179 : : * so using TASK_SIZE as limit.
6180 : : */
6181 : 0 : static u64 perf_ustack_task_size(struct pt_regs *regs)
6182 : : {
6183 [ # # ]: 0 : unsigned long addr = perf_user_stack_pointer(regs);
6184 : :
6185 [ # # # # : 0 : if (!addr || addr >= TASK_SIZE)
# # # # ]
6186 : 0 : return 0;
6187 : :
6188 [ # # # # ]: 0 : return TASK_SIZE - addr;
6189 : : }
6190 : :
6191 : : static u16
6192 : 0 : perf_sample_ustack_size(u16 stack_size, u16 header_size,
6193 : : struct pt_regs *regs)
6194 : : {
6195 : 0 : u64 task_size;
6196 : :
6197 : : /* No regs, no stack pointer, no dump. */
6198 [ # # ]: 0 : if (!regs)
6199 : : return 0;
6200 : :
6201 : : /*
6202 : : * Check if we fit in with the requested stack size into the:
6203 : : * - TASK_SIZE
6204 : : * If we don't, we limit the size to the TASK_SIZE.
6205 : : *
6206 : : * - remaining sample size
6207 : : * If we don't, we customize the stack size to
6208 : : * fit in to the remaining sample size.
6209 : : */
6210 : :
6211 : 0 : task_size = min((u64) USHRT_MAX, perf_ustack_task_size(regs));
6212 : 0 : stack_size = min(stack_size, (u16) task_size);
6213 : :
6214 : : /* Current header size plus static size and dynamic size. */
6215 : 0 : header_size += 2 * sizeof(u64);
6216 : :
6217 : : /* Do we fit in with the current stack dump size? */
6218 [ # # ]: 0 : if ((u16) (header_size + stack_size) < header_size) {
6219 : : /*
6220 : : * If we overflow the maximum size for the sample,
6221 : : * we customize the stack dump size to fit in.
6222 : : */
6223 : 0 : stack_size = USHRT_MAX - header_size - sizeof(u64);
6224 : 0 : stack_size = round_up(stack_size, sizeof(u64));
6225 : : }
6226 : :
6227 : : return stack_size;
6228 : : }
6229 : :
6230 : : static void
6231 : 0 : perf_output_sample_ustack(struct perf_output_handle *handle, u64 dump_size,
6232 : : struct pt_regs *regs)
6233 : : {
6234 : : /* Case of a kernel thread, nothing to dump */
6235 [ # # ]: 0 : if (!regs) {
6236 : 0 : u64 size = 0;
6237 : 0 : perf_output_put(handle, size);
6238 : : } else {
6239 : 0 : unsigned long sp;
6240 : 0 : unsigned int rem;
6241 : 0 : u64 dyn_size;
6242 : 0 : mm_segment_t fs;
6243 : :
6244 : : /*
6245 : : * We dump:
6246 : : * static size
6247 : : * - the size requested by user or the best one we can fit
6248 : : * in to the sample max size
6249 : : * data
6250 : : * - user stack dump data
6251 : : * dynamic size
6252 : : * - the actual dumped size
6253 : : */
6254 : :
6255 : : /* Static size. */
6256 : 0 : perf_output_put(handle, dump_size);
6257 : :
6258 : : /* Data. */
6259 [ # # # ]: 0 : sp = perf_user_stack_pointer(regs);
6260 [ # # # ]: 0 : fs = get_fs();
6261 [ # # # ]: 0 : set_fs(USER_DS);
6262 : 0 : rem = __output_copy_user(handle, (void *) sp, dump_size);
6263 : 0 : set_fs(fs);
6264 : 0 : dyn_size = dump_size - rem;
6265 : :
6266 : 0 : perf_output_skip(handle, rem);
6267 : :
6268 : : /* Dynamic size. */
6269 : 0 : perf_output_put(handle, dyn_size);
6270 : : }
6271 : 0 : }
6272 : :
6273 : : static unsigned long perf_prepare_sample_aux(struct perf_event *event,
6274 : : struct perf_sample_data *data,
6275 : : size_t size)
6276 : : {
6277 : : struct perf_event *sampler = event->aux_event;
6278 : : struct perf_buffer *rb;
6279 : :
6280 : : data->aux_size = 0;
6281 : :
6282 : : if (!sampler)
6283 : : goto out;
6284 : :
6285 : : if (WARN_ON_ONCE(READ_ONCE(sampler->state) != PERF_EVENT_STATE_ACTIVE))
6286 : : goto out;
6287 : :
6288 : : if (WARN_ON_ONCE(READ_ONCE(sampler->oncpu) != smp_processor_id()))
6289 : : goto out;
6290 : :
6291 : : rb = ring_buffer_get(sampler->parent ? sampler->parent : sampler);
6292 : : if (!rb)
6293 : : goto out;
6294 : :
6295 : : /*
6296 : : * If this is an NMI hit inside sampling code, don't take
6297 : : * the sample. See also perf_aux_sample_output().
6298 : : */
6299 : : if (READ_ONCE(rb->aux_in_sampling)) {
6300 : : data->aux_size = 0;
6301 : : } else {
6302 : : size = min_t(size_t, size, perf_aux_size(rb));
6303 : : data->aux_size = ALIGN(size, sizeof(u64));
6304 : : }
6305 : : ring_buffer_put(rb);
6306 : :
6307 : : out:
6308 : : return data->aux_size;
6309 : : }
6310 : :
6311 : 0 : long perf_pmu_snapshot_aux(struct perf_buffer *rb,
6312 : : struct perf_event *event,
6313 : : struct perf_output_handle *handle,
6314 : : unsigned long size)
6315 : : {
6316 : 0 : unsigned long flags;
6317 : 0 : long ret;
6318 : :
6319 : : /*
6320 : : * Normal ->start()/->stop() callbacks run in IRQ mode in scheduler
6321 : : * paths. If we start calling them in NMI context, they may race with
6322 : : * the IRQ ones, that is, for example, re-starting an event that's just
6323 : : * been stopped, which is why we're using a separate callback that
6324 : : * doesn't change the event state.
6325 : : *
6326 : : * IRQs need to be disabled to prevent IPIs from racing with us.
6327 : : */
6328 : 0 : local_irq_save(flags);
6329 : : /*
6330 : : * Guard against NMI hits inside the critical section;
6331 : : * see also perf_prepare_sample_aux().
6332 : : */
6333 : 0 : WRITE_ONCE(rb->aux_in_sampling, 1);
6334 : 0 : barrier();
6335 : :
6336 : 0 : ret = event->pmu->snapshot_aux(event, handle, size);
6337 : :
6338 : 0 : barrier();
6339 : 0 : WRITE_ONCE(rb->aux_in_sampling, 0);
6340 : 0 : local_irq_restore(flags);
6341 : :
6342 : 0 : return ret;
6343 : : }
6344 : :
6345 : : static void perf_aux_sample_output(struct perf_event *event,
6346 : : struct perf_output_handle *handle,
6347 : : struct perf_sample_data *data)
6348 : : {
6349 : : struct perf_event *sampler = event->aux_event;
6350 : : struct perf_buffer *rb;
6351 : : unsigned long pad;
6352 : : long size;
6353 : :
6354 : : if (WARN_ON_ONCE(!sampler || !data->aux_size))
6355 : : return;
6356 : :
6357 : : rb = ring_buffer_get(sampler->parent ? sampler->parent : sampler);
6358 : : if (!rb)
6359 : : return;
6360 : :
6361 : : size = perf_pmu_snapshot_aux(rb, sampler, handle, data->aux_size);
6362 : :
6363 : : /*
6364 : : * An error here means that perf_output_copy() failed (returned a
6365 : : * non-zero surplus that it didn't copy), which in its current
6366 : : * enlightened implementation is not possible. If that changes, we'd
6367 : : * like to know.
6368 : : */
6369 : : if (WARN_ON_ONCE(size < 0))
6370 : : goto out_put;
6371 : :
6372 : : /*
6373 : : * The pad comes from ALIGN()ing data->aux_size up to u64 in
6374 : : * perf_prepare_sample_aux(), so should not be more than that.
6375 : : */
6376 : : pad = data->aux_size - size;
6377 : : if (WARN_ON_ONCE(pad >= sizeof(u64)))
6378 : : pad = 8;
6379 : :
6380 : : if (pad) {
6381 : : u64 zero = 0;
6382 : : perf_output_copy(handle, &zero, pad);
6383 : : }
6384 : :
6385 : : out_put:
6386 : : ring_buffer_put(rb);
6387 : : }
6388 : :
6389 : : static void __perf_event_header__init_id(struct perf_event_header *header,
6390 : : struct perf_sample_data *data,
6391 : : struct perf_event *event)
6392 : : {
6393 : : u64 sample_type = event->attr.sample_type;
6394 : :
6395 : : data->type = sample_type;
6396 : : header->size += event->id_header_size;
6397 : :
6398 : : if (sample_type & PERF_SAMPLE_TID) {
6399 : : /* namespace issues */
6400 : : data->tid_entry.pid = perf_event_pid(event, current);
6401 : : data->tid_entry.tid = perf_event_tid(event, current);
6402 : : }
6403 : :
6404 : : if (sample_type & PERF_SAMPLE_TIME)
6405 : : data->time = perf_event_clock(event);
6406 : :
6407 : : if (sample_type & (PERF_SAMPLE_ID | PERF_SAMPLE_IDENTIFIER))
6408 : : data->id = primary_event_id(event);
6409 : :
6410 : : if (sample_type & PERF_SAMPLE_STREAM_ID)
6411 : : data->stream_id = event->id;
6412 : :
6413 : : if (sample_type & PERF_SAMPLE_CPU) {
6414 : : data->cpu_entry.cpu = raw_smp_processor_id();
6415 : : data->cpu_entry.reserved = 0;
6416 : : }
6417 : : }
6418 : :
6419 : 0 : void perf_event_header__init_id(struct perf_event_header *header,
6420 : : struct perf_sample_data *data,
6421 : : struct perf_event *event)
6422 : : {
6423 [ # # ]: 0 : if (event->attr.sample_id_all)
6424 : 0 : __perf_event_header__init_id(header, data, event);
6425 : 0 : }
6426 : :
6427 : 0 : static void __perf_event__output_id_sample(struct perf_output_handle *handle,
6428 : : struct perf_sample_data *data)
6429 : : {
6430 : 0 : u64 sample_type = data->type;
6431 : :
6432 [ # # ]: 0 : if (sample_type & PERF_SAMPLE_TID)
6433 : 0 : perf_output_put(handle, data->tid_entry);
6434 : :
6435 [ # # ]: 0 : if (sample_type & PERF_SAMPLE_TIME)
6436 : 0 : perf_output_put(handle, data->time);
6437 : :
6438 [ # # ]: 0 : if (sample_type & PERF_SAMPLE_ID)
6439 : 0 : perf_output_put(handle, data->id);
6440 : :
6441 [ # # ]: 0 : if (sample_type & PERF_SAMPLE_STREAM_ID)
6442 : 0 : perf_output_put(handle, data->stream_id);
6443 : :
6444 [ # # ]: 0 : if (sample_type & PERF_SAMPLE_CPU)
6445 : 0 : perf_output_put(handle, data->cpu_entry);
6446 : :
6447 [ # # ]: 0 : if (sample_type & PERF_SAMPLE_IDENTIFIER)
6448 : 0 : perf_output_put(handle, data->id);
6449 : 0 : }
6450 : :
6451 : 0 : void perf_event__output_id_sample(struct perf_event *event,
6452 : : struct perf_output_handle *handle,
6453 : : struct perf_sample_data *sample)
6454 : : {
6455 [ # # ]: 0 : if (event->attr.sample_id_all)
6456 : 0 : __perf_event__output_id_sample(handle, sample);
6457 : 0 : }
6458 : :
6459 : 0 : static void perf_output_read_one(struct perf_output_handle *handle,
6460 : : struct perf_event *event,
6461 : : u64 enabled, u64 running)
6462 : : {
6463 : 0 : u64 read_format = event->attr.read_format;
6464 : 0 : u64 values[4];
6465 : 0 : int n = 0;
6466 : :
6467 : 0 : values[n++] = perf_event_count(event);
6468 [ # # ]: 0 : if (read_format & PERF_FORMAT_TOTAL_TIME_ENABLED) {
6469 : 0 : values[n++] = enabled +
6470 : 0 : atomic64_read(&event->child_total_time_enabled);
6471 : : }
6472 [ # # ]: 0 : if (read_format & PERF_FORMAT_TOTAL_TIME_RUNNING) {
6473 : 0 : values[n++] = running +
6474 : 0 : atomic64_read(&event->child_total_time_running);
6475 : : }
6476 [ # # ]: 0 : if (read_format & PERF_FORMAT_ID)
6477 [ # # ]: 0 : values[n++] = primary_event_id(event);
6478 : :
6479 : 0 : __output_copy(handle, values, n * sizeof(u64));
6480 : 0 : }
6481 : :
6482 : 0 : static void perf_output_read_group(struct perf_output_handle *handle,
6483 : : struct perf_event *event,
6484 : : u64 enabled, u64 running)
6485 : : {
6486 : 0 : struct perf_event *leader = event->group_leader, *sub;
6487 : 0 : u64 read_format = event->attr.read_format;
6488 : 0 : u64 values[5];
6489 : 0 : int n = 0;
6490 : :
6491 : 0 : values[n++] = 1 + leader->nr_siblings;
6492 : :
6493 [ # # ]: 0 : if (read_format & PERF_FORMAT_TOTAL_TIME_ENABLED)
6494 : 0 : values[n++] = enabled;
6495 : :
6496 [ # # ]: 0 : if (read_format & PERF_FORMAT_TOTAL_TIME_RUNNING)
6497 : 0 : values[n++] = running;
6498 : :
6499 [ # # ]: 0 : if ((leader != event) &&
6500 [ # # ]: 0 : (leader->state == PERF_EVENT_STATE_ACTIVE))
6501 : 0 : leader->pmu->read(leader);
6502 : :
6503 : 0 : values[n++] = perf_event_count(leader);
6504 [ # # ]: 0 : if (read_format & PERF_FORMAT_ID)
6505 [ # # ]: 0 : values[n++] = primary_event_id(leader);
6506 : :
6507 : 0 : __output_copy(handle, values, n * sizeof(u64));
6508 : :
6509 [ # # # # ]: 0 : for_each_sibling_event(sub, leader) {
6510 : 0 : n = 0;
6511 : :
6512 [ # # ]: 0 : if ((sub != event) &&
6513 [ # # ]: 0 : (sub->state == PERF_EVENT_STATE_ACTIVE))
6514 : 0 : sub->pmu->read(sub);
6515 : :
6516 : 0 : values[n++] = perf_event_count(sub);
6517 [ # # ]: 0 : if (read_format & PERF_FORMAT_ID)
6518 [ # # ]: 0 : values[n++] = primary_event_id(sub);
6519 : :
6520 : 0 : __output_copy(handle, values, n * sizeof(u64));
6521 : : }
6522 : 0 : }
6523 : :
6524 : : #define PERF_FORMAT_TOTAL_TIMES (PERF_FORMAT_TOTAL_TIME_ENABLED|\
6525 : : PERF_FORMAT_TOTAL_TIME_RUNNING)
6526 : :
6527 : : /*
6528 : : * XXX PERF_SAMPLE_READ vs inherited events seems difficult.
6529 : : *
6530 : : * The problem is that its both hard and excessively expensive to iterate the
6531 : : * child list, not to mention that its impossible to IPI the children running
6532 : : * on another CPU, from interrupt/NMI context.
6533 : : */
6534 : 0 : static void perf_output_read(struct perf_output_handle *handle,
6535 : : struct perf_event *event)
6536 : : {
6537 : 0 : u64 enabled = 0, running = 0, now;
6538 : 0 : u64 read_format = event->attr.read_format;
6539 : :
6540 : : /*
6541 : : * compute total_time_enabled, total_time_running
6542 : : * based on snapshot values taken when the event
6543 : : * was last scheduled in.
6544 : : *
6545 : : * we cannot simply called update_context_time()
6546 : : * because of locking issue as we are called in
6547 : : * NMI context
6548 : : */
6549 [ # # ]: 0 : if (read_format & PERF_FORMAT_TOTAL_TIMES)
6550 : 0 : calc_timer_values(event, &now, &enabled, &running);
6551 : :
6552 [ # # ]: 0 : if (event->attr.read_format & PERF_FORMAT_GROUP)
6553 : 0 : perf_output_read_group(handle, event, enabled, running);
6554 : : else
6555 : 0 : perf_output_read_one(handle, event, enabled, running);
6556 : 0 : }
6557 : :
6558 : 0 : void perf_output_sample(struct perf_output_handle *handle,
6559 : : struct perf_event_header *header,
6560 : : struct perf_sample_data *data,
6561 : : struct perf_event *event)
6562 : : {
6563 : 0 : u64 sample_type = data->type;
6564 : :
6565 : 0 : perf_output_put(handle, *header);
6566 : :
6567 [ # # ]: 0 : if (sample_type & PERF_SAMPLE_IDENTIFIER)
6568 : 0 : perf_output_put(handle, data->id);
6569 : :
6570 [ # # ]: 0 : if (sample_type & PERF_SAMPLE_IP)
6571 : 0 : perf_output_put(handle, data->ip);
6572 : :
6573 [ # # ]: 0 : if (sample_type & PERF_SAMPLE_TID)
6574 : 0 : perf_output_put(handle, data->tid_entry);
6575 : :
6576 [ # # ]: 0 : if (sample_type & PERF_SAMPLE_TIME)
6577 : 0 : perf_output_put(handle, data->time);
6578 : :
6579 [ # # ]: 0 : if (sample_type & PERF_SAMPLE_ADDR)
6580 : 0 : perf_output_put(handle, data->addr);
6581 : :
6582 [ # # ]: 0 : if (sample_type & PERF_SAMPLE_ID)
6583 : 0 : perf_output_put(handle, data->id);
6584 : :
6585 [ # # ]: 0 : if (sample_type & PERF_SAMPLE_STREAM_ID)
6586 : 0 : perf_output_put(handle, data->stream_id);
6587 : :
6588 [ # # ]: 0 : if (sample_type & PERF_SAMPLE_CPU)
6589 : 0 : perf_output_put(handle, data->cpu_entry);
6590 : :
6591 [ # # ]: 0 : if (sample_type & PERF_SAMPLE_PERIOD)
6592 : 0 : perf_output_put(handle, data->period);
6593 : :
6594 [ # # ]: 0 : if (sample_type & PERF_SAMPLE_READ)
6595 : 0 : perf_output_read(handle, event);
6596 : :
6597 [ # # ]: 0 : if (sample_type & PERF_SAMPLE_CALLCHAIN) {
6598 : 0 : int size = 1;
6599 : :
6600 : 0 : size += data->callchain->nr;
6601 : 0 : size *= sizeof(u64);
6602 : 0 : __output_copy(handle, data->callchain, size);
6603 : : }
6604 : :
6605 [ # # ]: 0 : if (sample_type & PERF_SAMPLE_RAW) {
6606 : 0 : struct perf_raw_record *raw = data->raw;
6607 : :
6608 [ # # ]: 0 : if (raw) {
6609 : 0 : struct perf_raw_frag *frag = &raw->frag;
6610 : :
6611 : 0 : perf_output_put(handle, raw->size);
6612 : 0 : do {
6613 [ # # ]: 0 : if (frag->copy) {
6614 : 0 : __output_custom(handle, frag->copy,
6615 : 0 : frag->data, frag->size);
6616 : : } else {
6617 : 0 : __output_copy(handle, frag->data,
6618 : 0 : frag->size);
6619 : : }
6620 [ # # ]: 0 : if (perf_raw_frag_last(frag))
6621 : : break;
6622 : 0 : frag = frag->next;
6623 : 0 : } while (1);
6624 [ # # ]: 0 : if (frag->pad)
6625 : 0 : __output_skip(handle, NULL, frag->pad);
6626 : : } else {
6627 : 0 : struct {
6628 : : u32 size;
6629 : : u32 data;
6630 : 0 : } raw = {
6631 : : .size = sizeof(u32),
6632 : : .data = 0,
6633 : : };
6634 : 0 : perf_output_put(handle, raw);
6635 : : }
6636 : : }
6637 : :
6638 [ # # ]: 0 : if (sample_type & PERF_SAMPLE_BRANCH_STACK) {
6639 [ # # ]: 0 : if (data->br_stack) {
6640 : 0 : size_t size;
6641 : :
6642 : 0 : size = data->br_stack->nr
6643 : : * sizeof(struct perf_branch_entry);
6644 : :
6645 : 0 : perf_output_put(handle, data->br_stack->nr);
6646 : 0 : perf_output_copy(handle, data->br_stack->entries, size);
6647 : : } else {
6648 : : /*
6649 : : * we always store at least the value of nr
6650 : : */
6651 : 0 : u64 nr = 0;
6652 : 0 : perf_output_put(handle, nr);
6653 : : }
6654 : : }
6655 : :
6656 [ # # ]: 0 : if (sample_type & PERF_SAMPLE_REGS_USER) {
6657 : 0 : u64 abi = data->regs_user.abi;
6658 : :
6659 : : /*
6660 : : * If there are no regs to dump, notice it through
6661 : : * first u64 being zero (PERF_SAMPLE_REGS_ABI_NONE).
6662 : : */
6663 : 0 : perf_output_put(handle, abi);
6664 : :
6665 [ # # ]: 0 : if (abi) {
6666 : 0 : u64 mask = event->attr.sample_regs_user;
6667 : 0 : perf_output_sample_regs(handle,
6668 : : data->regs_user.regs,
6669 : : mask);
6670 : : }
6671 : : }
6672 : :
6673 [ # # ]: 0 : if (sample_type & PERF_SAMPLE_STACK_USER) {
6674 : 0 : perf_output_sample_ustack(handle,
6675 : : data->stack_user_size,
6676 : : data->regs_user.regs);
6677 : : }
6678 : :
6679 [ # # ]: 0 : if (sample_type & PERF_SAMPLE_WEIGHT)
6680 : 0 : perf_output_put(handle, data->weight);
6681 : :
6682 [ # # ]: 0 : if (sample_type & PERF_SAMPLE_DATA_SRC)
6683 : 0 : perf_output_put(handle, data->data_src.val);
6684 : :
6685 [ # # ]: 0 : if (sample_type & PERF_SAMPLE_TRANSACTION)
6686 : 0 : perf_output_put(handle, data->txn);
6687 : :
6688 [ # # ]: 0 : if (sample_type & PERF_SAMPLE_REGS_INTR) {
6689 : 0 : u64 abi = data->regs_intr.abi;
6690 : : /*
6691 : : * If there are no regs to dump, notice it through
6692 : : * first u64 being zero (PERF_SAMPLE_REGS_ABI_NONE).
6693 : : */
6694 : 0 : perf_output_put(handle, abi);
6695 : :
6696 [ # # ]: 0 : if (abi) {
6697 : 0 : u64 mask = event->attr.sample_regs_intr;
6698 : :
6699 : 0 : perf_output_sample_regs(handle,
6700 : : data->regs_intr.regs,
6701 : : mask);
6702 : : }
6703 : : }
6704 : :
6705 [ # # ]: 0 : if (sample_type & PERF_SAMPLE_PHYS_ADDR)
6706 : 0 : perf_output_put(handle, data->phys_addr);
6707 : :
6708 [ # # ]: 0 : if (sample_type & PERF_SAMPLE_AUX) {
6709 : 0 : perf_output_put(handle, data->aux_size);
6710 : :
6711 [ # # ]: 0 : if (data->aux_size)
6712 : 0 : perf_aux_sample_output(event, handle, data);
6713 : : }
6714 : :
6715 [ # # ]: 0 : if (!event->attr.watermark) {
6716 : 0 : int wakeup_events = event->attr.wakeup_events;
6717 : :
6718 [ # # ]: 0 : if (wakeup_events) {
6719 : 0 : struct perf_buffer *rb = handle->rb;
6720 : 0 : int events = local_inc_return(&rb->events);
6721 : :
6722 [ # # ]: 0 : if (events >= wakeup_events) {
6723 : 0 : local_sub(wakeup_events, &rb->events);
6724 : 0 : local_inc(&rb->wakeup);
6725 : : }
6726 : : }
6727 : : }
6728 : 0 : }
6729 : :
6730 : 0 : static u64 perf_virt_to_phys(u64 virt)
6731 : : {
6732 : 0 : u64 phys_addr = 0;
6733 : 0 : struct page *p = NULL;
6734 : :
6735 [ # # ]: 0 : if (!virt)
6736 : : return 0;
6737 : :
6738 [ # # # # : 0 : if (virt >= TASK_SIZE) {
# # ]
6739 : : /* If it's vmalloc()d memory, leave phys_addr as 0 */
6740 [ # # ]: 0 : if (virt_addr_valid((void *)(uintptr_t)virt) &&
6741 [ # # # # ]: 0 : !(virt >= VMALLOC_START && virt < VMALLOC_END))
6742 [ # # ]: 0 : phys_addr = (u64)virt_to_phys((void *)(uintptr_t)virt);
6743 : : } else {
6744 : : /*
6745 : : * Walking the pages tables for user address.
6746 : : * Interrupts are disabled, so it prevents any tear down
6747 : : * of the page tables.
6748 : : * Try IRQ-safe __get_user_pages_fast first.
6749 : : * If failed, leave phys_addr as 0.
6750 : : */
6751 [ # # # # ]: 0 : if ((current->mm != NULL) &&
6752 : 0 : (__get_user_pages_fast(virt, 1, 0, &p) == 1))
6753 : 0 : phys_addr = page_to_phys(p) + virt % PAGE_SIZE;
6754 : :
6755 [ # # ]: 0 : if (p)
6756 : 0 : put_page(p);
6757 : : }
6758 : :
6759 : : return phys_addr;
6760 : : }
6761 : :
6762 : : static struct perf_callchain_entry __empty_callchain = { .nr = 0, };
6763 : :
6764 : : struct perf_callchain_entry *
6765 : 0 : perf_callchain(struct perf_event *event, struct pt_regs *regs)
6766 : : {
6767 : 0 : bool kernel = !event->attr.exclude_callchain_kernel;
6768 : 0 : bool user = !event->attr.exclude_callchain_user;
6769 : : /* Disallow cross-task user callchains. */
6770 [ # # # # ]: 0 : bool crosstask = event->ctx->task && event->ctx->task != current;
6771 : 0 : const u32 max_stack = event->attr.sample_max_stack;
6772 : 0 : struct perf_callchain_entry *callchain;
6773 : :
6774 [ # # ]: 0 : if (!kernel && !user)
6775 : : return &__empty_callchain;
6776 : :
6777 : 0 : callchain = get_perf_callchain(regs, 0, kernel, user,
6778 : : max_stack, crosstask, true);
6779 [ # # ]: 0 : return callchain ?: &__empty_callchain;
6780 : : }
6781 : :
6782 : 0 : void perf_prepare_sample(struct perf_event_header *header,
6783 : : struct perf_sample_data *data,
6784 : : struct perf_event *event,
6785 : : struct pt_regs *regs)
6786 : : {
6787 : 0 : u64 sample_type = event->attr.sample_type;
6788 : :
6789 : 0 : header->type = PERF_RECORD_SAMPLE;
6790 : 0 : header->size = sizeof(*header) + event->header_size;
6791 : :
6792 : 0 : header->misc = 0;
6793 : 0 : header->misc |= perf_misc_flags(regs);
6794 : :
6795 : 0 : __perf_event_header__init_id(header, data, event);
6796 : :
6797 [ # # ]: 0 : if (sample_type & PERF_SAMPLE_IP)
6798 : 0 : data->ip = perf_instruction_pointer(regs);
6799 : :
6800 [ # # ]: 0 : if (sample_type & PERF_SAMPLE_CALLCHAIN) {
6801 : 0 : int size = 1;
6802 : :
6803 [ # # ]: 0 : if (!(sample_type & __PERF_SAMPLE_CALLCHAIN_EARLY))
6804 : 0 : data->callchain = perf_callchain(event, regs);
6805 : :
6806 : 0 : size += data->callchain->nr;
6807 : :
6808 : 0 : header->size += size * sizeof(u64);
6809 : : }
6810 : :
6811 [ # # ]: 0 : if (sample_type & PERF_SAMPLE_RAW) {
6812 : 0 : struct perf_raw_record *raw = data->raw;
6813 : 0 : int size;
6814 : :
6815 [ # # ]: 0 : if (raw) {
6816 : 0 : struct perf_raw_frag *frag = &raw->frag;
6817 : 0 : u32 sum = 0;
6818 : :
6819 : 0 : do {
6820 : 0 : sum += frag->size;
6821 [ # # ]: 0 : if (perf_raw_frag_last(frag))
6822 : : break;
6823 : 0 : frag = frag->next;
6824 : 0 : } while (1);
6825 : :
6826 : 0 : size = round_up(sum + sizeof(u32), sizeof(u64));
6827 : 0 : raw->size = size - sizeof(u32);
6828 : 0 : frag->pad = raw->size - sum;
6829 : : } else {
6830 : : size = sizeof(u64);
6831 : : }
6832 : :
6833 : 0 : header->size += size;
6834 : : }
6835 : :
6836 [ # # ]: 0 : if (sample_type & PERF_SAMPLE_BRANCH_STACK) {
6837 : 0 : int size = sizeof(u64); /* nr */
6838 [ # # ]: 0 : if (data->br_stack) {
6839 : 0 : size += data->br_stack->nr
6840 : : * sizeof(struct perf_branch_entry);
6841 : : }
6842 : 0 : header->size += size;
6843 : : }
6844 : :
6845 [ # # ]: 0 : if (sample_type & (PERF_SAMPLE_REGS_USER | PERF_SAMPLE_STACK_USER))
6846 : 0 : perf_sample_regs_user(&data->regs_user, regs,
6847 : : &data->regs_user_copy);
6848 : :
6849 [ # # ]: 0 : if (sample_type & PERF_SAMPLE_REGS_USER) {
6850 : : /* regs dump ABI info */
6851 : 0 : int size = sizeof(u64);
6852 : :
6853 [ # # ]: 0 : if (data->regs_user.regs) {
6854 : 0 : u64 mask = event->attr.sample_regs_user;
6855 [ # # ]: 0 : size += hweight64(mask) * sizeof(u64);
6856 : : }
6857 : :
6858 : 0 : header->size += size;
6859 : : }
6860 : :
6861 [ # # ]: 0 : if (sample_type & PERF_SAMPLE_STACK_USER) {
6862 : : /*
6863 : : * Either we need PERF_SAMPLE_STACK_USER bit to be always
6864 : : * processed as the last one or have additional check added
6865 : : * in case new sample type is added, because we could eat
6866 : : * up the rest of the sample size.
6867 : : */
6868 : 0 : u16 stack_size = event->attr.sample_stack_user;
6869 : 0 : u16 size = sizeof(u64);
6870 : :
6871 : 0 : stack_size = perf_sample_ustack_size(stack_size, header->size,
6872 : : data->regs_user.regs);
6873 : :
6874 : : /*
6875 : : * If there is something to dump, add space for the dump
6876 : : * itself and for the field that tells the dynamic size,
6877 : : * which is how many have been actually dumped.
6878 : : */
6879 [ # # ]: 0 : if (stack_size)
6880 : 0 : size += sizeof(u64) + stack_size;
6881 : :
6882 : 0 : data->stack_user_size = stack_size;
6883 : 0 : header->size += size;
6884 : : }
6885 : :
6886 [ # # ]: 0 : if (sample_type & PERF_SAMPLE_REGS_INTR) {
6887 : : /* regs dump ABI info */
6888 : 0 : int size = sizeof(u64);
6889 : :
6890 : 0 : perf_sample_regs_intr(&data->regs_intr, regs);
6891 : :
6892 [ # # ]: 0 : if (data->regs_intr.regs) {
6893 : 0 : u64 mask = event->attr.sample_regs_intr;
6894 : :
6895 [ # # ]: 0 : size += hweight64(mask) * sizeof(u64);
6896 : : }
6897 : :
6898 : 0 : header->size += size;
6899 : : }
6900 : :
6901 [ # # ]: 0 : if (sample_type & PERF_SAMPLE_PHYS_ADDR)
6902 : 0 : data->phys_addr = perf_virt_to_phys(data->addr);
6903 : :
6904 [ # # ]: 0 : if (sample_type & PERF_SAMPLE_AUX) {
6905 : 0 : u64 size;
6906 : :
6907 : 0 : header->size += sizeof(u64); /* size */
6908 : :
6909 : : /*
6910 : : * Given the 16bit nature of header::size, an AUX sample can
6911 : : * easily overflow it, what with all the preceding sample bits.
6912 : : * Make sure this doesn't happen by using up to U16_MAX bytes
6913 : : * per sample in total (rounded down to 8 byte boundary).
6914 : : */
6915 : 0 : size = min_t(size_t, U16_MAX - header->size,
6916 : : event->attr.aux_sample_size);
6917 : 0 : size = rounddown(size, 8);
6918 : 0 : size = perf_prepare_sample_aux(event, data, size);
6919 : :
6920 [ # # ]: 0 : WARN_ON_ONCE(size + header->size > U16_MAX);
6921 : 0 : header->size += size;
6922 : : }
6923 : : /*
6924 : : * If you're adding more sample types here, you likely need to do
6925 : : * something about the overflowing header::size, like repurpose the
6926 : : * lowest 3 bits of size, which should be always zero at the moment.
6927 : : * This raises a more important question, do we really need 512k sized
6928 : : * samples and why, so good argumentation is in order for whatever you
6929 : : * do here next.
6930 : : */
6931 [ # # ]: 0 : WARN_ON_ONCE(header->size & 7);
6932 : 0 : }
6933 : :
6934 : : static __always_inline int
6935 : 0 : __perf_event_output(struct perf_event *event,
6936 : : struct perf_sample_data *data,
6937 : : struct pt_regs *regs,
6938 : : int (*output_begin)(struct perf_output_handle *,
6939 : : struct perf_event *,
6940 : : unsigned int))
6941 : : {
6942 : 0 : struct perf_output_handle handle;
6943 : 0 : struct perf_event_header header;
6944 : 0 : int err;
6945 : :
6946 : : /* protect the callchain buffers */
6947 : 0 : rcu_read_lock();
6948 : :
6949 : 0 : perf_prepare_sample(&header, data, event, regs);
6950 : :
6951 : 0 : err = output_begin(&handle, event, header.size);
6952 [ # # # # : 0 : if (err)
# # ]
6953 : 0 : goto exit;
6954 : :
6955 : 0 : perf_output_sample(&handle, &header, data, event);
6956 : :
6957 : 0 : perf_output_end(&handle);
6958 : :
6959 : 0 : exit:
6960 : 0 : rcu_read_unlock();
6961 : 0 : return err;
6962 : : }
6963 : :
6964 : : void
6965 : 0 : perf_event_output_forward(struct perf_event *event,
6966 : : struct perf_sample_data *data,
6967 : : struct pt_regs *regs)
6968 : : {
6969 : 0 : __perf_event_output(event, data, regs, perf_output_begin_forward);
6970 : 0 : }
6971 : :
6972 : : void
6973 : 0 : perf_event_output_backward(struct perf_event *event,
6974 : : struct perf_sample_data *data,
6975 : : struct pt_regs *regs)
6976 : : {
6977 : 0 : __perf_event_output(event, data, regs, perf_output_begin_backward);
6978 : 0 : }
6979 : :
6980 : : int
6981 : 0 : perf_event_output(struct perf_event *event,
6982 : : struct perf_sample_data *data,
6983 : : struct pt_regs *regs)
6984 : : {
6985 : 0 : return __perf_event_output(event, data, regs, perf_output_begin);
6986 : : }
6987 : :
6988 : : /*
6989 : : * read event_id
6990 : : */
6991 : :
6992 : : struct perf_read_event {
6993 : : struct perf_event_header header;
6994 : :
6995 : : u32 pid;
6996 : : u32 tid;
6997 : : };
6998 : :
6999 : : static void
7000 : 0 : perf_event_read_event(struct perf_event *event,
7001 : : struct task_struct *task)
7002 : : {
7003 : 0 : struct perf_output_handle handle;
7004 : 0 : struct perf_sample_data sample;
7005 : 0 : struct perf_read_event read_event = {
7006 : : .header = {
7007 : : .type = PERF_RECORD_READ,
7008 : : .misc = 0,
7009 : 0 : .size = sizeof(read_event) + event->read_size,
7010 : : },
7011 : : .pid = perf_event_pid(event, task),
7012 : : .tid = perf_event_tid(event, task),
7013 : : };
7014 : 0 : int ret;
7015 : :
7016 [ # # ]: 0 : perf_event_header__init_id(&read_event.header, &sample, event);
7017 : 0 : ret = perf_output_begin(&handle, event, read_event.header.size);
7018 [ # # ]: 0 : if (ret)
7019 : 0 : return;
7020 : :
7021 : 0 : perf_output_put(&handle, read_event);
7022 : 0 : perf_output_read(&handle, event);
7023 [ # # ]: 0 : perf_event__output_id_sample(event, &handle, &sample);
7024 : :
7025 : 0 : perf_output_end(&handle);
7026 : : }
7027 : :
7028 : : typedef void (perf_iterate_f)(struct perf_event *event, void *data);
7029 : :
7030 : : static void
7031 : 0 : perf_iterate_ctx(struct perf_event_context *ctx,
7032 : : perf_iterate_f output,
7033 : : void *data, bool all)
7034 : : {
7035 : 0 : struct perf_event *event;
7036 : :
7037 [ # # ]: 0 : list_for_each_entry_rcu(event, &ctx->event_list, event_entry) {
7038 [ # # ]: 0 : if (!all) {
7039 [ # # ]: 0 : if (event->state < PERF_EVENT_STATE_INACTIVE)
7040 : 0 : continue;
7041 [ # # ]: 0 : if (!event_filter_match(event))
7042 : 0 : continue;
7043 : : }
7044 : :
7045 : 0 : output(event, data);
7046 : : }
7047 : 0 : }
7048 : :
7049 : 0 : static void perf_iterate_sb_cpu(perf_iterate_f output, void *data)
7050 : : {
7051 : 0 : struct pmu_event_list *pel = this_cpu_ptr(&pmu_sb_events);
7052 : 0 : struct perf_event *event;
7053 : :
7054 [ # # ]: 0 : list_for_each_entry_rcu(event, &pel->list, sb_list) {
7055 : : /*
7056 : : * Skip events that are not fully formed yet; ensure that
7057 : : * if we observe event->ctx, both event and ctx will be
7058 : : * complete enough. See perf_install_in_context().
7059 : : */
7060 [ # # ]: 0 : if (!smp_load_acquire(&event->ctx))
7061 : 0 : continue;
7062 : :
7063 [ # # ]: 0 : if (event->state < PERF_EVENT_STATE_INACTIVE)
7064 : 0 : continue;
7065 [ # # ]: 0 : if (!event_filter_match(event))
7066 : 0 : continue;
7067 : 0 : output(event, data);
7068 : : }
7069 : 0 : }
7070 : :
7071 : : /*
7072 : : * Iterate all events that need to receive side-band events.
7073 : : *
7074 : : * For new callers; ensure that account_pmu_sb_event() includes
7075 : : * your event, otherwise it might not get delivered.
7076 : : */
7077 : : static void
7078 : 0 : perf_iterate_sb(perf_iterate_f output, void *data,
7079 : : struct perf_event_context *task_ctx)
7080 : : {
7081 : 0 : struct perf_event_context *ctx;
7082 : 0 : int ctxn;
7083 : :
7084 : 0 : rcu_read_lock();
7085 : 0 : preempt_disable();
7086 : :
7087 : : /*
7088 : : * If we have task_ctx != NULL we only notify the task context itself.
7089 : : * The task_ctx is set only for EXIT events before releasing task
7090 : : * context.
7091 : : */
7092 [ # # ]: 0 : if (task_ctx) {
7093 : 0 : perf_iterate_ctx(task_ctx, output, data, false);
7094 : 0 : goto done;
7095 : : }
7096 : :
7097 : 0 : perf_iterate_sb_cpu(output, data);
7098 : :
7099 [ # # ]: 0 : for_each_task_context_nr(ctxn) {
7100 [ # # ]: 0 : ctx = rcu_dereference(current->perf_event_ctxp[ctxn]);
7101 [ # # ]: 0 : if (ctx)
7102 : 0 : perf_iterate_ctx(ctx, output, data, false);
7103 : : }
7104 : 0 : done:
7105 : 0 : preempt_enable();
7106 : 0 : rcu_read_unlock();
7107 : 0 : }
7108 : :
7109 : : /*
7110 : : * Clear all file-based filters at exec, they'll have to be
7111 : : * re-instated when/if these objects are mmapped again.
7112 : : */
7113 : 0 : static void perf_event_addr_filters_exec(struct perf_event *event, void *data)
7114 : : {
7115 [ # # ]: 0 : struct perf_addr_filters_head *ifh = perf_event_addr_filters(event);
7116 : 0 : struct perf_addr_filter *filter;
7117 : 0 : unsigned int restart = 0, count = 0;
7118 : 0 : unsigned long flags;
7119 : :
7120 [ # # ]: 0 : if (!has_addr_filter(event))
7121 : : return;
7122 : :
7123 : 0 : raw_spin_lock_irqsave(&ifh->lock, flags);
7124 [ # # ]: 0 : list_for_each_entry(filter, &ifh->list, entry) {
7125 [ # # ]: 0 : if (filter->path.dentry) {
7126 : 0 : event->addr_filter_ranges[count].start = 0;
7127 : 0 : event->addr_filter_ranges[count].size = 0;
7128 : 0 : restart++;
7129 : : }
7130 : :
7131 : 0 : count++;
7132 : : }
7133 : :
7134 [ # # ]: 0 : if (restart)
7135 : 0 : event->addr_filters_gen++;
7136 : 0 : raw_spin_unlock_irqrestore(&ifh->lock, flags);
7137 : :
7138 [ # # ]: 0 : if (restart)
7139 : 0 : perf_event_stop(event, 1);
7140 : : }
7141 : :
7142 : 9672 : void perf_event_exec(void)
7143 : : {
7144 : 9672 : struct perf_event_context *ctx;
7145 : 9672 : int ctxn;
7146 : :
7147 : 9672 : rcu_read_lock();
7148 [ + + ]: 38688 : for_each_task_context_nr(ctxn) {
7149 [ + - ]: 19344 : ctx = current->perf_event_ctxp[ctxn];
7150 [ + - ]: 19344 : if (!ctx)
7151 : 19344 : continue;
7152 : :
7153 : 0 : perf_event_enable_on_exec(ctxn);
7154 : :
7155 : 0 : perf_iterate_ctx(ctx, perf_event_addr_filters_exec, NULL,
7156 : : true);
7157 : : }
7158 : 9672 : rcu_read_unlock();
7159 : 9672 : }
7160 : :
7161 : : struct remote_output {
7162 : : struct perf_buffer *rb;
7163 : : int err;
7164 : : };
7165 : :
7166 : 0 : static void __perf_event_output_stop(struct perf_event *event, void *data)
7167 : : {
7168 : 0 : struct perf_event *parent = event->parent;
7169 : 0 : struct remote_output *ro = data;
7170 : 0 : struct perf_buffer *rb = ro->rb;
7171 : 0 : struct stop_event_data sd = {
7172 : : .event = event,
7173 : : };
7174 : :
7175 [ # # ]: 0 : if (!has_aux(event))
7176 : 0 : return;
7177 : :
7178 [ # # ]: 0 : if (!parent)
7179 : 0 : parent = event;
7180 : :
7181 : : /*
7182 : : * In case of inheritance, it will be the parent that links to the
7183 : : * ring-buffer, but it will be the child that's actually using it.
7184 : : *
7185 : : * We are using event::rb to determine if the event should be stopped,
7186 : : * however this may race with ring_buffer_attach() (through set_output),
7187 : : * which will make us skip the event that actually needs to be stopped.
7188 : : * So ring_buffer_attach() has to stop an aux event before re-assigning
7189 : : * its rb pointer.
7190 : : */
7191 [ # # ]: 0 : if (rcu_dereference(parent->rb) == rb)
7192 : 0 : ro->err = __perf_event_stop(&sd);
7193 : : }
7194 : :
7195 : 0 : static int __perf_pmu_output_stop(void *info)
7196 : : {
7197 : 0 : struct perf_event *event = info;
7198 : 0 : struct pmu *pmu = event->ctx->pmu;
7199 : 0 : struct perf_cpu_context *cpuctx = this_cpu_ptr(pmu->pmu_cpu_context);
7200 : 0 : struct remote_output ro = {
7201 : 0 : .rb = event->rb,
7202 : : };
7203 : :
7204 : 0 : rcu_read_lock();
7205 : 0 : perf_iterate_ctx(&cpuctx->ctx, __perf_event_output_stop, &ro, false);
7206 [ # # ]: 0 : if (cpuctx->task_ctx)
7207 : 0 : perf_iterate_ctx(cpuctx->task_ctx, __perf_event_output_stop,
7208 : : &ro, false);
7209 : 0 : rcu_read_unlock();
7210 : :
7211 : 0 : return ro.err;
7212 : : }
7213 : :
7214 : 0 : static void perf_pmu_output_stop(struct perf_event *event)
7215 : : {
7216 : 0 : struct perf_event *iter;
7217 : 0 : int err, cpu;
7218 : :
7219 : 0 : restart:
7220 : 0 : rcu_read_lock();
7221 [ # # ]: 0 : list_for_each_entry_rcu(iter, &event->rb->event_list, rb_entry) {
7222 : : /*
7223 : : * For per-CPU events, we need to make sure that neither they
7224 : : * nor their children are running; for cpu==-1 events it's
7225 : : * sufficient to stop the event itself if it's active, since
7226 : : * it can't have children.
7227 : : */
7228 : 0 : cpu = iter->cpu;
7229 [ # # ]: 0 : if (cpu == -1)
7230 : 0 : cpu = READ_ONCE(iter->oncpu);
7231 : :
7232 [ # # ]: 0 : if (cpu == -1)
7233 : 0 : continue;
7234 : :
7235 : 0 : err = cpu_function_call(cpu, __perf_pmu_output_stop, event);
7236 [ # # ]: 0 : if (err == -EAGAIN) {
7237 : 0 : rcu_read_unlock();
7238 : 0 : goto restart;
7239 : : }
7240 : : }
7241 : 0 : rcu_read_unlock();
7242 : 0 : }
7243 : :
7244 : : /*
7245 : : * task tracking -- fork/exit
7246 : : *
7247 : : * enabled by: attr.comm | attr.mmap | attr.mmap2 | attr.mmap_data | attr.task
7248 : : */
7249 : :
7250 : : struct perf_task_event {
7251 : : struct task_struct *task;
7252 : : struct perf_event_context *task_ctx;
7253 : :
7254 : : struct {
7255 : : struct perf_event_header header;
7256 : :
7257 : : u32 pid;
7258 : : u32 ppid;
7259 : : u32 tid;
7260 : : u32 ptid;
7261 : : u64 time;
7262 : : } event_id;
7263 : : };
7264 : :
7265 : 0 : static int perf_event_task_match(struct perf_event *event)
7266 : : {
7267 : 0 : return event->attr.comm || event->attr.mmap ||
7268 : 0 : event->attr.mmap2 || event->attr.mmap_data ||
7269 : : event->attr.task;
7270 : : }
7271 : :
7272 : 0 : static void perf_event_task_output(struct perf_event *event,
7273 : : void *data)
7274 : : {
7275 : 0 : struct perf_task_event *task_event = data;
7276 : 0 : struct perf_output_handle handle;
7277 : 0 : struct perf_sample_data sample;
7278 : 0 : struct task_struct *task = task_event->task;
7279 : 0 : int ret, size = task_event->event_id.header.size;
7280 : :
7281 [ # # ]: 0 : if (!perf_event_task_match(event))
7282 : 0 : return;
7283 : :
7284 [ # # ]: 0 : perf_event_header__init_id(&task_event->event_id.header, &sample, event);
7285 : :
7286 : 0 : ret = perf_output_begin(&handle, event,
7287 : 0 : task_event->event_id.header.size);
7288 [ # # ]: 0 : if (ret)
7289 : 0 : goto out;
7290 : :
7291 : 0 : task_event->event_id.pid = perf_event_pid(event, task);
7292 : 0 : task_event->event_id.ppid = perf_event_pid(event, current);
7293 : :
7294 : 0 : task_event->event_id.tid = perf_event_tid(event, task);
7295 : 0 : task_event->event_id.ptid = perf_event_tid(event, current);
7296 : :
7297 : 0 : task_event->event_id.time = perf_event_clock(event);
7298 : :
7299 : 0 : perf_output_put(&handle, task_event->event_id);
7300 : :
7301 [ # # ]: 0 : perf_event__output_id_sample(event, &handle, &sample);
7302 : :
7303 : 0 : perf_output_end(&handle);
7304 : 0 : out:
7305 : 0 : task_event->event_id.header.size = size;
7306 : : }
7307 : :
7308 : 21318 : static void perf_event_task(struct task_struct *task,
7309 : : struct perf_event_context *task_ctx,
7310 : : int new)
7311 : : {
7312 : 21318 : struct perf_task_event task_event;
7313 : :
7314 [ + - + - ]: 42636 : if (!atomic_read(&nr_comm_events) &&
7315 [ + - ]: 21318 : !atomic_read(&nr_mmap_events) &&
7316 : : !atomic_read(&nr_task_events))
7317 : 21318 : return;
7318 : :
7319 : 0 : task_event = (struct perf_task_event){
7320 : : .task = task,
7321 : : .task_ctx = task_ctx,
7322 : : .event_id = {
7323 : : .header = {
7324 [ # # ]: 0 : .type = new ? PERF_RECORD_FORK : PERF_RECORD_EXIT,
7325 : : .misc = 0,
7326 : : .size = sizeof(task_event.event_id),
7327 : : },
7328 : : /* .pid */
7329 : : /* .ppid */
7330 : : /* .tid */
7331 : : /* .ptid */
7332 : : /* .time */
7333 : : },
7334 : : };
7335 : :
7336 : 0 : perf_iterate_sb(perf_event_task_output,
7337 : : &task_event,
7338 : : task_ctx);
7339 : : }
7340 : :
7341 : 11126 : void perf_event_fork(struct task_struct *task)
7342 : : {
7343 : 11126 : perf_event_task(task, NULL, 1);
7344 : 11126 : perf_event_namespaces(task);
7345 : 11126 : }
7346 : :
7347 : : /*
7348 : : * comm tracking
7349 : : */
7350 : :
7351 : : struct perf_comm_event {
7352 : : struct task_struct *task;
7353 : : char *comm;
7354 : : int comm_size;
7355 : :
7356 : : struct {
7357 : : struct perf_event_header header;
7358 : :
7359 : : u32 pid;
7360 : : u32 tid;
7361 : : } event_id;
7362 : : };
7363 : :
7364 : 0 : static int perf_event_comm_match(struct perf_event *event)
7365 : : {
7366 : 0 : return event->attr.comm;
7367 : : }
7368 : :
7369 : 0 : static void perf_event_comm_output(struct perf_event *event,
7370 : : void *data)
7371 : : {
7372 : 0 : struct perf_comm_event *comm_event = data;
7373 : 0 : struct perf_output_handle handle;
7374 : 0 : struct perf_sample_data sample;
7375 : 0 : int size = comm_event->event_id.header.size;
7376 : 0 : int ret;
7377 : :
7378 [ # # ]: 0 : if (!perf_event_comm_match(event))
7379 : 0 : return;
7380 : :
7381 [ # # ]: 0 : perf_event_header__init_id(&comm_event->event_id.header, &sample, event);
7382 : 0 : ret = perf_output_begin(&handle, event,
7383 : 0 : comm_event->event_id.header.size);
7384 : :
7385 [ # # ]: 0 : if (ret)
7386 : 0 : goto out;
7387 : :
7388 : 0 : comm_event->event_id.pid = perf_event_pid(event, comm_event->task);
7389 : 0 : comm_event->event_id.tid = perf_event_tid(event, comm_event->task);
7390 : :
7391 : 0 : perf_output_put(&handle, comm_event->event_id);
7392 : 0 : __output_copy(&handle, comm_event->comm,
7393 : 0 : comm_event->comm_size);
7394 : :
7395 [ # # ]: 0 : perf_event__output_id_sample(event, &handle, &sample);
7396 : :
7397 : 0 : perf_output_end(&handle);
7398 : 0 : out:
7399 : 0 : comm_event->event_id.header.size = size;
7400 : : }
7401 : :
7402 : 0 : static void perf_event_comm_event(struct perf_comm_event *comm_event)
7403 : : {
7404 : 0 : char comm[TASK_COMM_LEN];
7405 : 0 : unsigned int size;
7406 : :
7407 : 0 : memset(comm, 0, sizeof(comm));
7408 : 0 : strlcpy(comm, comm_event->task->comm, sizeof(comm));
7409 : 0 : size = ALIGN(strlen(comm)+1, sizeof(u64));
7410 : :
7411 : 0 : comm_event->comm = comm;
7412 : 0 : comm_event->comm_size = size;
7413 : :
7414 : 0 : comm_event->event_id.header.size = sizeof(comm_event->event_id) + size;
7415 : :
7416 : 0 : perf_iterate_sb(perf_event_comm_output,
7417 : : comm_event,
7418 : : NULL);
7419 : 0 : }
7420 : :
7421 : 11321 : void perf_event_comm(struct task_struct *task, bool exec)
7422 : : {
7423 : 11321 : struct perf_comm_event comm_event;
7424 : :
7425 [ + - ]: 11321 : if (!atomic_read(&nr_comm_events))
7426 : 11321 : return;
7427 : :
7428 [ # # ]: 0 : comm_event = (struct perf_comm_event){
7429 : : .task = task,
7430 : : /* .comm */
7431 : : /* .comm_size */
7432 : : .event_id = {
7433 : : .header = {
7434 : : .type = PERF_RECORD_COMM,
7435 : : .misc = exec ? PERF_RECORD_MISC_COMM_EXEC : 0,
7436 : : /* .size */
7437 : : },
7438 : : /* .pid */
7439 : : /* .tid */
7440 : : },
7441 : : };
7442 : :
7443 : 0 : perf_event_comm_event(&comm_event);
7444 : : }
7445 : :
7446 : : /*
7447 : : * namespaces tracking
7448 : : */
7449 : :
7450 : : struct perf_namespaces_event {
7451 : : struct task_struct *task;
7452 : :
7453 : : struct {
7454 : : struct perf_event_header header;
7455 : :
7456 : : u32 pid;
7457 : : u32 tid;
7458 : : u64 nr_namespaces;
7459 : : struct perf_ns_link_info link_info[NR_NAMESPACES];
7460 : : } event_id;
7461 : : };
7462 : :
7463 : 0 : static int perf_event_namespaces_match(struct perf_event *event)
7464 : : {
7465 : 0 : return event->attr.namespaces;
7466 : : }
7467 : :
7468 : 0 : static void perf_event_namespaces_output(struct perf_event *event,
7469 : : void *data)
7470 : : {
7471 : 0 : struct perf_namespaces_event *namespaces_event = data;
7472 : 0 : struct perf_output_handle handle;
7473 : 0 : struct perf_sample_data sample;
7474 : 0 : u16 header_size = namespaces_event->event_id.header.size;
7475 : 0 : int ret;
7476 : :
7477 [ # # ]: 0 : if (!perf_event_namespaces_match(event))
7478 : 0 : return;
7479 : :
7480 [ # # ]: 0 : perf_event_header__init_id(&namespaces_event->event_id.header,
7481 : : &sample, event);
7482 : 0 : ret = perf_output_begin(&handle, event,
7483 : 0 : namespaces_event->event_id.header.size);
7484 [ # # ]: 0 : if (ret)
7485 : 0 : goto out;
7486 : :
7487 : 0 : namespaces_event->event_id.pid = perf_event_pid(event,
7488 : : namespaces_event->task);
7489 : 0 : namespaces_event->event_id.tid = perf_event_tid(event,
7490 : : namespaces_event->task);
7491 : :
7492 : 0 : perf_output_put(&handle, namespaces_event->event_id);
7493 : :
7494 [ # # ]: 0 : perf_event__output_id_sample(event, &handle, &sample);
7495 : :
7496 : 0 : perf_output_end(&handle);
7497 : 0 : out:
7498 : 0 : namespaces_event->event_id.header.size = header_size;
7499 : : }
7500 : :
7501 : : static void perf_fill_ns_link_info(struct perf_ns_link_info *ns_link_info,
7502 : : struct task_struct *task,
7503 : : const struct proc_ns_operations *ns_ops)
7504 : : {
7505 : : struct path ns_path;
7506 : : struct inode *ns_inode;
7507 : : int error;
7508 : :
7509 : : error = ns_get_path(&ns_path, task, ns_ops);
7510 : : if (!error) {
7511 : : ns_inode = ns_path.dentry->d_inode;
7512 : : ns_link_info->dev = new_encode_dev(ns_inode->i_sb->s_dev);
7513 : : ns_link_info->ino = ns_inode->i_ino;
7514 : : path_put(&ns_path);
7515 : : }
7516 : : }
7517 : :
7518 : 11165 : void perf_event_namespaces(struct task_struct *task)
7519 : : {
7520 : 11165 : struct perf_namespaces_event namespaces_event;
7521 : 11165 : struct perf_ns_link_info *ns_link_info;
7522 : :
7523 [ + - ]: 11165 : if (!atomic_read(&nr_namespaces_events))
7524 : 11165 : return;
7525 : :
7526 : 0 : namespaces_event = (struct perf_namespaces_event){
7527 : : .task = task,
7528 : : .event_id = {
7529 : : .header = {
7530 : : .type = PERF_RECORD_NAMESPACES,
7531 : : .misc = 0,
7532 : : .size = sizeof(namespaces_event.event_id),
7533 : : },
7534 : : /* .pid */
7535 : : /* .tid */
7536 : : .nr_namespaces = NR_NAMESPACES,
7537 : : /* .link_info[NR_NAMESPACES] */
7538 : : },
7539 : : };
7540 : :
7541 : 0 : ns_link_info = namespaces_event.event_id.link_info;
7542 : :
7543 : 0 : perf_fill_ns_link_info(&ns_link_info[MNT_NS_INDEX],
7544 : : task, &mntns_operations);
7545 : :
7546 : : #ifdef CONFIG_USER_NS
7547 : : perf_fill_ns_link_info(&ns_link_info[USER_NS_INDEX],
7548 : : task, &userns_operations);
7549 : : #endif
7550 : : #ifdef CONFIG_NET_NS
7551 : 0 : perf_fill_ns_link_info(&ns_link_info[NET_NS_INDEX],
7552 : : task, &netns_operations);
7553 : : #endif
7554 : : #ifdef CONFIG_UTS_NS
7555 : 0 : perf_fill_ns_link_info(&ns_link_info[UTS_NS_INDEX],
7556 : : task, &utsns_operations);
7557 : : #endif
7558 : : #ifdef CONFIG_IPC_NS
7559 : 0 : perf_fill_ns_link_info(&ns_link_info[IPC_NS_INDEX],
7560 : : task, &ipcns_operations);
7561 : : #endif
7562 : : #ifdef CONFIG_PID_NS
7563 : 0 : perf_fill_ns_link_info(&ns_link_info[PID_NS_INDEX],
7564 : : task, &pidns_operations);
7565 : : #endif
7566 : : #ifdef CONFIG_CGROUPS
7567 : 0 : perf_fill_ns_link_info(&ns_link_info[CGROUP_NS_INDEX],
7568 : : task, &cgroupns_operations);
7569 : : #endif
7570 : :
7571 : 0 : perf_iterate_sb(perf_event_namespaces_output,
7572 : : &namespaces_event,
7573 : : NULL);
7574 : : }
7575 : :
7576 : : /*
7577 : : * mmap tracking
7578 : : */
7579 : :
7580 : : struct perf_mmap_event {
7581 : : struct vm_area_struct *vma;
7582 : :
7583 : : const char *file_name;
7584 : : int file_size;
7585 : : int maj, min;
7586 : : u64 ino;
7587 : : u64 ino_generation;
7588 : : u32 prot, flags;
7589 : :
7590 : : struct {
7591 : : struct perf_event_header header;
7592 : :
7593 : : u32 pid;
7594 : : u32 tid;
7595 : : u64 start;
7596 : : u64 len;
7597 : : u64 pgoff;
7598 : : } event_id;
7599 : : };
7600 : :
7601 : 0 : static int perf_event_mmap_match(struct perf_event *event,
7602 : : void *data)
7603 : : {
7604 : 0 : struct perf_mmap_event *mmap_event = data;
7605 : 0 : struct vm_area_struct *vma = mmap_event->vma;
7606 : 0 : int executable = vma->vm_flags & VM_EXEC;
7607 : :
7608 [ # # # # ]: 0 : return (!executable && event->attr.mmap_data) ||
7609 [ # # ]: 0 : (executable && (event->attr.mmap || event->attr.mmap2));
7610 : : }
7611 : :
7612 : 0 : static void perf_event_mmap_output(struct perf_event *event,
7613 : : void *data)
7614 : : {
7615 : 0 : struct perf_mmap_event *mmap_event = data;
7616 : 0 : struct perf_output_handle handle;
7617 : 0 : struct perf_sample_data sample;
7618 : 0 : int size = mmap_event->event_id.header.size;
7619 : 0 : u32 type = mmap_event->event_id.header.type;
7620 : 0 : int ret;
7621 : :
7622 [ # # ]: 0 : if (!perf_event_mmap_match(event, data))
7623 : 0 : return;
7624 : :
7625 [ # # ]: 0 : if (event->attr.mmap2) {
7626 : 0 : mmap_event->event_id.header.type = PERF_RECORD_MMAP2;
7627 : 0 : mmap_event->event_id.header.size += sizeof(mmap_event->maj);
7628 : 0 : mmap_event->event_id.header.size += sizeof(mmap_event->min);
7629 : 0 : mmap_event->event_id.header.size += sizeof(mmap_event->ino);
7630 : 0 : mmap_event->event_id.header.size += sizeof(mmap_event->ino_generation);
7631 : 0 : mmap_event->event_id.header.size += sizeof(mmap_event->prot);
7632 : 0 : mmap_event->event_id.header.size += sizeof(mmap_event->flags);
7633 : : }
7634 : :
7635 [ # # ]: 0 : perf_event_header__init_id(&mmap_event->event_id.header, &sample, event);
7636 : 0 : ret = perf_output_begin(&handle, event,
7637 : 0 : mmap_event->event_id.header.size);
7638 [ # # ]: 0 : if (ret)
7639 : 0 : goto out;
7640 : :
7641 : 0 : mmap_event->event_id.pid = perf_event_pid(event, current);
7642 : 0 : mmap_event->event_id.tid = perf_event_tid(event, current);
7643 : :
7644 : 0 : perf_output_put(&handle, mmap_event->event_id);
7645 : :
7646 [ # # ]: 0 : if (event->attr.mmap2) {
7647 : 0 : perf_output_put(&handle, mmap_event->maj);
7648 : 0 : perf_output_put(&handle, mmap_event->min);
7649 : 0 : perf_output_put(&handle, mmap_event->ino);
7650 : 0 : perf_output_put(&handle, mmap_event->ino_generation);
7651 : 0 : perf_output_put(&handle, mmap_event->prot);
7652 : 0 : perf_output_put(&handle, mmap_event->flags);
7653 : : }
7654 : :
7655 : 0 : __output_copy(&handle, mmap_event->file_name,
7656 : 0 : mmap_event->file_size);
7657 : :
7658 [ # # ]: 0 : perf_event__output_id_sample(event, &handle, &sample);
7659 : :
7660 : 0 : perf_output_end(&handle);
7661 : 0 : out:
7662 : 0 : mmap_event->event_id.header.size = size;
7663 : 0 : mmap_event->event_id.header.type = type;
7664 : : }
7665 : :
7666 : 0 : static void perf_event_mmap_event(struct perf_mmap_event *mmap_event)
7667 : : {
7668 : 0 : struct vm_area_struct *vma = mmap_event->vma;
7669 : 0 : struct file *file = vma->vm_file;
7670 : 0 : int maj = 0, min = 0;
7671 : 0 : u64 ino = 0, gen = 0;
7672 : 0 : u32 prot = 0, flags = 0;
7673 : 0 : unsigned int size;
7674 : 0 : char tmp[16];
7675 : 0 : char *buf = NULL;
7676 : 0 : char *name;
7677 : :
7678 : 0 : if (vma->vm_flags & VM_READ)
7679 : : prot |= PROT_READ;
7680 [ # # ]: 0 : if (vma->vm_flags & VM_WRITE)
7681 : 0 : prot |= PROT_WRITE;
7682 [ # # ]: 0 : if (vma->vm_flags & VM_EXEC)
7683 : 0 : prot |= PROT_EXEC;
7684 : :
7685 [ # # ]: 0 : if (vma->vm_flags & VM_MAYSHARE)
7686 : : flags = MAP_SHARED;
7687 : : else
7688 : 0 : flags = MAP_PRIVATE;
7689 : :
7690 [ # # ]: 0 : if (vma->vm_flags & VM_DENYWRITE)
7691 : 0 : flags |= MAP_DENYWRITE;
7692 [ # # ]: 0 : if (vma->vm_flags & VM_MAYEXEC)
7693 : 0 : flags |= MAP_EXECUTABLE;
7694 [ # # ]: 0 : if (vma->vm_flags & VM_LOCKED)
7695 : 0 : flags |= MAP_LOCKED;
7696 [ # # ]: 0 : if (vma->vm_flags & VM_HUGETLB)
7697 : 0 : flags |= MAP_HUGETLB;
7698 : :
7699 [ # # ]: 0 : if (file) {
7700 : 0 : struct inode *inode;
7701 : 0 : dev_t dev;
7702 : :
7703 : 0 : buf = kmalloc(PATH_MAX, GFP_KERNEL);
7704 [ # # ]: 0 : if (!buf) {
7705 : 0 : name = "//enomem";
7706 : 0 : goto cpy_name;
7707 : : }
7708 : : /*
7709 : : * d_path() works from the end of the rb backwards, so we
7710 : : * need to add enough zero bytes after the string to handle
7711 : : * the 64bit alignment we do later.
7712 : : */
7713 : 0 : name = file_path(file, buf, PATH_MAX - sizeof(u64));
7714 [ # # ]: 0 : if (IS_ERR(name)) {
7715 : 0 : name = "//toolong";
7716 : 0 : goto cpy_name;
7717 : : }
7718 : 0 : inode = file_inode(vma->vm_file);
7719 : 0 : dev = inode->i_sb->s_dev;
7720 : 0 : ino = inode->i_ino;
7721 : 0 : gen = inode->i_generation;
7722 : 0 : maj = MAJOR(dev);
7723 : 0 : min = MINOR(dev);
7724 : :
7725 : 0 : goto got_name;
7726 : : } else {
7727 [ # # # # ]: 0 : if (vma->vm_ops && vma->vm_ops->name) {
7728 : 0 : name = (char *) vma->vm_ops->name(vma);
7729 [ # # ]: 0 : if (name)
7730 : 0 : goto cpy_name;
7731 : : }
7732 : :
7733 : 0 : name = (char *)arch_vma_name(vma);
7734 [ # # ]: 0 : if (name)
7735 : 0 : goto cpy_name;
7736 : :
7737 [ # # ]: 0 : if (vma->vm_start <= vma->vm_mm->start_brk &&
7738 [ # # ]: 0 : vma->vm_end >= vma->vm_mm->brk) {
7739 : 0 : name = "[heap]";
7740 : 0 : goto cpy_name;
7741 : : }
7742 [ # # ]: 0 : if (vma->vm_start <= vma->vm_mm->start_stack &&
7743 [ # # ]: 0 : vma->vm_end >= vma->vm_mm->start_stack) {
7744 : 0 : name = "[stack]";
7745 : 0 : goto cpy_name;
7746 : : }
7747 : :
7748 : 0 : name = "//anon";
7749 : 0 : goto cpy_name;
7750 : : }
7751 : :
7752 : 0 : cpy_name:
7753 : 0 : strlcpy(tmp, name, sizeof(tmp));
7754 : 0 : name = tmp;
7755 : 0 : got_name:
7756 : : /*
7757 : : * Since our buffer works in 8 byte units we need to align our string
7758 : : * size to a multiple of 8. However, we must guarantee the tail end is
7759 : : * zero'd out to avoid leaking random bits to userspace.
7760 : : */
7761 : 0 : size = strlen(name)+1;
7762 [ # # ]: 0 : while (!IS_ALIGNED(size, sizeof(u64)))
7763 : 0 : name[size++] = '\0';
7764 : :
7765 : 0 : mmap_event->file_name = name;
7766 : 0 : mmap_event->file_size = size;
7767 : 0 : mmap_event->maj = maj;
7768 : 0 : mmap_event->min = min;
7769 : 0 : mmap_event->ino = ino;
7770 : 0 : mmap_event->ino_generation = gen;
7771 : 0 : mmap_event->prot = prot;
7772 : 0 : mmap_event->flags = flags;
7773 : :
7774 [ # # ]: 0 : if (!(vma->vm_flags & VM_EXEC))
7775 : 0 : mmap_event->event_id.header.misc |= PERF_RECORD_MISC_MMAP_DATA;
7776 : :
7777 : 0 : mmap_event->event_id.header.size = sizeof(mmap_event->event_id) + size;
7778 : :
7779 : 0 : perf_iterate_sb(perf_event_mmap_output,
7780 : : mmap_event,
7781 : : NULL);
7782 : :
7783 : 0 : kfree(buf);
7784 : 0 : }
7785 : :
7786 : : /*
7787 : : * Check whether inode and address range match filter criteria.
7788 : : */
7789 : : static bool perf_addr_filter_match(struct perf_addr_filter *filter,
7790 : : struct file *file, unsigned long offset,
7791 : : unsigned long size)
7792 : : {
7793 : : /* d_inode(NULL) won't be equal to any mapped user-space file */
7794 : : if (!filter->path.dentry)
7795 : : return false;
7796 : :
7797 : : if (d_inode(filter->path.dentry) != file_inode(file))
7798 : : return false;
7799 : :
7800 : : if (filter->offset > offset + size)
7801 : : return false;
7802 : :
7803 : : if (filter->offset + filter->size < offset)
7804 : : return false;
7805 : :
7806 : : return true;
7807 : : }
7808 : :
7809 : : static bool perf_addr_filter_vma_adjust(struct perf_addr_filter *filter,
7810 : : struct vm_area_struct *vma,
7811 : : struct perf_addr_filter_range *fr)
7812 : : {
7813 : : unsigned long vma_size = vma->vm_end - vma->vm_start;
7814 : : unsigned long off = vma->vm_pgoff << PAGE_SHIFT;
7815 : : struct file *file = vma->vm_file;
7816 : :
7817 : : if (!perf_addr_filter_match(filter, file, off, vma_size))
7818 : : return false;
7819 : :
7820 : : if (filter->offset < off) {
7821 : : fr->start = vma->vm_start;
7822 : : fr->size = min(vma_size, filter->size - (off - filter->offset));
7823 : : } else {
7824 : : fr->start = vma->vm_start + filter->offset - off;
7825 : : fr->size = min(vma->vm_end - fr->start, filter->size);
7826 : : }
7827 : :
7828 : : return true;
7829 : : }
7830 : :
7831 : 0 : static void __perf_addr_filters_adjust(struct perf_event *event, void *data)
7832 : : {
7833 [ # # ]: 0 : struct perf_addr_filters_head *ifh = perf_event_addr_filters(event);
7834 : 0 : struct vm_area_struct *vma = data;
7835 : 0 : struct perf_addr_filter *filter;
7836 : 0 : unsigned int restart = 0, count = 0;
7837 : 0 : unsigned long flags;
7838 : :
7839 [ # # ]: 0 : if (!has_addr_filter(event))
7840 : : return;
7841 : :
7842 [ # # ]: 0 : if (!vma->vm_file)
7843 : : return;
7844 : :
7845 : 0 : raw_spin_lock_irqsave(&ifh->lock, flags);
7846 [ # # ]: 0 : list_for_each_entry(filter, &ifh->list, entry) {
7847 [ # # ]: 0 : if (perf_addr_filter_vma_adjust(filter, vma,
7848 : 0 : &event->addr_filter_ranges[count]))
7849 : 0 : restart++;
7850 : :
7851 : 0 : count++;
7852 : : }
7853 : :
7854 [ # # ]: 0 : if (restart)
7855 : 0 : event->addr_filters_gen++;
7856 : 0 : raw_spin_unlock_irqrestore(&ifh->lock, flags);
7857 : :
7858 [ # # ]: 0 : if (restart)
7859 : 0 : perf_event_stop(event, 1);
7860 : : }
7861 : :
7862 : : /*
7863 : : * Adjust all task's events' filters to the new vma
7864 : : */
7865 : 0 : static void perf_addr_filters_adjust(struct vm_area_struct *vma)
7866 : : {
7867 : 0 : struct perf_event_context *ctx;
7868 : 0 : int ctxn;
7869 : :
7870 : : /*
7871 : : * Data tracing isn't supported yet and as such there is no need
7872 : : * to keep track of anything that isn't related to executable code:
7873 : : */
7874 [ # # ]: 0 : if (!(vma->vm_flags & VM_EXEC))
7875 : : return;
7876 : :
7877 : 0 : rcu_read_lock();
7878 [ # # ]: 0 : for_each_task_context_nr(ctxn) {
7879 [ # # ]: 0 : ctx = rcu_dereference(current->perf_event_ctxp[ctxn]);
7880 [ # # ]: 0 : if (!ctx)
7881 : 0 : continue;
7882 : :
7883 : 0 : perf_iterate_ctx(ctx, __perf_addr_filters_adjust, vma, true);
7884 : : }
7885 : 0 : rcu_read_unlock();
7886 : : }
7887 : :
7888 : 464939 : void perf_event_mmap(struct vm_area_struct *vma)
7889 : : {
7890 : 464939 : struct perf_mmap_event mmap_event;
7891 : :
7892 [ + - ]: 464939 : if (!atomic_read(&nr_mmap_events))
7893 : 464939 : return;
7894 : :
7895 : 0 : mmap_event = (struct perf_mmap_event){
7896 : : .vma = vma,
7897 : : /* .file_name */
7898 : : /* .file_size */
7899 : : .event_id = {
7900 : : .header = {
7901 : : .type = PERF_RECORD_MMAP,
7902 : : .misc = PERF_RECORD_MISC_USER,
7903 : : /* .size */
7904 : : },
7905 : : /* .pid */
7906 : : /* .tid */
7907 : 0 : .start = vma->vm_start,
7908 : 0 : .len = vma->vm_end - vma->vm_start,
7909 : 0 : .pgoff = (u64)vma->vm_pgoff << PAGE_SHIFT,
7910 : : },
7911 : : /* .maj (attr_mmap2 only) */
7912 : : /* .min (attr_mmap2 only) */
7913 : : /* .ino (attr_mmap2 only) */
7914 : : /* .ino_generation (attr_mmap2 only) */
7915 : : /* .prot (attr_mmap2 only) */
7916 : : /* .flags (attr_mmap2 only) */
7917 : : };
7918 : :
7919 : 0 : perf_addr_filters_adjust(vma);
7920 : 0 : perf_event_mmap_event(&mmap_event);
7921 : : }
7922 : :
7923 : 0 : void perf_event_aux_event(struct perf_event *event, unsigned long head,
7924 : : unsigned long size, u64 flags)
7925 : : {
7926 : 0 : struct perf_output_handle handle;
7927 : 0 : struct perf_sample_data sample;
7928 : 0 : struct perf_aux_event {
7929 : : struct perf_event_header header;
7930 : : u64 offset;
7931 : : u64 size;
7932 : : u64 flags;
7933 : 0 : } rec = {
7934 : : .header = {
7935 : : .type = PERF_RECORD_AUX,
7936 : : .misc = 0,
7937 : : .size = sizeof(rec),
7938 : : },
7939 : : .offset = head,
7940 : : .size = size,
7941 : : .flags = flags,
7942 : : };
7943 : 0 : int ret;
7944 : :
7945 [ # # ]: 0 : perf_event_header__init_id(&rec.header, &sample, event);
7946 : 0 : ret = perf_output_begin(&handle, event, rec.header.size);
7947 : :
7948 [ # # ]: 0 : if (ret)
7949 : 0 : return;
7950 : :
7951 : 0 : perf_output_put(&handle, rec);
7952 [ # # ]: 0 : perf_event__output_id_sample(event, &handle, &sample);
7953 : :
7954 : 0 : perf_output_end(&handle);
7955 : : }
7956 : :
7957 : : /*
7958 : : * Lost/dropped samples logging
7959 : : */
7960 : 0 : void perf_log_lost_samples(struct perf_event *event, u64 lost)
7961 : : {
7962 : 0 : struct perf_output_handle handle;
7963 : 0 : struct perf_sample_data sample;
7964 : 0 : int ret;
7965 : :
7966 : 0 : struct {
7967 : : struct perf_event_header header;
7968 : : u64 lost;
7969 : 0 : } lost_samples_event = {
7970 : : .header = {
7971 : : .type = PERF_RECORD_LOST_SAMPLES,
7972 : : .misc = 0,
7973 : : .size = sizeof(lost_samples_event),
7974 : : },
7975 : : .lost = lost,
7976 : : };
7977 : :
7978 [ # # ]: 0 : perf_event_header__init_id(&lost_samples_event.header, &sample, event);
7979 : :
7980 : 0 : ret = perf_output_begin(&handle, event,
7981 : 0 : lost_samples_event.header.size);
7982 [ # # ]: 0 : if (ret)
7983 : 0 : return;
7984 : :
7985 : 0 : perf_output_put(&handle, lost_samples_event);
7986 [ # # ]: 0 : perf_event__output_id_sample(event, &handle, &sample);
7987 : 0 : perf_output_end(&handle);
7988 : : }
7989 : :
7990 : : /*
7991 : : * context_switch tracking
7992 : : */
7993 : :
7994 : : struct perf_switch_event {
7995 : : struct task_struct *task;
7996 : : struct task_struct *next_prev;
7997 : :
7998 : : struct {
7999 : : struct perf_event_header header;
8000 : : u32 next_prev_pid;
8001 : : u32 next_prev_tid;
8002 : : } event_id;
8003 : : };
8004 : :
8005 : 0 : static int perf_event_switch_match(struct perf_event *event)
8006 : : {
8007 : 0 : return event->attr.context_switch;
8008 : : }
8009 : :
8010 : 0 : static void perf_event_switch_output(struct perf_event *event, void *data)
8011 : : {
8012 : 0 : struct perf_switch_event *se = data;
8013 : 0 : struct perf_output_handle handle;
8014 : 0 : struct perf_sample_data sample;
8015 : 0 : int ret;
8016 : :
8017 [ # # ]: 0 : if (!perf_event_switch_match(event))
8018 : 0 : return;
8019 : :
8020 : : /* Only CPU-wide events are allowed to see next/prev pid/tid */
8021 [ # # ]: 0 : if (event->ctx->task) {
8022 : 0 : se->event_id.header.type = PERF_RECORD_SWITCH;
8023 : 0 : se->event_id.header.size = sizeof(se->event_id.header);
8024 : : } else {
8025 : 0 : se->event_id.header.type = PERF_RECORD_SWITCH_CPU_WIDE;
8026 : 0 : se->event_id.header.size = sizeof(se->event_id);
8027 : 0 : se->event_id.next_prev_pid =
8028 : 0 : perf_event_pid(event, se->next_prev);
8029 : 0 : se->event_id.next_prev_tid =
8030 : 0 : perf_event_tid(event, se->next_prev);
8031 : : }
8032 : :
8033 [ # # ]: 0 : perf_event_header__init_id(&se->event_id.header, &sample, event);
8034 : :
8035 : 0 : ret = perf_output_begin(&handle, event, se->event_id.header.size);
8036 [ # # ]: 0 : if (ret)
8037 : : return;
8038 : :
8039 [ # # ]: 0 : if (event->ctx->task)
8040 : 0 : perf_output_put(&handle, se->event_id.header);
8041 : : else
8042 : 0 : perf_output_put(&handle, se->event_id);
8043 : :
8044 [ # # ]: 0 : perf_event__output_id_sample(event, &handle, &sample);
8045 : :
8046 : 0 : perf_output_end(&handle);
8047 : : }
8048 : :
8049 : 0 : static void perf_event_switch(struct task_struct *task,
8050 : : struct task_struct *next_prev, bool sched_in)
8051 : : {
8052 : 0 : struct perf_switch_event switch_event;
8053 : :
8054 : : /* N.B. caller checks nr_switch_events != 0 */
8055 : :
8056 [ # # ]: 0 : switch_event = (struct perf_switch_event){
8057 : : .task = task,
8058 : : .next_prev = next_prev,
8059 : : .event_id = {
8060 : : .header = {
8061 : : /* .type */
8062 : : .misc = sched_in ? 0 : PERF_RECORD_MISC_SWITCH_OUT,
8063 : : /* .size */
8064 : : },
8065 : : /* .next_prev_pid */
8066 : : /* .next_prev_tid */
8067 : : },
8068 : : };
8069 : :
8070 [ # # # # ]: 0 : if (!sched_in && task->state == TASK_RUNNING)
8071 : 0 : switch_event.event_id.header.misc |=
8072 : : PERF_RECORD_MISC_SWITCH_OUT_PREEMPT;
8073 : :
8074 : 0 : perf_iterate_sb(perf_event_switch_output,
8075 : : &switch_event,
8076 : : NULL);
8077 : 0 : }
8078 : :
8079 : : /*
8080 : : * IRQ throttle logging
8081 : : */
8082 : :
8083 : 0 : static void perf_log_throttle(struct perf_event *event, int enable)
8084 : : {
8085 : 0 : struct perf_output_handle handle;
8086 : 0 : struct perf_sample_data sample;
8087 : 0 : int ret;
8088 : :
8089 : 0 : struct {
8090 : : struct perf_event_header header;
8091 : : u64 time;
8092 : : u64 id;
8093 : : u64 stream_id;
8094 : 0 : } throttle_event = {
8095 : : .header = {
8096 : : .type = PERF_RECORD_THROTTLE,
8097 : : .misc = 0,
8098 : : .size = sizeof(throttle_event),
8099 : : },
8100 : 0 : .time = perf_event_clock(event),
8101 [ # # ]: 0 : .id = primary_event_id(event),
8102 : : .stream_id = event->id,
8103 : : };
8104 : :
8105 [ # # ]: 0 : if (enable)
8106 : 0 : throttle_event.header.type = PERF_RECORD_UNTHROTTLE;
8107 : :
8108 [ # # ]: 0 : perf_event_header__init_id(&throttle_event.header, &sample, event);
8109 : :
8110 : 0 : ret = perf_output_begin(&handle, event,
8111 : 0 : throttle_event.header.size);
8112 [ # # ]: 0 : if (ret)
8113 : 0 : return;
8114 : :
8115 : 0 : perf_output_put(&handle, throttle_event);
8116 [ # # ]: 0 : perf_event__output_id_sample(event, &handle, &sample);
8117 : 0 : perf_output_end(&handle);
8118 : : }
8119 : :
8120 : : /*
8121 : : * ksymbol register/unregister tracking
8122 : : */
8123 : :
8124 : : struct perf_ksymbol_event {
8125 : : const char *name;
8126 : : int name_len;
8127 : : struct {
8128 : : struct perf_event_header header;
8129 : : u64 addr;
8130 : : u32 len;
8131 : : u16 ksym_type;
8132 : : u16 flags;
8133 : : } event_id;
8134 : : };
8135 : :
8136 : 0 : static int perf_event_ksymbol_match(struct perf_event *event)
8137 : : {
8138 : 0 : return event->attr.ksymbol;
8139 : : }
8140 : :
8141 : 0 : static void perf_event_ksymbol_output(struct perf_event *event, void *data)
8142 : : {
8143 : 0 : struct perf_ksymbol_event *ksymbol_event = data;
8144 : 0 : struct perf_output_handle handle;
8145 : 0 : struct perf_sample_data sample;
8146 : 0 : int ret;
8147 : :
8148 [ # # ]: 0 : if (!perf_event_ksymbol_match(event))
8149 : 0 : return;
8150 : :
8151 [ # # ]: 0 : perf_event_header__init_id(&ksymbol_event->event_id.header,
8152 : : &sample, event);
8153 : 0 : ret = perf_output_begin(&handle, event,
8154 : 0 : ksymbol_event->event_id.header.size);
8155 [ # # ]: 0 : if (ret)
8156 : : return;
8157 : :
8158 : 0 : perf_output_put(&handle, ksymbol_event->event_id);
8159 : 0 : __output_copy(&handle, ksymbol_event->name, ksymbol_event->name_len);
8160 [ # # ]: 0 : perf_event__output_id_sample(event, &handle, &sample);
8161 : :
8162 : 0 : perf_output_end(&handle);
8163 : : }
8164 : :
8165 : 0 : void perf_event_ksymbol(u16 ksym_type, u64 addr, u32 len, bool unregister,
8166 : : const char *sym)
8167 : : {
8168 : 0 : struct perf_ksymbol_event ksymbol_event;
8169 : 0 : char name[KSYM_NAME_LEN];
8170 : 0 : u16 flags = 0;
8171 : 0 : int name_len;
8172 : :
8173 [ # # ]: 0 : if (!atomic_read(&nr_ksymbol_events))
8174 : 0 : return;
8175 : :
8176 [ # # ]: 0 : if (ksym_type >= PERF_RECORD_KSYMBOL_TYPE_MAX ||
8177 : : ksym_type == PERF_RECORD_KSYMBOL_TYPE_UNKNOWN)
8178 : 0 : goto err;
8179 : :
8180 : 0 : strlcpy(name, sym, KSYM_NAME_LEN);
8181 : 0 : name_len = strlen(name) + 1;
8182 [ # # ]: 0 : while (!IS_ALIGNED(name_len, sizeof(u64)))
8183 : 0 : name[name_len++] = '\0';
8184 : 0 : BUILD_BUG_ON(KSYM_NAME_LEN % sizeof(u64));
8185 : :
8186 [ # # ]: 0 : if (unregister)
8187 : 0 : flags |= PERF_RECORD_KSYMBOL_FLAGS_UNREGISTER;
8188 : :
8189 : 0 : ksymbol_event = (struct perf_ksymbol_event){
8190 : : .name = name,
8191 : : .name_len = name_len,
8192 : : .event_id = {
8193 : : .header = {
8194 : : .type = PERF_RECORD_KSYMBOL,
8195 : 0 : .size = sizeof(ksymbol_event.event_id) +
8196 : : name_len,
8197 : : },
8198 : : .addr = addr,
8199 : : .len = len,
8200 : : .ksym_type = ksym_type,
8201 : : .flags = flags,
8202 : : },
8203 : : };
8204 : :
8205 : 0 : perf_iterate_sb(perf_event_ksymbol_output, &ksymbol_event, NULL);
8206 : 0 : return;
8207 : : err:
8208 [ # # ]: 0 : WARN_ONCE(1, "%s: Invalid KSYMBOL type 0x%x\n", __func__, ksym_type);
8209 : : }
8210 : :
8211 : : /*
8212 : : * bpf program load/unload tracking
8213 : : */
8214 : :
8215 : : struct perf_bpf_event {
8216 : : struct bpf_prog *prog;
8217 : : struct {
8218 : : struct perf_event_header header;
8219 : : u16 type;
8220 : : u16 flags;
8221 : : u32 id;
8222 : : u8 tag[BPF_TAG_SIZE];
8223 : : } event_id;
8224 : : };
8225 : :
8226 : 0 : static int perf_event_bpf_match(struct perf_event *event)
8227 : : {
8228 : 0 : return event->attr.bpf_event;
8229 : : }
8230 : :
8231 : 0 : static void perf_event_bpf_output(struct perf_event *event, void *data)
8232 : : {
8233 : 0 : struct perf_bpf_event *bpf_event = data;
8234 : 0 : struct perf_output_handle handle;
8235 : 0 : struct perf_sample_data sample;
8236 : 0 : int ret;
8237 : :
8238 [ # # ]: 0 : if (!perf_event_bpf_match(event))
8239 : 0 : return;
8240 : :
8241 [ # # ]: 0 : perf_event_header__init_id(&bpf_event->event_id.header,
8242 : : &sample, event);
8243 : 0 : ret = perf_output_begin(&handle, event,
8244 : 0 : bpf_event->event_id.header.size);
8245 [ # # ]: 0 : if (ret)
8246 : : return;
8247 : :
8248 : 0 : perf_output_put(&handle, bpf_event->event_id);
8249 [ # # ]: 0 : perf_event__output_id_sample(event, &handle, &sample);
8250 : :
8251 : 0 : perf_output_end(&handle);
8252 : : }
8253 : :
8254 : 0 : static void perf_event_bpf_emit_ksymbols(struct bpf_prog *prog,
8255 : : enum perf_bpf_event_type type)
8256 : : {
8257 : 0 : bool unregister = type == PERF_BPF_EVENT_PROG_UNLOAD;
8258 : 0 : char sym[KSYM_NAME_LEN];
8259 : 0 : int i;
8260 : :
8261 [ # # ]: 0 : if (prog->aux->func_cnt == 0) {
8262 : 0 : bpf_get_prog_name(prog, sym);
8263 : 0 : perf_event_ksymbol(PERF_RECORD_KSYMBOL_TYPE_BPF,
8264 : 0 : (u64)(unsigned long)prog->bpf_func,
8265 : : prog->jited_len, unregister, sym);
8266 : : } else {
8267 [ # # ]: 0 : for (i = 0; i < prog->aux->func_cnt; i++) {
8268 : 0 : struct bpf_prog *subprog = prog->aux->func[i];
8269 : :
8270 : 0 : bpf_get_prog_name(subprog, sym);
8271 : 0 : perf_event_ksymbol(
8272 : : PERF_RECORD_KSYMBOL_TYPE_BPF,
8273 : 0 : (u64)(unsigned long)subprog->bpf_func,
8274 : : subprog->jited_len, unregister, sym);
8275 : : }
8276 : : }
8277 : 0 : }
8278 : :
8279 : 0 : void perf_event_bpf_event(struct bpf_prog *prog,
8280 : : enum perf_bpf_event_type type,
8281 : : u16 flags)
8282 : : {
8283 : 0 : struct perf_bpf_event bpf_event;
8284 : :
8285 [ # # ]: 0 : if (type <= PERF_BPF_EVENT_UNKNOWN ||
8286 : : type >= PERF_BPF_EVENT_MAX)
8287 : 0 : return;
8288 : :
8289 : 0 : switch (type) {
8290 : : case PERF_BPF_EVENT_PROG_LOAD:
8291 : : case PERF_BPF_EVENT_PROG_UNLOAD:
8292 [ # # ]: 0 : if (atomic_read(&nr_ksymbol_events))
8293 : 0 : perf_event_bpf_emit_ksymbols(prog, type);
8294 : : break;
8295 : : default:
8296 : : break;
8297 : : }
8298 : :
8299 [ # # ]: 0 : if (!atomic_read(&nr_bpf_events))
8300 : : return;
8301 : :
8302 : 0 : bpf_event = (struct perf_bpf_event){
8303 : : .prog = prog,
8304 : : .event_id = {
8305 : : .header = {
8306 : : .type = PERF_RECORD_BPF_EVENT,
8307 : : .size = sizeof(bpf_event.event_id),
8308 : : },
8309 : : .type = type,
8310 : : .flags = flags,
8311 : 0 : .id = prog->aux->id,
8312 : : },
8313 : : };
8314 : :
8315 : 0 : BUILD_BUG_ON(BPF_TAG_SIZE % sizeof(u64));
8316 : :
8317 : 0 : memcpy(bpf_event.event_id.tag, prog->tag, BPF_TAG_SIZE);
8318 : 0 : perf_iterate_sb(perf_event_bpf_output, &bpf_event, NULL);
8319 : : }
8320 : :
8321 : 0 : void perf_event_itrace_started(struct perf_event *event)
8322 : : {
8323 : 0 : event->attach_state |= PERF_ATTACH_ITRACE;
8324 : 0 : }
8325 : :
8326 : 0 : static void perf_log_itrace_start(struct perf_event *event)
8327 : : {
8328 : 0 : struct perf_output_handle handle;
8329 : 0 : struct perf_sample_data sample;
8330 : 0 : struct perf_aux_event {
8331 : : struct perf_event_header header;
8332 : : u32 pid;
8333 : : u32 tid;
8334 : : } rec;
8335 : 0 : int ret;
8336 : :
8337 [ # # ]: 0 : if (event->parent)
8338 : 0 : event = event->parent;
8339 : :
8340 [ # # ]: 0 : if (!(event->pmu->capabilities & PERF_PMU_CAP_ITRACE) ||
8341 [ # # ]: 0 : event->attach_state & PERF_ATTACH_ITRACE)
8342 : 0 : return;
8343 : :
8344 : 0 : rec.header.type = PERF_RECORD_ITRACE_START;
8345 : 0 : rec.header.misc = 0;
8346 : 0 : rec.header.size = sizeof(rec);
8347 : 0 : rec.pid = perf_event_pid(event, current);
8348 : 0 : rec.tid = perf_event_tid(event, current);
8349 : :
8350 [ # # ]: 0 : perf_event_header__init_id(&rec.header, &sample, event);
8351 : 0 : ret = perf_output_begin(&handle, event, rec.header.size);
8352 : :
8353 [ # # ]: 0 : if (ret)
8354 : : return;
8355 : :
8356 : 0 : perf_output_put(&handle, rec);
8357 [ # # ]: 0 : perf_event__output_id_sample(event, &handle, &sample);
8358 : :
8359 : 0 : perf_output_end(&handle);
8360 : : }
8361 : :
8362 : : static int
8363 : 0 : __perf_event_account_interrupt(struct perf_event *event, int throttle)
8364 : : {
8365 : 0 : struct hw_perf_event *hwc = &event->hw;
8366 : 0 : int ret = 0;
8367 : 0 : u64 seq;
8368 : :
8369 [ # # ]: 0 : seq = __this_cpu_read(perf_throttled_seq);
8370 [ # # ]: 0 : if (seq != hwc->interrupts_seq) {
8371 : 0 : hwc->interrupts_seq = seq;
8372 : 0 : hwc->interrupts = 1;
8373 : : } else {
8374 : 0 : hwc->interrupts++;
8375 [ # # # # ]: 0 : if (unlikely(throttle
8376 : : && hwc->interrupts >= max_samples_per_tick)) {
8377 : 0 : __this_cpu_inc(perf_throttled_count);
8378 : 0 : tick_dep_set_cpu(smp_processor_id(), TICK_DEP_BIT_PERF_EVENTS);
8379 : 0 : hwc->interrupts = MAX_INTERRUPTS;
8380 : 0 : perf_log_throttle(event, 0);
8381 : 0 : ret = 1;
8382 : : }
8383 : : }
8384 : :
8385 [ # # ]: 0 : if (event->attr.freq) {
8386 : 0 : u64 now = perf_clock();
8387 : 0 : s64 delta = now - hwc->freq_time_stamp;
8388 : :
8389 : 0 : hwc->freq_time_stamp = now;
8390 : :
8391 [ # # ]: 0 : if (delta > 0 && delta < 2*TICK_NSEC)
8392 : 0 : perf_adjust_period(event, delta, hwc->last_period, true);
8393 : : }
8394 : :
8395 : 0 : return ret;
8396 : : }
8397 : :
8398 : 0 : int perf_event_account_interrupt(struct perf_event *event)
8399 : : {
8400 : 0 : return __perf_event_account_interrupt(event, 1);
8401 : : }
8402 : :
8403 : : /*
8404 : : * Generic event overflow handling, sampling.
8405 : : */
8406 : :
8407 : 0 : static int __perf_event_overflow(struct perf_event *event,
8408 : : int throttle, struct perf_sample_data *data,
8409 : : struct pt_regs *regs)
8410 : : {
8411 : 0 : int events = atomic_read(&event->event_limit);
8412 : 0 : int ret = 0;
8413 : :
8414 : : /*
8415 : : * Non-sampling counters might still use the PMI to fold short
8416 : : * hardware counters, ignore those.
8417 : : */
8418 [ # # ]: 0 : if (unlikely(!is_sampling_event(event)))
8419 : : return 0;
8420 : :
8421 : 0 : ret = __perf_event_account_interrupt(event, throttle);
8422 : :
8423 : : /*
8424 : : * XXX event_limit might not quite work as expected on inherited
8425 : : * events
8426 : : */
8427 : :
8428 : 0 : event->pending_kill = POLL_IN;
8429 [ # # # # ]: 0 : if (events && atomic_dec_and_test(&event->event_limit)) {
8430 : 0 : ret = 1;
8431 : 0 : event->pending_kill = POLL_HUP;
8432 : :
8433 : 0 : perf_event_disable_inatomic(event);
8434 : : }
8435 : :
8436 : 0 : READ_ONCE(event->overflow_handler)(event, data, regs);
8437 : :
8438 [ # # # # : 0 : if (*perf_event_fasync(event) && event->pending_kill) {
# # ]
8439 : 0 : event->pending_wakeup = 1;
8440 : 0 : irq_work_queue(&event->pending);
8441 : : }
8442 : :
8443 : : return ret;
8444 : : }
8445 : :
8446 : 0 : int perf_event_overflow(struct perf_event *event,
8447 : : struct perf_sample_data *data,
8448 : : struct pt_regs *regs)
8449 : : {
8450 : 0 : return __perf_event_overflow(event, 1, data, regs);
8451 : : }
8452 : :
8453 : : /*
8454 : : * Generic software event infrastructure
8455 : : */
8456 : :
8457 : : struct swevent_htable {
8458 : : struct swevent_hlist *swevent_hlist;
8459 : : struct mutex hlist_mutex;
8460 : : int hlist_refcount;
8461 : :
8462 : : /* Recursion avoidance in each contexts */
8463 : : int recursion[PERF_NR_CONTEXTS];
8464 : : };
8465 : :
8466 : : static DEFINE_PER_CPU(struct swevent_htable, swevent_htable);
8467 : :
8468 : : /*
8469 : : * We directly increment event->count and keep a second value in
8470 : : * event->hw.period_left to count intervals. This period event
8471 : : * is kept in the range [-sample_period, 0] so that we can use the
8472 : : * sign as trigger.
8473 : : */
8474 : :
8475 : 0 : u64 perf_swevent_set_period(struct perf_event *event)
8476 : : {
8477 : 0 : struct hw_perf_event *hwc = &event->hw;
8478 : 0 : u64 period = hwc->last_period;
8479 : 0 : u64 nr, offset;
8480 : 0 : s64 old, val;
8481 : :
8482 : 0 : hwc->last_period = hwc->sample_period;
8483 : :
8484 : 0 : again:
8485 : 0 : old = val = local64_read(&hwc->period_left);
8486 [ # # ]: 0 : if (val < 0)
8487 : : return 0;
8488 : :
8489 : 0 : nr = div64_u64(period + val, period);
8490 : 0 : offset = nr * period;
8491 : 0 : val -= offset;
8492 [ # # ]: 0 : if (local64_cmpxchg(&hwc->period_left, old, val) != old)
8493 : 0 : goto again;
8494 : :
8495 : : return nr;
8496 : : }
8497 : :
8498 : 0 : static void perf_swevent_overflow(struct perf_event *event, u64 overflow,
8499 : : struct perf_sample_data *data,
8500 : : struct pt_regs *regs)
8501 : : {
8502 : 0 : struct hw_perf_event *hwc = &event->hw;
8503 : 0 : int throttle = 0;
8504 : :
8505 [ # # ]: 0 : if (!overflow)
8506 : 0 : overflow = perf_swevent_set_period(event);
8507 : :
8508 [ # # ]: 0 : if (hwc->interrupts == MAX_INTERRUPTS)
8509 : : return;
8510 : :
8511 [ # # ]: 0 : for (; overflow; overflow--) {
8512 [ # # ]: 0 : if (__perf_event_overflow(event, throttle,
8513 : : data, regs)) {
8514 : : /*
8515 : : * We inhibit the overflow from happening when
8516 : : * hwc->interrupts == MAX_INTERRUPTS.
8517 : : */
8518 : : break;
8519 : : }
8520 : 0 : throttle = 1;
8521 : : }
8522 : : }
8523 : :
8524 : 0 : static void perf_swevent_event(struct perf_event *event, u64 nr,
8525 : : struct perf_sample_data *data,
8526 : : struct pt_regs *regs)
8527 : : {
8528 : 0 : struct hw_perf_event *hwc = &event->hw;
8529 : :
8530 : 0 : local64_add(nr, &event->count);
8531 : :
8532 [ # # ]: 0 : if (!regs)
8533 : : return;
8534 : :
8535 [ # # ]: 0 : if (!is_sampling_event(event))
8536 : : return;
8537 : :
8538 [ # # # # ]: 0 : if ((event->attr.sample_type & PERF_SAMPLE_PERIOD) && !event->attr.freq) {
8539 : 0 : data->period = nr;
8540 : 0 : return perf_swevent_overflow(event, 1, data, regs);
8541 : : } else
8542 : 0 : data->period = event->hw.last_period;
8543 : :
8544 [ # # # # : 0 : if (nr == 1 && hwc->sample_period == 1 && !event->attr.freq)
# # ]
8545 : 0 : return perf_swevent_overflow(event, 1, data, regs);
8546 : :
8547 [ # # ]: 0 : if (local64_add_negative(nr, &hwc->period_left))
8548 : : return;
8549 : :
8550 : 0 : perf_swevent_overflow(event, 0, data, regs);
8551 : : }
8552 : :
8553 : 0 : static int perf_exclude_event(struct perf_event *event,
8554 : : struct pt_regs *regs)
8555 : : {
8556 [ # # ]: 0 : if (event->hw.state & PERF_HES_STOPPED)
8557 : : return 1;
8558 : :
8559 [ # # ]: 0 : if (regs) {
8560 [ # # # # ]: 0 : if (event->attr.exclude_user && user_mode(regs))
8561 : : return 1;
8562 : :
8563 [ # # # # ]: 0 : if (event->attr.exclude_kernel && !user_mode(regs))
8564 : 0 : return 1;
8565 : : }
8566 : :
8567 : : return 0;
8568 : : }
8569 : :
8570 : 0 : static int perf_swevent_match(struct perf_event *event,
8571 : : enum perf_type_id type,
8572 : : u32 event_id,
8573 : : struct perf_sample_data *data,
8574 : : struct pt_regs *regs)
8575 : : {
8576 : 0 : if (event->attr.type != type)
8577 : : return 0;
8578 : :
8579 [ # # ]: 0 : if (event->attr.config != event_id)
8580 : : return 0;
8581 : :
8582 [ # # ]: 0 : if (perf_exclude_event(event, regs))
8583 : : return 0;
8584 : :
8585 : : return 1;
8586 : : }
8587 : :
8588 : 0 : static inline u64 swevent_hash(u64 type, u32 event_id)
8589 : : {
8590 : 0 : u64 val = event_id | (type << 32);
8591 : :
8592 : 0 : return hash_64(val, SWEVENT_HLIST_BITS);
8593 : : }
8594 : :
8595 : : static inline struct hlist_head *
8596 : 0 : __find_swevent_head(struct swevent_hlist *hlist, u64 type, u32 event_id)
8597 : : {
8598 : 0 : u64 hash = swevent_hash(type, event_id);
8599 : :
8600 : 0 : return &hlist->heads[hash];
8601 : : }
8602 : :
8603 : : /* For the read side: events when they trigger */
8604 : : static inline struct hlist_head *
8605 : 0 : find_swevent_head_rcu(struct swevent_htable *swhash, u64 type, u32 event_id)
8606 : : {
8607 : 0 : struct swevent_hlist *hlist;
8608 : :
8609 : 0 : hlist = rcu_dereference(swhash->swevent_hlist);
8610 [ # # ]: 0 : if (!hlist)
8611 : : return NULL;
8612 : :
8613 [ # # ]: 0 : return __find_swevent_head(hlist, type, event_id);
8614 : : }
8615 : :
8616 : : /* For the event head insertion and removal in the hlist */
8617 : : static inline struct hlist_head *
8618 : 0 : find_swevent_head(struct swevent_htable *swhash, struct perf_event *event)
8619 : : {
8620 : 0 : struct swevent_hlist *hlist;
8621 : 0 : u32 event_id = event->attr.config;
8622 : 0 : u64 type = event->attr.type;
8623 : :
8624 : : /*
8625 : : * Event scheduling is always serialized against hlist allocation
8626 : : * and release. Which makes the protected version suitable here.
8627 : : * The context lock guarantees that.
8628 : : */
8629 : 0 : hlist = rcu_dereference_protected(swhash->swevent_hlist,
8630 : : lockdep_is_held(&event->ctx->lock));
8631 : 0 : if (!hlist)
8632 : : return NULL;
8633 : :
8634 : 0 : return __find_swevent_head(hlist, type, event_id);
8635 : : }
8636 : :
8637 : 0 : static void do_perf_sw_event(enum perf_type_id type, u32 event_id,
8638 : : u64 nr,
8639 : : struct perf_sample_data *data,
8640 : : struct pt_regs *regs)
8641 : : {
8642 : 0 : struct swevent_htable *swhash = this_cpu_ptr(&swevent_htable);
8643 : 0 : struct perf_event *event;
8644 : 0 : struct hlist_head *head;
8645 : :
8646 : 0 : rcu_read_lock();
8647 [ # # ]: 0 : head = find_swevent_head_rcu(swhash, type, event_id);
8648 [ # # ]: 0 : if (!head)
8649 : 0 : goto end;
8650 : :
8651 [ # # # # : 0 : hlist_for_each_entry_rcu(event, head, hlist_entry) {
# # ]
8652 [ # # ]: 0 : if (perf_swevent_match(event, type, event_id, data, regs))
8653 : 0 : perf_swevent_event(event, nr, data, regs);
8654 : : }
8655 : 0 : end:
8656 : 0 : rcu_read_unlock();
8657 : 0 : }
8658 : :
8659 : : DEFINE_PER_CPU(struct pt_regs, __perf_regs[4]);
8660 : :
8661 : 0 : int perf_swevent_get_recursion_context(void)
8662 : : {
8663 : 0 : struct swevent_htable *swhash = this_cpu_ptr(&swevent_htable);
8664 : :
8665 : 0 : return get_recursion_context(swhash->recursion);
8666 : : }
8667 : : EXPORT_SYMBOL_GPL(perf_swevent_get_recursion_context);
8668 : :
8669 : 0 : void perf_swevent_put_recursion_context(int rctx)
8670 : : {
8671 : 0 : struct swevent_htable *swhash = this_cpu_ptr(&swevent_htable);
8672 : :
8673 : 0 : put_recursion_context(swhash->recursion, rctx);
8674 : 0 : }
8675 : :
8676 : 0 : void ___perf_sw_event(u32 event_id, u64 nr, struct pt_regs *regs, u64 addr)
8677 : : {
8678 : 0 : struct perf_sample_data data;
8679 : :
8680 [ # # # # ]: 0 : if (WARN_ON_ONCE(!regs))
8681 : 0 : return;
8682 : :
8683 : 0 : perf_sample_data_init(&data, addr, 0);
8684 : 0 : do_perf_sw_event(PERF_TYPE_SOFTWARE, event_id, nr, &data, regs);
8685 : : }
8686 : :
8687 : 0 : void __perf_sw_event(u32 event_id, u64 nr, struct pt_regs *regs, u64 addr)
8688 : : {
8689 : 0 : int rctx;
8690 : :
8691 : 0 : preempt_disable_notrace();
8692 : 0 : rctx = perf_swevent_get_recursion_context();
8693 [ # # ]: 0 : if (unlikely(rctx < 0))
8694 : 0 : goto fail;
8695 : :
8696 : 0 : ___perf_sw_event(event_id, nr, regs, addr);
8697 : :
8698 : 0 : perf_swevent_put_recursion_context(rctx);
8699 : 0 : fail:
8700 : 0 : preempt_enable_notrace();
8701 : 0 : }
8702 : :
8703 : 0 : static void perf_swevent_read(struct perf_event *event)
8704 : : {
8705 : 0 : }
8706 : :
8707 : 0 : static int perf_swevent_add(struct perf_event *event, int flags)
8708 : : {
8709 : 0 : struct swevent_htable *swhash = this_cpu_ptr(&swevent_htable);
8710 : 0 : struct hw_perf_event *hwc = &event->hw;
8711 : 0 : struct hlist_head *head;
8712 : :
8713 [ # # ]: 0 : if (is_sampling_event(event)) {
8714 : 0 : hwc->last_period = hwc->sample_period;
8715 : 0 : perf_swevent_set_period(event);
8716 : : }
8717 : :
8718 : 0 : hwc->state = !(flags & PERF_EF_START);
8719 : :
8720 [ # # ]: 0 : head = find_swevent_head(swhash, event);
8721 [ # # # # ]: 0 : if (WARN_ON_ONCE(!head))
8722 : : return -EINVAL;
8723 : :
8724 : 0 : hlist_add_head_rcu(&event->hlist_entry, head);
8725 : 0 : perf_event_update_userpage(event);
8726 : :
8727 : 0 : return 0;
8728 : : }
8729 : :
8730 : 0 : static void perf_swevent_del(struct perf_event *event, int flags)
8731 : : {
8732 [ # # ]: 0 : hlist_del_rcu(&event->hlist_entry);
8733 : 0 : }
8734 : :
8735 : 0 : static void perf_swevent_start(struct perf_event *event, int flags)
8736 : : {
8737 : 0 : event->hw.state = 0;
8738 : 0 : }
8739 : :
8740 : 0 : static void perf_swevent_stop(struct perf_event *event, int flags)
8741 : : {
8742 : 0 : event->hw.state = PERF_HES_STOPPED;
8743 : 0 : }
8744 : :
8745 : : /* Deref the hlist from the update side */
8746 : : static inline struct swevent_hlist *
8747 : 0 : swevent_hlist_deref(struct swevent_htable *swhash)
8748 : : {
8749 : 0 : return rcu_dereference_protected(swhash->swevent_hlist,
8750 : : lockdep_is_held(&swhash->hlist_mutex));
8751 : : }
8752 : :
8753 : 0 : static void swevent_hlist_release(struct swevent_htable *swhash)
8754 : : {
8755 : 0 : struct swevent_hlist *hlist = swevent_hlist_deref(swhash);
8756 : :
8757 : 0 : if (!hlist)
8758 : : return;
8759 : :
8760 : 0 : RCU_INIT_POINTER(swhash->swevent_hlist, NULL);
8761 : 0 : kfree_rcu(hlist, rcu_head);
8762 : : }
8763 : :
8764 : 0 : static void swevent_hlist_put_cpu(int cpu)
8765 : : {
8766 : 0 : struct swevent_htable *swhash = &per_cpu(swevent_htable, cpu);
8767 : :
8768 : 0 : mutex_lock(&swhash->hlist_mutex);
8769 : :
8770 [ # # ]: 0 : if (!--swhash->hlist_refcount)
8771 [ # # ]: 0 : swevent_hlist_release(swhash);
8772 : :
8773 : 0 : mutex_unlock(&swhash->hlist_mutex);
8774 : 0 : }
8775 : :
8776 : 0 : static void swevent_hlist_put(void)
8777 : : {
8778 : 0 : int cpu;
8779 : :
8780 [ # # ]: 0 : for_each_possible_cpu(cpu)
8781 : 0 : swevent_hlist_put_cpu(cpu);
8782 : 0 : }
8783 : :
8784 : 0 : static int swevent_hlist_get_cpu(int cpu)
8785 : : {
8786 : 0 : struct swevent_htable *swhash = &per_cpu(swevent_htable, cpu);
8787 : 0 : int err = 0;
8788 : :
8789 : 0 : mutex_lock(&swhash->hlist_mutex);
8790 [ # # # # ]: 0 : if (!swevent_hlist_deref(swhash) &&
8791 : : cpumask_test_cpu(cpu, perf_online_mask)) {
8792 : 0 : struct swevent_hlist *hlist;
8793 : :
8794 : 0 : hlist = kzalloc(sizeof(*hlist), GFP_KERNEL);
8795 [ # # ]: 0 : if (!hlist) {
8796 : 0 : err = -ENOMEM;
8797 : 0 : goto exit;
8798 : : }
8799 : 0 : rcu_assign_pointer(swhash->swevent_hlist, hlist);
8800 : : }
8801 : 0 : swhash->hlist_refcount++;
8802 : 0 : exit:
8803 : 0 : mutex_unlock(&swhash->hlist_mutex);
8804 : :
8805 : 0 : return err;
8806 : : }
8807 : :
8808 : 0 : static int swevent_hlist_get(void)
8809 : : {
8810 : 0 : int err, cpu, failed_cpu;
8811 : :
8812 : 0 : mutex_lock(&pmus_lock);
8813 [ # # ]: 0 : for_each_possible_cpu(cpu) {
8814 : 0 : err = swevent_hlist_get_cpu(cpu);
8815 [ # # ]: 0 : if (err) {
8816 : 0 : failed_cpu = cpu;
8817 : 0 : goto fail;
8818 : : }
8819 : : }
8820 : 0 : mutex_unlock(&pmus_lock);
8821 : 0 : return 0;
8822 : : fail:
8823 [ # # ]: 0 : for_each_possible_cpu(cpu) {
8824 [ # # ]: 0 : if (cpu == failed_cpu)
8825 : : break;
8826 : 0 : swevent_hlist_put_cpu(cpu);
8827 : : }
8828 : 0 : mutex_unlock(&pmus_lock);
8829 : 0 : return err;
8830 : : }
8831 : :
8832 : : struct static_key perf_swevent_enabled[PERF_COUNT_SW_MAX];
8833 : :
8834 : 0 : static void sw_perf_event_destroy(struct perf_event *event)
8835 : : {
8836 : 0 : u64 event_id = event->attr.config;
8837 : :
8838 [ # # ]: 0 : WARN_ON(event->parent);
8839 : :
8840 : 0 : static_key_slow_dec(&perf_swevent_enabled[event_id]);
8841 : 0 : swevent_hlist_put();
8842 : 0 : }
8843 : :
8844 : 0 : static int perf_swevent_init(struct perf_event *event)
8845 : : {
8846 : 0 : u64 event_id = event->attr.config;
8847 : :
8848 [ # # ]: 0 : if (event->attr.type != PERF_TYPE_SOFTWARE)
8849 : : return -ENOENT;
8850 : :
8851 : : /*
8852 : : * no branch sampling for software events
8853 : : */
8854 [ # # ]: 0 : if (has_branch_stack(event))
8855 : : return -EOPNOTSUPP;
8856 : :
8857 [ # # ]: 0 : switch (event_id) {
8858 : : case PERF_COUNT_SW_CPU_CLOCK:
8859 : : case PERF_COUNT_SW_TASK_CLOCK:
8860 : : return -ENOENT;
8861 : :
8862 : : default:
8863 : 0 : break;
8864 : : }
8865 : :
8866 [ # # ]: 0 : if (event_id >= PERF_COUNT_SW_MAX)
8867 : : return -ENOENT;
8868 : :
8869 [ # # ]: 0 : if (!event->parent) {
8870 : 0 : int err;
8871 : :
8872 : 0 : err = swevent_hlist_get();
8873 [ # # ]: 0 : if (err)
8874 : : return err;
8875 : :
8876 : 0 : static_key_slow_inc(&perf_swevent_enabled[event_id]);
8877 : 0 : event->destroy = sw_perf_event_destroy;
8878 : : }
8879 : :
8880 : : return 0;
8881 : : }
8882 : :
8883 : : static struct pmu perf_swevent = {
8884 : : .task_ctx_nr = perf_sw_context,
8885 : :
8886 : : .capabilities = PERF_PMU_CAP_NO_NMI,
8887 : :
8888 : : .event_init = perf_swevent_init,
8889 : : .add = perf_swevent_add,
8890 : : .del = perf_swevent_del,
8891 : : .start = perf_swevent_start,
8892 : : .stop = perf_swevent_stop,
8893 : : .read = perf_swevent_read,
8894 : : };
8895 : :
8896 : : #ifdef CONFIG_EVENT_TRACING
8897 : :
8898 : : static int perf_tp_filter_match(struct perf_event *event,
8899 : : struct perf_sample_data *data)
8900 : : {
8901 : : void *record = data->raw->frag.data;
8902 : :
8903 : : /* only top level events have filters set */
8904 : : if (event->parent)
8905 : : event = event->parent;
8906 : :
8907 : : if (likely(!event->filter) || filter_match_preds(event->filter, record))
8908 : : return 1;
8909 : : return 0;
8910 : : }
8911 : :
8912 : 0 : static int perf_tp_event_match(struct perf_event *event,
8913 : : struct perf_sample_data *data,
8914 : : struct pt_regs *regs)
8915 : : {
8916 [ # # ]: 0 : if (event->hw.state & PERF_HES_STOPPED)
8917 : : return 0;
8918 : : /*
8919 : : * If exclude_kernel, only trace user-space tracepoints (uprobes)
8920 : : */
8921 [ # # # # ]: 0 : if (event->attr.exclude_kernel && !user_mode(regs))
8922 : : return 0;
8923 : :
8924 [ # # ]: 0 : if (!perf_tp_filter_match(event, data))
8925 : 0 : return 0;
8926 : :
8927 : : return 1;
8928 : : }
8929 : :
8930 : 0 : void perf_trace_run_bpf_submit(void *raw_data, int size, int rctx,
8931 : : struct trace_event_call *call, u64 count,
8932 : : struct pt_regs *regs, struct hlist_head *head,
8933 : : struct task_struct *task)
8934 : : {
8935 [ # # ]: 0 : if (bpf_prog_array_valid(call)) {
8936 : 0 : *(struct pt_regs **)raw_data = regs;
8937 [ # # ]: 0 : if (!trace_call_bpf(call, raw_data) || hlist_empty(head)) {
8938 : 0 : perf_swevent_put_recursion_context(rctx);
8939 : 0 : return;
8940 : : }
8941 : : }
8942 : 0 : perf_tp_event(call->event.type, count, raw_data, size, regs, head,
8943 : : rctx, task);
8944 : : }
8945 : : EXPORT_SYMBOL_GPL(perf_trace_run_bpf_submit);
8946 : :
8947 : 0 : void perf_tp_event(u16 event_type, u64 count, void *record, int entry_size,
8948 : : struct pt_regs *regs, struct hlist_head *head, int rctx,
8949 : : struct task_struct *task)
8950 : : {
8951 : 0 : struct perf_sample_data data;
8952 : 0 : struct perf_event *event;
8953 : :
8954 : 0 : struct perf_raw_record raw = {
8955 : : .frag = {
8956 : : .size = entry_size,
8957 : : .data = record,
8958 : : },
8959 : : };
8960 : :
8961 : 0 : perf_sample_data_init(&data, 0, 0);
8962 : 0 : data.raw = &raw;
8963 : :
8964 : 0 : perf_trace_buf_update(record, event_type);
8965 : :
8966 [ # # # # : 0 : hlist_for_each_entry_rcu(event, head, hlist_entry) {
# # ]
8967 [ # # ]: 0 : if (perf_tp_event_match(event, &data, regs))
8968 : 0 : perf_swevent_event(event, count, &data, regs);
8969 : : }
8970 : :
8971 : : /*
8972 : : * If we got specified a target task, also iterate its context and
8973 : : * deliver this event there too.
8974 : : */
8975 [ # # # # ]: 0 : if (task && task != current) {
8976 : 0 : struct perf_event_context *ctx;
8977 : 0 : struct trace_entry *entry = record;
8978 : :
8979 : 0 : rcu_read_lock();
8980 [ # # ]: 0 : ctx = rcu_dereference(task->perf_event_ctxp[perf_sw_context]);
8981 [ # # ]: 0 : if (!ctx)
8982 : 0 : goto unlock;
8983 : :
8984 [ # # ]: 0 : list_for_each_entry_rcu(event, &ctx->event_list, event_entry) {
8985 [ # # ]: 0 : if (event->cpu != smp_processor_id())
8986 : 0 : continue;
8987 [ # # ]: 0 : if (event->attr.type != PERF_TYPE_TRACEPOINT)
8988 : 0 : continue;
8989 [ # # ]: 0 : if (event->attr.config != entry->type)
8990 : 0 : continue;
8991 [ # # ]: 0 : if (perf_tp_event_match(event, &data, regs))
8992 : 0 : perf_swevent_event(event, count, &data, regs);
8993 : : }
8994 : 0 : unlock:
8995 : 0 : rcu_read_unlock();
8996 : : }
8997 : :
8998 : 0 : perf_swevent_put_recursion_context(rctx);
8999 : 0 : }
9000 : : EXPORT_SYMBOL_GPL(perf_tp_event);
9001 : :
9002 : 0 : static void tp_perf_event_destroy(struct perf_event *event)
9003 : : {
9004 : 0 : perf_trace_destroy(event);
9005 : 0 : }
9006 : :
9007 : 0 : static int perf_tp_event_init(struct perf_event *event)
9008 : : {
9009 : 0 : int err;
9010 : :
9011 [ # # ]: 0 : if (event->attr.type != PERF_TYPE_TRACEPOINT)
9012 : : return -ENOENT;
9013 : :
9014 : : /*
9015 : : * no branch sampling for tracepoint events
9016 : : */
9017 [ # # ]: 0 : if (has_branch_stack(event))
9018 : : return -EOPNOTSUPP;
9019 : :
9020 : 0 : err = perf_trace_init(event);
9021 [ # # ]: 0 : if (err)
9022 : : return err;
9023 : :
9024 : 0 : event->destroy = tp_perf_event_destroy;
9025 : :
9026 : 0 : return 0;
9027 : : }
9028 : :
9029 : : static struct pmu perf_tracepoint = {
9030 : : .task_ctx_nr = perf_sw_context,
9031 : :
9032 : : .event_init = perf_tp_event_init,
9033 : : .add = perf_trace_add,
9034 : : .del = perf_trace_del,
9035 : : .start = perf_swevent_start,
9036 : : .stop = perf_swevent_stop,
9037 : : .read = perf_swevent_read,
9038 : : };
9039 : :
9040 : : #if defined(CONFIG_KPROBE_EVENTS) || defined(CONFIG_UPROBE_EVENTS)
9041 : : /*
9042 : : * Flags in config, used by dynamic PMU kprobe and uprobe
9043 : : * The flags should match following PMU_FORMAT_ATTR().
9044 : : *
9045 : : * PERF_PROBE_CONFIG_IS_RETPROBE if set, create kretprobe/uretprobe
9046 : : * if not set, create kprobe/uprobe
9047 : : *
9048 : : * The following values specify a reference counter (or semaphore in the
9049 : : * terminology of tools like dtrace, systemtap, etc.) Userspace Statically
9050 : : * Defined Tracepoints (USDT). Currently, we use 40 bit for the offset.
9051 : : *
9052 : : * PERF_UPROBE_REF_CTR_OFFSET_BITS # of bits in config as th offset
9053 : : * PERF_UPROBE_REF_CTR_OFFSET_SHIFT # of bits to shift left
9054 : : */
9055 : : enum perf_probe_config {
9056 : : PERF_PROBE_CONFIG_IS_RETPROBE = 1U << 0, /* [k,u]retprobe */
9057 : : PERF_UPROBE_REF_CTR_OFFSET_BITS = 32,
9058 : : PERF_UPROBE_REF_CTR_OFFSET_SHIFT = 64 - PERF_UPROBE_REF_CTR_OFFSET_BITS,
9059 : : };
9060 : :
9061 : 0 : PMU_FORMAT_ATTR(retprobe, "config:0");
9062 : : #endif
9063 : :
9064 : : #ifdef CONFIG_KPROBE_EVENTS
9065 : : static struct attribute *kprobe_attrs[] = {
9066 : : &format_attr_retprobe.attr,
9067 : : NULL,
9068 : : };
9069 : :
9070 : : static struct attribute_group kprobe_format_group = {
9071 : : .name = "format",
9072 : : .attrs = kprobe_attrs,
9073 : : };
9074 : :
9075 : : static const struct attribute_group *kprobe_attr_groups[] = {
9076 : : &kprobe_format_group,
9077 : : NULL,
9078 : : };
9079 : :
9080 : : static int perf_kprobe_event_init(struct perf_event *event);
9081 : : static struct pmu perf_kprobe = {
9082 : : .task_ctx_nr = perf_sw_context,
9083 : : .event_init = perf_kprobe_event_init,
9084 : : .add = perf_trace_add,
9085 : : .del = perf_trace_del,
9086 : : .start = perf_swevent_start,
9087 : : .stop = perf_swevent_stop,
9088 : : .read = perf_swevent_read,
9089 : : .attr_groups = kprobe_attr_groups,
9090 : : };
9091 : :
9092 : 0 : static int perf_kprobe_event_init(struct perf_event *event)
9093 : : {
9094 : 0 : int err;
9095 : 0 : bool is_retprobe;
9096 : :
9097 [ # # ]: 0 : if (event->attr.type != perf_kprobe.type)
9098 : : return -ENOENT;
9099 : :
9100 [ # # ]: 0 : if (!capable(CAP_SYS_ADMIN))
9101 : : return -EACCES;
9102 : :
9103 : : /*
9104 : : * no branch sampling for probe events
9105 : : */
9106 [ # # ]: 0 : if (has_branch_stack(event))
9107 : : return -EOPNOTSUPP;
9108 : :
9109 : 0 : is_retprobe = event->attr.config & PERF_PROBE_CONFIG_IS_RETPROBE;
9110 : 0 : err = perf_kprobe_init(event, is_retprobe);
9111 [ # # ]: 0 : if (err)
9112 : : return err;
9113 : :
9114 : 0 : event->destroy = perf_kprobe_destroy;
9115 : :
9116 : 0 : return 0;
9117 : : }
9118 : : #endif /* CONFIG_KPROBE_EVENTS */
9119 : :
9120 : : #ifdef CONFIG_UPROBE_EVENTS
9121 : 0 : PMU_FORMAT_ATTR(ref_ctr_offset, "config:32-63");
9122 : :
9123 : : static struct attribute *uprobe_attrs[] = {
9124 : : &format_attr_retprobe.attr,
9125 : : &format_attr_ref_ctr_offset.attr,
9126 : : NULL,
9127 : : };
9128 : :
9129 : : static struct attribute_group uprobe_format_group = {
9130 : : .name = "format",
9131 : : .attrs = uprobe_attrs,
9132 : : };
9133 : :
9134 : : static const struct attribute_group *uprobe_attr_groups[] = {
9135 : : &uprobe_format_group,
9136 : : NULL,
9137 : : };
9138 : :
9139 : : static int perf_uprobe_event_init(struct perf_event *event);
9140 : : static struct pmu perf_uprobe = {
9141 : : .task_ctx_nr = perf_sw_context,
9142 : : .event_init = perf_uprobe_event_init,
9143 : : .add = perf_trace_add,
9144 : : .del = perf_trace_del,
9145 : : .start = perf_swevent_start,
9146 : : .stop = perf_swevent_stop,
9147 : : .read = perf_swevent_read,
9148 : : .attr_groups = uprobe_attr_groups,
9149 : : };
9150 : :
9151 : 0 : static int perf_uprobe_event_init(struct perf_event *event)
9152 : : {
9153 : 0 : int err;
9154 : 0 : unsigned long ref_ctr_offset;
9155 : 0 : bool is_retprobe;
9156 : :
9157 [ # # ]: 0 : if (event->attr.type != perf_uprobe.type)
9158 : : return -ENOENT;
9159 : :
9160 [ # # ]: 0 : if (!capable(CAP_SYS_ADMIN))
9161 : : return -EACCES;
9162 : :
9163 : : /*
9164 : : * no branch sampling for probe events
9165 : : */
9166 [ # # ]: 0 : if (has_branch_stack(event))
9167 : : return -EOPNOTSUPP;
9168 : :
9169 : 0 : is_retprobe = event->attr.config & PERF_PROBE_CONFIG_IS_RETPROBE;
9170 : 0 : ref_ctr_offset = event->attr.config >> PERF_UPROBE_REF_CTR_OFFSET_SHIFT;
9171 : 0 : err = perf_uprobe_init(event, ref_ctr_offset, is_retprobe);
9172 [ # # ]: 0 : if (err)
9173 : : return err;
9174 : :
9175 : 0 : event->destroy = perf_uprobe_destroy;
9176 : :
9177 : 0 : return 0;
9178 : : }
9179 : : #endif /* CONFIG_UPROBE_EVENTS */
9180 : :
9181 : 13 : static inline void perf_tp_register(void)
9182 : : {
9183 : 13 : perf_pmu_register(&perf_tracepoint, "tracepoint", PERF_TYPE_TRACEPOINT);
9184 : : #ifdef CONFIG_KPROBE_EVENTS
9185 : 13 : perf_pmu_register(&perf_kprobe, "kprobe", -1);
9186 : : #endif
9187 : : #ifdef CONFIG_UPROBE_EVENTS
9188 : 13 : perf_pmu_register(&perf_uprobe, "uprobe", -1);
9189 : : #endif
9190 : 13 : }
9191 : :
9192 : 0 : static void perf_event_free_filter(struct perf_event *event)
9193 : : {
9194 : 0 : ftrace_profile_free_filter(event);
9195 : : }
9196 : :
9197 : : #ifdef CONFIG_BPF_SYSCALL
9198 : : static void bpf_overflow_handler(struct perf_event *event,
9199 : : struct perf_sample_data *data,
9200 : : struct pt_regs *regs)
9201 : : {
9202 : : struct bpf_perf_event_data_kern ctx = {
9203 : : .data = data,
9204 : : .event = event,
9205 : : };
9206 : : int ret = 0;
9207 : :
9208 : : ctx.regs = perf_arch_bpf_user_pt_regs(regs);
9209 : : preempt_disable();
9210 : : if (unlikely(__this_cpu_inc_return(bpf_prog_active) != 1))
9211 : : goto out;
9212 : : rcu_read_lock();
9213 : : ret = BPF_PROG_RUN(event->prog, &ctx);
9214 : : rcu_read_unlock();
9215 : : out:
9216 : : __this_cpu_dec(bpf_prog_active);
9217 : : preempt_enable();
9218 : : if (!ret)
9219 : : return;
9220 : :
9221 : : event->orig_overflow_handler(event, data, regs);
9222 : : }
9223 : :
9224 : : static int perf_event_set_bpf_handler(struct perf_event *event, u32 prog_fd)
9225 : : {
9226 : : struct bpf_prog *prog;
9227 : :
9228 : : if (event->overflow_handler_context)
9229 : : /* hw breakpoint or kernel counter */
9230 : : return -EINVAL;
9231 : :
9232 : : if (event->prog)
9233 : : return -EEXIST;
9234 : :
9235 : : prog = bpf_prog_get_type(prog_fd, BPF_PROG_TYPE_PERF_EVENT);
9236 : : if (IS_ERR(prog))
9237 : : return PTR_ERR(prog);
9238 : :
9239 : : event->prog = prog;
9240 : : event->orig_overflow_handler = READ_ONCE(event->overflow_handler);
9241 : : WRITE_ONCE(event->overflow_handler, bpf_overflow_handler);
9242 : : return 0;
9243 : : }
9244 : :
9245 : : static void perf_event_free_bpf_handler(struct perf_event *event)
9246 : : {
9247 : : struct bpf_prog *prog = event->prog;
9248 : :
9249 : : if (!prog)
9250 : : return;
9251 : :
9252 : : WRITE_ONCE(event->overflow_handler, event->orig_overflow_handler);
9253 : : event->prog = NULL;
9254 : : bpf_prog_put(prog);
9255 : : }
9256 : : #else
9257 : : static int perf_event_set_bpf_handler(struct perf_event *event, u32 prog_fd)
9258 : : {
9259 : : return -EOPNOTSUPP;
9260 : : }
9261 : : static void perf_event_free_bpf_handler(struct perf_event *event)
9262 : : {
9263 : : }
9264 : : #endif
9265 : :
9266 : : /*
9267 : : * returns true if the event is a tracepoint, or a kprobe/upprobe created
9268 : : * with perf_event_open()
9269 : : */
9270 : 0 : static inline bool perf_event_is_tracing(struct perf_event *event)
9271 : : {
9272 : 0 : if (event->pmu == &perf_tracepoint)
9273 : : return true;
9274 : : #ifdef CONFIG_KPROBE_EVENTS
9275 [ # # # # ]: 0 : if (event->pmu == &perf_kprobe)
9276 : : return true;
9277 : : #endif
9278 : : #ifdef CONFIG_UPROBE_EVENTS
9279 [ # # # # ]: 0 : if (event->pmu == &perf_uprobe)
9280 : : return true;
9281 : : #endif
9282 : : return false;
9283 : : }
9284 : :
9285 : 0 : static int perf_event_set_bpf_prog(struct perf_event *event, u32 prog_fd)
9286 : : {
9287 : 0 : bool is_kprobe, is_tracepoint, is_syscall_tp;
9288 : 0 : struct bpf_prog *prog;
9289 : 0 : int ret;
9290 : :
9291 [ # # ]: 0 : if (!perf_event_is_tracing(event))
9292 : : return perf_event_set_bpf_handler(event, prog_fd);
9293 : :
9294 : 0 : is_kprobe = event->tp_event->flags & TRACE_EVENT_FL_UKPROBE;
9295 : 0 : is_tracepoint = event->tp_event->flags & TRACE_EVENT_FL_TRACEPOINT;
9296 [ # # ]: 0 : is_syscall_tp = is_syscall_trace_event(event->tp_event);
9297 [ # # ]: 0 : if (!is_kprobe && !is_tracepoint && !is_syscall_tp)
9298 : : /* bpf programs can only be attached to u/kprobe or tracepoint */
9299 : : return -EINVAL;
9300 : :
9301 : 0 : prog = bpf_prog_get(prog_fd);
9302 : 0 : if (IS_ERR(prog))
9303 : 0 : return PTR_ERR(prog);
9304 : :
9305 : : if ((is_kprobe && prog->type != BPF_PROG_TYPE_KPROBE) ||
9306 : : (is_tracepoint && prog->type != BPF_PROG_TYPE_TRACEPOINT) ||
9307 : : (is_syscall_tp && prog->type != BPF_PROG_TYPE_TRACEPOINT)) {
9308 : : /* valid fd, but invalid bpf program type */
9309 : : bpf_prog_put(prog);
9310 : : return -EINVAL;
9311 : : }
9312 : :
9313 : : /* Kprobe override only works for kprobes, not uprobes. */
9314 : : if (prog->kprobe_override &&
9315 : : !(event->tp_event->flags & TRACE_EVENT_FL_KPROBE)) {
9316 : : bpf_prog_put(prog);
9317 : : return -EINVAL;
9318 : : }
9319 : :
9320 : : if (is_tracepoint || is_syscall_tp) {
9321 : : int off = trace_event_get_offsets(event->tp_event);
9322 : :
9323 : : if (prog->aux->max_ctx_offset > off) {
9324 : : bpf_prog_put(prog);
9325 : : return -EACCES;
9326 : : }
9327 : : }
9328 : :
9329 : : ret = perf_event_attach_bpf_prog(event, prog);
9330 : : if (ret)
9331 : : bpf_prog_put(prog);
9332 : : return ret;
9333 : : }
9334 : :
9335 : 0 : static void perf_event_free_bpf_prog(struct perf_event *event)
9336 : : {
9337 : 0 : if (!perf_event_is_tracing(event)) {
9338 : : perf_event_free_bpf_handler(event);
9339 : : return;
9340 : : }
9341 : : perf_event_detach_bpf_prog(event);
9342 : : }
9343 : :
9344 : : #else
9345 : :
9346 : : static inline void perf_tp_register(void)
9347 : : {
9348 : : }
9349 : :
9350 : : static void perf_event_free_filter(struct perf_event *event)
9351 : : {
9352 : : }
9353 : :
9354 : : static int perf_event_set_bpf_prog(struct perf_event *event, u32 prog_fd)
9355 : : {
9356 : : return -ENOENT;
9357 : : }
9358 : :
9359 : : static void perf_event_free_bpf_prog(struct perf_event *event)
9360 : : {
9361 : : }
9362 : : #endif /* CONFIG_EVENT_TRACING */
9363 : :
9364 : : #ifdef CONFIG_HAVE_HW_BREAKPOINT
9365 : 0 : void perf_bp_event(struct perf_event *bp, void *data)
9366 : : {
9367 : 0 : struct perf_sample_data sample;
9368 : 0 : struct pt_regs *regs = data;
9369 : :
9370 [ # # ]: 0 : perf_sample_data_init(&sample, bp->attr.bp_addr, 0);
9371 : :
9372 [ # # # # ]: 0 : if (!bp->hw.state && !perf_exclude_event(bp, regs))
9373 : 0 : perf_swevent_event(bp, 1, &sample, regs);
9374 : 0 : }
9375 : : #endif
9376 : :
9377 : : /*
9378 : : * Allocate a new address filter
9379 : : */
9380 : : static struct perf_addr_filter *
9381 : : perf_addr_filter_new(struct perf_event *event, struct list_head *filters)
9382 : : {
9383 : : int node = cpu_to_node(event->cpu == -1 ? 0 : event->cpu);
9384 : : struct perf_addr_filter *filter;
9385 : :
9386 : : filter = kzalloc_node(sizeof(*filter), GFP_KERNEL, node);
9387 : : if (!filter)
9388 : : return NULL;
9389 : :
9390 : : INIT_LIST_HEAD(&filter->entry);
9391 : : list_add_tail(&filter->entry, filters);
9392 : :
9393 : : return filter;
9394 : : }
9395 : :
9396 : 0 : static void free_filters_list(struct list_head *filters)
9397 : : {
9398 : 0 : struct perf_addr_filter *filter, *iter;
9399 : :
9400 [ # # ]: 0 : list_for_each_entry_safe(filter, iter, filters, entry) {
9401 : 0 : path_put(&filter->path);
9402 : 0 : list_del(&filter->entry);
9403 : 0 : kfree(filter);
9404 : : }
9405 : 0 : }
9406 : :
9407 : : /*
9408 : : * Free existing address filters and optionally install new ones
9409 : : */
9410 : 0 : static void perf_addr_filters_splice(struct perf_event *event,
9411 : : struct list_head *head)
9412 : : {
9413 : 0 : unsigned long flags;
9414 : 0 : LIST_HEAD(list);
9415 : :
9416 [ # # ]: 0 : if (!has_addr_filter(event))
9417 : 0 : return;
9418 : :
9419 : : /* don't bother with children, they don't have their own filters */
9420 [ # # ]: 0 : if (event->parent)
9421 : : return;
9422 : :
9423 : 0 : raw_spin_lock_irqsave(&event->addr_filters.lock, flags);
9424 : :
9425 [ # # ]: 0 : list_splice_init(&event->addr_filters.list, &list);
9426 [ # # ]: 0 : if (head)
9427 [ # # ]: 0 : list_splice(head, &event->addr_filters.list);
9428 : :
9429 : 0 : raw_spin_unlock_irqrestore(&event->addr_filters.lock, flags);
9430 : :
9431 : 0 : free_filters_list(&list);
9432 : : }
9433 : :
9434 : : /*
9435 : : * Scan through mm's vmas and see if one of them matches the
9436 : : * @filter; if so, adjust filter's address range.
9437 : : * Called with mm::mmap_sem down for reading.
9438 : : */
9439 : 0 : static void perf_addr_filter_apply(struct perf_addr_filter *filter,
9440 : : struct mm_struct *mm,
9441 : : struct perf_addr_filter_range *fr)
9442 : : {
9443 : 0 : struct vm_area_struct *vma;
9444 : :
9445 [ # # ]: 0 : for (vma = mm->mmap; vma; vma = vma->vm_next) {
9446 [ # # ]: 0 : if (!vma->vm_file)
9447 : 0 : continue;
9448 : :
9449 [ # # ]: 0 : if (perf_addr_filter_vma_adjust(filter, vma, fr))
9450 : : return;
9451 : : }
9452 : : }
9453 : :
9454 : : /*
9455 : : * Update event's address range filters based on the
9456 : : * task's existing mappings, if any.
9457 : : */
9458 : 0 : static void perf_event_addr_filters_apply(struct perf_event *event)
9459 : : {
9460 [ # # ]: 0 : struct perf_addr_filters_head *ifh = perf_event_addr_filters(event);
9461 [ # # ]: 0 : struct task_struct *task = READ_ONCE(event->ctx->task);
9462 : 0 : struct perf_addr_filter *filter;
9463 : 0 : struct mm_struct *mm = NULL;
9464 : 0 : unsigned int count = 0;
9465 : 0 : unsigned long flags;
9466 : :
9467 : : /*
9468 : : * We may observe TASK_TOMBSTONE, which means that the event tear-down
9469 : : * will stop on the parent's child_mutex that our caller is also holding
9470 : : */
9471 [ # # ]: 0 : if (task == TASK_TOMBSTONE)
9472 : : return;
9473 : :
9474 [ # # ]: 0 : if (ifh->nr_file_filters) {
9475 : 0 : mm = get_task_mm(event->ctx->task);
9476 [ # # ]: 0 : if (!mm)
9477 : 0 : goto restart;
9478 : :
9479 : 0 : down_read(&mm->mmap_sem);
9480 : : }
9481 : :
9482 : 0 : raw_spin_lock_irqsave(&ifh->lock, flags);
9483 [ # # ]: 0 : list_for_each_entry(filter, &ifh->list, entry) {
9484 [ # # ]: 0 : if (filter->path.dentry) {
9485 : : /*
9486 : : * Adjust base offset if the filter is associated to a
9487 : : * binary that needs to be mapped:
9488 : : */
9489 : 0 : event->addr_filter_ranges[count].start = 0;
9490 : 0 : event->addr_filter_ranges[count].size = 0;
9491 : :
9492 : 0 : perf_addr_filter_apply(filter, mm, &event->addr_filter_ranges[count]);
9493 : : } else {
9494 : 0 : event->addr_filter_ranges[count].start = filter->offset;
9495 : 0 : event->addr_filter_ranges[count].size = filter->size;
9496 : : }
9497 : :
9498 : 0 : count++;
9499 : : }
9500 : :
9501 : 0 : event->addr_filters_gen++;
9502 : 0 : raw_spin_unlock_irqrestore(&ifh->lock, flags);
9503 : :
9504 [ # # ]: 0 : if (ifh->nr_file_filters) {
9505 : 0 : up_read(&mm->mmap_sem);
9506 : :
9507 : 0 : mmput(mm);
9508 : : }
9509 : :
9510 : 0 : restart:
9511 : 0 : perf_event_stop(event, 1);
9512 : : }
9513 : :
9514 : : /*
9515 : : * Address range filtering: limiting the data to certain
9516 : : * instruction address ranges. Filters are ioctl()ed to us from
9517 : : * userspace as ascii strings.
9518 : : *
9519 : : * Filter string format:
9520 : : *
9521 : : * ACTION RANGE_SPEC
9522 : : * where ACTION is one of the
9523 : : * * "filter": limit the trace to this region
9524 : : * * "start": start tracing from this address
9525 : : * * "stop": stop tracing at this address/region;
9526 : : * RANGE_SPEC is
9527 : : * * for kernel addresses: <start address>[/<size>]
9528 : : * * for object files: <start address>[/<size>]@</path/to/object/file>
9529 : : *
9530 : : * if <size> is not specified or is zero, the range is treated as a single
9531 : : * address; not valid for ACTION=="filter".
9532 : : */
9533 : : enum {
9534 : : IF_ACT_NONE = -1,
9535 : : IF_ACT_FILTER,
9536 : : IF_ACT_START,
9537 : : IF_ACT_STOP,
9538 : : IF_SRC_FILE,
9539 : : IF_SRC_KERNEL,
9540 : : IF_SRC_FILEADDR,
9541 : : IF_SRC_KERNELADDR,
9542 : : };
9543 : :
9544 : : enum {
9545 : : IF_STATE_ACTION = 0,
9546 : : IF_STATE_SOURCE,
9547 : : IF_STATE_END,
9548 : : };
9549 : :
9550 : : static const match_table_t if_tokens = {
9551 : : { IF_ACT_FILTER, "filter" },
9552 : : { IF_ACT_START, "start" },
9553 : : { IF_ACT_STOP, "stop" },
9554 : : { IF_SRC_FILE, "%u/%u@%s" },
9555 : : { IF_SRC_KERNEL, "%u/%u" },
9556 : : { IF_SRC_FILEADDR, "%u@%s" },
9557 : : { IF_SRC_KERNELADDR, "%u" },
9558 : : { IF_ACT_NONE, NULL },
9559 : : };
9560 : :
9561 : : /*
9562 : : * Address filter string parser
9563 : : */
9564 : : static int
9565 : 0 : perf_event_parse_addr_filter(struct perf_event *event, char *fstr,
9566 : : struct list_head *filters)
9567 : : {
9568 : 0 : struct perf_addr_filter *filter = NULL;
9569 : 0 : char *start, *orig, *filename = NULL;
9570 : 0 : substring_t args[MAX_OPT_ARGS];
9571 : 0 : int state = IF_STATE_ACTION, token;
9572 : 0 : unsigned int kernel = 0;
9573 : 0 : int ret = -EINVAL;
9574 : :
9575 : 0 : orig = fstr = kstrdup(fstr, GFP_KERNEL);
9576 [ # # ]: 0 : if (!fstr)
9577 : : return -ENOMEM;
9578 : :
9579 [ # # ]: 0 : while ((start = strsep(&fstr, " ,\n")) != NULL) {
9580 : 0 : static const enum perf_addr_filter_action_t actions[] = {
9581 : : [IF_ACT_FILTER] = PERF_ADDR_FILTER_ACTION_FILTER,
9582 : : [IF_ACT_START] = PERF_ADDR_FILTER_ACTION_START,
9583 : : [IF_ACT_STOP] = PERF_ADDR_FILTER_ACTION_STOP,
9584 : : };
9585 : 0 : ret = -EINVAL;
9586 : :
9587 [ # # ]: 0 : if (!*start)
9588 : 0 : continue;
9589 : :
9590 : : /* filter definition begins */
9591 [ # # ]: 0 : if (state == IF_STATE_ACTION) {
9592 : 0 : filter = perf_addr_filter_new(event, filters);
9593 [ # # ]: 0 : if (!filter)
9594 : 0 : goto fail;
9595 : : }
9596 : :
9597 : 0 : token = match_token(start, if_tokens, args);
9598 [ # # # # ]: 0 : switch (token) {
9599 : 0 : case IF_ACT_FILTER:
9600 : : case IF_ACT_START:
9601 : : case IF_ACT_STOP:
9602 [ # # ]: 0 : if (state != IF_STATE_ACTION)
9603 : 0 : goto fail;
9604 : :
9605 : 0 : filter->action = actions[token];
9606 : 0 : state = IF_STATE_SOURCE;
9607 : 0 : break;
9608 : :
9609 : 0 : case IF_SRC_KERNELADDR:
9610 : : case IF_SRC_KERNEL:
9611 : 0 : kernel = 1;
9612 : : /* fall through */
9613 : :
9614 : 0 : case IF_SRC_FILEADDR:
9615 : : case IF_SRC_FILE:
9616 [ # # ]: 0 : if (state != IF_STATE_SOURCE)
9617 : 0 : goto fail;
9618 : :
9619 : 0 : *args[0].to = 0;
9620 : 0 : ret = kstrtoul(args[0].from, 0, &filter->offset);
9621 [ # # ]: 0 : if (ret)
9622 : 0 : goto fail;
9623 : :
9624 [ # # ]: 0 : if (token == IF_SRC_KERNEL || token == IF_SRC_FILE) {
9625 : 0 : *args[1].to = 0;
9626 : 0 : ret = kstrtoul(args[1].from, 0, &filter->size);
9627 [ # # ]: 0 : if (ret)
9628 : 0 : goto fail;
9629 : : }
9630 : :
9631 [ # # ]: 0 : if (token == IF_SRC_FILE || token == IF_SRC_FILEADDR) {
9632 [ # # ]: 0 : int fpos = token == IF_SRC_FILE ? 2 : 1;
9633 : :
9634 : 0 : filename = match_strdup(&args[fpos]);
9635 [ # # ]: 0 : if (!filename) {
9636 : 0 : ret = -ENOMEM;
9637 : 0 : goto fail;
9638 : : }
9639 : : }
9640 : :
9641 : : state = IF_STATE_END;
9642 : : break;
9643 : :
9644 : 0 : default:
9645 : 0 : goto fail;
9646 : : }
9647 : :
9648 : : /*
9649 : : * Filter definition is fully parsed, validate and install it.
9650 : : * Make sure that it doesn't contradict itself or the event's
9651 : : * attribute.
9652 : : */
9653 [ # # ]: 0 : if (state == IF_STATE_END) {
9654 : 0 : ret = -EINVAL;
9655 [ # # # # ]: 0 : if (kernel && event->attr.exclude_kernel)
9656 : 0 : goto fail;
9657 : :
9658 : : /*
9659 : : * ACTION "filter" must have a non-zero length region
9660 : : * specified.
9661 : : */
9662 [ # # ]: 0 : if (filter->action == PERF_ADDR_FILTER_ACTION_FILTER &&
9663 [ # # ]: 0 : !filter->size)
9664 : 0 : goto fail;
9665 : :
9666 [ # # ]: 0 : if (!kernel) {
9667 [ # # ]: 0 : if (!filename)
9668 : 0 : goto fail;
9669 : :
9670 : : /*
9671 : : * For now, we only support file-based filters
9672 : : * in per-task events; doing so for CPU-wide
9673 : : * events requires additional context switching
9674 : : * trickery, since same object code will be
9675 : : * mapped at different virtual addresses in
9676 : : * different processes.
9677 : : */
9678 : 0 : ret = -EOPNOTSUPP;
9679 [ # # ]: 0 : if (!event->ctx->task)
9680 : 0 : goto fail_free_name;
9681 : :
9682 : : /* look up the path and grab its inode */
9683 : 0 : ret = kern_path(filename, LOOKUP_FOLLOW,
9684 : : &filter->path);
9685 [ # # ]: 0 : if (ret)
9686 : 0 : goto fail_free_name;
9687 : :
9688 : 0 : kfree(filename);
9689 : 0 : filename = NULL;
9690 : :
9691 : 0 : ret = -EINVAL;
9692 [ # # # # ]: 0 : if (!filter->path.dentry ||
9693 [ # # ]: 0 : !S_ISREG(d_inode(filter->path.dentry)
9694 : : ->i_mode))
9695 : 0 : goto fail;
9696 : :
9697 : 0 : event->addr_filters.nr_file_filters++;
9698 : : }
9699 : :
9700 : : /* ready to consume more filters */
9701 : : state = IF_STATE_ACTION;
9702 : : filter = NULL;
9703 : : }
9704 : : }
9705 : :
9706 [ # # ]: 0 : if (state != IF_STATE_ACTION)
9707 : 0 : goto fail;
9708 : :
9709 : 0 : kfree(orig);
9710 : :
9711 : 0 : return 0;
9712 : :
9713 : 0 : fail_free_name:
9714 : 0 : kfree(filename);
9715 : 0 : fail:
9716 : 0 : free_filters_list(filters);
9717 : 0 : kfree(orig);
9718 : :
9719 : 0 : return ret;
9720 : : }
9721 : :
9722 : : static int
9723 : 0 : perf_event_set_addr_filter(struct perf_event *event, char *filter_str)
9724 : : {
9725 : 0 : LIST_HEAD(filters);
9726 : 0 : int ret;
9727 : :
9728 : : /*
9729 : : * Since this is called in perf_ioctl() path, we're already holding
9730 : : * ctx::mutex.
9731 : : */
9732 : 0 : lockdep_assert_held(&event->ctx->mutex);
9733 : :
9734 [ # # # # ]: 0 : if (WARN_ON_ONCE(event->parent))
9735 : : return -EINVAL;
9736 : :
9737 : 0 : ret = perf_event_parse_addr_filter(event, filter_str, &filters);
9738 [ # # ]: 0 : if (ret)
9739 : 0 : goto fail_clear_files;
9740 : :
9741 : 0 : ret = event->pmu->addr_filters_validate(&filters);
9742 [ # # ]: 0 : if (ret)
9743 : 0 : goto fail_free_filters;
9744 : :
9745 : : /* remove existing filters, if any */
9746 : 0 : perf_addr_filters_splice(event, &filters);
9747 : :
9748 : : /* install new filters */
9749 : 0 : perf_event_for_each_child(event, perf_event_addr_filters_apply);
9750 : :
9751 : 0 : return ret;
9752 : :
9753 : : fail_free_filters:
9754 : 0 : free_filters_list(&filters);
9755 : :
9756 : 0 : fail_clear_files:
9757 : 0 : event->addr_filters.nr_file_filters = 0;
9758 : :
9759 : 0 : return ret;
9760 : : }
9761 : :
9762 : 0 : static int perf_event_set_filter(struct perf_event *event, void __user *arg)
9763 : : {
9764 : 0 : int ret = -EINVAL;
9765 : 0 : char *filter_str;
9766 : :
9767 : 0 : filter_str = strndup_user(arg, PAGE_SIZE);
9768 [ # # ]: 0 : if (IS_ERR(filter_str))
9769 : 0 : return PTR_ERR(filter_str);
9770 : :
9771 : : #ifdef CONFIG_EVENT_TRACING
9772 [ # # ]: 0 : if (perf_event_is_tracing(event)) {
9773 : 0 : struct perf_event_context *ctx = event->ctx;
9774 : :
9775 : : /*
9776 : : * Beware, here be dragons!!
9777 : : *
9778 : : * the tracepoint muck will deadlock against ctx->mutex, but
9779 : : * the tracepoint stuff does not actually need it. So
9780 : : * temporarily drop ctx->mutex. As per perf_event_ctx_lock() we
9781 : : * already have a reference on ctx.
9782 : : *
9783 : : * This can result in event getting moved to a different ctx,
9784 : : * but that does not affect the tracepoint state.
9785 : : */
9786 : 0 : mutex_unlock(&ctx->mutex);
9787 : 0 : ret = ftrace_profile_set_filter(event, event->attr.config, filter_str);
9788 : 0 : mutex_lock(&ctx->mutex);
9789 : : } else
9790 : : #endif
9791 [ # # ]: 0 : if (has_addr_filter(event))
9792 : 0 : ret = perf_event_set_addr_filter(event, filter_str);
9793 : :
9794 : 0 : kfree(filter_str);
9795 : 0 : return ret;
9796 : : }
9797 : :
9798 : : /*
9799 : : * hrtimer based swevent callback
9800 : : */
9801 : :
9802 : 0 : static enum hrtimer_restart perf_swevent_hrtimer(struct hrtimer *hrtimer)
9803 : : {
9804 : 0 : enum hrtimer_restart ret = HRTIMER_RESTART;
9805 : 0 : struct perf_sample_data data;
9806 : 0 : struct pt_regs *regs;
9807 : 0 : struct perf_event *event;
9808 : 0 : u64 period;
9809 : :
9810 : 0 : event = container_of(hrtimer, struct perf_event, hw.hrtimer);
9811 : :
9812 [ # # ]: 0 : if (event->state != PERF_EVENT_STATE_ACTIVE)
9813 : : return HRTIMER_NORESTART;
9814 : :
9815 : 0 : event->pmu->read(event);
9816 : :
9817 [ # # ]: 0 : perf_sample_data_init(&data, 0, event->hw.last_period);
9818 [ # # ]: 0 : regs = get_irq_regs();
9819 : :
9820 [ # # # # ]: 0 : if (regs && !perf_exclude_event(event, regs)) {
9821 [ # # # # ]: 0 : if (!(event->attr.exclude_idle && is_idle_task(current)))
9822 [ # # ]: 0 : if (__perf_event_overflow(event, 1, &data, regs))
9823 : 0 : ret = HRTIMER_NORESTART;
9824 : : }
9825 : :
9826 : 0 : period = max_t(u64, 10000, event->hw.sample_period);
9827 : 0 : hrtimer_forward_now(hrtimer, ns_to_ktime(period));
9828 : :
9829 : 0 : return ret;
9830 : : }
9831 : :
9832 : 0 : static void perf_swevent_start_hrtimer(struct perf_event *event)
9833 : : {
9834 : 0 : struct hw_perf_event *hwc = &event->hw;
9835 : 0 : s64 period;
9836 : :
9837 [ # # ]: 0 : if (!is_sampling_event(event))
9838 : : return;
9839 : :
9840 : 0 : period = local64_read(&hwc->period_left);
9841 [ # # ]: 0 : if (period) {
9842 [ # # ]: 0 : if (period < 0)
9843 : 0 : period = 10000;
9844 : :
9845 : 0 : local64_set(&hwc->period_left, 0);
9846 : : } else {
9847 : 0 : period = max_t(u64, 10000, hwc->sample_period);
9848 : : }
9849 : 0 : hrtimer_start(&hwc->hrtimer, ns_to_ktime(period),
9850 : : HRTIMER_MODE_REL_PINNED_HARD);
9851 : : }
9852 : :
9853 : 0 : static void perf_swevent_cancel_hrtimer(struct perf_event *event)
9854 : : {
9855 : 0 : struct hw_perf_event *hwc = &event->hw;
9856 : :
9857 [ # # ]: 0 : if (is_sampling_event(event)) {
9858 : 0 : ktime_t remaining = hrtimer_get_remaining(&hwc->hrtimer);
9859 : 0 : local64_set(&hwc->period_left, ktime_to_ns(remaining));
9860 : :
9861 : 0 : hrtimer_cancel(&hwc->hrtimer);
9862 : : }
9863 : 0 : }
9864 : :
9865 : 0 : static void perf_swevent_init_hrtimer(struct perf_event *event)
9866 : : {
9867 : 0 : struct hw_perf_event *hwc = &event->hw;
9868 : :
9869 [ # # ]: 0 : if (!is_sampling_event(event))
9870 : : return;
9871 : :
9872 : 0 : hrtimer_init(&hwc->hrtimer, CLOCK_MONOTONIC, HRTIMER_MODE_REL_HARD);
9873 : 0 : hwc->hrtimer.function = perf_swevent_hrtimer;
9874 : :
9875 : : /*
9876 : : * Since hrtimers have a fixed rate, we can do a static freq->period
9877 : : * mapping and avoid the whole period adjust feedback stuff.
9878 : : */
9879 [ # # ]: 0 : if (event->attr.freq) {
9880 : 0 : long freq = event->attr.sample_freq;
9881 : :
9882 : 0 : event->attr.sample_period = NSEC_PER_SEC / freq;
9883 : 0 : hwc->sample_period = event->attr.sample_period;
9884 : 0 : local64_set(&hwc->period_left, hwc->sample_period);
9885 : 0 : hwc->last_period = hwc->sample_period;
9886 : 0 : event->attr.freq = 0;
9887 : : }
9888 : : }
9889 : :
9890 : : /*
9891 : : * Software event: cpu wall time clock
9892 : : */
9893 : :
9894 : 0 : static void cpu_clock_event_update(struct perf_event *event)
9895 : : {
9896 : 0 : s64 prev;
9897 : 0 : u64 now;
9898 : :
9899 : 0 : now = local_clock();
9900 : 0 : prev = local64_xchg(&event->hw.prev_count, now);
9901 : 0 : local64_add(now - prev, &event->count);
9902 : 0 : }
9903 : :
9904 : 0 : static void cpu_clock_event_start(struct perf_event *event, int flags)
9905 : : {
9906 : 0 : local64_set(&event->hw.prev_count, local_clock());
9907 : 0 : perf_swevent_start_hrtimer(event);
9908 : 0 : }
9909 : :
9910 : 0 : static void cpu_clock_event_stop(struct perf_event *event, int flags)
9911 : : {
9912 : 0 : perf_swevent_cancel_hrtimer(event);
9913 : 0 : cpu_clock_event_update(event);
9914 : 0 : }
9915 : :
9916 : 0 : static int cpu_clock_event_add(struct perf_event *event, int flags)
9917 : : {
9918 [ # # ]: 0 : if (flags & PERF_EF_START)
9919 : 0 : cpu_clock_event_start(event, flags);
9920 : 0 : perf_event_update_userpage(event);
9921 : :
9922 : 0 : return 0;
9923 : : }
9924 : :
9925 : 0 : static void cpu_clock_event_del(struct perf_event *event, int flags)
9926 : : {
9927 : 0 : cpu_clock_event_stop(event, flags);
9928 : 0 : }
9929 : :
9930 : 0 : static void cpu_clock_event_read(struct perf_event *event)
9931 : : {
9932 : 0 : cpu_clock_event_update(event);
9933 : 0 : }
9934 : :
9935 : 0 : static int cpu_clock_event_init(struct perf_event *event)
9936 : : {
9937 [ # # ]: 0 : if (event->attr.type != PERF_TYPE_SOFTWARE)
9938 : : return -ENOENT;
9939 : :
9940 [ # # ]: 0 : if (event->attr.config != PERF_COUNT_SW_CPU_CLOCK)
9941 : : return -ENOENT;
9942 : :
9943 : : /*
9944 : : * no branch sampling for software events
9945 : : */
9946 [ # # ]: 0 : if (has_branch_stack(event))
9947 : : return -EOPNOTSUPP;
9948 : :
9949 : 0 : perf_swevent_init_hrtimer(event);
9950 : :
9951 : 0 : return 0;
9952 : : }
9953 : :
9954 : : static struct pmu perf_cpu_clock = {
9955 : : .task_ctx_nr = perf_sw_context,
9956 : :
9957 : : .capabilities = PERF_PMU_CAP_NO_NMI,
9958 : :
9959 : : .event_init = cpu_clock_event_init,
9960 : : .add = cpu_clock_event_add,
9961 : : .del = cpu_clock_event_del,
9962 : : .start = cpu_clock_event_start,
9963 : : .stop = cpu_clock_event_stop,
9964 : : .read = cpu_clock_event_read,
9965 : : };
9966 : :
9967 : : /*
9968 : : * Software event: task time clock
9969 : : */
9970 : :
9971 : 0 : static void task_clock_event_update(struct perf_event *event, u64 now)
9972 : : {
9973 : 0 : u64 prev;
9974 : 0 : s64 delta;
9975 : :
9976 : 0 : prev = local64_xchg(&event->hw.prev_count, now);
9977 : 0 : delta = now - prev;
9978 : 0 : local64_add(delta, &event->count);
9979 : : }
9980 : :
9981 : 0 : static void task_clock_event_start(struct perf_event *event, int flags)
9982 : : {
9983 : 0 : local64_set(&event->hw.prev_count, event->ctx->time);
9984 : 0 : perf_swevent_start_hrtimer(event);
9985 : 0 : }
9986 : :
9987 : 0 : static void task_clock_event_stop(struct perf_event *event, int flags)
9988 : : {
9989 : 0 : perf_swevent_cancel_hrtimer(event);
9990 : 0 : task_clock_event_update(event, event->ctx->time);
9991 : 0 : }
9992 : :
9993 : 0 : static int task_clock_event_add(struct perf_event *event, int flags)
9994 : : {
9995 [ # # ]: 0 : if (flags & PERF_EF_START)
9996 : 0 : task_clock_event_start(event, flags);
9997 : 0 : perf_event_update_userpage(event);
9998 : :
9999 : 0 : return 0;
10000 : : }
10001 : :
10002 : 0 : static void task_clock_event_del(struct perf_event *event, int flags)
10003 : : {
10004 : 0 : task_clock_event_stop(event, PERF_EF_UPDATE);
10005 : 0 : }
10006 : :
10007 : 0 : static void task_clock_event_read(struct perf_event *event)
10008 : : {
10009 : 0 : u64 now = perf_clock();
10010 : 0 : u64 delta = now - event->ctx->timestamp;
10011 : 0 : u64 time = event->ctx->time + delta;
10012 : :
10013 : 0 : task_clock_event_update(event, time);
10014 : 0 : }
10015 : :
10016 : 0 : static int task_clock_event_init(struct perf_event *event)
10017 : : {
10018 [ # # ]: 0 : if (event->attr.type != PERF_TYPE_SOFTWARE)
10019 : : return -ENOENT;
10020 : :
10021 [ # # ]: 0 : if (event->attr.config != PERF_COUNT_SW_TASK_CLOCK)
10022 : : return -ENOENT;
10023 : :
10024 : : /*
10025 : : * no branch sampling for software events
10026 : : */
10027 [ # # ]: 0 : if (has_branch_stack(event))
10028 : : return -EOPNOTSUPP;
10029 : :
10030 : 0 : perf_swevent_init_hrtimer(event);
10031 : :
10032 : 0 : return 0;
10033 : : }
10034 : :
10035 : : static struct pmu perf_task_clock = {
10036 : : .task_ctx_nr = perf_sw_context,
10037 : :
10038 : : .capabilities = PERF_PMU_CAP_NO_NMI,
10039 : :
10040 : : .event_init = task_clock_event_init,
10041 : : .add = task_clock_event_add,
10042 : : .del = task_clock_event_del,
10043 : : .start = task_clock_event_start,
10044 : : .stop = task_clock_event_stop,
10045 : : .read = task_clock_event_read,
10046 : : };
10047 : :
10048 : 0 : static void perf_pmu_nop_void(struct pmu *pmu)
10049 : : {
10050 : 0 : }
10051 : :
10052 : 0 : static void perf_pmu_nop_txn(struct pmu *pmu, unsigned int flags)
10053 : : {
10054 : 0 : }
10055 : :
10056 : 0 : static int perf_pmu_nop_int(struct pmu *pmu)
10057 : : {
10058 : 0 : return 0;
10059 : : }
10060 : :
10061 : 0 : static int perf_event_nop_int(struct perf_event *event, u64 value)
10062 : : {
10063 : 0 : return 0;
10064 : : }
10065 : :
10066 : : static DEFINE_PER_CPU(unsigned int, nop_txn_flags);
10067 : :
10068 : 0 : static void perf_pmu_start_txn(struct pmu *pmu, unsigned int flags)
10069 : : {
10070 [ # # ]: 0 : __this_cpu_write(nop_txn_flags, flags);
10071 : :
10072 [ # # ]: 0 : if (flags & ~PERF_PMU_TXN_ADD)
10073 : : return;
10074 : :
10075 : 0 : perf_pmu_disable(pmu);
10076 : : }
10077 : :
10078 : 0 : static int perf_pmu_commit_txn(struct pmu *pmu)
10079 : : {
10080 [ # # ]: 0 : unsigned int flags = __this_cpu_read(nop_txn_flags);
10081 : :
10082 : 0 : __this_cpu_write(nop_txn_flags, 0);
10083 : :
10084 [ # # ]: 0 : if (flags & ~PERF_PMU_TXN_ADD)
10085 : : return 0;
10086 : :
10087 : 0 : perf_pmu_enable(pmu);
10088 : : return 0;
10089 : : }
10090 : :
10091 : 0 : static void perf_pmu_cancel_txn(struct pmu *pmu)
10092 : : {
10093 [ # # ]: 0 : unsigned int flags = __this_cpu_read(nop_txn_flags);
10094 : :
10095 : 0 : __this_cpu_write(nop_txn_flags, 0);
10096 : :
10097 [ # # ]: 0 : if (flags & ~PERF_PMU_TXN_ADD)
10098 : : return;
10099 : :
10100 : 0 : perf_pmu_enable(pmu);
10101 : : }
10102 : :
10103 : 0 : static int perf_event_idx_default(struct perf_event *event)
10104 : : {
10105 : 0 : return 0;
10106 : : }
10107 : :
10108 : : /*
10109 : : * Ensures all contexts with the same task_ctx_nr have the same
10110 : : * pmu_cpu_context too.
10111 : : */
10112 : 117 : static struct perf_cpu_context __percpu *find_pmu_context(int ctxn)
10113 : : {
10114 : 117 : struct pmu *pmu;
10115 : :
10116 : 117 : if (ctxn < 0)
10117 : : return NULL;
10118 : :
10119 [ + + ]: 208 : list_for_each_entry(pmu, &pmus, entry) {
10120 [ + + ]: 182 : if (pmu->task_ctx_nr == ctxn)
10121 : 91 : return pmu->pmu_cpu_context;
10122 : : }
10123 : :
10124 : : return NULL;
10125 : : }
10126 : :
10127 : 0 : static void free_pmu_context(struct pmu *pmu)
10128 : : {
10129 : : /*
10130 : : * Static contexts such as perf_sw_context have a global lifetime
10131 : : * and may be shared between different PMUs. Avoid freeing them
10132 : : * when a single PMU is going away.
10133 : : */
10134 : 0 : if (pmu->task_ctx_nr > perf_invalid_context)
10135 : : return;
10136 : :
10137 : 0 : free_percpu(pmu->pmu_cpu_context);
10138 : : }
10139 : :
10140 : : /*
10141 : : * Let userspace know that this PMU supports address range filtering:
10142 : : */
10143 : 0 : static ssize_t nr_addr_filters_show(struct device *dev,
10144 : : struct device_attribute *attr,
10145 : : char *page)
10146 : : {
10147 : 0 : struct pmu *pmu = dev_get_drvdata(dev);
10148 : :
10149 : 0 : return snprintf(page, PAGE_SIZE - 1, "%d\n", pmu->nr_addr_filters);
10150 : : }
10151 : : DEVICE_ATTR_RO(nr_addr_filters);
10152 : :
10153 : : static struct idr pmu_idr;
10154 : :
10155 : : static ssize_t
10156 : 0 : type_show(struct device *dev, struct device_attribute *attr, char *page)
10157 : : {
10158 : 0 : struct pmu *pmu = dev_get_drvdata(dev);
10159 : :
10160 : 0 : return snprintf(page, PAGE_SIZE-1, "%d\n", pmu->type);
10161 : : }
10162 : : static DEVICE_ATTR_RO(type);
10163 : :
10164 : : static ssize_t
10165 : 0 : perf_event_mux_interval_ms_show(struct device *dev,
10166 : : struct device_attribute *attr,
10167 : : char *page)
10168 : : {
10169 : 0 : struct pmu *pmu = dev_get_drvdata(dev);
10170 : :
10171 : 0 : return snprintf(page, PAGE_SIZE-1, "%d\n", pmu->hrtimer_interval_ms);
10172 : : }
10173 : :
10174 : : static DEFINE_MUTEX(mux_interval_mutex);
10175 : :
10176 : : static ssize_t
10177 : 0 : perf_event_mux_interval_ms_store(struct device *dev,
10178 : : struct device_attribute *attr,
10179 : : const char *buf, size_t count)
10180 : : {
10181 : 0 : struct pmu *pmu = dev_get_drvdata(dev);
10182 : 0 : int timer, cpu, ret;
10183 : :
10184 : 0 : ret = kstrtoint(buf, 0, &timer);
10185 [ # # ]: 0 : if (ret)
10186 : 0 : return ret;
10187 : :
10188 [ # # ]: 0 : if (timer < 1)
10189 : : return -EINVAL;
10190 : :
10191 : : /* same value, noting to do */
10192 [ # # ]: 0 : if (timer == pmu->hrtimer_interval_ms)
10193 : 0 : return count;
10194 : :
10195 : 0 : mutex_lock(&mux_interval_mutex);
10196 : 0 : pmu->hrtimer_interval_ms = timer;
10197 : :
10198 : : /* update all cpuctx for this PMU */
10199 : 0 : cpus_read_lock();
10200 [ # # ]: 0 : for_each_online_cpu(cpu) {
10201 : 0 : struct perf_cpu_context *cpuctx;
10202 : 0 : cpuctx = per_cpu_ptr(pmu->pmu_cpu_context, cpu);
10203 : 0 : cpuctx->hrtimer_interval = ns_to_ktime(NSEC_PER_MSEC * timer);
10204 : :
10205 : 0 : cpu_function_call(cpu,
10206 : : (remote_function_f)perf_mux_hrtimer_restart, cpuctx);
10207 : : }
10208 : 0 : cpus_read_unlock();
10209 : 0 : mutex_unlock(&mux_interval_mutex);
10210 : :
10211 : 0 : return count;
10212 : : }
10213 : : static DEVICE_ATTR_RW(perf_event_mux_interval_ms);
10214 : :
10215 : : static struct attribute *pmu_dev_attrs[] = {
10216 : : &dev_attr_type.attr,
10217 : : &dev_attr_perf_event_mux_interval_ms.attr,
10218 : : NULL,
10219 : : };
10220 : : ATTRIBUTE_GROUPS(pmu_dev);
10221 : :
10222 : : static int pmu_bus_running;
10223 : : static struct bus_type pmu_bus = {
10224 : : .name = "event_source",
10225 : : .dev_groups = pmu_dev_groups,
10226 : : };
10227 : :
10228 : 0 : static void pmu_dev_release(struct device *dev)
10229 : : {
10230 : 0 : kfree(dev);
10231 : 0 : }
10232 : :
10233 : 91 : static int pmu_dev_alloc(struct pmu *pmu)
10234 : : {
10235 : 91 : int ret = -ENOMEM;
10236 : :
10237 : 91 : pmu->dev = kzalloc(sizeof(struct device), GFP_KERNEL);
10238 [ - + ]: 91 : if (!pmu->dev)
10239 : 0 : goto out;
10240 : :
10241 : 91 : pmu->dev->groups = pmu->attr_groups;
10242 : 91 : device_initialize(pmu->dev);
10243 : 91 : ret = dev_set_name(pmu->dev, "%s", pmu->name);
10244 [ - + ]: 91 : if (ret)
10245 : 0 : goto free_dev;
10246 : :
10247 : 91 : dev_set_drvdata(pmu->dev, pmu);
10248 : 91 : pmu->dev->bus = &pmu_bus;
10249 : 91 : pmu->dev->release = pmu_dev_release;
10250 : 91 : ret = device_add(pmu->dev);
10251 [ - + ]: 91 : if (ret)
10252 : 0 : goto free_dev;
10253 : :
10254 : : /* For PMUs with address filters, throw in an extra attribute: */
10255 [ - + ]: 91 : if (pmu->nr_addr_filters)
10256 : 0 : ret = device_create_file(pmu->dev, &dev_attr_nr_addr_filters);
10257 : :
10258 [ - + ]: 91 : if (ret)
10259 : 0 : goto del_dev;
10260 : :
10261 [ + + ]: 91 : if (pmu->attr_update)
10262 : 13 : ret = sysfs_update_groups(&pmu->dev->kobj, pmu->attr_update);
10263 : :
10264 [ - + ]: 91 : if (ret)
10265 : 0 : goto del_dev;
10266 : :
10267 : 91 : out:
10268 : 91 : return ret;
10269 : :
10270 : 0 : del_dev:
10271 : 0 : device_del(pmu->dev);
10272 : :
10273 : 0 : free_dev:
10274 : 0 : put_device(pmu->dev);
10275 : 0 : goto out;
10276 : : }
10277 : :
10278 : : static struct lock_class_key cpuctx_mutex;
10279 : : static struct lock_class_key cpuctx_lock;
10280 : :
10281 : 117 : int perf_pmu_register(struct pmu *pmu, const char *name, int type)
10282 : : {
10283 : 117 : int cpu, ret, max = PERF_TYPE_MAX;
10284 : :
10285 : 117 : mutex_lock(&pmus_lock);
10286 : 117 : ret = -ENOMEM;
10287 : 117 : pmu->pmu_disable_count = alloc_percpu(int);
10288 [ - + ]: 117 : if (!pmu->pmu_disable_count)
10289 : 0 : goto unlock;
10290 : :
10291 : 117 : pmu->type = -1;
10292 [ + + ]: 117 : if (!name)
10293 : 26 : goto skip_type;
10294 : 91 : pmu->name = name;
10295 : :
10296 [ + + ]: 91 : if (type != PERF_TYPE_SOFTWARE) {
10297 [ + + ]: 78 : if (type >= 0)
10298 : 39 : max = type;
10299 : :
10300 : 78 : ret = idr_alloc(&pmu_idr, pmu, max, 0, GFP_KERNEL);
10301 [ - + ]: 78 : if (ret < 0)
10302 : 0 : goto free_pdc;
10303 : :
10304 [ - + ]: 78 : WARN_ON(type >= 0 && ret != type);
10305 : :
10306 : : type = ret;
10307 : : }
10308 : 91 : pmu->type = type;
10309 : :
10310 [ - + ]: 91 : if (pmu_bus_running) {
10311 : 0 : ret = pmu_dev_alloc(pmu);
10312 [ # # ]: 0 : if (ret)
10313 : 0 : goto free_idr;
10314 : : }
10315 : :
10316 : 91 : skip_type:
10317 [ + + ]: 117 : if (pmu->task_ctx_nr == perf_hw_context) {
10318 : 13 : static int hw_context_taken = 0;
10319 : :
10320 : : /*
10321 : : * Other than systems with heterogeneous CPUs, it never makes
10322 : : * sense for two PMUs to share perf_hw_context. PMUs which are
10323 : : * uncore must use perf_invalid_context.
10324 : : */
10325 [ - + - - : 26 : if (WARN_ON_ONCE(hw_context_taken &&
- + - + ]
10326 : : !(pmu->capabilities & PERF_PMU_CAP_HETEROGENEOUS_CPUS)))
10327 : 0 : pmu->task_ctx_nr = perf_invalid_context;
10328 : :
10329 : 13 : hw_context_taken = 1;
10330 : : }
10331 : :
10332 [ + - ]: 117 : pmu->pmu_cpu_context = find_pmu_context(pmu->task_ctx_nr);
10333 [ + + ]: 117 : if (pmu->pmu_cpu_context)
10334 : 91 : goto got_cpu_context;
10335 : :
10336 : 26 : ret = -ENOMEM;
10337 : 26 : pmu->pmu_cpu_context = alloc_percpu(struct perf_cpu_context);
10338 [ - + ]: 26 : if (!pmu->pmu_cpu_context)
10339 : 0 : goto free_dev;
10340 : :
10341 [ + + ]: 52 : for_each_possible_cpu(cpu) {
10342 : 26 : struct perf_cpu_context *cpuctx;
10343 : :
10344 : 26 : cpuctx = per_cpu_ptr(pmu->pmu_cpu_context, cpu);
10345 : 26 : __perf_event_init_context(&cpuctx->ctx);
10346 : 26 : lockdep_set_class(&cpuctx->ctx.mutex, &cpuctx_mutex);
10347 : 26 : lockdep_set_class(&cpuctx->ctx.lock, &cpuctx_lock);
10348 : 26 : cpuctx->ctx.pmu = pmu;
10349 : 26 : cpuctx->online = cpumask_test_cpu(cpu, perf_online_mask);
10350 : :
10351 : 26 : __perf_mux_hrtimer_init(cpuctx, cpu);
10352 : : }
10353 : :
10354 : 26 : got_cpu_context:
10355 [ + + ]: 117 : if (!pmu->start_txn) {
10356 [ - + ]: 104 : if (pmu->pmu_enable) {
10357 : : /*
10358 : : * If we have pmu_enable/pmu_disable calls, install
10359 : : * transaction stubs that use that to try and batch
10360 : : * hardware accesses.
10361 : : */
10362 : 0 : pmu->start_txn = perf_pmu_start_txn;
10363 : 0 : pmu->commit_txn = perf_pmu_commit_txn;
10364 : 0 : pmu->cancel_txn = perf_pmu_cancel_txn;
10365 : : } else {
10366 : 104 : pmu->start_txn = perf_pmu_nop_txn;
10367 : 104 : pmu->commit_txn = perf_pmu_nop_int;
10368 : 104 : pmu->cancel_txn = perf_pmu_nop_void;
10369 : : }
10370 : : }
10371 : :
10372 [ + + ]: 117 : if (!pmu->pmu_enable) {
10373 : 104 : pmu->pmu_enable = perf_pmu_nop_void;
10374 : 104 : pmu->pmu_disable = perf_pmu_nop_void;
10375 : : }
10376 : :
10377 [ + + ]: 117 : if (!pmu->check_period)
10378 : 104 : pmu->check_period = perf_event_nop_int;
10379 : :
10380 [ + + ]: 117 : if (!pmu->event_idx)
10381 : 104 : pmu->event_idx = perf_event_idx_default;
10382 : :
10383 : : /*
10384 : : * Ensure the TYPE_SOFTWARE PMUs are at the head of the list,
10385 : : * since these cannot be in the IDR. This way the linear search
10386 : : * is fast, provided a valid software event is provided.
10387 : : */
10388 [ + + ]: 117 : if (type == PERF_TYPE_SOFTWARE || !name)
10389 : 39 : list_add_rcu(&pmu->entry, &pmus);
10390 : : else
10391 : 78 : list_add_tail_rcu(&pmu->entry, &pmus);
10392 : :
10393 : 117 : atomic_set(&pmu->exclusive_cnt, 0);
10394 : 117 : ret = 0;
10395 : 117 : unlock:
10396 : 117 : mutex_unlock(&pmus_lock);
10397 : :
10398 : 117 : return ret;
10399 : :
10400 : : free_dev:
10401 : 0 : device_del(pmu->dev);
10402 : 0 : put_device(pmu->dev);
10403 : :
10404 : 0 : free_idr:
10405 [ # # ]: 0 : if (pmu->type != PERF_TYPE_SOFTWARE)
10406 : 0 : idr_remove(&pmu_idr, pmu->type);
10407 : :
10408 : 0 : free_pdc:
10409 : 0 : free_percpu(pmu->pmu_disable_count);
10410 : 0 : goto unlock;
10411 : : }
10412 : : EXPORT_SYMBOL_GPL(perf_pmu_register);
10413 : :
10414 : 0 : void perf_pmu_unregister(struct pmu *pmu)
10415 : : {
10416 : 0 : mutex_lock(&pmus_lock);
10417 : 0 : list_del_rcu(&pmu->entry);
10418 : :
10419 : : /*
10420 : : * We dereference the pmu list under both SRCU and regular RCU, so
10421 : : * synchronize against both of those.
10422 : : */
10423 : 0 : synchronize_srcu(&pmus_srcu);
10424 : 0 : synchronize_rcu();
10425 : :
10426 : 0 : free_percpu(pmu->pmu_disable_count);
10427 [ # # ]: 0 : if (pmu->type != PERF_TYPE_SOFTWARE)
10428 : 0 : idr_remove(&pmu_idr, pmu->type);
10429 [ # # ]: 0 : if (pmu_bus_running) {
10430 [ # # ]: 0 : if (pmu->nr_addr_filters)
10431 : 0 : device_remove_file(pmu->dev, &dev_attr_nr_addr_filters);
10432 : 0 : device_del(pmu->dev);
10433 : 0 : put_device(pmu->dev);
10434 : : }
10435 [ # # ]: 0 : free_pmu_context(pmu);
10436 : 0 : mutex_unlock(&pmus_lock);
10437 : 0 : }
10438 : : EXPORT_SYMBOL_GPL(perf_pmu_unregister);
10439 : :
10440 : 0 : static inline bool has_extended_regs(struct perf_event *event)
10441 : : {
10442 : 0 : return (event->attr.sample_regs_user & PERF_REG_EXTENDED_MASK) ||
10443 [ # # ]: 0 : (event->attr.sample_regs_intr & PERF_REG_EXTENDED_MASK);
10444 : : }
10445 : :
10446 : 0 : static int perf_try_init_event(struct pmu *pmu, struct perf_event *event)
10447 : : {
10448 : 0 : struct perf_event_context *ctx = NULL;
10449 : 0 : int ret;
10450 : :
10451 [ # # ]: 0 : if (!try_module_get(pmu->module))
10452 : : return -ENODEV;
10453 : :
10454 : : /*
10455 : : * A number of pmu->event_init() methods iterate the sibling_list to,
10456 : : * for example, validate if the group fits on the PMU. Therefore,
10457 : : * if this is a sibling event, acquire the ctx->mutex to protect
10458 : : * the sibling_list.
10459 : : */
10460 [ # # # # ]: 0 : if (event->group_leader != event && pmu->task_ctx_nr != perf_sw_context) {
10461 : : /*
10462 : : * This ctx->mutex can nest when we're called through
10463 : : * inheritance. See the perf_event_ctx_lock_nested() comment.
10464 : : */
10465 : 0 : ctx = perf_event_ctx_lock_nested(event->group_leader,
10466 : : SINGLE_DEPTH_NESTING);
10467 [ # # ]: 0 : BUG_ON(!ctx);
10468 : : }
10469 : :
10470 : 0 : event->pmu = pmu;
10471 : 0 : ret = pmu->event_init(event);
10472 : :
10473 [ # # ]: 0 : if (ctx)
10474 : 0 : perf_event_ctx_unlock(event->group_leader, ctx);
10475 : :
10476 [ # # ]: 0 : if (!ret) {
10477 [ # # # # ]: 0 : if (!(pmu->capabilities & PERF_PMU_CAP_EXTENDED_REGS) &&
10478 [ # # ]: 0 : has_extended_regs(event))
10479 : 0 : ret = -EOPNOTSUPP;
10480 : :
10481 [ # # # # ]: 0 : if (pmu->capabilities & PERF_PMU_CAP_NO_EXCLUDE &&
10482 : : event_has_any_exclude_flag(event))
10483 : : ret = -EINVAL;
10484 : :
10485 [ # # # # ]: 0 : if (ret && event->destroy)
10486 : 0 : event->destroy(event);
10487 : : }
10488 : :
10489 [ # # ]: 0 : if (ret)
10490 : 0 : module_put(pmu->module);
10491 : :
10492 : : return ret;
10493 : : }
10494 : :
10495 : 0 : static struct pmu *perf_init_event(struct perf_event *event)
10496 : : {
10497 : 0 : int idx, type, ret;
10498 : 0 : struct pmu *pmu;
10499 : :
10500 : 0 : idx = srcu_read_lock(&pmus_srcu);
10501 : :
10502 : : /* Try parent's PMU first: */
10503 [ # # # # ]: 0 : if (event->parent && event->parent->pmu) {
10504 : 0 : pmu = event->parent->pmu;
10505 : 0 : ret = perf_try_init_event(pmu, event);
10506 [ # # ]: 0 : if (!ret)
10507 : 0 : goto unlock;
10508 : : }
10509 : :
10510 : : /*
10511 : : * PERF_TYPE_HARDWARE and PERF_TYPE_HW_CACHE
10512 : : * are often aliases for PERF_TYPE_RAW.
10513 : : */
10514 : 0 : type = event->attr.type;
10515 [ # # ]: 0 : if (type == PERF_TYPE_HARDWARE || type == PERF_TYPE_HW_CACHE)
10516 : 0 : type = PERF_TYPE_RAW;
10517 : :
10518 : 0 : again:
10519 : 0 : rcu_read_lock();
10520 : 0 : pmu = idr_find(&pmu_idr, type);
10521 : 0 : rcu_read_unlock();
10522 [ # # ]: 0 : if (pmu) {
10523 : 0 : ret = perf_try_init_event(pmu, event);
10524 [ # # # # ]: 0 : if (ret == -ENOENT && event->attr.type != type) {
10525 : 0 : type = event->attr.type;
10526 : 0 : goto again;
10527 : : }
10528 : :
10529 [ # # ]: 0 : if (ret)
10530 : 0 : pmu = ERR_PTR(ret);
10531 : :
10532 : 0 : goto unlock;
10533 : : }
10534 : :
10535 [ # # ]: 0 : list_for_each_entry_rcu(pmu, &pmus, entry, lockdep_is_held(&pmus_srcu)) {
10536 : 0 : ret = perf_try_init_event(pmu, event);
10537 [ # # ]: 0 : if (!ret)
10538 : 0 : goto unlock;
10539 : :
10540 [ # # ]: 0 : if (ret != -ENOENT) {
10541 : 0 : pmu = ERR_PTR(ret);
10542 : 0 : goto unlock;
10543 : : }
10544 : : }
10545 : : pmu = ERR_PTR(-ENOENT);
10546 : 0 : unlock:
10547 : 0 : srcu_read_unlock(&pmus_srcu, idx);
10548 : :
10549 : 0 : return pmu;
10550 : : }
10551 : :
10552 : 0 : static void attach_sb_event(struct perf_event *event)
10553 : : {
10554 : 0 : struct pmu_event_list *pel = per_cpu_ptr(&pmu_sb_events, event->cpu);
10555 : :
10556 : 0 : raw_spin_lock(&pel->lock);
10557 : 0 : list_add_rcu(&event->sb_list, &pel->list);
10558 : 0 : raw_spin_unlock(&pel->lock);
10559 : 0 : }
10560 : :
10561 : : /*
10562 : : * We keep a list of all !task (and therefore per-cpu) events
10563 : : * that need to receive side-band records.
10564 : : *
10565 : : * This avoids having to scan all the various PMU per-cpu contexts
10566 : : * looking for them.
10567 : : */
10568 : 0 : static void account_pmu_sb_event(struct perf_event *event)
10569 : : {
10570 [ # # ]: 0 : if (is_sb_event(event))
10571 : 0 : attach_sb_event(event);
10572 : 0 : }
10573 : :
10574 : 0 : static void account_event_cpu(struct perf_event *event, int cpu)
10575 : : {
10576 : 0 : if (event->parent)
10577 : : return;
10578 : :
10579 : : if (is_cgroup_event(event))
10580 : : atomic_inc(&per_cpu(perf_cgroup_events, cpu));
10581 : : }
10582 : :
10583 : : /* Freq events need the tick to stay alive (see perf_event_task_tick). */
10584 : : static void account_freq_event_nohz(void)
10585 : : {
10586 : : #ifdef CONFIG_NO_HZ_FULL
10587 : : /* Lock so we don't race with concurrent unaccount */
10588 : : spin_lock(&nr_freq_lock);
10589 : : if (atomic_inc_return(&nr_freq_events) == 1)
10590 : : tick_nohz_dep_set(TICK_DEP_BIT_PERF_EVENTS);
10591 : : spin_unlock(&nr_freq_lock);
10592 : : #endif
10593 : : }
10594 : :
10595 : 0 : static void account_freq_event(void)
10596 : : {
10597 : 0 : if (tick_nohz_full_enabled())
10598 : : account_freq_event_nohz();
10599 : : else
10600 : 0 : atomic_inc(&nr_freq_events);
10601 : 0 : }
10602 : :
10603 : :
10604 : 0 : static void account_event(struct perf_event *event)
10605 : : {
10606 : 0 : bool inc = false;
10607 : :
10608 [ # # ]: 0 : if (event->parent)
10609 : : return;
10610 : :
10611 [ # # ]: 0 : if (event->attach_state & PERF_ATTACH_TASK)
10612 : 0 : inc = true;
10613 [ # # ]: 0 : if (event->attr.mmap || event->attr.mmap_data)
10614 : 0 : atomic_inc(&nr_mmap_events);
10615 [ # # ]: 0 : if (event->attr.comm)
10616 : 0 : atomic_inc(&nr_comm_events);
10617 [ # # ]: 0 : if (event->attr.namespaces)
10618 : 0 : atomic_inc(&nr_namespaces_events);
10619 [ # # ]: 0 : if (event->attr.task)
10620 : 0 : atomic_inc(&nr_task_events);
10621 [ # # ]: 0 : if (event->attr.freq)
10622 : 0 : account_freq_event();
10623 [ # # ]: 0 : if (event->attr.context_switch) {
10624 : 0 : atomic_inc(&nr_switch_events);
10625 : 0 : inc = true;
10626 : : }
10627 [ # # ]: 0 : if (has_branch_stack(event))
10628 : 0 : inc = true;
10629 : 0 : if (is_cgroup_event(event))
10630 : : inc = true;
10631 [ # # ]: 0 : if (event->attr.ksymbol)
10632 : 0 : atomic_inc(&nr_ksymbol_events);
10633 [ # # ]: 0 : if (event->attr.bpf_event)
10634 : 0 : atomic_inc(&nr_bpf_events);
10635 : :
10636 [ # # ]: 0 : if (inc) {
10637 : : /*
10638 : : * We need the mutex here because static_branch_enable()
10639 : : * must complete *before* the perf_sched_count increment
10640 : : * becomes visible.
10641 : : */
10642 [ # # ]: 0 : if (atomic_inc_not_zero(&perf_sched_count))
10643 : 0 : goto enabled;
10644 : :
10645 : 0 : mutex_lock(&perf_sched_mutex);
10646 [ # # ]: 0 : if (!atomic_read(&perf_sched_count)) {
10647 : 0 : static_branch_enable(&perf_sched_events);
10648 : : /*
10649 : : * Guarantee that all CPUs observe they key change and
10650 : : * call the perf scheduling hooks before proceeding to
10651 : : * install events that need them.
10652 : : */
10653 : 0 : synchronize_rcu();
10654 : : }
10655 : : /*
10656 : : * Now that we have waited for the sync_sched(), allow further
10657 : : * increments to by-pass the mutex.
10658 : : */
10659 : 0 : atomic_inc(&perf_sched_count);
10660 : 0 : mutex_unlock(&perf_sched_mutex);
10661 : : }
10662 : 0 : enabled:
10663 : :
10664 : 0 : account_event_cpu(event, event->cpu);
10665 : :
10666 : 0 : account_pmu_sb_event(event);
10667 : : }
10668 : :
10669 : : /*
10670 : : * Allocate and initialize an event structure
10671 : : */
10672 : : static struct perf_event *
10673 : 0 : perf_event_alloc(struct perf_event_attr *attr, int cpu,
10674 : : struct task_struct *task,
10675 : : struct perf_event *group_leader,
10676 : : struct perf_event *parent_event,
10677 : : perf_overflow_handler_t overflow_handler,
10678 : : void *context, int cgroup_fd)
10679 : : {
10680 : 0 : struct pmu *pmu;
10681 : 0 : struct perf_event *event;
10682 : 0 : struct hw_perf_event *hwc;
10683 : 0 : long err = -EINVAL;
10684 : :
10685 [ # # ]: 0 : if ((unsigned)cpu >= nr_cpu_ids) {
10686 [ # # ]: 0 : if (!task || cpu != -1)
10687 : : return ERR_PTR(-EINVAL);
10688 : : }
10689 : :
10690 : 0 : event = kzalloc(sizeof(*event), GFP_KERNEL);
10691 [ # # ]: 0 : if (!event)
10692 : : return ERR_PTR(-ENOMEM);
10693 : :
10694 : : /*
10695 : : * Single events are their own group leaders, with an
10696 : : * empty sibling list:
10697 : : */
10698 [ # # ]: 0 : if (!group_leader)
10699 : 0 : group_leader = event;
10700 : :
10701 : 0 : mutex_init(&event->child_mutex);
10702 : 0 : INIT_LIST_HEAD(&event->child_list);
10703 : :
10704 : 0 : INIT_LIST_HEAD(&event->event_entry);
10705 : 0 : INIT_LIST_HEAD(&event->sibling_list);
10706 : 0 : INIT_LIST_HEAD(&event->active_list);
10707 : 0 : init_event_group(event);
10708 : 0 : INIT_LIST_HEAD(&event->rb_entry);
10709 : 0 : INIT_LIST_HEAD(&event->active_entry);
10710 : 0 : INIT_LIST_HEAD(&event->addr_filters.list);
10711 : 0 : INIT_HLIST_NODE(&event->hlist_entry);
10712 : :
10713 : :
10714 : 0 : init_waitqueue_head(&event->waitq);
10715 : 0 : event->pending_disable = -1;
10716 : 0 : init_irq_work(&event->pending, perf_pending_event);
10717 : :
10718 : 0 : mutex_init(&event->mmap_mutex);
10719 : 0 : raw_spin_lock_init(&event->addr_filters.lock);
10720 : :
10721 : 0 : atomic_long_set(&event->refcount, 1);
10722 : 0 : event->cpu = cpu;
10723 : 0 : event->attr = *attr;
10724 : 0 : event->group_leader = group_leader;
10725 : 0 : event->pmu = NULL;
10726 : 0 : event->oncpu = -1;
10727 : :
10728 : 0 : event->parent = parent_event;
10729 : :
10730 : 0 : event->ns = get_pid_ns(task_active_pid_ns(current));
10731 : 0 : event->id = atomic64_inc_return(&perf_event_id);
10732 : :
10733 : 0 : event->state = PERF_EVENT_STATE_INACTIVE;
10734 : :
10735 [ # # ]: 0 : if (task) {
10736 : 0 : event->attach_state = PERF_ATTACH_TASK;
10737 : : /*
10738 : : * XXX pmu::event_init needs to know what task to account to
10739 : : * and we cannot use the ctx information because we need the
10740 : : * pmu before we get a ctx.
10741 : : */
10742 : 0 : event->hw.target = get_task_struct(task);
10743 : : }
10744 : :
10745 : 0 : event->clock = &local_clock;
10746 [ # # ]: 0 : if (parent_event)
10747 : 0 : event->clock = parent_event->clock;
10748 : :
10749 [ # # ]: 0 : if (!overflow_handler && parent_event) {
10750 : 0 : overflow_handler = parent_event->overflow_handler;
10751 : 0 : context = parent_event->overflow_handler_context;
10752 : : #if defined(CONFIG_BPF_SYSCALL) && defined(CONFIG_EVENT_TRACING)
10753 : : if (overflow_handler == bpf_overflow_handler) {
10754 : : struct bpf_prog *prog = parent_event->prog;
10755 : :
10756 : : bpf_prog_inc(prog);
10757 : : event->prog = prog;
10758 : : event->orig_overflow_handler =
10759 : : parent_event->orig_overflow_handler;
10760 : : }
10761 : : #endif
10762 : : }
10763 : :
10764 [ # # ]: 0 : if (overflow_handler) {
10765 : 0 : event->overflow_handler = overflow_handler;
10766 : 0 : event->overflow_handler_context = context;
10767 [ # # ]: 0 : } else if (is_write_backward(event)){
10768 : 0 : event->overflow_handler = perf_event_output_backward;
10769 : 0 : event->overflow_handler_context = NULL;
10770 : : } else {
10771 : 0 : event->overflow_handler = perf_event_output_forward;
10772 : 0 : event->overflow_handler_context = NULL;
10773 : : }
10774 : :
10775 : 0 : perf_event__state_init(event);
10776 : :
10777 : 0 : pmu = NULL;
10778 : :
10779 : 0 : hwc = &event->hw;
10780 : 0 : hwc->sample_period = attr->sample_period;
10781 [ # # # # ]: 0 : if (attr->freq && attr->sample_freq)
10782 : 0 : hwc->sample_period = 1;
10783 : 0 : hwc->last_period = hwc->sample_period;
10784 : :
10785 : 0 : local64_set(&hwc->period_left, hwc->sample_period);
10786 : :
10787 : : /*
10788 : : * We currently do not support PERF_SAMPLE_READ on inherited events.
10789 : : * See perf_output_read().
10790 : : */
10791 [ # # # # ]: 0 : if (attr->inherit && (attr->sample_type & PERF_SAMPLE_READ))
10792 : 0 : goto err_ns;
10793 : :
10794 [ # # ]: 0 : if (!has_branch_stack(event))
10795 : 0 : event->attr.branch_sample_type = 0;
10796 : :
10797 [ # # ]: 0 : if (cgroup_fd != -1) {
10798 : 0 : err = perf_cgroup_connect(cgroup_fd, event, attr, group_leader);
10799 : 0 : if (err)
10800 : 0 : goto err_ns;
10801 : : }
10802 : :
10803 : 0 : pmu = perf_init_event(event);
10804 [ # # ]: 0 : if (IS_ERR(pmu)) {
10805 : 0 : err = PTR_ERR(pmu);
10806 : 0 : goto err_ns;
10807 : : }
10808 : :
10809 : : /*
10810 : : * Disallow uncore-cgroup events, they don't make sense as the cgroup will
10811 : : * be different on other CPUs in the uncore mask.
10812 : : */
10813 : 0 : if (pmu->task_ctx_nr == perf_invalid_context && cgroup_fd != -1) {
10814 : : err = -EINVAL;
10815 : : goto err_pmu;
10816 : : }
10817 : :
10818 [ # # ]: 0 : if (event->attr.aux_output &&
10819 [ # # ]: 0 : !(pmu->capabilities & PERF_PMU_CAP_AUX_OUTPUT)) {
10820 : 0 : err = -EOPNOTSUPP;
10821 : 0 : goto err_pmu;
10822 : : }
10823 : :
10824 : 0 : err = exclusive_event_init(event);
10825 [ # # ]: 0 : if (err)
10826 : 0 : goto err_pmu;
10827 : :
10828 [ # # ]: 0 : if (has_addr_filter(event)) {
10829 : 0 : event->addr_filter_ranges = kcalloc(pmu->nr_addr_filters,
10830 : : sizeof(struct perf_addr_filter_range),
10831 : : GFP_KERNEL);
10832 [ # # ]: 0 : if (!event->addr_filter_ranges) {
10833 : 0 : err = -ENOMEM;
10834 : 0 : goto err_per_task;
10835 : : }
10836 : :
10837 : : /*
10838 : : * Clone the parent's vma offsets: they are valid until exec()
10839 : : * even if the mm is not shared with the parent.
10840 : : */
10841 [ # # ]: 0 : if (event->parent) {
10842 : 0 : struct perf_addr_filters_head *ifh = perf_event_addr_filters(event);
10843 : :
10844 : 0 : raw_spin_lock_irq(&ifh->lock);
10845 : 0 : memcpy(event->addr_filter_ranges,
10846 : 0 : event->parent->addr_filter_ranges,
10847 : 0 : pmu->nr_addr_filters * sizeof(struct perf_addr_filter_range));
10848 : 0 : raw_spin_unlock_irq(&ifh->lock);
10849 : : }
10850 : :
10851 : : /* force hw sync on the address filters */
10852 : 0 : event->addr_filters_gen = 1;
10853 : : }
10854 : :
10855 [ # # ]: 0 : if (!event->parent) {
10856 [ # # ]: 0 : if (event->attr.sample_type & PERF_SAMPLE_CALLCHAIN) {
10857 : 0 : err = get_callchain_buffers(attr->sample_max_stack);
10858 [ # # ]: 0 : if (err)
10859 : 0 : goto err_addr_filters;
10860 : : }
10861 : : }
10862 : :
10863 : 0 : err = security_perf_event_alloc(event);
10864 [ # # ]: 0 : if (err)
10865 : 0 : goto err_callchain_buffer;
10866 : :
10867 : : /* symmetric to unaccount_event() in _free_event() */
10868 : 0 : account_event(event);
10869 : :
10870 : 0 : return event;
10871 : :
10872 : : err_callchain_buffer:
10873 [ # # ]: 0 : if (!event->parent) {
10874 [ # # ]: 0 : if (event->attr.sample_type & PERF_SAMPLE_CALLCHAIN)
10875 : 0 : put_callchain_buffers();
10876 : : }
10877 : 0 : err_addr_filters:
10878 : 0 : kfree(event->addr_filter_ranges);
10879 : :
10880 : 0 : err_per_task:
10881 : 0 : exclusive_event_destroy(event);
10882 : :
10883 : 0 : err_pmu:
10884 [ # # ]: 0 : if (event->destroy)
10885 : 0 : event->destroy(event);
10886 : 0 : module_put(pmu->module);
10887 : 0 : err_ns:
10888 : 0 : if (is_cgroup_event(event))
10889 : : perf_detach_cgroup(event);
10890 [ # # ]: 0 : if (event->ns)
10891 : 0 : put_pid_ns(event->ns);
10892 [ # # ]: 0 : if (event->hw.target)
10893 : 0 : put_task_struct(event->hw.target);
10894 : 0 : kfree(event);
10895 : :
10896 : 0 : return ERR_PTR(err);
10897 : : }
10898 : :
10899 : 0 : static int perf_copy_attr(struct perf_event_attr __user *uattr,
10900 : : struct perf_event_attr *attr)
10901 : : {
10902 : 0 : u32 size;
10903 : 0 : int ret;
10904 : :
10905 : : /* Zero the full structure, so that a short copy will be nice. */
10906 : 0 : memset(attr, 0, sizeof(*attr));
10907 : :
10908 : 0 : ret = get_user(size, &uattr->size);
10909 [ # # ]: 0 : if (ret)
10910 : : return ret;
10911 : :
10912 : : /* ABI compatibility quirk: */
10913 [ # # ]: 0 : if (!size)
10914 : 0 : size = PERF_ATTR_SIZE_VER0;
10915 [ # # ]: 0 : if (size < PERF_ATTR_SIZE_VER0 || size > PAGE_SIZE)
10916 : 0 : goto err_size;
10917 : :
10918 [ # # ]: 0 : ret = copy_struct_from_user(attr, sizeof(*attr), uattr, size);
10919 : 0 : if (ret) {
10920 [ # # ]: 0 : if (ret == -E2BIG)
10921 : 0 : goto err_size;
10922 : : return ret;
10923 : : }
10924 : :
10925 : 0 : attr->size = size;
10926 : :
10927 [ # # # # : 0 : if (attr->__reserved_1 || attr->__reserved_2 || attr->__reserved_3)
# # ]
10928 : : return -EINVAL;
10929 : :
10930 [ # # ]: 0 : if (attr->sample_type & ~(PERF_SAMPLE_MAX-1))
10931 : : return -EINVAL;
10932 : :
10933 [ # # ]: 0 : if (attr->read_format & ~(PERF_FORMAT_MAX-1))
10934 : : return -EINVAL;
10935 : :
10936 [ # # ]: 0 : if (attr->sample_type & PERF_SAMPLE_BRANCH_STACK) {
10937 : 0 : u64 mask = attr->branch_sample_type;
10938 : :
10939 : : /* only using defined bits */
10940 [ # # ]: 0 : if (mask & ~(PERF_SAMPLE_BRANCH_MAX-1))
10941 : : return -EINVAL;
10942 : :
10943 : : /* at least one branch bit must be set */
10944 [ # # ]: 0 : if (!(mask & ~PERF_SAMPLE_BRANCH_PLM_ALL))
10945 : : return -EINVAL;
10946 : :
10947 : : /* propagate priv level, when not set for branch */
10948 [ # # ]: 0 : if (!(mask & PERF_SAMPLE_BRANCH_PLM_ALL)) {
10949 : :
10950 : : /* exclude_kernel checked on syscall entry */
10951 [ # # ]: 0 : if (!attr->exclude_kernel)
10952 : 0 : mask |= PERF_SAMPLE_BRANCH_KERNEL;
10953 : :
10954 [ # # ]: 0 : if (!attr->exclude_user)
10955 : 0 : mask |= PERF_SAMPLE_BRANCH_USER;
10956 : :
10957 [ # # ]: 0 : if (!attr->exclude_hv)
10958 : 0 : mask |= PERF_SAMPLE_BRANCH_HV;
10959 : : /*
10960 : : * adjust user setting (for HW filter setup)
10961 : : */
10962 : 0 : attr->branch_sample_type = mask;
10963 : : }
10964 : : /* privileged levels capture (kernel, hv): check permissions */
10965 [ # # ]: 0 : if (mask & PERF_SAMPLE_BRANCH_PERM_PLM) {
10966 : 0 : ret = perf_allow_kernel(attr);
10967 [ # # ]: 0 : if (ret)
10968 : : return ret;
10969 : : }
10970 : : }
10971 : :
10972 [ # # ]: 0 : if (attr->sample_type & PERF_SAMPLE_REGS_USER) {
10973 : 0 : ret = perf_reg_validate(attr->sample_regs_user);
10974 [ # # ]: 0 : if (ret)
10975 : : return ret;
10976 : : }
10977 : :
10978 [ # # ]: 0 : if (attr->sample_type & PERF_SAMPLE_STACK_USER) {
10979 [ # # ]: 0 : if (!arch_perf_have_user_stack_dump())
10980 : : return -ENOSYS;
10981 : :
10982 : : /*
10983 : : * We have __u32 type for the size, but so far
10984 : : * we can only use __u16 as maximum due to the
10985 : : * __u16 sample size limit.
10986 : : */
10987 [ # # ]: 0 : if (attr->sample_stack_user >= USHRT_MAX)
10988 : : return -EINVAL;
10989 [ # # ]: 0 : else if (!IS_ALIGNED(attr->sample_stack_user, sizeof(u64)))
10990 : : return -EINVAL;
10991 : : }
10992 : :
10993 [ # # ]: 0 : if (!attr->sample_max_stack)
10994 : 0 : attr->sample_max_stack = sysctl_perf_event_max_stack;
10995 : :
10996 [ # # ]: 0 : if (attr->sample_type & PERF_SAMPLE_REGS_INTR)
10997 : 0 : ret = perf_reg_validate(attr->sample_regs_intr);
10998 : 0 : out:
10999 : : return ret;
11000 : :
11001 : 0 : err_size:
11002 : 0 : put_user(sizeof(*attr), &uattr->size);
11003 : 0 : ret = -E2BIG;
11004 : 0 : goto out;
11005 : : }
11006 : :
11007 : : static int
11008 : 0 : perf_event_set_output(struct perf_event *event, struct perf_event *output_event)
11009 : : {
11010 : 0 : struct perf_buffer *rb = NULL;
11011 : 0 : int ret = -EINVAL;
11012 : :
11013 [ # # ]: 0 : if (!output_event)
11014 : 0 : goto set;
11015 : :
11016 : : /* don't allow circular references */
11017 [ # # ]: 0 : if (event == output_event)
11018 : 0 : goto out;
11019 : :
11020 : : /*
11021 : : * Don't allow cross-cpu buffers
11022 : : */
11023 [ # # ]: 0 : if (output_event->cpu != event->cpu)
11024 : 0 : goto out;
11025 : :
11026 : : /*
11027 : : * If its not a per-cpu rb, it must be the same task.
11028 : : */
11029 [ # # # # ]: 0 : if (output_event->cpu == -1 && output_event->ctx != event->ctx)
11030 : 0 : goto out;
11031 : :
11032 : : /*
11033 : : * Mixing clocks in the same buffer is trouble you don't need.
11034 : : */
11035 [ # # ]: 0 : if (output_event->clock != event->clock)
11036 : 0 : goto out;
11037 : :
11038 : : /*
11039 : : * Either writing ring buffer from beginning or from end.
11040 : : * Mixing is not allowed.
11041 : : */
11042 [ # # ]: 0 : if (is_write_backward(output_event) != is_write_backward(event))
11043 : 0 : goto out;
11044 : :
11045 : : /*
11046 : : * If both events generate aux data, they must be on the same PMU
11047 : : */
11048 [ # # # # : 0 : if (has_aux(event) && has_aux(output_event) &&
# # ]
11049 : : event->pmu != output_event->pmu)
11050 : 0 : goto out;
11051 : :
11052 : 0 : set:
11053 : 0 : mutex_lock(&event->mmap_mutex);
11054 : : /* Can't redirect output if we've got an active mmap() */
11055 [ # # ]: 0 : if (atomic_read(&event->mmap_count))
11056 : 0 : goto unlock;
11057 : :
11058 [ # # ]: 0 : if (output_event) {
11059 : : /* get the rb we want to redirect to */
11060 : 0 : rb = ring_buffer_get(output_event);
11061 [ # # ]: 0 : if (!rb)
11062 : 0 : goto unlock;
11063 : : }
11064 : :
11065 : 0 : ring_buffer_attach(event, rb);
11066 : :
11067 : 0 : ret = 0;
11068 : 0 : unlock:
11069 : 0 : mutex_unlock(&event->mmap_mutex);
11070 : :
11071 : 0 : out:
11072 : 0 : return ret;
11073 : : }
11074 : :
11075 : 0 : static void mutex_lock_double(struct mutex *a, struct mutex *b)
11076 : : {
11077 : 0 : if (b < a)
11078 : 0 : swap(a, b);
11079 : :
11080 : 0 : mutex_lock(a);
11081 : 0 : mutex_lock_nested(b, SINGLE_DEPTH_NESTING);
11082 : : }
11083 : :
11084 : 0 : static int perf_event_set_clock(struct perf_event *event, clockid_t clk_id)
11085 : : {
11086 : 0 : bool nmi_safe = false;
11087 : :
11088 : 0 : switch (clk_id) {
11089 : 0 : case CLOCK_MONOTONIC:
11090 : 0 : event->clock = &ktime_get_mono_fast_ns;
11091 : 0 : nmi_safe = true;
11092 : 0 : break;
11093 : :
11094 : 0 : case CLOCK_MONOTONIC_RAW:
11095 : 0 : event->clock = &ktime_get_raw_fast_ns;
11096 : 0 : nmi_safe = true;
11097 : 0 : break;
11098 : :
11099 : 0 : case CLOCK_REALTIME:
11100 : 0 : event->clock = &ktime_get_real_ns;
11101 : 0 : break;
11102 : :
11103 : 0 : case CLOCK_BOOTTIME:
11104 : 0 : event->clock = &ktime_get_boottime_ns;
11105 : 0 : break;
11106 : :
11107 : 0 : case CLOCK_TAI:
11108 : 0 : event->clock = &ktime_get_clocktai_ns;
11109 : 0 : break;
11110 : :
11111 : : default:
11112 : : return -EINVAL;
11113 : : }
11114 : :
11115 [ # # ]: 0 : if (!nmi_safe && !(event->pmu->capabilities & PERF_PMU_CAP_NO_NMI))
11116 : : return -EINVAL;
11117 : :
11118 : : return 0;
11119 : : }
11120 : :
11121 : : /*
11122 : : * Variation on perf_event_ctx_lock_nested(), except we take two context
11123 : : * mutexes.
11124 : : */
11125 : : static struct perf_event_context *
11126 : 0 : __perf_event_ctx_lock_double(struct perf_event *group_leader,
11127 : : struct perf_event_context *ctx)
11128 : : {
11129 : 0 : struct perf_event_context *gctx;
11130 : :
11131 : : again:
11132 : 0 : rcu_read_lock();
11133 : 0 : gctx = READ_ONCE(group_leader->ctx);
11134 [ # # ]: 0 : if (!refcount_inc_not_zero(&gctx->refcount)) {
11135 : 0 : rcu_read_unlock();
11136 : 0 : goto again;
11137 : : }
11138 : 0 : rcu_read_unlock();
11139 : :
11140 [ # # ]: 0 : mutex_lock_double(&gctx->mutex, &ctx->mutex);
11141 : :
11142 [ # # ]: 0 : if (group_leader->ctx != gctx) {
11143 : 0 : mutex_unlock(&ctx->mutex);
11144 : 0 : mutex_unlock(&gctx->mutex);
11145 : 0 : put_ctx(gctx);
11146 : 0 : goto again;
11147 : : }
11148 : :
11149 : 0 : return gctx;
11150 : : }
11151 : :
11152 : : /**
11153 : : * sys_perf_event_open - open a performance event, associate it to a task/cpu
11154 : : *
11155 : : * @attr_uptr: event_id type attributes for monitoring/sampling
11156 : : * @pid: target pid
11157 : : * @cpu: target cpu
11158 : : * @group_fd: group leader event fd
11159 : : */
11160 : 0 : SYSCALL_DEFINE5(perf_event_open,
11161 : : struct perf_event_attr __user *, attr_uptr,
11162 : : pid_t, pid, int, cpu, int, group_fd, unsigned long, flags)
11163 : : {
11164 : 0 : struct perf_event *group_leader = NULL, *output_event = NULL;
11165 : 0 : struct perf_event *event, *sibling;
11166 : 0 : struct perf_event_attr attr;
11167 : 0 : struct perf_event_context *ctx, *uninitialized_var(gctx);
11168 : 0 : struct file *event_file = NULL;
11169 : 0 : struct fd group = {NULL, 0};
11170 : 0 : struct task_struct *task = NULL;
11171 : 0 : struct pmu *pmu;
11172 : 0 : int event_fd;
11173 : 0 : int move_group = 0;
11174 : 0 : int err;
11175 : 0 : int f_flags = O_RDWR;
11176 : 0 : int cgroup_fd = -1;
11177 : :
11178 : : /* for future expandability... */
11179 [ # # ]: 0 : if (flags & ~PERF_FLAG_ALL)
11180 : : return -EINVAL;
11181 : :
11182 : : /* Do we allow access to perf_event_open(2) ? */
11183 : 0 : err = security_perf_event_open(&attr, PERF_SECURITY_OPEN);
11184 [ # # ]: 0 : if (err)
11185 : 0 : return err;
11186 : :
11187 : 0 : err = perf_copy_attr(attr_uptr, &attr);
11188 [ # # ]: 0 : if (err)
11189 : 0 : return err;
11190 : :
11191 [ # # ]: 0 : if (!attr.exclude_kernel) {
11192 : 0 : err = perf_allow_kernel(&attr);
11193 [ # # ]: 0 : if (err)
11194 : 0 : return err;
11195 : : }
11196 : :
11197 [ # # ]: 0 : if (attr.namespaces) {
11198 [ # # ]: 0 : if (!capable(CAP_SYS_ADMIN))
11199 : : return -EACCES;
11200 : : }
11201 : :
11202 [ # # ]: 0 : if (attr.freq) {
11203 [ # # ]: 0 : if (attr.sample_freq > sysctl_perf_event_sample_rate)
11204 : : return -EINVAL;
11205 : : } else {
11206 [ # # ]: 0 : if (attr.sample_period & (1ULL << 63))
11207 : : return -EINVAL;
11208 : : }
11209 : :
11210 : : /* Only privileged users can get physical addresses */
11211 [ # # ]: 0 : if ((attr.sample_type & PERF_SAMPLE_PHYS_ADDR)) {
11212 : 0 : err = perf_allow_kernel(&attr);
11213 [ # # ]: 0 : if (err)
11214 : 0 : return err;
11215 : : }
11216 : :
11217 : 0 : err = security_locked_down(LOCKDOWN_PERF);
11218 [ # # # # ]: 0 : if (err && (attr.sample_type & PERF_SAMPLE_REGS_INTR))
11219 : : /* REGS_INTR can leak data, lockdown must prevent this */
11220 : 0 : return err;
11221 : :
11222 : 0 : err = 0;
11223 : :
11224 : : /*
11225 : : * In cgroup mode, the pid argument is used to pass the fd
11226 : : * opened to the cgroup directory in cgroupfs. The cpu argument
11227 : : * designates the cpu on which to monitor threads from that
11228 : : * cgroup.
11229 : : */
11230 [ # # # # ]: 0 : if ((flags & PERF_FLAG_PID_CGROUP) && (pid == -1 || cpu == -1))
11231 : : return -EINVAL;
11232 : :
11233 [ # # ]: 0 : if (flags & PERF_FLAG_FD_CLOEXEC)
11234 : 0 : f_flags |= O_CLOEXEC;
11235 : :
11236 : 0 : event_fd = get_unused_fd_flags(f_flags);
11237 [ # # ]: 0 : if (event_fd < 0)
11238 : 0 : return event_fd;
11239 : :
11240 [ # # ]: 0 : if (group_fd != -1) {
11241 : 0 : err = perf_fget_light(group_fd, &group);
11242 [ # # ]: 0 : if (err)
11243 : 0 : goto err_fd;
11244 : 0 : group_leader = group.file->private_data;
11245 [ # # ]: 0 : if (flags & PERF_FLAG_FD_OUTPUT)
11246 : 0 : output_event = group_leader;
11247 [ # # ]: 0 : if (flags & PERF_FLAG_FD_NO_GROUP)
11248 : 0 : group_leader = NULL;
11249 : : }
11250 : :
11251 [ # # # # ]: 0 : if (pid != -1 && !(flags & PERF_FLAG_PID_CGROUP)) {
11252 : 0 : task = find_lively_task_by_vpid(pid);
11253 [ # # ]: 0 : if (IS_ERR(task)) {
11254 : 0 : err = PTR_ERR(task);
11255 : 0 : goto err_group_fd;
11256 : : }
11257 : : }
11258 : :
11259 [ # # ]: 0 : if (task && group_leader &&
11260 [ # # ]: 0 : group_leader->attr.inherit != attr.inherit) {
11261 : 0 : err = -EINVAL;
11262 : 0 : goto err_task;
11263 : : }
11264 : :
11265 [ # # ]: 0 : if (task) {
11266 : 0 : err = mutex_lock_interruptible(&task->signal->cred_guard_mutex);
11267 [ # # ]: 0 : if (err)
11268 : 0 : goto err_task;
11269 : :
11270 : : /*
11271 : : * Reuse ptrace permission checks for now.
11272 : : *
11273 : : * We must hold cred_guard_mutex across this and any potential
11274 : : * perf_install_in_context() call for this new event to
11275 : : * serialize against exec() altering our credentials (and the
11276 : : * perf_event_exit_task() that could imply).
11277 : : */
11278 : 0 : err = -EACCES;
11279 [ # # ]: 0 : if (!ptrace_may_access(task, PTRACE_MODE_READ_REALCREDS))
11280 : 0 : goto err_cred;
11281 : : }
11282 : :
11283 [ # # ]: 0 : if (flags & PERF_FLAG_PID_CGROUP)
11284 : 0 : cgroup_fd = pid;
11285 : :
11286 : 0 : event = perf_event_alloc(&attr, cpu, task, group_leader, NULL,
11287 : : NULL, NULL, cgroup_fd);
11288 [ # # ]: 0 : if (IS_ERR(event)) {
11289 : 0 : err = PTR_ERR(event);
11290 : 0 : goto err_cred;
11291 : : }
11292 : :
11293 [ # # ]: 0 : if (is_sampling_event(event)) {
11294 [ # # ]: 0 : if (event->pmu->capabilities & PERF_PMU_CAP_NO_INTERRUPT) {
11295 : 0 : err = -EOPNOTSUPP;
11296 : 0 : goto err_alloc;
11297 : : }
11298 : : }
11299 : :
11300 : : /*
11301 : : * Special case software events and allow them to be part of
11302 : : * any hardware group.
11303 : : */
11304 : 0 : pmu = event->pmu;
11305 : :
11306 [ # # ]: 0 : if (attr.use_clockid) {
11307 [ # # # # : 0 : err = perf_event_set_clock(event, attr.clockid);
# # ]
11308 : 0 : if (err)
11309 : 0 : goto err_alloc;
11310 : : }
11311 : :
11312 [ # # ]: 0 : if (pmu->task_ctx_nr == perf_sw_context)
11313 : 0 : event->event_caps |= PERF_EV_CAP_SOFTWARE;
11314 : :
11315 [ # # ]: 0 : if (group_leader) {
11316 [ # # # # ]: 0 : if (is_software_event(event) &&
11317 [ # # ]: 0 : !in_software_context(group_leader)) {
11318 : : /*
11319 : : * If the event is a sw event, but the group_leader
11320 : : * is on hw context.
11321 : : *
11322 : : * Allow the addition of software events to hw
11323 : : * groups, this is safe because software events
11324 : : * never fail to schedule.
11325 : : */
11326 : : pmu = group_leader->ctx->pmu;
11327 [ # # # # ]: 0 : } else if (!is_software_event(event) &&
11328 [ # # ]: 0 : is_software_event(group_leader) &&
11329 : 0 : (group_leader->group_caps & PERF_EV_CAP_SOFTWARE)) {
11330 : : /*
11331 : : * In case the group is a pure software group, and we
11332 : : * try to add a hardware event, move the whole group to
11333 : : * the hardware context.
11334 : : */
11335 : : move_group = 1;
11336 : : }
11337 : : }
11338 : :
11339 : : /*
11340 : : * Get the target context (task or percpu):
11341 : : */
11342 : 0 : ctx = find_get_context(pmu, task, event);
11343 [ # # ]: 0 : if (IS_ERR(ctx)) {
11344 : 0 : err = PTR_ERR(ctx);
11345 : 0 : goto err_alloc;
11346 : : }
11347 : :
11348 : : /*
11349 : : * Look up the group leader (we will attach this event to it):
11350 : : */
11351 [ # # ]: 0 : if (group_leader) {
11352 : 0 : err = -EINVAL;
11353 : :
11354 : : /*
11355 : : * Do not allow a recursive hierarchy (this new sibling
11356 : : * becoming part of another group-sibling):
11357 : : */
11358 [ # # ]: 0 : if (group_leader->group_leader != group_leader)
11359 : 0 : goto err_context;
11360 : :
11361 : : /* All events in a group should have the same clock */
11362 [ # # ]: 0 : if (group_leader->clock != event->clock)
11363 : 0 : goto err_context;
11364 : :
11365 : : /*
11366 : : * Make sure we're both events for the same CPU;
11367 : : * grouping events for different CPUs is broken; since
11368 : : * you can never concurrently schedule them anyhow.
11369 : : */
11370 [ # # ]: 0 : if (group_leader->cpu != event->cpu)
11371 : 0 : goto err_context;
11372 : :
11373 : : /*
11374 : : * Make sure we're both on the same task, or both
11375 : : * per-CPU events.
11376 : : */
11377 [ # # ]: 0 : if (group_leader->ctx->task != ctx->task)
11378 : 0 : goto err_context;
11379 : :
11380 : : /*
11381 : : * Do not allow to attach to a group in a different task
11382 : : * or CPU context. If we're moving SW events, we'll fix
11383 : : * this up later, so allow that.
11384 : : */
11385 [ # # # # ]: 0 : if (!move_group && group_leader->ctx != ctx)
11386 : 0 : goto err_context;
11387 : :
11388 : : /*
11389 : : * Only a group leader can be exclusive or pinned
11390 : : */
11391 [ # # ]: 0 : if (attr.exclusive || attr.pinned)
11392 : 0 : goto err_context;
11393 : : }
11394 : :
11395 [ # # ]: 0 : if (output_event) {
11396 : 0 : err = perf_event_set_output(event, output_event);
11397 [ # # ]: 0 : if (err)
11398 : 0 : goto err_context;
11399 : : }
11400 : :
11401 : 0 : event_file = anon_inode_getfile("[perf_event]", &perf_fops, event,
11402 : : f_flags);
11403 [ # # ]: 0 : if (IS_ERR(event_file)) {
11404 : 0 : err = PTR_ERR(event_file);
11405 : 0 : event_file = NULL;
11406 : 0 : goto err_context;
11407 : : }
11408 : :
11409 [ # # ]: 0 : if (move_group) {
11410 : 0 : gctx = __perf_event_ctx_lock_double(group_leader, ctx);
11411 : :
11412 [ # # ]: 0 : if (gctx->task == TASK_TOMBSTONE) {
11413 : 0 : err = -ESRCH;
11414 : 0 : goto err_locked;
11415 : : }
11416 : :
11417 : : /*
11418 : : * Check if we raced against another sys_perf_event_open() call
11419 : : * moving the software group underneath us.
11420 : : */
11421 [ # # ]: 0 : if (!(group_leader->group_caps & PERF_EV_CAP_SOFTWARE)) {
11422 : : /*
11423 : : * If someone moved the group out from under us, check
11424 : : * if this new event wound up on the same ctx, if so
11425 : : * its the regular !move_group case, otherwise fail.
11426 : : */
11427 [ # # ]: 0 : if (gctx != ctx) {
11428 : 0 : err = -EINVAL;
11429 : 0 : goto err_locked;
11430 : : } else {
11431 : 0 : perf_event_ctx_unlock(group_leader, gctx);
11432 : 0 : move_group = 0;
11433 : : }
11434 : : }
11435 : :
11436 : : /*
11437 : : * Failure to create exclusive events returns -EBUSY.
11438 : : */
11439 : 0 : err = -EBUSY;
11440 [ # # ]: 0 : if (!exclusive_event_installable(group_leader, ctx))
11441 : 0 : goto err_locked;
11442 : :
11443 [ # # # # ]: 0 : for_each_sibling_event(sibling, group_leader) {
11444 [ # # ]: 0 : if (!exclusive_event_installable(sibling, ctx))
11445 : 0 : goto err_locked;
11446 : : }
11447 : : } else {
11448 : 0 : mutex_lock(&ctx->mutex);
11449 : : }
11450 : :
11451 [ # # ]: 0 : if (ctx->task == TASK_TOMBSTONE) {
11452 : 0 : err = -ESRCH;
11453 : 0 : goto err_locked;
11454 : : }
11455 : :
11456 [ # # ]: 0 : if (!perf_event_validate_size(event)) {
11457 : 0 : err = -E2BIG;
11458 : 0 : goto err_locked;
11459 : : }
11460 : :
11461 [ # # ]: 0 : if (!task) {
11462 : : /*
11463 : : * Check if the @cpu we're creating an event for is online.
11464 : : *
11465 : : * We use the perf_cpu_context::ctx::mutex to serialize against
11466 : : * the hotplug notifiers. See perf_event_{init,exit}_cpu().
11467 : : */
11468 : 0 : struct perf_cpu_context *cpuctx =
11469 : 0 : container_of(ctx, struct perf_cpu_context, ctx);
11470 : :
11471 [ # # ]: 0 : if (!cpuctx->online) {
11472 : 0 : err = -ENODEV;
11473 : 0 : goto err_locked;
11474 : : }
11475 : : }
11476 : :
11477 [ # # # # : 0 : if (perf_need_aux_event(event) && !perf_get_aux_event(event, group_leader)) {
# # ]
11478 : 0 : err = -EINVAL;
11479 : 0 : goto err_locked;
11480 : : }
11481 : :
11482 : : /*
11483 : : * Must be under the same ctx::mutex as perf_install_in_context(),
11484 : : * because we need to serialize with concurrent event creation.
11485 : : */
11486 [ # # ]: 0 : if (!exclusive_event_installable(event, ctx)) {
11487 : 0 : err = -EBUSY;
11488 : 0 : goto err_locked;
11489 : : }
11490 : :
11491 [ # # ]: 0 : WARN_ON_ONCE(ctx->parent_ctx);
11492 : :
11493 : : /*
11494 : : * This is the point on no return; we cannot fail hereafter. This is
11495 : : * where we start modifying current state.
11496 : : */
11497 : :
11498 [ # # ]: 0 : if (move_group) {
11499 : : /*
11500 : : * See perf_event_ctx_lock() for comments on the details
11501 : : * of swizzling perf_event::ctx.
11502 : : */
11503 : 0 : perf_remove_from_context(group_leader, 0);
11504 : 0 : put_ctx(gctx);
11505 : :
11506 [ # # # # ]: 0 : for_each_sibling_event(sibling, group_leader) {
11507 : 0 : perf_remove_from_context(sibling, 0);
11508 : 0 : put_ctx(gctx);
11509 : : }
11510 : :
11511 : : /*
11512 : : * Wait for everybody to stop referencing the events through
11513 : : * the old lists, before installing it on new lists.
11514 : : */
11515 : 0 : synchronize_rcu();
11516 : :
11517 : : /*
11518 : : * Install the group siblings before the group leader.
11519 : : *
11520 : : * Because a group leader will try and install the entire group
11521 : : * (through the sibling list, which is still in-tact), we can
11522 : : * end up with siblings installed in the wrong context.
11523 : : *
11524 : : * By installing siblings first we NO-OP because they're not
11525 : : * reachable through the group lists.
11526 : : */
11527 [ # # # # ]: 0 : for_each_sibling_event(sibling, group_leader) {
11528 : 0 : perf_event__state_init(sibling);
11529 : 0 : perf_install_in_context(ctx, sibling, sibling->cpu);
11530 : 0 : get_ctx(ctx);
11531 : : }
11532 : :
11533 : : /*
11534 : : * Removing from the context ends up with disabled
11535 : : * event. What we want here is event in the initial
11536 : : * startup state, ready to be add into new context.
11537 : : */
11538 : 0 : perf_event__state_init(group_leader);
11539 : 0 : perf_install_in_context(ctx, group_leader, group_leader->cpu);
11540 : 0 : get_ctx(ctx);
11541 : : }
11542 : :
11543 : : /*
11544 : : * Precalculate sample_data sizes; do while holding ctx::mutex such
11545 : : * that we're serialized against further additions and before
11546 : : * perf_install_in_context() which is the point the event is active and
11547 : : * can use these values.
11548 : : */
11549 : 0 : perf_event__header_size(event);
11550 : 0 : perf_event__id_header_size(event);
11551 : :
11552 : 0 : event->owner = current;
11553 : :
11554 : 0 : perf_install_in_context(ctx, event, event->cpu);
11555 : 0 : perf_unpin_context(ctx);
11556 : :
11557 [ # # ]: 0 : if (move_group)
11558 : 0 : perf_event_ctx_unlock(group_leader, gctx);
11559 : 0 : mutex_unlock(&ctx->mutex);
11560 : :
11561 [ # # ]: 0 : if (task) {
11562 : 0 : mutex_unlock(&task->signal->cred_guard_mutex);
11563 : 0 : put_task_struct(task);
11564 : : }
11565 : :
11566 : 0 : mutex_lock(¤t->perf_event_mutex);
11567 : 0 : list_add_tail(&event->owner_entry, ¤t->perf_event_list);
11568 : 0 : mutex_unlock(¤t->perf_event_mutex);
11569 : :
11570 : : /*
11571 : : * Drop the reference on the group_event after placing the
11572 : : * new event on the sibling_list. This ensures destruction
11573 : : * of the group leader will find the pointer to itself in
11574 : : * perf_group_detach().
11575 : : */
11576 [ # # ]: 0 : fdput(group);
11577 : 0 : fd_install(event_fd, event_file);
11578 : 0 : return event_fd;
11579 : :
11580 : 0 : err_locked:
11581 [ # # ]: 0 : if (move_group)
11582 : 0 : perf_event_ctx_unlock(group_leader, gctx);
11583 : 0 : mutex_unlock(&ctx->mutex);
11584 : : /* err_file: */
11585 : 0 : fput(event_file);
11586 : 0 : err_context:
11587 : 0 : perf_unpin_context(ctx);
11588 : 0 : put_ctx(ctx);
11589 : : err_alloc:
11590 : : /*
11591 : : * If event_file is set, the fput() above will have called ->release()
11592 : : * and that will take care of freeing the event.
11593 : : */
11594 [ # # ]: 0 : if (!event_file)
11595 : 0 : free_event(event);
11596 : 0 : err_cred:
11597 [ # # ]: 0 : if (task)
11598 : 0 : mutex_unlock(&task->signal->cred_guard_mutex);
11599 : 0 : err_task:
11600 [ # # ]: 0 : if (task)
11601 : 0 : put_task_struct(task);
11602 : 0 : err_group_fd:
11603 [ # # ]: 0 : fdput(group);
11604 : 0 : err_fd:
11605 : 0 : put_unused_fd(event_fd);
11606 : 0 : return err;
11607 : : }
11608 : :
11609 : : /**
11610 : : * perf_event_create_kernel_counter
11611 : : *
11612 : : * @attr: attributes of the counter to create
11613 : : * @cpu: cpu in which the counter is bound
11614 : : * @task: task to profile (NULL for percpu)
11615 : : */
11616 : : struct perf_event *
11617 : 0 : perf_event_create_kernel_counter(struct perf_event_attr *attr, int cpu,
11618 : : struct task_struct *task,
11619 : : perf_overflow_handler_t overflow_handler,
11620 : : void *context)
11621 : : {
11622 : 0 : struct perf_event_context *ctx;
11623 : 0 : struct perf_event *event;
11624 : 0 : int err;
11625 : :
11626 : : /*
11627 : : * Grouping is not supported for kernel events, neither is 'AUX',
11628 : : * make sure the caller's intentions are adjusted.
11629 : : */
11630 [ # # ]: 0 : if (attr->aux_output)
11631 : : return ERR_PTR(-EINVAL);
11632 : :
11633 : 0 : event = perf_event_alloc(attr, cpu, task, NULL, NULL,
11634 : : overflow_handler, context, -1);
11635 [ # # ]: 0 : if (IS_ERR(event)) {
11636 : 0 : err = PTR_ERR(event);
11637 : 0 : goto err;
11638 : : }
11639 : :
11640 : : /* Mark owner so we could distinguish it from user events. */
11641 : 0 : event->owner = TASK_TOMBSTONE;
11642 : :
11643 : : /*
11644 : : * Get the target context (task or percpu):
11645 : : */
11646 : 0 : ctx = find_get_context(event->pmu, task, event);
11647 [ # # ]: 0 : if (IS_ERR(ctx)) {
11648 : 0 : err = PTR_ERR(ctx);
11649 : 0 : goto err_free;
11650 : : }
11651 : :
11652 [ # # ]: 0 : WARN_ON_ONCE(ctx->parent_ctx);
11653 : 0 : mutex_lock(&ctx->mutex);
11654 [ # # ]: 0 : if (ctx->task == TASK_TOMBSTONE) {
11655 : 0 : err = -ESRCH;
11656 : 0 : goto err_unlock;
11657 : : }
11658 : :
11659 [ # # ]: 0 : if (!task) {
11660 : : /*
11661 : : * Check if the @cpu we're creating an event for is online.
11662 : : *
11663 : : * We use the perf_cpu_context::ctx::mutex to serialize against
11664 : : * the hotplug notifiers. See perf_event_{init,exit}_cpu().
11665 : : */
11666 : 0 : struct perf_cpu_context *cpuctx =
11667 : 0 : container_of(ctx, struct perf_cpu_context, ctx);
11668 [ # # ]: 0 : if (!cpuctx->online) {
11669 : 0 : err = -ENODEV;
11670 : 0 : goto err_unlock;
11671 : : }
11672 : : }
11673 : :
11674 [ # # ]: 0 : if (!exclusive_event_installable(event, ctx)) {
11675 : 0 : err = -EBUSY;
11676 : 0 : goto err_unlock;
11677 : : }
11678 : :
11679 : 0 : perf_install_in_context(ctx, event, event->cpu);
11680 : 0 : perf_unpin_context(ctx);
11681 : 0 : mutex_unlock(&ctx->mutex);
11682 : :
11683 : 0 : return event;
11684 : :
11685 : 0 : err_unlock:
11686 : 0 : mutex_unlock(&ctx->mutex);
11687 : 0 : perf_unpin_context(ctx);
11688 : 0 : put_ctx(ctx);
11689 : 0 : err_free:
11690 : 0 : free_event(event);
11691 : 0 : err:
11692 : 0 : return ERR_PTR(err);
11693 : : }
11694 : : EXPORT_SYMBOL_GPL(perf_event_create_kernel_counter);
11695 : :
11696 : 0 : void perf_pmu_migrate_context(struct pmu *pmu, int src_cpu, int dst_cpu)
11697 : : {
11698 : 0 : struct perf_event_context *src_ctx;
11699 : 0 : struct perf_event_context *dst_ctx;
11700 : 0 : struct perf_event *event, *tmp;
11701 : 0 : LIST_HEAD(events);
11702 : :
11703 : 0 : src_ctx = &per_cpu_ptr(pmu->pmu_cpu_context, src_cpu)->ctx;
11704 : 0 : dst_ctx = &per_cpu_ptr(pmu->pmu_cpu_context, dst_cpu)->ctx;
11705 : :
11706 : : /*
11707 : : * See perf_event_ctx_lock() for comments on the details
11708 : : * of swizzling perf_event::ctx.
11709 : : */
11710 [ # # ]: 0 : mutex_lock_double(&src_ctx->mutex, &dst_ctx->mutex);
11711 [ # # ]: 0 : list_for_each_entry_safe(event, tmp, &src_ctx->event_list,
11712 : : event_entry) {
11713 : 0 : perf_remove_from_context(event, 0);
11714 : 0 : unaccount_event_cpu(event, src_cpu);
11715 : 0 : put_ctx(src_ctx);
11716 : 0 : list_add(&event->migrate_entry, &events);
11717 : : }
11718 : :
11719 : : /*
11720 : : * Wait for the events to quiesce before re-instating them.
11721 : : */
11722 : 0 : synchronize_rcu();
11723 : :
11724 : : /*
11725 : : * Re-instate events in 2 passes.
11726 : : *
11727 : : * Skip over group leaders and only install siblings on this first
11728 : : * pass, siblings will not get enabled without a leader, however a
11729 : : * leader will enable its siblings, even if those are still on the old
11730 : : * context.
11731 : : */
11732 [ # # ]: 0 : list_for_each_entry_safe(event, tmp, &events, migrate_entry) {
11733 [ # # ]: 0 : if (event->group_leader == event)
11734 : 0 : continue;
11735 : :
11736 [ # # ]: 0 : list_del(&event->migrate_entry);
11737 [ # # ]: 0 : if (event->state >= PERF_EVENT_STATE_OFF)
11738 : 0 : event->state = PERF_EVENT_STATE_INACTIVE;
11739 : 0 : account_event_cpu(event, dst_cpu);
11740 : 0 : perf_install_in_context(dst_ctx, event, dst_cpu);
11741 : 0 : get_ctx(dst_ctx);
11742 : : }
11743 : :
11744 : : /*
11745 : : * Once all the siblings are setup properly, install the group leaders
11746 : : * to make it go.
11747 : : */
11748 [ # # ]: 0 : list_for_each_entry_safe(event, tmp, &events, migrate_entry) {
11749 [ # # ]: 0 : list_del(&event->migrate_entry);
11750 [ # # ]: 0 : if (event->state >= PERF_EVENT_STATE_OFF)
11751 : 0 : event->state = PERF_EVENT_STATE_INACTIVE;
11752 : 0 : account_event_cpu(event, dst_cpu);
11753 : 0 : perf_install_in_context(dst_ctx, event, dst_cpu);
11754 : 0 : get_ctx(dst_ctx);
11755 : : }
11756 : 0 : mutex_unlock(&dst_ctx->mutex);
11757 : 0 : mutex_unlock(&src_ctx->mutex);
11758 : 0 : }
11759 : : EXPORT_SYMBOL_GPL(perf_pmu_migrate_context);
11760 : :
11761 : 0 : static void sync_child_event(struct perf_event *child_event,
11762 : : struct task_struct *child)
11763 : : {
11764 : 0 : struct perf_event *parent_event = child_event->parent;
11765 : 0 : u64 child_val;
11766 : :
11767 [ # # ]: 0 : if (child_event->attr.inherit_stat)
11768 : 0 : perf_event_read_event(child_event, child);
11769 : :
11770 : 0 : child_val = perf_event_count(child_event);
11771 : :
11772 : : /*
11773 : : * Add back the child's count to the parent's count:
11774 : : */
11775 : 0 : atomic64_add(child_val, &parent_event->child_count);
11776 : 0 : atomic64_add(child_event->total_time_enabled,
11777 : : &parent_event->child_total_time_enabled);
11778 : 0 : atomic64_add(child_event->total_time_running,
11779 : : &parent_event->child_total_time_running);
11780 : 0 : }
11781 : :
11782 : : static void
11783 : 0 : perf_event_exit_event(struct perf_event *child_event,
11784 : : struct perf_event_context *child_ctx,
11785 : : struct task_struct *child)
11786 : : {
11787 : 0 : struct perf_event *parent_event = child_event->parent;
11788 : :
11789 : : /*
11790 : : * Do not destroy the 'original' grouping; because of the context
11791 : : * switch optimization the original events could've ended up in a
11792 : : * random child task.
11793 : : *
11794 : : * If we were to destroy the original group, all group related
11795 : : * operations would cease to function properly after this random
11796 : : * child dies.
11797 : : *
11798 : : * Do destroy all inherited groups, we don't care about those
11799 : : * and being thorough is better.
11800 : : */
11801 : 0 : raw_spin_lock_irq(&child_ctx->lock);
11802 [ # # ]: 0 : WARN_ON_ONCE(child_ctx->is_active);
11803 : :
11804 [ # # ]: 0 : if (parent_event)
11805 : 0 : perf_group_detach(child_event);
11806 : 0 : list_del_event(child_event, child_ctx);
11807 : 0 : perf_event_set_state(child_event, PERF_EVENT_STATE_EXIT); /* is_event_hup() */
11808 : 0 : raw_spin_unlock_irq(&child_ctx->lock);
11809 : :
11810 : : /*
11811 : : * Parent events are governed by their filedesc, retain them.
11812 : : */
11813 [ # # ]: 0 : if (!parent_event) {
11814 : 0 : perf_event_wakeup(child_event);
11815 : 0 : return;
11816 : : }
11817 : : /*
11818 : : * Child events can be cleaned up.
11819 : : */
11820 : :
11821 : 0 : sync_child_event(child_event, child);
11822 : :
11823 : : /*
11824 : : * Remove this event from the parent's list
11825 : : */
11826 [ # # ]: 0 : WARN_ON_ONCE(parent_event->ctx->parent_ctx);
11827 : 0 : mutex_lock(&parent_event->child_mutex);
11828 : 0 : list_del_init(&child_event->child_list);
11829 : 0 : mutex_unlock(&parent_event->child_mutex);
11830 : :
11831 : : /*
11832 : : * Kick perf_poll() for is_event_hup().
11833 : : */
11834 : 0 : perf_event_wakeup(parent_event);
11835 : 0 : free_event(child_event);
11836 : 0 : put_event(parent_event);
11837 : : }
11838 : :
11839 : 20384 : static void perf_event_exit_task_context(struct task_struct *child, int ctxn)
11840 : : {
11841 : 20384 : struct perf_event_context *child_ctx, *clone_ctx = NULL;
11842 : 20384 : struct perf_event *child_event, *next;
11843 : :
11844 [ - + ]: 20384 : WARN_ON_ONCE(child != current);
11845 : :
11846 : 20384 : child_ctx = perf_pin_task_context(child, ctxn);
11847 [ - + ]: 20384 : if (!child_ctx)
11848 : : return;
11849 : :
11850 : : /*
11851 : : * In order to reduce the amount of tricky in ctx tear-down, we hold
11852 : : * ctx::mutex over the entire thing. This serializes against almost
11853 : : * everything that wants to access the ctx.
11854 : : *
11855 : : * The exception is sys_perf_event_open() /
11856 : : * perf_event_create_kernel_count() which does find_get_context()
11857 : : * without ctx::mutex (it cannot because of the move_group double mutex
11858 : : * lock thing). See the comments in perf_install_in_context().
11859 : : */
11860 : 0 : mutex_lock(&child_ctx->mutex);
11861 : :
11862 : : /*
11863 : : * In a single ctx::lock section, de-schedule the events and detach the
11864 : : * context from the task such that we cannot ever get it scheduled back
11865 : : * in.
11866 : : */
11867 : 0 : raw_spin_lock_irq(&child_ctx->lock);
11868 : 0 : task_ctx_sched_out(__get_cpu_context(child_ctx), child_ctx, EVENT_ALL);
11869 : :
11870 : : /*
11871 : : * Now that the context is inactive, destroy the task <-> ctx relation
11872 : : * and mark the context dead.
11873 : : */
11874 : 0 : RCU_INIT_POINTER(child->perf_event_ctxp[ctxn], NULL);
11875 : 0 : put_ctx(child_ctx); /* cannot be last */
11876 : 0 : WRITE_ONCE(child_ctx->task, TASK_TOMBSTONE);
11877 : 0 : put_task_struct(current); /* cannot be last */
11878 : :
11879 [ # # ]: 0 : clone_ctx = unclone_ctx(child_ctx);
11880 : 0 : raw_spin_unlock_irq(&child_ctx->lock);
11881 : :
11882 [ # # ]: 0 : if (clone_ctx)
11883 : 0 : put_ctx(clone_ctx);
11884 : :
11885 : : /*
11886 : : * Report the task dead after unscheduling the events so that we
11887 : : * won't get any samples after PERF_RECORD_EXIT. We can however still
11888 : : * get a few PERF_RECORD_READ events.
11889 : : */
11890 : 0 : perf_event_task(child, child_ctx, 0);
11891 : :
11892 [ # # ]: 0 : list_for_each_entry_safe(child_event, next, &child_ctx->event_list, event_entry)
11893 : 0 : perf_event_exit_event(child_event, child_ctx, child);
11894 : :
11895 : 0 : mutex_unlock(&child_ctx->mutex);
11896 : :
11897 : 0 : put_ctx(child_ctx);
11898 : : }
11899 : :
11900 : : /*
11901 : : * When a child task exits, feed back event values to parent events.
11902 : : *
11903 : : * Can be called with cred_guard_mutex held when called from
11904 : : * install_exec_creds().
11905 : : */
11906 : 10192 : void perf_event_exit_task(struct task_struct *child)
11907 : : {
11908 : 10192 : struct perf_event *event, *tmp;
11909 : 10192 : int ctxn;
11910 : :
11911 : 10192 : mutex_lock(&child->perf_event_mutex);
11912 [ - + ]: 10192 : list_for_each_entry_safe(event, tmp, &child->perf_event_list,
11913 : : owner_entry) {
11914 : 0 : list_del_init(&event->owner_entry);
11915 : :
11916 : : /*
11917 : : * Ensure the list deletion is visible before we clear
11918 : : * the owner, closes a race against perf_release() where
11919 : : * we need to serialize on the owner->perf_event_mutex.
11920 : : */
11921 : 0 : smp_store_release(&event->owner, NULL);
11922 : : }
11923 : 10192 : mutex_unlock(&child->perf_event_mutex);
11924 : :
11925 [ + + ]: 40768 : for_each_task_context_nr(ctxn)
11926 : 20384 : perf_event_exit_task_context(child, ctxn);
11927 : :
11928 : : /*
11929 : : * The perf_event_exit_task_context calls perf_event_task
11930 : : * with child's task_ctx, which generates EXIT events for
11931 : : * child contexts and sets child->perf_event_ctxp[] to NULL.
11932 : : * At this point we need to send EXIT events to cpu contexts.
11933 : : */
11934 : 10192 : perf_event_task(child, NULL, 0);
11935 : 10192 : }
11936 : :
11937 : 0 : static void perf_free_event(struct perf_event *event,
11938 : : struct perf_event_context *ctx)
11939 : : {
11940 : 0 : struct perf_event *parent = event->parent;
11941 : :
11942 [ # # # # ]: 0 : if (WARN_ON_ONCE(!parent))
11943 : : return;
11944 : :
11945 : 0 : mutex_lock(&parent->child_mutex);
11946 : 0 : list_del_init(&event->child_list);
11947 : 0 : mutex_unlock(&parent->child_mutex);
11948 : :
11949 : 0 : put_event(parent);
11950 : :
11951 : 0 : raw_spin_lock_irq(&ctx->lock);
11952 : 0 : perf_group_detach(event);
11953 : 0 : list_del_event(event, ctx);
11954 : 0 : raw_spin_unlock_irq(&ctx->lock);
11955 : 0 : free_event(event);
11956 : : }
11957 : :
11958 : : /*
11959 : : * Free a context as created by inheritance by perf_event_init_task() below,
11960 : : * used by fork() in case of fail.
11961 : : *
11962 : : * Even though the task has never lived, the context and events have been
11963 : : * exposed through the child_list, so we must take care tearing it all down.
11964 : : */
11965 : 0 : void perf_event_free_task(struct task_struct *task)
11966 : : {
11967 : 0 : struct perf_event_context *ctx;
11968 : 0 : struct perf_event *event, *tmp;
11969 : 0 : int ctxn;
11970 : :
11971 [ # # ]: 0 : for_each_task_context_nr(ctxn) {
11972 : 0 : ctx = task->perf_event_ctxp[ctxn];
11973 [ # # ]: 0 : if (!ctx)
11974 : 0 : continue;
11975 : :
11976 : 0 : mutex_lock(&ctx->mutex);
11977 : 0 : raw_spin_lock_irq(&ctx->lock);
11978 : : /*
11979 : : * Destroy the task <-> ctx relation and mark the context dead.
11980 : : *
11981 : : * This is important because even though the task hasn't been
11982 : : * exposed yet the context has been (through child_list).
11983 : : */
11984 : 0 : RCU_INIT_POINTER(task->perf_event_ctxp[ctxn], NULL);
11985 : 0 : WRITE_ONCE(ctx->task, TASK_TOMBSTONE);
11986 : 0 : put_task_struct(task); /* cannot be last */
11987 : 0 : raw_spin_unlock_irq(&ctx->lock);
11988 : :
11989 [ # # ]: 0 : list_for_each_entry_safe(event, tmp, &ctx->event_list, event_entry)
11990 : 0 : perf_free_event(event, ctx);
11991 : :
11992 : 0 : mutex_unlock(&ctx->mutex);
11993 : :
11994 : : /*
11995 : : * perf_event_release_kernel() could've stolen some of our
11996 : : * child events and still have them on its free_list. In that
11997 : : * case we must wait for these events to have been freed (in
11998 : : * particular all their references to this task must've been
11999 : : * dropped).
12000 : : *
12001 : : * Without this copy_process() will unconditionally free this
12002 : : * task (irrespective of its reference count) and
12003 : : * _free_event()'s put_task_struct(event->hw.target) will be a
12004 : : * use-after-free.
12005 : : *
12006 : : * Wait for all events to drop their context reference.
12007 : : */
12008 [ # # # # ]: 0 : wait_var_event(&ctx->refcount, refcount_read(&ctx->refcount) == 1);
12009 : 0 : put_ctx(ctx); /* must be last */
12010 : : }
12011 : 0 : }
12012 : :
12013 : 10157 : void perf_event_delayed_put(struct task_struct *task)
12014 : : {
12015 : 10157 : int ctxn;
12016 : :
12017 [ + + ]: 30471 : for_each_task_context_nr(ctxn)
12018 [ - + ]: 20314 : WARN_ON_ONCE(task->perf_event_ctxp[ctxn]);
12019 : 10157 : }
12020 : :
12021 : 0 : struct file *perf_event_get(unsigned int fd)
12022 : : {
12023 : 0 : struct file *file = fget(fd);
12024 [ # # ]: 0 : if (!file)
12025 : : return ERR_PTR(-EBADF);
12026 : :
12027 [ # # ]: 0 : if (file->f_op != &perf_fops) {
12028 : 0 : fput(file);
12029 : 0 : return ERR_PTR(-EBADF);
12030 : : }
12031 : :
12032 : : return file;
12033 : : }
12034 : :
12035 : 0 : const struct perf_event *perf_get_event(struct file *file)
12036 : : {
12037 [ # # ]: 0 : if (file->f_op != &perf_fops)
12038 : : return ERR_PTR(-EINVAL);
12039 : :
12040 : 0 : return file->private_data;
12041 : : }
12042 : :
12043 : 0 : const struct perf_event_attr *perf_event_attrs(struct perf_event *event)
12044 : : {
12045 [ # # ]: 0 : if (!event)
12046 : : return ERR_PTR(-EINVAL);
12047 : :
12048 : 0 : return &event->attr;
12049 : : }
12050 : :
12051 : : /*
12052 : : * Inherit an event from parent task to child task.
12053 : : *
12054 : : * Returns:
12055 : : * - valid pointer on success
12056 : : * - NULL for orphaned events
12057 : : * - IS_ERR() on error
12058 : : */
12059 : : static struct perf_event *
12060 : : inherit_event(struct perf_event *parent_event,
12061 : : struct task_struct *parent,
12062 : : struct perf_event_context *parent_ctx,
12063 : : struct task_struct *child,
12064 : : struct perf_event *group_leader,
12065 : : struct perf_event_context *child_ctx)
12066 : : {
12067 : : enum perf_event_state parent_state = parent_event->state;
12068 : : struct perf_event *child_event;
12069 : : unsigned long flags;
12070 : :
12071 : : /*
12072 : : * Instead of creating recursive hierarchies of events,
12073 : : * we link inherited events back to the original parent,
12074 : : * which has a filp for sure, which we use as the reference
12075 : : * count:
12076 : : */
12077 : : if (parent_event->parent)
12078 : : parent_event = parent_event->parent;
12079 : :
12080 : : child_event = perf_event_alloc(&parent_event->attr,
12081 : : parent_event->cpu,
12082 : : child,
12083 : : group_leader, parent_event,
12084 : : NULL, NULL, -1);
12085 : : if (IS_ERR(child_event))
12086 : : return child_event;
12087 : :
12088 : :
12089 : : if ((child_event->attach_state & PERF_ATTACH_TASK_DATA) &&
12090 : : !child_ctx->task_ctx_data) {
12091 : : struct pmu *pmu = child_event->pmu;
12092 : :
12093 : : child_ctx->task_ctx_data = kzalloc(pmu->task_ctx_size,
12094 : : GFP_KERNEL);
12095 : : if (!child_ctx->task_ctx_data) {
12096 : : free_event(child_event);
12097 : : return ERR_PTR(-ENOMEM);
12098 : : }
12099 : : }
12100 : :
12101 : : /*
12102 : : * is_orphaned_event() and list_add_tail(&parent_event->child_list)
12103 : : * must be under the same lock in order to serialize against
12104 : : * perf_event_release_kernel(), such that either we must observe
12105 : : * is_orphaned_event() or they will observe us on the child_list.
12106 : : */
12107 : : mutex_lock(&parent_event->child_mutex);
12108 : : if (is_orphaned_event(parent_event) ||
12109 : : !atomic_long_inc_not_zero(&parent_event->refcount)) {
12110 : : mutex_unlock(&parent_event->child_mutex);
12111 : : /* task_ctx_data is freed with child_ctx */
12112 : : free_event(child_event);
12113 : : return NULL;
12114 : : }
12115 : :
12116 : : get_ctx(child_ctx);
12117 : :
12118 : : /*
12119 : : * Make the child state follow the state of the parent event,
12120 : : * not its attr.disabled bit. We hold the parent's mutex,
12121 : : * so we won't race with perf_event_{en, dis}able_family.
12122 : : */
12123 : : if (parent_state >= PERF_EVENT_STATE_INACTIVE)
12124 : : child_event->state = PERF_EVENT_STATE_INACTIVE;
12125 : : else
12126 : : child_event->state = PERF_EVENT_STATE_OFF;
12127 : :
12128 : : if (parent_event->attr.freq) {
12129 : : u64 sample_period = parent_event->hw.sample_period;
12130 : : struct hw_perf_event *hwc = &child_event->hw;
12131 : :
12132 : : hwc->sample_period = sample_period;
12133 : : hwc->last_period = sample_period;
12134 : :
12135 : : local64_set(&hwc->period_left, sample_period);
12136 : : }
12137 : :
12138 : : child_event->ctx = child_ctx;
12139 : : child_event->overflow_handler = parent_event->overflow_handler;
12140 : : child_event->overflow_handler_context
12141 : : = parent_event->overflow_handler_context;
12142 : :
12143 : : /*
12144 : : * Precalculate sample_data sizes
12145 : : */
12146 : : perf_event__header_size(child_event);
12147 : : perf_event__id_header_size(child_event);
12148 : :
12149 : : /*
12150 : : * Link it up in the child's context:
12151 : : */
12152 : : raw_spin_lock_irqsave(&child_ctx->lock, flags);
12153 : : add_event_to_ctx(child_event, child_ctx);
12154 : : raw_spin_unlock_irqrestore(&child_ctx->lock, flags);
12155 : :
12156 : : /*
12157 : : * Link this into the parent event's child list
12158 : : */
12159 : : list_add_tail(&child_event->child_list, &parent_event->child_list);
12160 : : mutex_unlock(&parent_event->child_mutex);
12161 : :
12162 : : return child_event;
12163 : : }
12164 : :
12165 : : /*
12166 : : * Inherits an event group.
12167 : : *
12168 : : * This will quietly suppress orphaned events; !inherit_event() is not an error.
12169 : : * This matches with perf_event_release_kernel() removing all child events.
12170 : : *
12171 : : * Returns:
12172 : : * - 0 on success
12173 : : * - <0 on error
12174 : : */
12175 : : static int inherit_group(struct perf_event *parent_event,
12176 : : struct task_struct *parent,
12177 : : struct perf_event_context *parent_ctx,
12178 : : struct task_struct *child,
12179 : : struct perf_event_context *child_ctx)
12180 : : {
12181 : : struct perf_event *leader;
12182 : : struct perf_event *sub;
12183 : : struct perf_event *child_ctr;
12184 : :
12185 : : leader = inherit_event(parent_event, parent, parent_ctx,
12186 : : child, NULL, child_ctx);
12187 : : if (IS_ERR(leader))
12188 : : return PTR_ERR(leader);
12189 : : /*
12190 : : * @leader can be NULL here because of is_orphaned_event(). In this
12191 : : * case inherit_event() will create individual events, similar to what
12192 : : * perf_group_detach() would do anyway.
12193 : : */
12194 : : for_each_sibling_event(sub, parent_event) {
12195 : : child_ctr = inherit_event(sub, parent, parent_ctx,
12196 : : child, leader, child_ctx);
12197 : : if (IS_ERR(child_ctr))
12198 : : return PTR_ERR(child_ctr);
12199 : :
12200 : : if (sub->aux_event == parent_event && child_ctr &&
12201 : : !perf_get_aux_event(child_ctr, leader))
12202 : : return -EINVAL;
12203 : : }
12204 : : return 0;
12205 : : }
12206 : :
12207 : : /*
12208 : : * Creates the child task context and tries to inherit the event-group.
12209 : : *
12210 : : * Clears @inherited_all on !attr.inherited or error. Note that we'll leave
12211 : : * inherited_all set when we 'fail' to inherit an orphaned event; this is
12212 : : * consistent with perf_event_release_kernel() removing all child events.
12213 : : *
12214 : : * Returns:
12215 : : * - 0 on success
12216 : : * - <0 on error
12217 : : */
12218 : : static int
12219 : : inherit_task_group(struct perf_event *event, struct task_struct *parent,
12220 : : struct perf_event_context *parent_ctx,
12221 : : struct task_struct *child, int ctxn,
12222 : : int *inherited_all)
12223 : : {
12224 : : int ret;
12225 : : struct perf_event_context *child_ctx;
12226 : :
12227 : : if (!event->attr.inherit) {
12228 : : *inherited_all = 0;
12229 : : return 0;
12230 : : }
12231 : :
12232 : : child_ctx = child->perf_event_ctxp[ctxn];
12233 : : if (!child_ctx) {
12234 : : /*
12235 : : * This is executed from the parent task context, so
12236 : : * inherit events that have been marked for cloning.
12237 : : * First allocate and initialize a context for the
12238 : : * child.
12239 : : */
12240 : : child_ctx = alloc_perf_context(parent_ctx->pmu, child);
12241 : : if (!child_ctx)
12242 : : return -ENOMEM;
12243 : :
12244 : : child->perf_event_ctxp[ctxn] = child_ctx;
12245 : : }
12246 : :
12247 : : ret = inherit_group(event, parent, parent_ctx,
12248 : : child, child_ctx);
12249 : :
12250 : : if (ret)
12251 : : *inherited_all = 0;
12252 : :
12253 : : return ret;
12254 : : }
12255 : :
12256 : : /*
12257 : : * Initialize the perf_event context in task_struct
12258 : : */
12259 : 22252 : static int perf_event_init_context(struct task_struct *child, int ctxn)
12260 : : {
12261 : 22252 : struct perf_event_context *child_ctx, *parent_ctx;
12262 : 22252 : struct perf_event_context *cloned_ctx;
12263 : 22252 : struct perf_event *event;
12264 [ - + ]: 22252 : struct task_struct *parent = current;
12265 : 22252 : int inherited_all = 1;
12266 : 22252 : unsigned long flags;
12267 : 22252 : int ret = 0;
12268 : :
12269 [ - + ]: 22252 : if (likely(!parent->perf_event_ctxp[ctxn]))
12270 : : return 0;
12271 : :
12272 : : /*
12273 : : * If the parent's context is a clone, pin it so it won't get
12274 : : * swapped under us.
12275 : : */
12276 : 0 : parent_ctx = perf_pin_task_context(parent, ctxn);
12277 [ # # ]: 0 : if (!parent_ctx)
12278 : : return 0;
12279 : :
12280 : : /*
12281 : : * No need to check if parent_ctx != NULL here; since we saw
12282 : : * it non-NULL earlier, the only reason for it to become NULL
12283 : : * is if we exit, and since we're currently in the middle of
12284 : : * a fork we can't be exiting at the same time.
12285 : : */
12286 : :
12287 : : /*
12288 : : * Lock the parent list. No need to lock the child - not PID
12289 : : * hashed yet and not running, so nobody can access it.
12290 : : */
12291 : 0 : mutex_lock(&parent_ctx->mutex);
12292 : :
12293 : : /*
12294 : : * We dont have to disable NMIs - we are only looking at
12295 : : * the list, not manipulating it:
12296 : : */
12297 [ # # # # : 0 : perf_event_groups_for_each(event, &parent_ctx->pinned_groups) {
# # ]
12298 : 0 : ret = inherit_task_group(event, parent, parent_ctx,
12299 : : child, ctxn, &inherited_all);
12300 [ # # ]: 0 : if (ret)
12301 : 0 : goto out_unlock;
12302 : : }
12303 : :
12304 : : /*
12305 : : * We can't hold ctx->lock when iterating the ->flexible_group list due
12306 : : * to allocations, but we need to prevent rotation because
12307 : : * rotate_ctx() will change the list from interrupt context.
12308 : : */
12309 : 0 : raw_spin_lock_irqsave(&parent_ctx->lock, flags);
12310 : 0 : parent_ctx->rotate_disable = 1;
12311 : 0 : raw_spin_unlock_irqrestore(&parent_ctx->lock, flags);
12312 : :
12313 [ # # # # : 0 : perf_event_groups_for_each(event, &parent_ctx->flexible_groups) {
# # ]
12314 : 0 : ret = inherit_task_group(event, parent, parent_ctx,
12315 : : child, ctxn, &inherited_all);
12316 [ # # ]: 0 : if (ret)
12317 : 0 : goto out_unlock;
12318 : : }
12319 : :
12320 : 0 : raw_spin_lock_irqsave(&parent_ctx->lock, flags);
12321 : 0 : parent_ctx->rotate_disable = 0;
12322 : :
12323 : 0 : child_ctx = child->perf_event_ctxp[ctxn];
12324 : :
12325 [ # # # # ]: 0 : if (child_ctx && inherited_all) {
12326 : : /*
12327 : : * Mark the child context as a clone of the parent
12328 : : * context, or of whatever the parent is a clone of.
12329 : : *
12330 : : * Note that if the parent is a clone, the holding of
12331 : : * parent_ctx->lock avoids it from being uncloned.
12332 : : */
12333 : 0 : cloned_ctx = parent_ctx->parent_ctx;
12334 [ # # ]: 0 : if (cloned_ctx) {
12335 : 0 : child_ctx->parent_ctx = cloned_ctx;
12336 : 0 : child_ctx->parent_gen = parent_ctx->parent_gen;
12337 : : } else {
12338 : 0 : child_ctx->parent_ctx = parent_ctx;
12339 : 0 : child_ctx->parent_gen = parent_ctx->generation;
12340 : : }
12341 : 0 : get_ctx(child_ctx->parent_ctx);
12342 : : }
12343 : :
12344 : 0 : raw_spin_unlock_irqrestore(&parent_ctx->lock, flags);
12345 : 0 : out_unlock:
12346 : 0 : mutex_unlock(&parent_ctx->mutex);
12347 : :
12348 : 0 : perf_unpin_context(parent_ctx);
12349 : 0 : put_ctx(parent_ctx);
12350 : :
12351 : 0 : return ret;
12352 : : }
12353 : :
12354 : : /*
12355 : : * Initialize the perf_event context in task_struct
12356 : : */
12357 : 11126 : int perf_event_init_task(struct task_struct *child)
12358 : : {
12359 : 11126 : int ctxn, ret;
12360 : :
12361 : 11126 : memset(child->perf_event_ctxp, 0, sizeof(child->perf_event_ctxp));
12362 : 11126 : mutex_init(&child->perf_event_mutex);
12363 : 11126 : INIT_LIST_HEAD(&child->perf_event_list);
12364 : :
12365 [ + + ]: 33378 : for_each_task_context_nr(ctxn) {
12366 : 22252 : ret = perf_event_init_context(child, ctxn);
12367 [ - + ]: 22252 : if (ret) {
12368 : 0 : perf_event_free_task(child);
12369 : 0 : return ret;
12370 : : }
12371 : : }
12372 : :
12373 : : return 0;
12374 : : }
12375 : :
12376 : 13 : static void __init perf_event_init_all_cpus(void)
12377 : : {
12378 : 13 : struct swevent_htable *swhash;
12379 : 13 : int cpu;
12380 : :
12381 : 13 : zalloc_cpumask_var(&perf_online_mask, GFP_KERNEL);
12382 : :
12383 [ + + ]: 26 : for_each_possible_cpu(cpu) {
12384 : 13 : swhash = &per_cpu(swevent_htable, cpu);
12385 : 13 : mutex_init(&swhash->hlist_mutex);
12386 : 13 : INIT_LIST_HEAD(&per_cpu(active_ctx_list, cpu));
12387 : :
12388 : 13 : INIT_LIST_HEAD(&per_cpu(pmu_sb_events.list, cpu));
12389 : 13 : raw_spin_lock_init(&per_cpu(pmu_sb_events.lock, cpu));
12390 : :
12391 : : #ifdef CONFIG_CGROUP_PERF
12392 : : INIT_LIST_HEAD(&per_cpu(cgrp_cpuctx_list, cpu));
12393 : : #endif
12394 : 13 : INIT_LIST_HEAD(&per_cpu(sched_cb_list, cpu));
12395 : : }
12396 : 13 : }
12397 : :
12398 : 13 : static void perf_swevent_init_cpu(unsigned int cpu)
12399 : : {
12400 : 13 : struct swevent_htable *swhash = &per_cpu(swevent_htable, cpu);
12401 : :
12402 : 13 : mutex_lock(&swhash->hlist_mutex);
12403 [ - + - - ]: 13 : if (swhash->hlist_refcount > 0 && !swevent_hlist_deref(swhash)) {
12404 : 0 : struct swevent_hlist *hlist;
12405 : :
12406 : 0 : hlist = kzalloc_node(sizeof(*hlist), GFP_KERNEL, cpu_to_node(cpu));
12407 [ # # ]: 0 : WARN_ON(!hlist);
12408 : 0 : rcu_assign_pointer(swhash->swevent_hlist, hlist);
12409 : : }
12410 : 13 : mutex_unlock(&swhash->hlist_mutex);
12411 : 13 : }
12412 : :
12413 : : #if defined CONFIG_HOTPLUG_CPU || defined CONFIG_KEXEC_CORE
12414 : 0 : static void __perf_event_exit_context(void *__info)
12415 : : {
12416 : 0 : struct perf_event_context *ctx = __info;
12417 : 0 : struct perf_cpu_context *cpuctx = __get_cpu_context(ctx);
12418 : 0 : struct perf_event *event;
12419 : :
12420 : 0 : raw_spin_lock(&ctx->lock);
12421 : 0 : ctx_sched_out(ctx, cpuctx, EVENT_TIME);
12422 [ # # ]: 0 : list_for_each_entry(event, &ctx->event_list, event_entry)
12423 : 0 : __perf_remove_from_context(event, cpuctx, ctx, (void *)DETACH_GROUP);
12424 : 0 : raw_spin_unlock(&ctx->lock);
12425 : 0 : }
12426 : :
12427 : 0 : static void perf_event_exit_cpu_context(int cpu)
12428 : : {
12429 : 0 : struct perf_cpu_context *cpuctx;
12430 : 0 : struct perf_event_context *ctx;
12431 : 0 : struct pmu *pmu;
12432 : :
12433 : 0 : mutex_lock(&pmus_lock);
12434 [ # # ]: 0 : list_for_each_entry(pmu, &pmus, entry) {
12435 : 0 : cpuctx = per_cpu_ptr(pmu->pmu_cpu_context, cpu);
12436 : 0 : ctx = &cpuctx->ctx;
12437 : :
12438 : 0 : mutex_lock(&ctx->mutex);
12439 : 0 : smp_call_function_single(cpu, __perf_event_exit_context, ctx, 1);
12440 : 0 : cpuctx->online = 0;
12441 : 0 : mutex_unlock(&ctx->mutex);
12442 : : }
12443 : 0 : cpumask_clear_cpu(cpu, perf_online_mask);
12444 : 0 : mutex_unlock(&pmus_lock);
12445 : 0 : }
12446 : : #else
12447 : :
12448 : : static void perf_event_exit_cpu_context(int cpu) { }
12449 : :
12450 : : #endif
12451 : :
12452 : 13 : int perf_event_init_cpu(unsigned int cpu)
12453 : : {
12454 : 13 : struct perf_cpu_context *cpuctx;
12455 : 13 : struct perf_event_context *ctx;
12456 : 13 : struct pmu *pmu;
12457 : :
12458 : 13 : perf_swevent_init_cpu(cpu);
12459 : :
12460 : 13 : mutex_lock(&pmus_lock);
12461 : 13 : cpumask_set_cpu(cpu, perf_online_mask);
12462 [ + + ]: 91 : list_for_each_entry(pmu, &pmus, entry) {
12463 : 78 : cpuctx = per_cpu_ptr(pmu->pmu_cpu_context, cpu);
12464 : 78 : ctx = &cpuctx->ctx;
12465 : :
12466 : 78 : mutex_lock(&ctx->mutex);
12467 : 78 : cpuctx->online = 1;
12468 : 78 : mutex_unlock(&ctx->mutex);
12469 : : }
12470 : 13 : mutex_unlock(&pmus_lock);
12471 : :
12472 : 13 : return 0;
12473 : : }
12474 : :
12475 : 0 : int perf_event_exit_cpu(unsigned int cpu)
12476 : : {
12477 : 0 : perf_event_exit_cpu_context(cpu);
12478 : 0 : return 0;
12479 : : }
12480 : :
12481 : : static int
12482 : 0 : perf_reboot(struct notifier_block *notifier, unsigned long val, void *v)
12483 : : {
12484 : 0 : int cpu;
12485 : :
12486 [ # # ]: 0 : for_each_online_cpu(cpu)
12487 : 0 : perf_event_exit_cpu(cpu);
12488 : :
12489 : 0 : return NOTIFY_OK;
12490 : : }
12491 : :
12492 : : /*
12493 : : * Run the perf reboot notifier at the very last possible moment so that
12494 : : * the generic watchdog code runs as long as possible.
12495 : : */
12496 : : static struct notifier_block perf_reboot_notifier = {
12497 : : .notifier_call = perf_reboot,
12498 : : .priority = INT_MIN,
12499 : : };
12500 : :
12501 : 13 : void __init perf_event_init(void)
12502 : : {
12503 : 13 : int ret;
12504 : :
12505 : 13 : idr_init(&pmu_idr);
12506 : :
12507 : 13 : perf_event_init_all_cpus();
12508 : 13 : init_srcu_struct(&pmus_srcu);
12509 : 13 : perf_pmu_register(&perf_swevent, "software", PERF_TYPE_SOFTWARE);
12510 : 13 : perf_pmu_register(&perf_cpu_clock, NULL, -1);
12511 : 13 : perf_pmu_register(&perf_task_clock, NULL, -1);
12512 : 13 : perf_tp_register();
12513 : 13 : perf_event_init_cpu(smp_processor_id());
12514 : 13 : register_reboot_notifier(&perf_reboot_notifier);
12515 : :
12516 : 13 : ret = init_hw_breakpoint();
12517 [ - + ]: 13 : WARN(ret, "hw_breakpoint initialization failed with: %d", ret);
12518 : :
12519 : : /*
12520 : : * Build time assertion that we keep the data_head at the intended
12521 : : * location. IOW, validation we got the __reserved[] size right.
12522 : : */
12523 : 13 : BUILD_BUG_ON((offsetof(struct perf_event_mmap_page, data_head))
12524 : : != 1024);
12525 : 13 : }
12526 : :
12527 : 0 : ssize_t perf_event_sysfs_show(struct device *dev, struct device_attribute *attr,
12528 : : char *page)
12529 : : {
12530 : 0 : struct perf_pmu_events_attr *pmu_attr =
12531 : 0 : container_of(attr, struct perf_pmu_events_attr, attr);
12532 : :
12533 [ # # ]: 0 : if (pmu_attr->event_str)
12534 : 0 : return sprintf(page, "%s\n", pmu_attr->event_str);
12535 : :
12536 : : return 0;
12537 : : }
12538 : : EXPORT_SYMBOL_GPL(perf_event_sysfs_show);
12539 : :
12540 : 13 : static int __init perf_event_sysfs_init(void)
12541 : : {
12542 : 13 : struct pmu *pmu;
12543 : 13 : int ret;
12544 : :
12545 : 13 : mutex_lock(&pmus_lock);
12546 : :
12547 : 13 : ret = bus_register(&pmu_bus);
12548 [ - + ]: 13 : if (ret)
12549 : 0 : goto unlock;
12550 : :
12551 [ + + ]: 130 : list_for_each_entry(pmu, &pmus, entry) {
12552 [ + + - + ]: 117 : if (!pmu->name || pmu->type < 0)
12553 : 26 : continue;
12554 : :
12555 : 91 : ret = pmu_dev_alloc(pmu);
12556 [ - + ]: 91 : WARN(ret, "Failed to register pmu: %s, reason %d\n", pmu->name, ret);
12557 : : }
12558 : 13 : pmu_bus_running = 1;
12559 : 13 : ret = 0;
12560 : :
12561 : 13 : unlock:
12562 : 13 : mutex_unlock(&pmus_lock);
12563 : :
12564 : 13 : return ret;
12565 : : }
12566 : : device_initcall(perf_event_sysfs_init);
12567 : :
12568 : : #ifdef CONFIG_CGROUP_PERF
12569 : : static struct cgroup_subsys_state *
12570 : : perf_cgroup_css_alloc(struct cgroup_subsys_state *parent_css)
12571 : : {
12572 : : struct perf_cgroup *jc;
12573 : :
12574 : : jc = kzalloc(sizeof(*jc), GFP_KERNEL);
12575 : : if (!jc)
12576 : : return ERR_PTR(-ENOMEM);
12577 : :
12578 : : jc->info = alloc_percpu(struct perf_cgroup_info);
12579 : : if (!jc->info) {
12580 : : kfree(jc);
12581 : : return ERR_PTR(-ENOMEM);
12582 : : }
12583 : :
12584 : : return &jc->css;
12585 : : }
12586 : :
12587 : : static void perf_cgroup_css_free(struct cgroup_subsys_state *css)
12588 : : {
12589 : : struct perf_cgroup *jc = container_of(css, struct perf_cgroup, css);
12590 : :
12591 : : free_percpu(jc->info);
12592 : : kfree(jc);
12593 : : }
12594 : :
12595 : : static int __perf_cgroup_move(void *info)
12596 : : {
12597 : : struct task_struct *task = info;
12598 : : rcu_read_lock();
12599 : : perf_cgroup_switch(task, PERF_CGROUP_SWOUT | PERF_CGROUP_SWIN);
12600 : : rcu_read_unlock();
12601 : : return 0;
12602 : : }
12603 : :
12604 : : static void perf_cgroup_attach(struct cgroup_taskset *tset)
12605 : : {
12606 : : struct task_struct *task;
12607 : : struct cgroup_subsys_state *css;
12608 : :
12609 : : cgroup_taskset_for_each(task, css, tset)
12610 : : task_function_call(task, __perf_cgroup_move, task);
12611 : : }
12612 : :
12613 : : struct cgroup_subsys perf_event_cgrp_subsys = {
12614 : : .css_alloc = perf_cgroup_css_alloc,
12615 : : .css_free = perf_cgroup_css_free,
12616 : : .attach = perf_cgroup_attach,
12617 : : /*
12618 : : * Implicitly enable on dfl hierarchy so that perf events can
12619 : : * always be filtered by cgroup2 path as long as perf_event
12620 : : * controller is not mounted on a legacy hierarchy.
12621 : : */
12622 : : .implicit_on_dfl = true,
12623 : : .threaded = true,
12624 : : };
12625 : : #endif /* CONFIG_CGROUP_PERF */
|
