Merge branch 'work.misc' of git://git.kernel.org/pub/scm/linux/kernel/git/viro/vfs
[muen/linux.git] / kernel / events / core.c
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 static void remote_function(void *data)
67 {
68         struct remote_function_call *tfc = data;
69         struct task_struct *p = tfc->p;
70
71         if (p) {
72                 /* -EAGAIN */
73                 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                 tfc->ret = -ESRCH; /* No such (running) process */
82                 if (p != current)
83                         return;
84         }
85
86         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 task_function_call(struct task_struct *p, remote_function_f func, void *info)
104 {
105         struct remote_function_call data = {
106                 .p      = p,
107                 .func   = func,
108                 .info   = info,
109                 .ret    = -EAGAIN,
110         };
111         int ret;
112
113         do {
114                 ret = smp_call_function_single(task_cpu(p), remote_function, &data, 1);
115                 if (!ret)
116                         ret = data.ret;
117         } while (ret == -EAGAIN);
118
119         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 static int cpu_function_call(int cpu, remote_function_f func, void *info)
132 {
133         struct remote_function_call data = {
134                 .p      = NULL,
135                 .func   = func,
136                 .info   = info,
137                 .ret    = -ENXIO, /* No such CPU */
138         };
139
140         smp_call_function_single(cpu, remote_function, &data, 1);
141
142         return data.ret;
143 }
144
145 static inline struct perf_cpu_context *
146 __get_cpu_context(struct perf_event_context *ctx)
147 {
148         return this_cpu_ptr(ctx->pmu->pmu_cpu_context);
149 }
150
151 static void perf_ctx_lock(struct perf_cpu_context *cpuctx,
152                           struct perf_event_context *ctx)
153 {
154         raw_spin_lock(&cpuctx->ctx.lock);
155         if (ctx)
156                 raw_spin_lock(&ctx->lock);
157 }
158
159 static void perf_ctx_unlock(struct perf_cpu_context *cpuctx,
160                             struct perf_event_context *ctx)
161 {
162         if (ctx)
163                 raw_spin_unlock(&ctx->lock);
164         raw_spin_unlock(&cpuctx->ctx.lock);
165 }
166
167 #define TASK_TOMBSTONE ((void *)-1L)
168
169 static bool is_kernel_event(struct perf_event *event)
170 {
171         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 static int event_function(void *info)
203 {
204         struct event_function_struct *efs = info;
205         struct perf_event *event = efs->event;
206         struct perf_event_context *ctx = event->ctx;
207         struct perf_cpu_context *cpuctx = __get_cpu_context(ctx);
208         struct perf_event_context *task_ctx = cpuctx->task_ctx;
209         int ret = 0;
210
211         lockdep_assert_irqs_disabled();
212
213         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         if (ctx->task) {
219                 if (ctx->task != current) {
220                         ret = -ESRCH;
221                         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                 WARN_ON_ONCE(!ctx->is_active);
232                 /*
233                  * And since we have ctx->is_active, cpuctx->task_ctx must
234                  * match.
235                  */
236                 WARN_ON_ONCE(task_ctx != ctx);
237         } else {
238                 WARN_ON_ONCE(&cpuctx->ctx != ctx);
239         }
240
241         efs->func(event, cpuctx, ctx, efs->data);
242 unlock:
243         perf_ctx_unlock(cpuctx, task_ctx);
244
245         return ret;
246 }
247
248 static void event_function_call(struct perf_event *event, event_f func, void *data)
249 {
250         struct perf_event_context *ctx = event->ctx;
251         struct task_struct *task = READ_ONCE(ctx->task); /* verified in event_function */
252         struct event_function_struct efs = {
253                 .event = event,
254                 .func = func,
255                 .data = data,
256         };
257
258         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                 lockdep_assert_held(&ctx->mutex);
265         }
266
267         if (!task) {
268                 cpu_function_call(event->cpu, event_function, &efs);
269                 return;
270         }
271
272         if (task == TASK_TOMBSTONE)
273                 return;
274
275 again:
276         if (!task_function_call(task, event_function, &efs))
277                 return;
278
279         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         task = ctx->task;
285         if (task == TASK_TOMBSTONE) {
286                 raw_spin_unlock_irq(&ctx->lock);
287                 return;
288         }
289         if (ctx->is_active) {
290                 raw_spin_unlock_irq(&ctx->lock);
291                 goto again;
292         }
293         func(event, NULL, ctx, data);
294         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 static void event_function_local(struct perf_event *event, event_f func, void *data)
302 {
303         struct perf_event_context *ctx = event->ctx;
304         struct perf_cpu_context *cpuctx = __get_cpu_context(ctx);
305         struct task_struct *task = READ_ONCE(ctx->task);
306         struct perf_event_context *task_ctx = NULL;
307
308         lockdep_assert_irqs_disabled();
309
310         if (task) {
311                 if (task == TASK_TOMBSTONE)
312                         return;
313
314                 task_ctx = ctx;
315         }
316
317         perf_ctx_lock(cpuctx, task_ctx);
318
319         task = ctx->task;
320         if (task == TASK_TOMBSTONE)
321                 goto unlock;
322
323         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                 if (ctx->is_active) {
330                         if (WARN_ON_ONCE(task != current))
331                                 goto unlock;
332
333                         if (WARN_ON_ONCE(cpuctx->task_ctx != ctx))
334                                 goto unlock;
335                 }
336         } else {
337                 WARN_ON_ONCE(&cpuctx->ctx != ctx);
338         }
339
340         func(event, cpuctx, ctx, data);
341 unlock:
342         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 static void update_perf_cpu_limits(void)
423 {
424         u64 tmp = perf_sample_period_ns;
425
426         tmp *= sysctl_perf_cpu_time_max_percent;
427         tmp = div_u64(tmp, 100);
428         if (!tmp)
429                 tmp = 1;
430
431         WRITE_ONCE(perf_sample_allowed_ns, tmp);
432 }
433
434 static bool perf_rotate_context(struct perf_cpu_context *cpuctx);
435
436 int perf_proc_update_handler(struct ctl_table *table, int write,
437                 void __user *buffer, size_t *lenp,
438                 loff_t *ppos)
439 {
440         int ret;
441         int perf_cpu = sysctl_perf_cpu_time_max_percent;
442         /*
443          * If throttling is disabled don't allow the write:
444          */
445         if (write && (perf_cpu == 100 || perf_cpu == 0))
446                 return -EINVAL;
447
448         ret = proc_dointvec_minmax(table, write, buffer, lenp, ppos);
449         if (ret || !write)
450                 return ret;
451
452         max_samples_per_tick = DIV_ROUND_UP(sysctl_perf_event_sample_rate, HZ);
453         perf_sample_period_ns = NSEC_PER_SEC / sysctl_perf_event_sample_rate;
454         update_perf_cpu_limits();
455
456         return 0;
457 }
458
459 int sysctl_perf_cpu_time_max_percent __read_mostly = DEFAULT_CPU_TIME_MAX_PERCENT;
460
461 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         int ret = proc_dointvec_minmax(table, write, buffer, lenp, ppos);
466
467         if (ret || !write)
468                 return ret;
469
470         if (sysctl_perf_cpu_time_max_percent == 100 ||
471             sysctl_perf_cpu_time_max_percent == 0) {
472                 printk(KERN_WARNING
473                        "perf: Dynamic interrupt throttling disabled, can hang your system!\n");
474                 WRITE_ONCE(perf_sample_allowed_ns, 0);
475         } else {
476                 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 static void perf_duration_warn(struct irq_work *w)
495 {
496         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 }
502
503 static DEFINE_IRQ_WORK(perf_duration_work, perf_duration_warn);
504
505 void perf_sample_event_took(u64 sample_len_ns)
506 {
507         u64 max_len = READ_ONCE(perf_sample_allowed_ns);
508         u64 running_len;
509         u64 avg_len;
510         u32 max;
511
512         if (max_len == 0)
513                 return;
514
515         /* Decay the counter by 1 average sample. */
516         running_len = __this_cpu_read(running_sample_length);
517         running_len -= running_len/NR_ACCUMULATED_SAMPLES;
518         running_len += sample_len_ns;
519         __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         avg_len = running_len/NR_ACCUMULATED_SAMPLES;
527         if (avg_len <= max_len)
528                 return;
529
530         __report_avg = avg_len;
531         __report_allowed = max_len;
532
533         /*
534          * Compute a throttle threshold 25% below the current duration.
535          */
536         avg_len += avg_len / 4;
537         max = (TICK_NSEC / 100) * sysctl_perf_cpu_time_max_percent;
538         if (avg_len < max)
539                 max /= (u32)avg_len;
540         else
541                 max = 1;
542
543         WRITE_ONCE(perf_sample_allowed_ns, avg_len);
544         WRITE_ONCE(max_samples_per_tick, max);
545
546         sysctl_perf_event_sample_rate = max * HZ;
547         perf_sample_period_ns = NSEC_PER_SEC / sysctl_perf_event_sample_rate;
548
549         if (!irq_work_queue(&perf_duration_work)) {
550                 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 void __weak perf_event_print_debug(void)        { }
570
571 extern __weak const char *perf_pmu_name(void)
572 {
573         return "pmu";
574 }
575
576 static inline u64 perf_clock(void)
577 {
578         return local_clock();
579 }
580
581 static inline u64 perf_event_clock(struct perf_event *event)
582 {
583         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 __perf_effective_state(struct perf_event *event)
610 {
611         struct perf_event *leader = event->group_leader;
612
613         if (leader->state <= PERF_EVENT_STATE_OFF)
614                 return leader->state;
615
616         return event->state;
617 }
618
619 static __always_inline void
620 __perf_update_times(struct perf_event *event, u64 now, u64 *enabled, u64 *running)
621 {
622         enum perf_event_state state = __perf_effective_state(event);
623         u64 delta = now - event->tstamp;
624
625         *enabled = event->total_time_enabled;
626         if (state >= PERF_EVENT_STATE_INACTIVE)
627                 *enabled += delta;
628
629         *running = event->total_time_running;
630         if (state >= PERF_EVENT_STATE_ACTIVE)
631                 *running += delta;
632 }
633
634 static void perf_event_update_time(struct perf_event *event)
635 {
636         u64 now = perf_event_time(event);
637
638         __perf_update_times(event, now, &event->total_time_enabled,
639                                         &event->total_time_running);
640         event->tstamp = now;
641 }
642
643 static void perf_event_update_sibling_time(struct perf_event *leader)
644 {
645         struct perf_event *sibling;
646
647         for_each_sibling_event(sibling, leader)
648                 perf_event_update_time(sibling);
649 }
650
651 static void
652 perf_event_set_state(struct perf_event *event, enum perf_event_state state)
653 {
654         if (event->state == state)
655                 return;
656
657         perf_event_update_time(event);
658         /*
659          * If a group leader gets enabled/disabled all its siblings
660          * are affected too.
661          */
662         if ((event->state < 0) ^ (state < 0))
663                 perf_event_update_sibling_time(event);
664
665         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          * this will always be called from the right CPU.
955          */
956         cpuctx = __get_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, this_cpu_ptr(&cgrp_cpuctx_list));
983         else
984                 list_del(cpuctx_entry);
985 }
986
987 #else /* !CONFIG_CGROUP_PERF */
988
989 static inline bool
990 perf_cgroup_match(struct perf_event *event)
991 {
992         return true;
993 }
994
995 static inline void perf_detach_cgroup(struct perf_event *event)
996 {}
997
998 static inline int is_cgroup_event(struct perf_event *event)
999 {
1000         return 0;
1001 }
1002
1003 static inline void update_cgrp_time_from_event(struct perf_event *event)
1004 {
1005 }
1006
1007 static inline void update_cgrp_time_from_cpuctx(struct perf_cpu_context *cpuctx)
1008 {
1009 }
1010
1011 static inline void perf_cgroup_sched_out(struct task_struct *task,
1012                                          struct task_struct *next)
1013 {
1014 }
1015
1016 static inline void perf_cgroup_sched_in(struct task_struct *prev,
1017                                         struct task_struct *task)
1018 {
1019 }
1020
1021 static inline int perf_cgroup_connect(pid_t pid, struct perf_event *event,
1022                                       struct perf_event_attr *attr,
1023                                       struct perf_event *group_leader)
1024 {
1025         return -EINVAL;
1026 }
1027
1028 static inline void
1029 perf_cgroup_set_timestamp(struct task_struct *task,
1030                           struct perf_event_context *ctx)
1031 {
1032 }
1033
1034 void
1035 perf_cgroup_switch(struct task_struct *task, struct task_struct *next)
1036 {
1037 }
1038
1039 static inline void
1040 perf_cgroup_set_shadow_time(struct perf_event *event, u64 now)
1041 {
1042 }
1043
1044 static inline u64 perf_cgroup_event_time(struct perf_event *event)
1045 {
1046         return 0;
1047 }
1048
1049 static inline void
1050 list_update_cgroup_event(struct perf_event *event,
1051                          struct perf_event_context *ctx, bool add)
1052 {
1053 }
1054
1055 #endif
1056
1057 /*
1058  * set default to be dependent on timer tick just
1059  * like original code
1060  */
1061 #define PERF_CPU_HRTIMER (1000 / HZ)
1062 /*
1063  * function must be called with interrupts disabled
1064  */
1065 static enum hrtimer_restart perf_mux_hrtimer_handler(struct hrtimer *hr)
1066 {
1067         struct perf_cpu_context *cpuctx;
1068         bool rotations;
1069
1070         lockdep_assert_irqs_disabled();
1071
1072         cpuctx = container_of(hr, struct perf_cpu_context, hrtimer);
1073         rotations = perf_rotate_context(cpuctx);
1074
1075         raw_spin_lock(&cpuctx->hrtimer_lock);
1076         if (rotations)
1077                 hrtimer_forward_now(hr, cpuctx->hrtimer_interval);
1078         else
1079                 cpuctx->hrtimer_active = 0;
1080         raw_spin_unlock(&cpuctx->hrtimer_lock);
1081
1082         return rotations ? HRTIMER_RESTART : HRTIMER_NORESTART;
1083 }
1084
1085 static void __perf_mux_hrtimer_init(struct perf_cpu_context *cpuctx, int cpu)
1086 {
1087         struct hrtimer *timer = &cpuctx->hrtimer;
1088         struct pmu *pmu = cpuctx->ctx.pmu;
1089         u64 interval;
1090
1091         /* no multiplexing needed for SW PMU */
1092         if (pmu->task_ctx_nr == perf_sw_context)
1093                 return;
1094
1095         /*
1096          * check default is sane, if not set then force to
1097          * default interval (1/tick)
1098          */
1099         interval = pmu->hrtimer_interval_ms;
1100         if (interval < 1)
1101                 interval = pmu->hrtimer_interval_ms = PERF_CPU_HRTIMER;
1102
1103         cpuctx->hrtimer_interval = ns_to_ktime(NSEC_PER_MSEC * interval);
1104
1105         raw_spin_lock_init(&cpuctx->hrtimer_lock);
1106         hrtimer_init(timer, CLOCK_MONOTONIC, HRTIMER_MODE_ABS_PINNED);
1107         timer->function = perf_mux_hrtimer_handler;
1108 }
1109
1110 static int perf_mux_hrtimer_restart(struct perf_cpu_context *cpuctx)
1111 {
1112         struct hrtimer *timer = &cpuctx->hrtimer;
1113         struct pmu *pmu = cpuctx->ctx.pmu;
1114         unsigned long flags;
1115
1116         /* not for SW PMU */
1117         if (pmu->task_ctx_nr == perf_sw_context)
1118                 return 0;
1119
1120         raw_spin_lock_irqsave(&cpuctx->hrtimer_lock, flags);
1121         if (!cpuctx->hrtimer_active) {
1122                 cpuctx->hrtimer_active = 1;
1123                 hrtimer_forward_now(timer, cpuctx->hrtimer_interval);
1124                 hrtimer_start_expires(timer, HRTIMER_MODE_ABS_PINNED);
1125         }
1126         raw_spin_unlock_irqrestore(&cpuctx->hrtimer_lock, flags);
1127
1128         return 0;
1129 }
1130
1131 void perf_pmu_disable(struct pmu *pmu)
1132 {
1133         int *count = this_cpu_ptr(pmu->pmu_disable_count);
1134         if (!(*count)++)
1135                 pmu->pmu_disable(pmu);
1136 }
1137
1138 void perf_pmu_enable(struct pmu *pmu)
1139 {
1140         int *count = this_cpu_ptr(pmu->pmu_disable_count);
1141         if (!--(*count))
1142                 pmu->pmu_enable(pmu);
1143 }
1144
1145 static DEFINE_PER_CPU(struct list_head, active_ctx_list);
1146
1147 /*
1148  * perf_event_ctx_activate(), perf_event_ctx_deactivate(), and
1149  * perf_event_task_tick() are fully serialized because they're strictly cpu
1150  * affine and perf_event_ctx{activate,deactivate} are called with IRQs
1151  * disabled, while perf_event_task_tick is called from IRQ context.
1152  */
1153 static void perf_event_ctx_activate(struct perf_event_context *ctx)
1154 {
1155         struct list_head *head = this_cpu_ptr(&active_ctx_list);
1156
1157         lockdep_assert_irqs_disabled();
1158
1159         WARN_ON(!list_empty(&ctx->active_ctx_list));
1160
1161         list_add(&ctx->active_ctx_list, head);
1162 }
1163
1164 static void perf_event_ctx_deactivate(struct perf_event_context *ctx)
1165 {
1166         lockdep_assert_irqs_disabled();
1167
1168         WARN_ON(list_empty(&ctx->active_ctx_list));
1169
1170         list_del_init(&ctx->active_ctx_list);
1171 }
1172
1173 static void get_ctx(struct perf_event_context *ctx)
1174 {
1175         refcount_inc(&ctx->refcount);
1176 }
1177
1178 static void free_ctx(struct rcu_head *head)
1179 {
1180         struct perf_event_context *ctx;
1181
1182         ctx = container_of(head, struct perf_event_context, rcu_head);
1183         kfree(ctx->task_ctx_data);
1184         kfree(ctx);
1185 }
1186
1187 static void put_ctx(struct perf_event_context *ctx)
1188 {
1189         if (refcount_dec_and_test(&ctx->refcount)) {
1190                 if (ctx->parent_ctx)
1191                         put_ctx(ctx->parent_ctx);
1192                 if (ctx->task && ctx->task != TASK_TOMBSTONE)
1193                         put_task_struct(ctx->task);
1194                 call_rcu(&ctx->rcu_head, free_ctx);
1195         }
1196 }
1197
1198 /*
1199  * Because of perf_event::ctx migration in sys_perf_event_open::move_group and
1200  * perf_pmu_migrate_context() we need some magic.
1201  *
1202  * Those places that change perf_event::ctx will hold both
1203  * perf_event_ctx::mutex of the 'old' and 'new' ctx value.
1204  *
1205  * Lock ordering is by mutex address. There are two other sites where
1206  * perf_event_context::mutex nests and those are:
1207  *
1208  *  - perf_event_exit_task_context()    [ child , 0 ]
1209  *      perf_event_exit_event()
1210  *        put_event()                   [ parent, 1 ]
1211  *
1212  *  - perf_event_init_context()         [ parent, 0 ]
1213  *      inherit_task_group()
1214  *        inherit_group()
1215  *          inherit_event()
1216  *            perf_event_alloc()
1217  *              perf_init_event()
1218  *                perf_try_init_event() [ child , 1 ]
1219  *
1220  * While it appears there is an obvious deadlock here -- the parent and child
1221  * nesting levels are inverted between the two. This is in fact safe because
1222  * life-time rules separate them. That is an exiting task cannot fork, and a
1223  * spawning task cannot (yet) exit.
1224  *
1225  * But remember that that these are parent<->child context relations, and
1226  * migration does not affect children, therefore these two orderings should not
1227  * interact.
1228  *
1229  * The change in perf_event::ctx does not affect children (as claimed above)
1230  * because the sys_perf_event_open() case will install a new event and break
1231  * the ctx parent<->child relation, and perf_pmu_migrate_context() is only
1232  * concerned with cpuctx and that doesn't have children.
1233  *
1234  * The places that change perf_event::ctx will issue:
1235  *
1236  *   perf_remove_from_context();
1237  *   synchronize_rcu();
1238  *   perf_install_in_context();
1239  *
1240  * to affect the change. The remove_from_context() + synchronize_rcu() should
1241  * quiesce the event, after which we can install it in the new location. This
1242  * means that only external vectors (perf_fops, prctl) can perturb the event
1243  * while in transit. Therefore all such accessors should also acquire
1244  * perf_event_context::mutex to serialize against this.
1245  *
1246  * However; because event->ctx can change while we're waiting to acquire
1247  * ctx->mutex we must be careful and use the below perf_event_ctx_lock()
1248  * function.
1249  *
1250  * Lock order:
1251  *    cred_guard_mutex
1252  *      task_struct::perf_event_mutex
1253  *        perf_event_context::mutex
1254  *          perf_event::child_mutex;
1255  *            perf_event_context::lock
1256  *          perf_event::mmap_mutex
1257  *          mmap_sem
1258  *            perf_addr_filters_head::lock
1259  *
1260  *    cpu_hotplug_lock
1261  *      pmus_lock
1262  *        cpuctx->mutex / perf_event_context::mutex
1263  */
1264 static struct perf_event_context *
1265 perf_event_ctx_lock_nested(struct perf_event *event, int nesting)
1266 {
1267         struct perf_event_context *ctx;
1268
1269 again:
1270         rcu_read_lock();
1271         ctx = READ_ONCE(event->ctx);
1272         if (!refcount_inc_not_zero(&ctx->refcount)) {
1273                 rcu_read_unlock();
1274                 goto again;
1275         }
1276         rcu_read_unlock();
1277
1278         mutex_lock_nested(&ctx->mutex, nesting);
1279         if (event->ctx != ctx) {
1280                 mutex_unlock(&ctx->mutex);
1281                 put_ctx(ctx);
1282                 goto again;
1283         }
1284
1285         return ctx;
1286 }
1287
1288 static inline struct perf_event_context *
1289 perf_event_ctx_lock(struct perf_event *event)
1290 {
1291         return perf_event_ctx_lock_nested(event, 0);
1292 }
1293
1294 static void perf_event_ctx_unlock(struct perf_event *event,
1295                                   struct perf_event_context *ctx)
1296 {
1297         mutex_unlock(&ctx->mutex);
1298         put_ctx(ctx);
1299 }
1300
1301 /*
1302  * This must be done under the ctx->lock, such as to serialize against
1303  * context_equiv(), therefore we cannot call put_ctx() since that might end up
1304  * calling scheduler related locks and ctx->lock nests inside those.
1305  */
1306 static __must_check struct perf_event_context *
1307 unclone_ctx(struct perf_event_context *ctx)
1308 {
1309         struct perf_event_context *parent_ctx = ctx->parent_ctx;
1310
1311         lockdep_assert_held(&ctx->lock);
1312
1313         if (parent_ctx)
1314                 ctx->parent_ctx = NULL;
1315         ctx->generation++;
1316
1317         return parent_ctx;
1318 }
1319
1320 static u32 perf_event_pid_type(struct perf_event *event, struct task_struct *p,
1321                                 enum pid_type type)
1322 {
1323         u32 nr;
1324         /*
1325          * only top level events have the pid namespace they were created in
1326          */
1327         if (event->parent)
1328                 event = event->parent;
1329
1330         nr = __task_pid_nr_ns(p, type, event->ns);
1331         /* avoid -1 if it is idle thread or runs in another ns */
1332         if (!nr && !pid_alive(p))
1333                 nr = -1;
1334         return nr;
1335 }
1336
1337 static u32 perf_event_pid(struct perf_event *event, struct task_struct *p)
1338 {
1339         return perf_event_pid_type(event, p, PIDTYPE_TGID);
1340 }
1341
1342 static u32 perf_event_tid(struct perf_event *event, struct task_struct *p)
1343 {
1344         return perf_event_pid_type(event, p, PIDTYPE_PID);
1345 }
1346
1347 /*
1348  * If we inherit events we want to return the parent event id
1349  * to userspace.
1350  */
1351 static u64 primary_event_id(struct perf_event *event)
1352 {
1353         u64 id = event->id;
1354
1355         if (event->parent)
1356                 id = event->parent->id;
1357
1358         return id;
1359 }
1360
1361 /*
1362  * Get the perf_event_context for a task and lock it.
1363  *
1364  * This has to cope with with the fact that until it is locked,
1365  * the context could get moved to another task.
1366  */
1367 static struct perf_event_context *
1368 perf_lock_task_context(struct task_struct *task, int ctxn, unsigned long *flags)
1369 {
1370         struct perf_event_context *ctx;
1371
1372 retry:
1373         /*
1374          * One of the few rules of preemptible RCU is that one cannot do
1375          * rcu_read_unlock() while holding a scheduler (or nested) lock when
1376          * part of the read side critical section was irqs-enabled -- see
1377          * rcu_read_unlock_special().
1378          *
1379          * Since ctx->lock nests under rq->lock we must ensure the entire read
1380          * side critical section has interrupts disabled.
1381          */
1382         local_irq_save(*flags);
1383         rcu_read_lock();
1384         ctx = rcu_dereference(task->perf_event_ctxp[ctxn]);
1385         if (ctx) {
1386                 /*
1387                  * If this context is a clone of another, it might
1388                  * get swapped for another underneath us by
1389                  * perf_event_task_sched_out, though the
1390                  * rcu_read_lock() protects us from any context
1391                  * getting freed.  Lock the context and check if it
1392                  * got swapped before we could get the lock, and retry
1393                  * if so.  If we locked the right context, then it
1394                  * can't get swapped on us any more.
1395                  */
1396                 raw_spin_lock(&ctx->lock);
1397                 if (ctx != rcu_dereference(task->perf_event_ctxp[ctxn])) {
1398                         raw_spin_unlock(&ctx->lock);
1399                         rcu_read_unlock();
1400                         local_irq_restore(*flags);
1401                         goto retry;
1402                 }
1403
1404                 if (ctx->task == TASK_TOMBSTONE ||
1405                     !refcount_inc_not_zero(&ctx->refcount)) {
1406                         raw_spin_unlock(&ctx->lock);
1407                         ctx = NULL;
1408                 } else {
1409                         WARN_ON_ONCE(ctx->task != task);
1410                 }
1411         }
1412         rcu_read_unlock();
1413         if (!ctx)
1414                 local_irq_restore(*flags);
1415         return ctx;
1416 }
1417
1418 /*
1419  * Get the context for a task and increment its pin_count so it
1420  * can't get swapped to another task.  This also increments its
1421  * reference count so that the context can't get freed.
1422  */
1423 static struct perf_event_context *
1424 perf_pin_task_context(struct task_struct *task, int ctxn)
1425 {
1426         struct perf_event_context *ctx;
1427         unsigned long flags;
1428
1429         ctx = perf_lock_task_context(task, ctxn, &flags);
1430         if (ctx) {
1431                 ++ctx->pin_count;
1432                 raw_spin_unlock_irqrestore(&ctx->lock, flags);
1433         }
1434         return ctx;
1435 }
1436
1437 static void perf_unpin_context(struct perf_event_context *ctx)
1438 {
1439         unsigned long flags;
1440
1441         raw_spin_lock_irqsave(&ctx->lock, flags);
1442         --ctx->pin_count;
1443         raw_spin_unlock_irqrestore(&ctx->lock, flags);
1444 }
1445
1446 /*
1447  * Update the record of the current time in a context.
1448  */
1449 static void update_context_time(struct perf_event_context *ctx)
1450 {
1451         u64 now = perf_clock();
1452
1453         ctx->time += now - ctx->timestamp;
1454         ctx->timestamp = now;
1455 }
1456
1457 static u64 perf_event_time(struct perf_event *event)
1458 {
1459         struct perf_event_context *ctx = event->ctx;
1460
1461         if (is_cgroup_event(event))
1462                 return perf_cgroup_event_time(event);
1463
1464         return ctx ? ctx->time : 0;
1465 }
1466
1467 static enum event_type_t get_event_type(struct perf_event *event)
1468 {
1469         struct perf_event_context *ctx = event->ctx;
1470         enum event_type_t event_type;
1471
1472         lockdep_assert_held(&ctx->lock);
1473
1474         /*
1475          * It's 'group type', really, because if our group leader is
1476          * pinned, so are we.
1477          */
1478         if (event->group_leader != event)
1479                 event = event->group_leader;
1480
1481         event_type = event->attr.pinned ? EVENT_PINNED : EVENT_FLEXIBLE;
1482         if (!ctx->task)
1483                 event_type |= EVENT_CPU;
1484
1485         return event_type;
1486 }
1487
1488 /*
1489  * Helper function to initialize event group nodes.
1490  */
1491 static void init_event_group(struct perf_event *event)
1492 {
1493         RB_CLEAR_NODE(&event->group_node);
1494         event->group_index = 0;
1495 }
1496
1497 /*
1498  * Extract pinned or flexible groups from the context
1499  * based on event attrs bits.
1500  */
1501 static struct perf_event_groups *
1502 get_event_groups(struct perf_event *event, struct perf_event_context *ctx)
1503 {
1504         if (event->attr.pinned)
1505                 return &ctx->pinned_groups;
1506         else
1507                 return &ctx->flexible_groups;
1508 }
1509
1510 /*
1511  * Helper function to initializes perf_event_group trees.
1512  */
1513 static void perf_event_groups_init(struct perf_event_groups *groups)
1514 {
1515         groups->tree = RB_ROOT;
1516         groups->index = 0;
1517 }
1518
1519 /*
1520  * Compare function for event groups;
1521  *
1522  * Implements complex key that first sorts by CPU and then by virtual index
1523  * which provides ordering when rotating groups for the same CPU.
1524  */
1525 static bool
1526 perf_event_groups_less(struct perf_event *left, struct perf_event *right)
1527 {
1528         if (left->cpu < right->cpu)
1529                 return true;
1530         if (left->cpu > right->cpu)
1531                 return false;
1532
1533         if (left->group_index < right->group_index)
1534                 return true;
1535         if (left->group_index > right->group_index)
1536                 return false;
1537
1538         return false;
1539 }
1540
1541 /*
1542  * Insert @event into @groups' tree; using {@event->cpu, ++@groups->index} for
1543  * key (see perf_event_groups_less). This places it last inside the CPU
1544  * subtree.
1545  */
1546 static void
1547 perf_event_groups_insert(struct perf_event_groups *groups,
1548                          struct perf_event *event)
1549 {
1550         struct perf_event *node_event;
1551         struct rb_node *parent;
1552         struct rb_node **node;
1553
1554         event->group_index = ++groups->index;
1555
1556         node = &groups->tree.rb_node;
1557         parent = *node;
1558
1559         while (*node) {
1560                 parent = *node;
1561                 node_event = container_of(*node, struct perf_event, group_node);
1562
1563                 if (perf_event_groups_less(event, node_event))
1564                         node = &parent->rb_left;
1565                 else
1566                         node = &parent->rb_right;
1567         }
1568
1569         rb_link_node(&event->group_node, parent, node);
1570         rb_insert_color(&event->group_node, &groups->tree);
1571 }
1572
1573 /*
1574  * Helper function to insert event into the pinned or flexible groups.
1575  */
1576 static void
1577 add_event_to_groups(struct perf_event *event, struct perf_event_context *ctx)
1578 {
1579         struct perf_event_groups *groups;
1580
1581         groups = get_event_groups(event, ctx);
1582         perf_event_groups_insert(groups, event);
1583 }
1584
1585 /*
1586  * Delete a group from a tree.
1587  */
1588 static void
1589 perf_event_groups_delete(struct perf_event_groups *groups,
1590                          struct perf_event *event)
1591 {
1592         WARN_ON_ONCE(RB_EMPTY_NODE(&event->group_node) ||
1593                      RB_EMPTY_ROOT(&groups->tree));
1594
1595         rb_erase(&event->group_node, &groups->tree);
1596         init_event_group(event);
1597 }
1598
1599 /*
1600  * Helper function to delete event from its groups.
1601  */
1602 static void
1603 del_event_from_groups(struct perf_event *event, struct perf_event_context *ctx)
1604 {
1605         struct perf_event_groups *groups;
1606
1607         groups = get_event_groups(event, ctx);
1608         perf_event_groups_delete(groups, event);
1609 }
1610
1611 /*
1612  * Get the leftmost event in the @cpu subtree.
1613  */
1614 static struct perf_event *
1615 perf_event_groups_first(struct perf_event_groups *groups, int cpu)
1616 {
1617         struct perf_event *node_event = NULL, *match = NULL;
1618         struct rb_node *node = groups->tree.rb_node;
1619
1620         while (node) {
1621                 node_event = container_of(node, struct perf_event, group_node);
1622
1623                 if (cpu < node_event->cpu) {
1624                         node = node->rb_left;
1625                 } else if (cpu > node_event->cpu) {
1626                         node = node->rb_right;
1627                 } else {
1628                         match = node_event;
1629                         node = node->rb_left;
1630                 }
1631         }
1632
1633         return match;
1634 }
1635
1636 /*
1637  * Like rb_entry_next_safe() for the @cpu subtree.
1638  */
1639 static struct perf_event *
1640 perf_event_groups_next(struct perf_event *event)
1641 {
1642         struct perf_event *next;
1643
1644         next = rb_entry_safe(rb_next(&event->group_node), typeof(*event), group_node);
1645         if (next && next->cpu == event->cpu)
1646                 return next;
1647
1648         return NULL;
1649 }
1650
1651 /*
1652  * Iterate through the whole groups tree.
1653  */
1654 #define perf_event_groups_for_each(event, groups)                       \
1655         for (event = rb_entry_safe(rb_first(&((groups)->tree)),         \
1656                                 typeof(*event), group_node); event;     \
1657                 event = rb_entry_safe(rb_next(&event->group_node),      \
1658                                 typeof(*event), group_node))
1659
1660 /*
1661  * Add an event from the lists for its context.
1662  * Must be called with ctx->mutex and ctx->lock held.
1663  */
1664 static void
1665 list_add_event(struct perf_event *event, struct perf_event_context *ctx)
1666 {
1667         lockdep_assert_held(&ctx->lock);
1668
1669         WARN_ON_ONCE(event->attach_state & PERF_ATTACH_CONTEXT);
1670         event->attach_state |= PERF_ATTACH_CONTEXT;
1671
1672         event->tstamp = perf_event_time(event);
1673
1674         /*
1675          * If we're a stand alone event or group leader, we go to the context
1676          * list, group events are kept attached to the group so that
1677          * perf_group_detach can, at all times, locate all siblings.
1678          */
1679         if (event->group_leader == event) {
1680                 event->group_caps = event->event_caps;
1681                 add_event_to_groups(event, ctx);
1682         }
1683
1684         list_update_cgroup_event(event, ctx, true);
1685
1686         list_add_rcu(&event->event_entry, &ctx->event_list);
1687         ctx->nr_events++;
1688         if (event->attr.inherit_stat)
1689                 ctx->nr_stat++;
1690
1691         ctx->generation++;
1692 }
1693
1694 /*
1695  * Initialize event state based on the perf_event_attr::disabled.
1696  */
1697 static inline void perf_event__state_init(struct perf_event *event)
1698 {
1699         event->state = event->attr.disabled ? PERF_EVENT_STATE_OFF :
1700                                               PERF_EVENT_STATE_INACTIVE;
1701 }
1702
1703 static void __perf_event_read_size(struct perf_event *event, int nr_siblings)
1704 {
1705         int entry = sizeof(u64); /* value */
1706         int size = 0;
1707         int nr = 1;
1708
1709         if (event->attr.read_format & PERF_FORMAT_TOTAL_TIME_ENABLED)
1710                 size += sizeof(u64);
1711
1712         if (event->attr.read_format & PERF_FORMAT_TOTAL_TIME_RUNNING)
1713                 size += sizeof(u64);
1714
1715         if (event->attr.read_format & PERF_FORMAT_ID)
1716                 entry += sizeof(u64);
1717
1718         if (event->attr.read_format & PERF_FORMAT_GROUP) {
1719                 nr += nr_siblings;
1720                 size += sizeof(u64);
1721         }
1722
1723         size += entry * nr;
1724         event->read_size = size;
1725 }
1726
1727 static void __perf_event_header_size(struct perf_event *event, u64 sample_type)
1728 {
1729         struct perf_sample_data *data;
1730         u16 size = 0;
1731
1732         if (sample_type & PERF_SAMPLE_IP)
1733                 size += sizeof(data->ip);
1734
1735         if (sample_type & PERF_SAMPLE_ADDR)
1736                 size += sizeof(data->addr);
1737
1738         if (sample_type & PERF_SAMPLE_PERIOD)
1739                 size += sizeof(data->period);
1740
1741         if (sample_type & PERF_SAMPLE_WEIGHT)
1742                 size += sizeof(data->weight);
1743
1744         if (sample_type & PERF_SAMPLE_READ)
1745                 size += event->read_size;
1746
1747         if (sample_type & PERF_SAMPLE_DATA_SRC)
1748                 size += sizeof(data->data_src.val);
1749
1750         if (sample_type & PERF_SAMPLE_TRANSACTION)
1751                 size += sizeof(data->txn);
1752
1753         if (sample_type & PERF_SAMPLE_PHYS_ADDR)
1754                 size += sizeof(data->phys_addr);
1755
1756         event->header_size = size;
1757 }
1758
1759 /*
1760  * Called at perf_event creation and when events are attached/detached from a
1761  * group.
1762  */
1763 static void perf_event__header_size(struct perf_event *event)
1764 {
1765         __perf_event_read_size(event,
1766                                event->group_leader->nr_siblings);
1767         __perf_event_header_size(event, event->attr.sample_type);
1768 }
1769
1770 static void perf_event__id_header_size(struct perf_event *event)
1771 {
1772         struct perf_sample_data *data;
1773         u64 sample_type = event->attr.sample_type;
1774         u16 size = 0;
1775
1776         if (sample_type & PERF_SAMPLE_TID)
1777                 size += sizeof(data->tid_entry);
1778
1779         if (sample_type & PERF_SAMPLE_TIME)
1780                 size += sizeof(data->time);
1781
1782         if (sample_type & PERF_SAMPLE_IDENTIFIER)
1783                 size += sizeof(data->id);
1784
1785         if (sample_type & PERF_SAMPLE_ID)
1786                 size += sizeof(data->id);
1787
1788         if (sample_type & PERF_SAMPLE_STREAM_ID)
1789                 size += sizeof(data->stream_id);
1790
1791         if (sample_type & PERF_SAMPLE_CPU)
1792                 size += sizeof(data->cpu_entry);
1793
1794         event->id_header_size = size;
1795 }
1796
1797 static bool perf_event_validate_size(struct perf_event *event)
1798 {
1799         /*
1800          * The values computed here will be over-written when we actually
1801          * attach the event.
1802          */
1803         __perf_event_read_size(event, event->group_leader->nr_siblings + 1);
1804         __perf_event_header_size(event, event->attr.sample_type & ~PERF_SAMPLE_READ);
1805         perf_event__id_header_size(event);
1806
1807         /*
1808          * Sum the lot; should not exceed the 64k limit we have on records.
1809          * Conservative limit to allow for callchains and other variable fields.
1810          */
1811         if (event->read_size + event->header_size +
1812             event->id_header_size + sizeof(struct perf_event_header) >= 16*1024)
1813                 return false;
1814
1815         return true;
1816 }
1817
1818 static void perf_group_attach(struct perf_event *event)
1819 {
1820         struct perf_event *group_leader = event->group_leader, *pos;
1821
1822         lockdep_assert_held(&event->ctx->lock);
1823
1824         /*
1825          * We can have double attach due to group movement in perf_event_open.
1826          */
1827         if (event->attach_state & PERF_ATTACH_GROUP)
1828                 return;
1829
1830         event->attach_state |= PERF_ATTACH_GROUP;
1831
1832         if (group_leader == event)
1833                 return;
1834
1835         WARN_ON_ONCE(group_leader->ctx != event->ctx);
1836
1837         group_leader->group_caps &= event->event_caps;
1838
1839         list_add_tail(&event->sibling_list, &group_leader->sibling_list);
1840         group_leader->nr_siblings++;
1841
1842         perf_event__header_size(group_leader);
1843
1844         for_each_sibling_event(pos, group_leader)
1845                 perf_event__header_size(pos);
1846 }
1847
1848 /*
1849  * Remove an event from the lists for its context.
1850  * Must be called with ctx->mutex and ctx->lock held.
1851  */
1852 static void
1853 list_del_event(struct perf_event *event, struct perf_event_context *ctx)
1854 {
1855         WARN_ON_ONCE(event->ctx != ctx);
1856         lockdep_assert_held(&ctx->lock);
1857
1858         /*
1859          * We can have double detach due to exit/hot-unplug + close.
1860          */
1861         if (!(event->attach_state & PERF_ATTACH_CONTEXT))
1862                 return;
1863
1864         event->attach_state &= ~PERF_ATTACH_CONTEXT;
1865
1866         list_update_cgroup_event(event, ctx, false);
1867
1868         ctx->nr_events--;
1869         if (event->attr.inherit_stat)
1870                 ctx->nr_stat--;
1871
1872         list_del_rcu(&event->event_entry);
1873
1874         if (event->group_leader == event)
1875                 del_event_from_groups(event, ctx);
1876
1877         /*
1878          * If event was in error state, then keep it
1879          * that way, otherwise bogus counts will be
1880          * returned on read(). The only way to get out
1881          * of error state is by explicit re-enabling
1882          * of the event
1883          */
1884         if (event->state > PERF_EVENT_STATE_OFF)
1885                 perf_event_set_state(event, PERF_EVENT_STATE_OFF);
1886
1887         ctx->generation++;
1888 }
1889
1890 static void perf_group_detach(struct perf_event *event)
1891 {
1892         struct perf_event *sibling, *tmp;
1893         struct perf_event_context *ctx = event->ctx;
1894
1895         lockdep_assert_held(&ctx->lock);
1896
1897         /*
1898          * We can have double detach due to exit/hot-unplug + close.
1899          */
1900         if (!(event->attach_state & PERF_ATTACH_GROUP))
1901                 return;
1902
1903         event->attach_state &= ~PERF_ATTACH_GROUP;
1904
1905         /*
1906          * If this is a sibling, remove it from its group.
1907          */
1908         if (event->group_leader != event) {
1909                 list_del_init(&event->sibling_list);
1910                 event->group_leader->nr_siblings--;
1911                 goto out;
1912         }
1913
1914         /*
1915          * If this was a group event with sibling events then
1916          * upgrade the siblings to singleton events by adding them
1917          * to whatever list we are on.
1918          */
1919         list_for_each_entry_safe(sibling, tmp, &event->sibling_list, sibling_list) {
1920
1921                 sibling->group_leader = sibling;
1922                 list_del_init(&sibling->sibling_list);
1923
1924                 /* Inherit group flags from the previous leader */
1925                 sibling->group_caps = event->group_caps;
1926
1927                 if (!RB_EMPTY_NODE(&event->group_node)) {
1928                         add_event_to_groups(sibling, event->ctx);
1929
1930                         if (sibling->state == PERF_EVENT_STATE_ACTIVE) {
1931                                 struct list_head *list = sibling->attr.pinned ?
1932                                         &ctx->pinned_active : &ctx->flexible_active;
1933
1934                                 list_add_tail(&sibling->active_list, list);
1935                         }
1936                 }
1937
1938                 WARN_ON_ONCE(sibling->ctx != event->ctx);
1939         }
1940
1941 out:
1942         perf_event__header_size(event->group_leader);
1943
1944         for_each_sibling_event(tmp, event->group_leader)
1945                 perf_event__header_size(tmp);
1946 }
1947
1948 static bool is_orphaned_event(struct perf_event *event)
1949 {
1950         return event->state == PERF_EVENT_STATE_DEAD;
1951 }
1952
1953 static inline int __pmu_filter_match(struct perf_event *event)
1954 {
1955         struct pmu *pmu = event->pmu;
1956         return pmu->filter_match ? pmu->filter_match(event) : 1;
1957 }
1958
1959 /*
1960  * Check whether we should attempt to schedule an event group based on
1961  * PMU-specific filtering. An event group can consist of HW and SW events,
1962  * potentially with a SW leader, so we must check all the filters, to
1963  * determine whether a group is schedulable:
1964  */
1965 static inline int pmu_filter_match(struct perf_event *event)
1966 {
1967         struct perf_event *sibling;
1968
1969         if (!__pmu_filter_match(event))
1970                 return 0;
1971
1972         for_each_sibling_event(sibling, event) {
1973                 if (!__pmu_filter_match(sibling))
1974                         return 0;
1975         }
1976
1977         return 1;
1978 }
1979
1980 static inline int
1981 event_filter_match(struct perf_event *event)
1982 {
1983         return (event->cpu == -1 || event->cpu == smp_processor_id()) &&
1984                perf_cgroup_match(event) && pmu_filter_match(event);
1985 }
1986
1987 static void
1988 event_sched_out(struct perf_event *event,
1989                   struct perf_cpu_context *cpuctx,
1990                   struct perf_event_context *ctx)
1991 {
1992         enum perf_event_state state = PERF_EVENT_STATE_INACTIVE;
1993
1994         WARN_ON_ONCE(event->ctx != ctx);
1995         lockdep_assert_held(&ctx->lock);
1996
1997         if (event->state != PERF_EVENT_STATE_ACTIVE)
1998                 return;
1999
2000         /*
2001          * Asymmetry; we only schedule events _IN_ through ctx_sched_in(), but
2002          * we can schedule events _OUT_ individually through things like
2003          * __perf_remove_from_context().
2004          */
2005         list_del_init(&event->active_list);
2006
2007         perf_pmu_disable(event->pmu);
2008
2009         event->pmu->del(event, 0);
2010         event->oncpu = -1;
2011
2012         if (READ_ONCE(event->pending_disable) >= 0) {
2013                 WRITE_ONCE(event->pending_disable, -1);
2014                 state = PERF_EVENT_STATE_OFF;
2015         }
2016         perf_event_set_state(event, state);
2017
2018         if (!is_software_event(event))
2019                 cpuctx->active_oncpu--;
2020         if (!--ctx->nr_active)
2021                 perf_event_ctx_deactivate(ctx);
2022         if (event->attr.freq && event->attr.sample_freq)
2023                 ctx->nr_freq--;
2024         if (event->attr.exclusive || !cpuctx->active_oncpu)
2025                 cpuctx->exclusive = 0;
2026
2027         perf_pmu_enable(event->pmu);
2028 }
2029
2030 static void
2031 group_sched_out(struct perf_event *group_event,
2032                 struct perf_cpu_context *cpuctx,
2033                 struct perf_event_context *ctx)
2034 {
2035         struct perf_event *event;
2036
2037         if (group_event->state != PERF_EVENT_STATE_ACTIVE)
2038                 return;
2039
2040         perf_pmu_disable(ctx->pmu);
2041
2042         event_sched_out(group_event, cpuctx, ctx);
2043
2044         /*
2045          * Schedule out siblings (if any):
2046          */
2047         for_each_sibling_event(event, group_event)
2048                 event_sched_out(event, cpuctx, ctx);
2049
2050         perf_pmu_enable(ctx->pmu);
2051
2052         if (group_event->attr.exclusive)
2053                 cpuctx->exclusive = 0;
2054 }
2055
2056 #define DETACH_GROUP    0x01UL
2057
2058 /*
2059  * Cross CPU call to remove a performance event
2060  *
2061  * We disable the event on the hardware level first. After that we
2062  * remove it from the context list.
2063  */
2064 static void
2065 __perf_remove_from_context(struct perf_event *event,
2066                            struct perf_cpu_context *cpuctx,
2067                            struct perf_event_context *ctx,
2068                            void *info)
2069 {
2070         unsigned long flags = (unsigned long)info;
2071
2072         if (ctx->is_active & EVENT_TIME) {
2073                 update_context_time(ctx);
2074                 update_cgrp_time_from_cpuctx(cpuctx);
2075         }
2076
2077         event_sched_out(event, cpuctx, ctx);
2078         if (flags & DETACH_GROUP)
2079                 perf_group_detach(event);
2080         list_del_event(event, ctx);
2081
2082         if (!ctx->nr_events && ctx->is_active) {
2083                 ctx->is_active = 0;
2084                 if (ctx->task) {
2085                         WARN_ON_ONCE(cpuctx->task_ctx != ctx);
2086                         cpuctx->task_ctx = NULL;
2087                 }
2088         }
2089 }
2090
2091 /*
2092  * Remove the event from a task's (or a CPU's) list of events.
2093  *
2094  * If event->ctx is a cloned context, callers must make sure that
2095  * every task struct that event->ctx->task could possibly point to
2096  * remains valid.  This is OK when called from perf_release since
2097  * that only calls us on the top-level context, which can't be a clone.
2098  * When called from perf_event_exit_task, it's OK because the
2099  * context has been detached from its task.
2100  */
2101 static void perf_remove_from_context(struct perf_event *event, unsigned long flags)
2102 {
2103         struct perf_event_context *ctx = event->ctx;
2104
2105         lockdep_assert_held(&ctx->mutex);
2106
2107         event_function_call(event, __perf_remove_from_context, (void *)flags);
2108
2109         /*
2110          * The above event_function_call() can NO-OP when it hits
2111          * TASK_TOMBSTONE. In that case we must already have been detached
2112          * from the context (by perf_event_exit_event()) but the grouping
2113          * might still be in-tact.
2114          */
2115         WARN_ON_ONCE(event->attach_state & PERF_ATTACH_CONTEXT);
2116         if ((flags & DETACH_GROUP) &&
2117             (event->attach_state & PERF_ATTACH_GROUP)) {
2118                 /*
2119                  * Since in that case we cannot possibly be scheduled, simply
2120                  * detach now.
2121                  */
2122                 raw_spin_lock_irq(&ctx->lock);
2123                 perf_group_detach(event);
2124                 raw_spin_unlock_irq(&ctx->lock);
2125         }
2126 }
2127
2128 /*
2129  * Cross CPU call to disable a performance event
2130  */
2131 static void __perf_event_disable(struct perf_event *event,
2132                                  struct perf_cpu_context *cpuctx,
2133                                  struct perf_event_context *ctx,
2134                                  void *info)
2135 {
2136         if (event->state < PERF_EVENT_STATE_INACTIVE)
2137                 return;
2138
2139         if (ctx->is_active & EVENT_TIME) {
2140                 update_context_time(ctx);
2141                 update_cgrp_time_from_event(event);
2142         }
2143
2144         if (event == event->group_leader)
2145                 group_sched_out(event, cpuctx, ctx);
2146         else
2147                 event_sched_out(event, cpuctx, ctx);
2148
2149         perf_event_set_state(event, PERF_EVENT_STATE_OFF);
2150 }
2151
2152 /*
2153  * Disable an event.
2154  *
2155  * If event->ctx is a cloned context, callers must make sure that
2156  * every task struct that event->ctx->task could possibly point to
2157  * remains valid.  This condition is satisifed when called through
2158  * perf_event_for_each_child or perf_event_for_each because they
2159  * hold the top-level event's child_mutex, so any descendant that
2160  * goes to exit will block in perf_event_exit_event().
2161  *
2162  * When called from perf_pending_event it's OK because event->ctx
2163  * is the current context on this CPU and preemption is disabled,
2164  * hence we can't get into perf_event_task_sched_out for this context.
2165  */
2166 static void _perf_event_disable(struct perf_event *event)
2167 {
2168         struct perf_event_context *ctx = event->ctx;
2169
2170         raw_spin_lock_irq(&ctx->lock);
2171         if (event->state <= PERF_EVENT_STATE_OFF) {
2172                 raw_spin_unlock_irq(&ctx->lock);
2173                 return;
2174         }
2175         raw_spin_unlock_irq(&ctx->lock);
2176
2177         event_function_call(event, __perf_event_disable, NULL);
2178 }
2179
2180 void perf_event_disable_local(struct perf_event *event)
2181 {
2182         event_function_local(event, __perf_event_disable, NULL);
2183 }
2184
2185 /*
2186  * Strictly speaking kernel users cannot create groups and therefore this
2187  * interface does not need the perf_event_ctx_lock() magic.
2188  */
2189 void perf_event_disable(struct perf_event *event)
2190 {
2191         struct perf_event_context *ctx;
2192
2193         ctx = perf_event_ctx_lock(event);
2194         _perf_event_disable(event);
2195         perf_event_ctx_unlock(event, ctx);
2196 }
2197 EXPORT_SYMBOL_GPL(perf_event_disable);
2198
2199 void perf_event_disable_inatomic(struct perf_event *event)
2200 {
2201         WRITE_ONCE(event->pending_disable, smp_processor_id());
2202         /* can fail, see perf_pending_event_disable() */
2203         irq_work_queue(&event->pending);
2204 }
2205
2206 static void perf_set_shadow_time(struct perf_event *event,
2207                                  struct perf_event_context *ctx)
2208 {
2209         /*
2210          * use the correct time source for the time snapshot
2211          *
2212          * We could get by without this by leveraging the
2213          * fact that to get to this function, the caller
2214          * has most likely already called update_context_time()
2215          * and update_cgrp_time_xx() and thus both timestamp
2216          * are identical (or very close). Given that tstamp is,
2217          * already adjusted for cgroup, we could say that:
2218          *    tstamp - ctx->timestamp
2219          * is equivalent to
2220          *    tstamp - cgrp->timestamp.
2221          *
2222          * Then, in perf_output_read(), the calculation would
2223          * work with no changes because:
2224          * - event is guaranteed scheduled in
2225          * - no scheduled out in between
2226          * - thus the timestamp would be the same
2227          *
2228          * But this is a bit hairy.
2229          *
2230          * So instead, we have an explicit cgroup call to remain
2231          * within the time time source all along. We believe it
2232          * is cleaner and simpler to understand.
2233          */
2234         if (is_cgroup_event(event))
2235                 perf_cgroup_set_shadow_time(event, event->tstamp);
2236         else
2237                 event->shadow_ctx_time = event->tstamp - ctx->timestamp;
2238 }
2239
2240 #define MAX_INTERRUPTS (~0ULL)
2241
2242 static void perf_log_throttle(struct perf_event *event, int enable);
2243 static void perf_log_itrace_start(struct perf_event *event);
2244
2245 static int
2246 event_sched_in(struct perf_event *event,
2247                  struct perf_cpu_context *cpuctx,
2248                  struct perf_event_context *ctx)
2249 {
2250         int ret = 0;
2251
2252         lockdep_assert_held(&ctx->lock);
2253
2254         if (event->state <= PERF_EVENT_STATE_OFF)
2255                 return 0;
2256
2257         WRITE_ONCE(event->oncpu, smp_processor_id());
2258         /*
2259          * Order event::oncpu write to happen before the ACTIVE state is
2260          * visible. This allows perf_event_{stop,read}() to observe the correct
2261          * ->oncpu if it sees ACTIVE.
2262          */
2263         smp_wmb();
2264         perf_event_set_state(event, PERF_EVENT_STATE_ACTIVE);
2265
2266         /*
2267          * Unthrottle events, since we scheduled we might have missed several
2268          * ticks already, also for a heavily scheduling task there is little
2269          * guarantee it'll get a tick in a timely manner.
2270          */
2271         if (unlikely(event->hw.interrupts == MAX_INTERRUPTS)) {
2272                 perf_log_throttle(event, 1);
2273                 event->hw.interrupts = 0;
2274         }
2275
2276         perf_pmu_disable(event->pmu);
2277
2278         perf_set_shadow_time(event, ctx);
2279
2280         perf_log_itrace_start(event);
2281
2282         if (event->pmu->add(event, PERF_EF_START)) {
2283                 perf_event_set_state(event, PERF_EVENT_STATE_INACTIVE);
2284                 event->oncpu = -1;
2285                 ret = -EAGAIN;
2286                 goto out;
2287         }
2288
2289         if (!is_software_event(event))
2290                 cpuctx->active_oncpu++;
2291         if (!ctx->nr_active++)
2292                 perf_event_ctx_activate(ctx);
2293         if (event->attr.freq && event->attr.sample_freq)
2294                 ctx->nr_freq++;
2295
2296         if (event->attr.exclusive)
2297                 cpuctx->exclusive = 1;
2298
2299 out:
2300         perf_pmu_enable(event->pmu);
2301
2302         return ret;
2303 }
2304
2305 static int
2306 group_sched_in(struct perf_event *group_event,
2307                struct perf_cpu_context *cpuctx,
2308                struct perf_event_context *ctx)
2309 {
2310         struct perf_event *event, *partial_group = NULL;
2311         struct pmu *pmu = ctx->pmu;
2312
2313         if (group_event->state == PERF_EVENT_STATE_OFF)
2314                 return 0;
2315
2316         pmu->start_txn(pmu, PERF_PMU_TXN_ADD);
2317
2318         if (event_sched_in(group_event, cpuctx, ctx)) {
2319                 pmu->cancel_txn(pmu);
2320                 perf_mux_hrtimer_restart(cpuctx);
2321                 return -EAGAIN;
2322         }
2323
2324         /*
2325          * Schedule in siblings as one group (if any):
2326          */
2327         for_each_sibling_event(event, group_event) {
2328                 if (event_sched_in(event, cpuctx, ctx)) {
2329                         partial_group = event;
2330                         goto group_error;
2331                 }
2332         }
2333
2334         if (!pmu->commit_txn(pmu))
2335                 return 0;
2336
2337 group_error:
2338         /*
2339          * Groups can be scheduled in as one unit only, so undo any
2340          * partial group before returning:
2341          * The events up to the failed event are scheduled out normally.
2342          */
2343         for_each_sibling_event(event, group_event) {
2344                 if (event == partial_group)
2345                         break;
2346
2347                 event_sched_out(event, cpuctx, ctx);
2348         }
2349         event_sched_out(group_event, cpuctx, ctx);
2350
2351         pmu->cancel_txn(pmu);
2352
2353         perf_mux_hrtimer_restart(cpuctx);
2354
2355         return -EAGAIN;
2356 }
2357
2358 /*
2359  * Work out whether we can put this event group on the CPU now.
2360  */
2361 static int group_can_go_on(struct perf_event *event,
2362                            struct perf_cpu_context *cpuctx,
2363                            int can_add_hw)
2364 {
2365         /*
2366          * Groups consisting entirely of software events can always go on.
2367          */
2368         if (event->group_caps & PERF_EV_CAP_SOFTWARE)
2369                 return 1;
2370         /*
2371          * If an exclusive group is already on, no other hardware
2372          * events can go on.
2373          */
2374         if (cpuctx->exclusive)
2375                 return 0;
2376         /*
2377          * If this group is exclusive and there are already
2378          * events on the CPU, it can't go on.
2379          */
2380         if (event->attr.exclusive && cpuctx->active_oncpu)
2381                 return 0;
2382         /*
2383          * Otherwise, try to add it if all previous groups were able
2384          * to go on.
2385          */
2386         return can_add_hw;
2387 }
2388
2389 static void add_event_to_ctx(struct perf_event *event,
2390                                struct perf_event_context *ctx)
2391 {
2392         list_add_event(event, ctx);
2393         perf_group_attach(event);
2394 }
2395
2396 static void ctx_sched_out(struct perf_event_context *ctx,
2397                           struct perf_cpu_context *cpuctx,
2398                           enum event_type_t event_type);
2399 static void
2400 ctx_sched_in(struct perf_event_context *ctx,
2401              struct perf_cpu_context *cpuctx,
2402              enum event_type_t event_type,
2403              struct task_struct *task);
2404
2405 static void task_ctx_sched_out(struct perf_cpu_context *cpuctx,
2406                                struct perf_event_context *ctx,
2407                                enum event_type_t event_type)
2408 {
2409         if (!cpuctx->task_ctx)
2410                 return;
2411
2412         if (WARN_ON_ONCE(ctx != cpuctx->task_ctx))
2413                 return;
2414
2415         ctx_sched_out(ctx, cpuctx, event_type);
2416 }
2417
2418 static void perf_event_sched_in(struct perf_cpu_context *cpuctx,
2419                                 struct perf_event_context *ctx,
2420                                 struct task_struct *task)
2421 {
2422         cpu_ctx_sched_in(cpuctx, EVENT_PINNED, task);
2423         if (ctx)
2424                 ctx_sched_in(ctx, cpuctx, EVENT_PINNED, task);
2425         cpu_ctx_sched_in(cpuctx, EVENT_FLEXIBLE, task);
2426         if (ctx)
2427                 ctx_sched_in(ctx, cpuctx, EVENT_FLEXIBLE, task);
2428 }
2429
2430 /*
2431  * We want to maintain the following priority of scheduling:
2432  *  - CPU pinned (EVENT_CPU | EVENT_PINNED)
2433  *  - task pinned (EVENT_PINNED)
2434  *  - CPU flexible (EVENT_CPU | EVENT_FLEXIBLE)
2435  *  - task flexible (EVENT_FLEXIBLE).
2436  *
2437  * In order to avoid unscheduling and scheduling back in everything every
2438  * time an event is added, only do it for the groups of equal priority and
2439  * below.
2440  *
2441  * This can be called after a batch operation on task events, in which case
2442  * event_type is a bit mask of the types of events involved. For CPU events,
2443  * event_type is only either EVENT_PINNED or EVENT_FLEXIBLE.
2444  */
2445 static void ctx_resched(struct perf_cpu_context *cpuctx,
2446                         struct perf_event_context *task_ctx,
2447                         enum event_type_t event_type)
2448 {
2449         enum event_type_t ctx_event_type;
2450         bool cpu_event = !!(event_type & EVENT_CPU);
2451
2452         /*
2453          * If pinned groups are involved, flexible groups also need to be
2454          * scheduled out.
2455          */
2456         if (event_type & EVENT_PINNED)
2457                 event_type |= EVENT_FLEXIBLE;
2458
2459         ctx_event_type = event_type & EVENT_ALL;
2460
2461         perf_pmu_disable(cpuctx->ctx.pmu);
2462         if (task_ctx)
2463                 task_ctx_sched_out(cpuctx, task_ctx, event_type);
2464
2465         /*
2466          * Decide which cpu ctx groups to schedule out based on the types
2467          * of events that caused rescheduling:
2468          *  - EVENT_CPU: schedule out corresponding groups;
2469          *  - EVENT_PINNED task events: schedule out EVENT_FLEXIBLE groups;
2470          *  - otherwise, do nothing more.
2471          */
2472         if (cpu_event)
2473                 cpu_ctx_sched_out(cpuctx, ctx_event_type);
2474         else if (ctx_event_type & EVENT_PINNED)
2475                 cpu_ctx_sched_out(cpuctx, EVENT_FLEXIBLE);
2476
2477         perf_event_sched_in(cpuctx, task_ctx, current);
2478         perf_pmu_enable(cpuctx->ctx.pmu);
2479 }
2480
2481 void perf_pmu_resched(struct pmu *pmu)
2482 {
2483         struct perf_cpu_context *cpuctx = this_cpu_ptr(pmu->pmu_cpu_context);
2484         struct perf_event_context *task_ctx = cpuctx->task_ctx;
2485
2486         perf_ctx_lock(cpuctx, task_ctx);
2487         ctx_resched(cpuctx, task_ctx, EVENT_ALL|EVENT_CPU);
2488         perf_ctx_unlock(cpuctx, task_ctx);
2489 }
2490
2491 /*
2492  * Cross CPU call to install and enable a performance event
2493  *
2494  * Very similar to remote_function() + event_function() but cannot assume that
2495  * things like ctx->is_active and cpuctx->task_ctx are set.
2496  */
2497 static int  __perf_install_in_context(void *info)
2498 {
2499         struct perf_event *event = info;
2500         struct perf_event_context *ctx = event->ctx;
2501         struct perf_cpu_context *cpuctx = __get_cpu_context(ctx);
2502         struct perf_event_context *task_ctx = cpuctx->task_ctx;
2503         bool reprogram = true;
2504         int ret = 0;
2505
2506         raw_spin_lock(&cpuctx->ctx.lock);
2507         if (ctx->task) {
2508                 raw_spin_lock(&ctx->lock);
2509                 task_ctx = ctx;
2510
2511                 reprogram = (ctx->task == current);
2512
2513                 /*
2514                  * If the task is running, it must be running on this CPU,
2515                  * otherwise we cannot reprogram things.
2516                  *
2517                  * If its not running, we don't care, ctx->lock will
2518                  * serialize against it becoming runnable.
2519                  */
2520                 if (task_curr(ctx->task) && !reprogram) {
2521                         ret = -ESRCH;
2522                         goto unlock;
2523                 }
2524
2525                 WARN_ON_ONCE(reprogram && cpuctx->task_ctx && cpuctx->task_ctx != ctx);
2526         } else if (task_ctx) {
2527                 raw_spin_lock(&task_ctx->lock);
2528         }
2529
2530 #ifdef CONFIG_CGROUP_PERF
2531         if (is_cgroup_event(event)) {
2532                 /*
2533                  * If the current cgroup doesn't match the event's
2534                  * cgroup, we should not try to schedule it.
2535                  */
2536                 struct perf_cgroup *cgrp = perf_cgroup_from_task(current, ctx);
2537                 reprogram = cgroup_is_descendant(cgrp->css.cgroup,
2538                                         event->cgrp->css.cgroup);
2539         }
2540 #endif
2541
2542         if (reprogram) {
2543                 ctx_sched_out(ctx, cpuctx, EVENT_TIME);
2544                 add_event_to_ctx(event, ctx);
2545                 ctx_resched(cpuctx, task_ctx, get_event_type(event));
2546         } else {
2547                 add_event_to_ctx(event, ctx);
2548         }
2549
2550 unlock:
2551         perf_ctx_unlock(cpuctx, task_ctx);
2552
2553         return ret;
2554 }
2555
2556 static bool exclusive_event_installable(struct perf_event *event,
2557                                         struct perf_event_context *ctx);
2558
2559 /*
2560  * Attach a performance event to a context.
2561  *
2562  * Very similar to event_function_call, see comment there.
2563  */
2564 static void
2565 perf_install_in_context(struct perf_event_context *ctx,
2566                         struct perf_event *event,
2567                         int cpu)
2568 {
2569         struct task_struct *task = READ_ONCE(ctx->task);
2570
2571         lockdep_assert_held(&ctx->mutex);
2572
2573         WARN_ON_ONCE(!exclusive_event_installable(event, ctx));
2574
2575         if (event->cpu != -1)
2576                 event->cpu = cpu;
2577
2578         /*
2579          * Ensures that if we can observe event->ctx, both the event and ctx
2580          * will be 'complete'. See perf_iterate_sb_cpu().
2581          */
2582         smp_store_release(&event->ctx, ctx);
2583
2584         if (!task) {
2585                 cpu_function_call(cpu, __perf_install_in_context, event);
2586                 return;
2587         }
2588
2589         /*
2590          * Should not happen, we validate the ctx is still alive before calling.
2591          */
2592         if (WARN_ON_ONCE(task == TASK_TOMBSTONE))
2593                 return;
2594
2595         /*
2596          * Installing events is tricky because we cannot rely on ctx->is_active
2597          * to be set in case this is the nr_events 0 -> 1 transition.
2598          *
2599          * Instead we use task_curr(), which tells us if the task is running.
2600          * However, since we use task_curr() outside of rq::lock, we can race
2601          * against the actual state. This means the result can be wrong.
2602          *
2603          * If we get a false positive, we retry, this is harmless.
2604          *
2605          * If we get a false negative, things are complicated. If we are after
2606          * perf_event_context_sched_in() ctx::lock will serialize us, and the
2607          * value must be correct. If we're before, it doesn't matter since
2608          * perf_event_context_sched_in() will program the counter.
2609          *
2610          * However, this hinges on the remote context switch having observed
2611          * our task->perf_event_ctxp[] store, such that it will in fact take
2612          * ctx::lock in perf_event_context_sched_in().
2613          *
2614          * We do this by task_function_call(), if the IPI fails to hit the task
2615          * we know any future context switch of task must see the
2616          * perf_event_ctpx[] store.
2617          */
2618
2619         /*
2620          * This smp_mb() orders the task->perf_event_ctxp[] store with the
2621          * task_cpu() load, such that if the IPI then does not find the task
2622          * running, a future context switch of that task must observe the
2623          * store.
2624          */
2625         smp_mb();
2626 again:
2627         if (!task_function_call(task, __perf_install_in_context, event))
2628                 return;
2629
2630         raw_spin_lock_irq(&ctx->lock);
2631         task = ctx->task;
2632         if (WARN_ON_ONCE(task == TASK_TOMBSTONE)) {
2633                 /*
2634                  * Cannot happen because we already checked above (which also
2635                  * cannot happen), and we hold ctx->mutex, which serializes us
2636                  * against perf_event_exit_task_context().
2637                  */
2638                 raw_spin_unlock_irq(&ctx->lock);
2639                 return;
2640         }
2641         /*
2642          * If the task is not running, ctx->lock will avoid it becoming so,
2643          * thus we can safely install the event.
2644          */
2645         if (task_curr(task)) {
2646                 raw_spin_unlock_irq(&ctx->lock);
2647                 goto again;
2648         }
2649         add_event_to_ctx(event, ctx);
2650         raw_spin_unlock_irq(&ctx->lock);
2651 }
2652
2653 /*
2654  * Cross CPU call to enable a performance event
2655  */
2656 static void __perf_event_enable(struct perf_event *event,
2657                                 struct perf_cpu_context *cpuctx,
2658                                 struct perf_event_context *ctx,
2659                                 void *info)
2660 {
2661         struct perf_event *leader = event->group_leader;
2662         struct perf_event_context *task_ctx;
2663
2664         if (event->state >= PERF_EVENT_STATE_INACTIVE ||
2665             event->state <= PERF_EVENT_STATE_ERROR)
2666                 return;
2667
2668         if (ctx->is_active)
2669                 ctx_sched_out(ctx, cpuctx, EVENT_TIME);
2670
2671         perf_event_set_state(event, PERF_EVENT_STATE_INACTIVE);
2672
2673         if (!ctx->is_active)
2674                 return;
2675
2676         if (!event_filter_match(event)) {
2677                 ctx_sched_in(ctx, cpuctx, EVENT_TIME, current);
2678                 return;
2679         }
2680
2681         /*
2682          * If the event is in a group and isn't the group leader,
2683          * then don't put it on unless the group is on.
2684          */
2685         if (leader != event && leader->state != PERF_EVENT_STATE_ACTIVE) {
2686                 ctx_sched_in(ctx, cpuctx, EVENT_TIME, current);
2687                 return;
2688         }
2689
2690         task_ctx = cpuctx->task_ctx;
2691         if (ctx->task)
2692                 WARN_ON_ONCE(task_ctx != ctx);
2693
2694         ctx_resched(cpuctx, task_ctx, get_event_type(event));
2695 }
2696
2697 /*
2698  * Enable an event.
2699  *
2700  * If event->ctx is a cloned context, callers must make sure that
2701  * every task struct that event->ctx->task could possibly point to
2702  * remains valid.  This condition is satisfied when called through
2703  * perf_event_for_each_child or perf_event_for_each as described
2704  * for perf_event_disable.
2705  */
2706 static void _perf_event_enable(struct perf_event *event)
2707 {
2708         struct perf_event_context *ctx = event->ctx;
2709
2710         raw_spin_lock_irq(&ctx->lock);
2711         if (event->state >= PERF_EVENT_STATE_INACTIVE ||
2712             event->state <  PERF_EVENT_STATE_ERROR) {
2713                 raw_spin_unlock_irq(&ctx->lock);
2714                 return;
2715         }
2716
2717         /*
2718          * If the event is in error state, clear that first.
2719          *
2720          * That way, if we see the event in error state below, we know that it
2721          * has gone back into error state, as distinct from the task having
2722          * been scheduled away before the cross-call arrived.
2723          */
2724         if (event->state == PERF_EVENT_STATE_ERROR)
2725                 event->state = PERF_EVENT_STATE_OFF;
2726         raw_spin_unlock_irq(&ctx->lock);
2727
2728         event_function_call(event, __perf_event_enable, NULL);
2729 }
2730
2731 /*
2732  * See perf_event_disable();
2733  */
2734 void perf_event_enable(struct perf_event *event)
2735 {
2736         struct perf_event_context *ctx;
2737
2738         ctx = perf_event_ctx_lock(event);
2739         _perf_event_enable(event);
2740         perf_event_ctx_unlock(event, ctx);
2741 }
2742 EXPORT_SYMBOL_GPL(perf_event_enable);
2743
2744 struct stop_event_data {
2745         struct perf_event       *event;
2746         unsigned int            restart;
2747 };
2748
2749 static int __perf_event_stop(void *info)
2750 {
2751         struct stop_event_data *sd = info;
2752         struct perf_event *event = sd->event;
2753
2754         /* if it's already INACTIVE, do nothing */
2755         if (READ_ONCE(event->state) != PERF_EVENT_STATE_ACTIVE)
2756                 return 0;
2757
2758         /* matches smp_wmb() in event_sched_in() */
2759         smp_rmb();
2760
2761         /*
2762          * There is a window with interrupts enabled before we get here,
2763          * so we need to check again lest we try to stop another CPU's event.
2764          */
2765         if (READ_ONCE(event->oncpu) != smp_processor_id())
2766                 return -EAGAIN;
2767
2768         event->pmu->stop(event, PERF_EF_UPDATE);
2769
2770         /*
2771          * May race with the actual stop (through perf_pmu_output_stop()),
2772          * but it is only used for events with AUX ring buffer, and such
2773          * events will refuse to restart because of rb::aux_mmap_count==0,
2774          * see comments in perf_aux_output_begin().
2775          *
2776          * Since this is happening on an event-local CPU, no trace is lost
2777          * while restarting.
2778          */
2779         if (sd->restart)
2780                 event->pmu->start(event, 0);
2781
2782         return 0;
2783 }
2784
2785 static int perf_event_stop(struct perf_event *event, int restart)
2786 {
2787         struct stop_event_data sd = {
2788                 .event          = event,
2789                 .restart        = restart,
2790         };
2791         int ret = 0;
2792
2793         do {
2794                 if (READ_ONCE(event->state) != PERF_EVENT_STATE_ACTIVE)
2795                         return 0;
2796
2797                 /* matches smp_wmb() in event_sched_in() */
2798                 smp_rmb();
2799
2800                 /*
2801                  * We only want to restart ACTIVE events, so if the event goes
2802                  * inactive here (event->oncpu==-1), there's nothing more to do;
2803                  * fall through with ret==-ENXIO.
2804                  */
2805                 ret = cpu_function_call(READ_ONCE(event->oncpu),
2806                                         __perf_event_stop, &sd);
2807         } while (ret == -EAGAIN);
2808
2809         return ret;
2810 }
2811
2812 /*
2813  * In order to contain the amount of racy and tricky in the address filter
2814  * configuration management, it is a two part process:
2815  *
2816  * (p1) when userspace mappings change as a result of (1) or (2) or (3) below,
2817  *      we update the addresses of corresponding vmas in
2818  *      event::addr_filter_ranges array and bump the event::addr_filters_gen;
2819  * (p2) when an event is scheduled in (pmu::add), it calls
2820  *      perf_event_addr_filters_sync() which calls pmu::addr_filters_sync()
2821  *      if the generation has changed since the previous call.
2822  *
2823  * If (p1) happens while the event is active, we restart it to force (p2).
2824  *
2825  * (1) perf_addr_filters_apply(): adjusting filters' offsets based on
2826  *     pre-existing mappings, called once when new filters arrive via SET_FILTER
2827  *     ioctl;
2828  * (2) perf_addr_filters_adjust(): adjusting filters' offsets based on newly
2829  *     registered mapping, called for every new mmap(), with mm::mmap_sem down
2830  *     for reading;
2831  * (3) perf_event_addr_filters_exec(): clearing filters' offsets in the process
2832  *     of exec.
2833  */
2834 void perf_event_addr_filters_sync(struct perf_event *event)
2835 {
2836         struct perf_addr_filters_head *ifh = perf_event_addr_filters(event);
2837
2838         if (!has_addr_filter(event))
2839                 return;
2840
2841         raw_spin_lock(&ifh->lock);
2842         if (event->addr_filters_gen != event->hw.addr_filters_gen) {
2843                 event->pmu->addr_filters_sync(event);
2844                 event->hw.addr_filters_gen = event->addr_filters_gen;
2845         }
2846         raw_spin_unlock(&ifh->lock);
2847 }
2848 EXPORT_SYMBOL_GPL(perf_event_addr_filters_sync);
2849
2850 static int _perf_event_refresh(struct perf_event *event, int refresh)
2851 {
2852         /*
2853          * not supported on inherited events
2854          */
2855         if (event->attr.inherit || !is_sampling_event(event))
2856                 return -EINVAL;
2857
2858         atomic_add(refresh, &event->event_limit);
2859         _perf_event_enable(event);
2860
2861         return 0;
2862 }
2863
2864 /*
2865  * See perf_event_disable()
2866  */
2867 int perf_event_refresh(struct perf_event *event, int refresh)
2868 {
2869         struct perf_event_context *ctx;
2870         int ret;
2871
2872         ctx = perf_event_ctx_lock(event);
2873         ret = _perf_event_refresh(event, refresh);
2874         perf_event_ctx_unlock(event, ctx);
2875
2876         return ret;
2877 }
2878 EXPORT_SYMBOL_GPL(perf_event_refresh);
2879
2880 static int perf_event_modify_breakpoint(struct perf_event *bp,
2881                                          struct perf_event_attr *attr)
2882 {
2883         int err;
2884
2885         _perf_event_disable(bp);
2886
2887         err = modify_user_hw_breakpoint_check(bp, attr, true);
2888
2889         if (!bp->attr.disabled)
2890                 _perf_event_enable(bp);
2891
2892         return err;
2893 }
2894
2895 static int perf_event_modify_attr(struct perf_event *event,
2896                                   struct perf_event_attr *attr)
2897 {
2898         if (event->attr.type != attr->type)
2899                 return -EINVAL;
2900
2901         switch (event->attr.type) {
2902         case PERF_TYPE_BREAKPOINT:
2903                 return perf_event_modify_breakpoint(event, attr);
2904         default:
2905                 /* Place holder for future additions. */
2906                 return -EOPNOTSUPP;
2907         }
2908 }
2909
2910 static void ctx_sched_out(struct perf_event_context *ctx,
2911                           struct perf_cpu_context *cpuctx,
2912                           enum event_type_t event_type)
2913 {
2914         struct perf_event *event, *tmp;
2915         int is_active = ctx->is_active;
2916
2917         lockdep_assert_held(&ctx->lock);
2918
2919         if (likely(!ctx->nr_events)) {
2920                 /*
2921                  * See __perf_remove_from_context().
2922                  */
2923                 WARN_ON_ONCE(ctx->is_active);
2924                 if (ctx->task)
2925                         WARN_ON_ONCE(cpuctx->task_ctx);
2926                 return;
2927         }
2928
2929         ctx->is_active &= ~event_type;
2930         if (!(ctx->is_active & EVENT_ALL))
2931                 ctx->is_active = 0;
2932
2933         if (ctx->task) {
2934                 WARN_ON_ONCE(cpuctx->task_ctx != ctx);
2935                 if (!ctx->is_active)
2936                         cpuctx->task_ctx = NULL;
2937         }
2938
2939         /*
2940          * Always update time if it was set; not only when it changes.
2941          * Otherwise we can 'forget' to update time for any but the last
2942          * context we sched out. For example:
2943          *
2944          *   ctx_sched_out(.event_type = EVENT_FLEXIBLE)
2945          *   ctx_sched_out(.event_type = EVENT_PINNED)
2946          *
2947          * would only update time for the pinned events.
2948          */
2949         if (is_active & EVENT_TIME) {
2950                 /* update (and stop) ctx time */
2951                 update_context_time(ctx);
2952                 update_cgrp_time_from_cpuctx(cpuctx);
2953         }
2954
2955         is_active ^= ctx->is_active; /* changed bits */
2956
2957         if (!ctx->nr_active || !(is_active & EVENT_ALL))
2958                 return;
2959
2960         /*
2961          * If we had been multiplexing, no rotations are necessary, now no events
2962          * are active.
2963          */
2964         ctx->rotate_necessary = 0;
2965
2966         perf_pmu_disable(ctx->pmu);
2967         if (is_active & EVENT_PINNED) {
2968                 list_for_each_entry_safe(event, tmp, &ctx->pinned_active, active_list)
2969                         group_sched_out(event, cpuctx, ctx);
2970         }
2971
2972         if (is_active & EVENT_FLEXIBLE) {
2973                 list_for_each_entry_safe(event, tmp, &ctx->flexible_active, active_list)
2974                         group_sched_out(event, cpuctx, ctx);
2975         }
2976         perf_pmu_enable(ctx->pmu);
2977 }
2978
2979 /*
2980  * Test whether two contexts are equivalent, i.e. whether they have both been
2981  * cloned from the same version of the same context.
2982  *
2983  * Equivalence is measured using a generation number in the context that is
2984  * incremented on each modification to it; see unclone_ctx(), list_add_event()
2985  * and list_del_event().
2986  */
2987 static int context_equiv(struct perf_event_context *ctx1,
2988                          struct perf_event_context *ctx2)
2989 {
2990         lockdep_assert_held(&ctx1->lock);
2991         lockdep_assert_held(&ctx2->lock);
2992
2993         /* Pinning disables the swap optimization */
2994         if (ctx1->pin_count || ctx2->pin_count)
2995                 return 0;
2996
2997         /* If ctx1 is the parent of ctx2 */
2998         if (ctx1 == ctx2->parent_ctx && ctx1->generation == ctx2->parent_gen)
2999                 return 1;
3000
3001         /* If ctx2 is the parent of ctx1 */
3002         if (ctx1->parent_ctx == ctx2 && ctx1->parent_gen == ctx2->generation)
3003                 return 1;
3004
3005         /*
3006          * If ctx1 and ctx2 have the same parent; we flatten the parent
3007          * hierarchy, see perf_event_init_context().
3008          */
3009         if (ctx1->parent_ctx && ctx1->parent_ctx == ctx2->parent_ctx &&
3010                         ctx1->parent_gen == ctx2->parent_gen)
3011                 return 1;
3012
3013         /* Unmatched */
3014         return 0;
3015 }
3016
3017 static void __perf_event_sync_stat(struct perf_event *event,
3018                                      struct perf_event *next_event)
3019 {
3020         u64 value;
3021
3022         if (!event->attr.inherit_stat)
3023                 return;
3024
3025         /*
3026          * Update the event value, we cannot use perf_event_read()
3027          * because we're in the middle of a context switch and have IRQs
3028          * disabled, which upsets smp_call_function_single(), however
3029          * we know the event must be on the current CPU, therefore we
3030          * don't need to use it.
3031          */
3032         if (event->state == PERF_EVENT_STATE_ACTIVE)
3033                 event->pmu->read(event);
3034
3035         perf_event_update_time(event);
3036
3037         /*
3038          * In order to keep per-task stats reliable we need to flip the event
3039          * values when we flip the contexts.
3040          */
3041         value = local64_read(&next_event->count);
3042         value = local64_xchg(&event->count, value);
3043         local64_set(&next_event->count, value);
3044
3045         swap(event->total_time_enabled, next_event->total_time_enabled);
3046         swap(event->total_time_running, next_event->total_time_running);
3047
3048         /*
3049          * Since we swizzled the values, update the user visible data too.
3050          */
3051         perf_event_update_userpage(event);
3052         perf_event_update_userpage(next_event);
3053 }
3054
3055 static void perf_event_sync_stat(struct perf_event_context *ctx,
3056                                    struct perf_event_context *next_ctx)
3057 {
3058         struct perf_event *event, *next_event;
3059
3060         if (!ctx->nr_stat)
3061                 return;
3062
3063         update_context_time(ctx);
3064
3065         event = list_first_entry(&ctx->event_list,
3066                                    struct perf_event, event_entry);
3067
3068         next_event = list_first_entry(&next_ctx->event_list,
3069                                         struct perf_event, event_entry);
3070
3071         while (&event->event_entry != &ctx->event_list &&
3072                &next_event->event_entry != &next_ctx->event_list) {
3073
3074                 __perf_event_sync_stat(event, next_event);
3075
3076                 event = list_next_entry(event, event_entry);
3077                 next_event = list_next_entry(next_event, event_entry);
3078         }
3079 }
3080
3081 static void perf_event_context_sched_out(struct task_struct *task, int ctxn,
3082                                          struct task_struct *next)
3083 {
3084         struct perf_event_context *ctx = task->perf_event_ctxp[ctxn];
3085         struct perf_event_context *next_ctx;
3086         struct perf_event_context *parent, *next_parent;
3087         struct perf_cpu_context *cpuctx;
3088         int do_switch = 1;
3089
3090         if (likely(!ctx))
3091                 return;
3092
3093         cpuctx = __get_cpu_context(ctx);
3094         if (!cpuctx->task_ctx)
3095                 return;
3096
3097         rcu_read_lock();
3098         next_ctx = next->perf_event_ctxp[ctxn];
3099         if (!next_ctx)
3100                 goto unlock;
3101
3102         parent = rcu_dereference(ctx->parent_ctx);
3103         next_parent = rcu_dereference(next_ctx->parent_ctx);
3104
3105         /* If neither context have a parent context; they cannot be clones. */
3106         if (!parent && !next_parent)
3107                 goto unlock;
3108
3109         if (next_parent == ctx || next_ctx == parent || next_parent == parent) {
3110                 /*
3111                  * Looks like the two contexts are clones, so we might be
3112                  * able to optimize the context switch.  We lock both
3113                  * contexts and check that they are clones under the
3114                  * lock (including re-checking that neither has been
3115                  * uncloned in the meantime).  It doesn't matter which
3116                  * order we take the locks because no other cpu could
3117                  * be trying to lock both of these tasks.
3118                  */
3119                 raw_spin_lock(&ctx->lock);
3120                 raw_spin_lock_nested(&next_ctx->lock, SINGLE_DEPTH_NESTING);
3121                 if (context_equiv(ctx, next_ctx)) {
3122                         WRITE_ONCE(ctx->task, next);
3123                         WRITE_ONCE(next_ctx->task, task);
3124
3125                         swap(ctx->task_ctx_data, next_ctx->task_ctx_data);
3126
3127                         /*
3128                          * RCU_INIT_POINTER here is safe because we've not
3129                          * modified the ctx and the above modification of
3130                          * ctx->task and ctx->task_ctx_data are immaterial
3131                          * since those values are always verified under
3132                          * ctx->lock which we're now holding.
3133                          */
3134                         RCU_INIT_POINTER(task->perf_event_ctxp[ctxn], next_ctx);
3135                         RCU_INIT_POINTER(next->perf_event_ctxp[ctxn], ctx);
3136
3137                         do_switch = 0;
3138
3139                         perf_event_sync_stat(ctx, next_ctx);
3140                 }
3141                 raw_spin_unlock(&next_ctx->lock);
3142                 raw_spin_unlock(&ctx->lock);
3143         }
3144 unlock:
3145         rcu_read_unlock();
3146
3147         if (do_switch) {
3148                 raw_spin_lock(&ctx->lock);
3149                 task_ctx_sched_out(cpuctx, ctx, EVENT_ALL);
3150                 raw_spin_unlock(&ctx->lock);
3151         }
3152 }
3153
3154 static DEFINE_PER_CPU(struct list_head, sched_cb_list);
3155
3156 void perf_sched_cb_dec(struct pmu *pmu)
3157 {
3158         struct perf_cpu_context *cpuctx = this_cpu_ptr(pmu->pmu_cpu_context);
3159
3160         this_cpu_dec(perf_sched_cb_usages);
3161
3162         if (!--cpuctx->sched_cb_usage)
3163                 list_del(&cpuctx->sched_cb_entry);
3164 }
3165
3166
3167 void perf_sched_cb_inc(struct pmu *pmu)
3168 {
3169         struct perf_cpu_context *cpuctx = this_cpu_ptr(pmu->pmu_cpu_context);
3170
3171         if (!cpuctx->sched_cb_usage++)
3172                 list_add(&cpuctx->sched_cb_entry, this_cpu_ptr(&sched_cb_list));
3173
3174         this_cpu_inc(perf_sched_cb_usages);
3175 }
3176
3177 /*
3178  * This function provides the context switch callback to the lower code
3179  * layer. It is invoked ONLY when the context switch callback is enabled.
3180  *
3181  * This callback is relevant even to per-cpu events; for example multi event
3182  * PEBS requires this to provide PID/TID information. This requires we flush
3183  * all queued PEBS records before we context switch to a new task.
3184  */
3185 static void perf_pmu_sched_task(struct task_struct *prev,
3186                                 struct task_struct *next,
3187                                 bool sched_in)
3188 {
3189         struct perf_cpu_context *cpuctx;
3190         struct pmu *pmu;
3191
3192         if (prev == next)
3193                 return;
3194
3195         list_for_each_entry(cpuctx, this_cpu_ptr(&sched_cb_list), sched_cb_entry) {
3196                 pmu = cpuctx->ctx.pmu; /* software PMUs will not have sched_task */
3197
3198                 if (WARN_ON_ONCE(!pmu->sched_task))
3199                         continue;
3200
3201                 perf_ctx_lock(cpuctx, cpuctx->task_ctx);
3202                 perf_pmu_disable(pmu);
3203
3204                 pmu->sched_task(cpuctx->task_ctx, sched_in);
3205
3206                 perf_pmu_enable(pmu);
3207                 perf_ctx_unlock(cpuctx, cpuctx->task_ctx);
3208         }
3209 }
3210
3211 static void perf_event_switch(struct task_struct *task,
3212                               struct task_struct *next_prev, bool sched_in);
3213
3214 #define for_each_task_context_nr(ctxn)                                  \
3215         for ((ctxn) = 0; (ctxn) < perf_nr_task_contexts; (ctxn)++)
3216
3217 /*
3218  * Called from scheduler to remove the events of the current task,
3219  * with interrupts disabled.
3220  *
3221  * We stop each event and update the event value in event->count.
3222  *
3223  * This does not protect us against NMI, but disable()
3224  * sets the disabled bit in the control field of event _before_
3225  * accessing the event control register. If a NMI hits, then it will
3226  * not restart the event.
3227  */
3228 void __perf_event_task_sched_out(struct task_struct *task,
3229                                  struct task_struct *next)
3230 {
3231         int ctxn;
3232
3233         if (__this_cpu_read(perf_sched_cb_usages))
3234                 perf_pmu_sched_task(task, next, false);
3235
3236         if (atomic_read(&nr_switch_events))
3237                 perf_event_switch(task, next, false);
3238
3239         for_each_task_context_nr(ctxn)
3240                 perf_event_context_sched_out(task, ctxn, next);
3241
3242         /*
3243          * if cgroup events exist on this CPU, then we need
3244          * to check if we have to switch out PMU state.
3245          * cgroup event are system-wide mode only
3246          */
3247         if (atomic_read(this_cpu_ptr(&perf_cgroup_events)))
3248                 perf_cgroup_sched_out(task, next);
3249 }
3250
3251 /*
3252  * Called with IRQs disabled
3253  */
3254 static void cpu_ctx_sched_out(struct perf_cpu_context *cpuctx,
3255                               enum event_type_t event_type)
3256 {
3257         ctx_sched_out(&cpuctx->ctx, cpuctx, event_type);
3258 }
3259
3260 static int visit_groups_merge(struct perf_event_groups *groups, int cpu,
3261                               int (*func)(struct perf_event *, void *), void *data)
3262 {
3263         struct perf_event **evt, *evt1, *evt2;
3264         int ret;
3265
3266         evt1 = perf_event_groups_first(groups, -1);
3267         evt2 = perf_event_groups_first(groups, cpu);
3268
3269         while (evt1 || evt2) {
3270                 if (evt1 && evt2) {
3271                         if (evt1->group_index < evt2->group_index)
3272                                 evt = &evt1;
3273                         else
3274                                 evt = &evt2;
3275                 } else if (evt1) {
3276                         evt = &evt1;
3277                 } else {
3278                         evt = &evt2;
3279                 }
3280
3281                 ret = func(*evt, data);
3282                 if (ret)
3283                         return ret;
3284
3285                 *evt = perf_event_groups_next(*evt);
3286         }
3287
3288         return 0;
3289 }
3290
3291 struct sched_in_data {
3292         struct perf_event_context *ctx;
3293         struct perf_cpu_context *cpuctx;
3294         int can_add_hw;
3295 };
3296
3297 static int pinned_sched_in(struct perf_event *event, void *data)
3298 {
3299         struct sched_in_data *sid = data;
3300
3301         if (event->state <= PERF_EVENT_STATE_OFF)
3302                 return 0;
3303
3304         if (!event_filter_match(event))
3305                 return 0;
3306
3307         if (group_can_go_on(event, sid->cpuctx, sid->can_add_hw)) {
3308                 if (!group_sched_in(event, sid->cpuctx, sid->ctx))
3309                         list_add_tail(&event->active_list, &sid->ctx->pinned_active);
3310         }
3311
3312         /*
3313          * If this pinned group hasn't been scheduled,
3314          * put it in error state.
3315          */
3316         if (event->state == PERF_EVENT_STATE_INACTIVE)
3317                 perf_event_set_state(event, PERF_EVENT_STATE_ERROR);
3318
3319         return 0;
3320 }
3321
3322 static int flexible_sched_in(struct perf_event *event, void *data)
3323 {
3324         struct sched_in_data *sid = data;
3325
3326         if (event->state <= PERF_EVENT_STATE_OFF)
3327                 return 0;
3328
3329         if (!event_filter_match(event))
3330                 return 0;
3331
3332         if (group_can_go_on(event, sid->cpuctx, sid->can_add_hw)) {
3333                 int ret = group_sched_in(event, sid->cpuctx, sid->ctx);
3334                 if (ret) {
3335                         sid->can_add_hw = 0;
3336                         sid->ctx->rotate_necessary = 1;
3337                         return 0;
3338                 }
3339                 list_add_tail(&event->active_list, &sid->ctx->flexible_active);
3340         }
3341
3342         return 0;
3343 }
3344
3345 static void
3346 ctx_pinned_sched_in(struct perf_event_context *ctx,
3347                     struct perf_cpu_context *cpuctx)
3348 {
3349         struct sched_in_data sid = {
3350                 .ctx = ctx,
3351                 .cpuctx = cpuctx,
3352                 .can_add_hw = 1,
3353         };
3354
3355         visit_groups_merge(&ctx->pinned_groups,
3356                            smp_processor_id(),
3357                            pinned_sched_in, &sid);
3358 }
3359
3360 static void
3361 ctx_flexible_sched_in(struct perf_event_context *ctx,
3362                       struct perf_cpu_context *cpuctx)
3363 {
3364         struct sched_in_data sid = {
3365                 .ctx = ctx,
3366                 .cpuctx = cpuctx,
3367                 .can_add_hw = 1,
3368         };
3369
3370         visit_groups_merge(&ctx->flexible_groups,
3371                            smp_processor_id(),
3372                            flexible_sched_in, &sid);
3373 }
3374
3375 static void
3376 ctx_sched_in(struct perf_event_context *ctx,
3377              struct perf_cpu_context *cpuctx,
3378              enum event_type_t event_type,
3379              struct task_struct *task)
3380 {
3381         int is_active = ctx->is_active;
3382         u64 now;
3383
3384         lockdep_assert_held(&ctx->lock);
3385
3386         if (likely(!ctx->nr_events))
3387                 return;
3388
3389         ctx->is_active |= (event_type | EVENT_TIME);
3390         if (ctx->task) {
3391                 if (!is_active)
3392                         cpuctx->task_ctx = ctx;
3393                 else
3394                         WARN_ON_ONCE(cpuctx->task_ctx != ctx);
3395         }
3396
3397         is_active ^= ctx->is_active; /* changed bits */
3398
3399         if (is_active & EVENT_TIME) {
3400                 /* start ctx time */
3401                 now = perf_clock();
3402                 ctx->timestamp = now;
3403                 perf_cgroup_set_timestamp(task, ctx);
3404         }
3405
3406         /*
3407          * First go through the list and put on any pinned groups
3408          * in order to give them the best chance of going on.
3409          */
3410         if (is_active & EVENT_PINNED)
3411                 ctx_pinned_sched_in(ctx, cpuctx);
3412
3413         /* Then walk through the lower prio flexible groups */
3414         if (is_active & EVENT_FLEXIBLE)
3415                 ctx_flexible_sched_in(ctx, cpuctx);
3416 }
3417
3418 static void cpu_ctx_sched_in(struct perf_cpu_context *cpuctx,
3419                              enum event_type_t event_type,
3420                              struct task_struct *task)
3421 {
3422         struct perf_event_context *ctx = &cpuctx->ctx;
3423
3424         ctx_sched_in(ctx, cpuctx, event_type, task);
3425 }
3426
3427 static void perf_event_context_sched_in(struct perf_event_context *ctx,
3428                                         struct task_struct *task)
3429 {
3430         struct perf_cpu_context *cpuctx;
3431
3432         cpuctx = __get_cpu_context(ctx);
3433         if (cpuctx->task_ctx == ctx)
3434                 return;
3435
3436         perf_ctx_lock(cpuctx, ctx);
3437         /*
3438          * We must check ctx->nr_events while holding ctx->lock, such
3439          * that we serialize against perf_install_in_context().
3440          */
3441         if (!ctx->nr_events)
3442                 goto unlock;
3443
3444         perf_pmu_disable(ctx->pmu);
3445         /*
3446          * We want to keep the following priority order:
3447          * cpu pinned (that don't need to move), task pinned,
3448          * cpu flexible, task flexible.
3449          *
3450          * However, if task's ctx is not carrying any pinned
3451          * events, no need to flip the cpuctx's events around.
3452          */
3453         if (!RB_EMPTY_ROOT(&ctx->pinned_groups.tree))
3454                 cpu_ctx_sched_out(cpuctx, EVENT_FLEXIBLE);
3455         perf_event_sched_in(cpuctx, ctx, task);
3456         perf_pmu_enable(ctx->pmu);
3457
3458 unlock:
3459         perf_ctx_unlock(cpuctx, ctx);
3460 }
3461
3462 /*
3463  * Called from scheduler to add the events of the current task
3464  * with interrupts disabled.
3465  *
3466  * We restore the event value and then enable it.
3467  *
3468  * This does not protect us against NMI, but enable()
3469  * sets the enabled bit in the control field of event _before_
3470  * accessing the event control register. If a NMI hits, then it will
3471  * keep the event running.
3472  */
3473 void __perf_event_task_sched_in(struct task_struct *prev,
3474                                 struct task_struct *task)
3475 {
3476         struct perf_event_context *ctx;
3477         int ctxn;
3478
3479         /*
3480          * If cgroup events exist on this CPU, then we need to check if we have
3481          * to switch in PMU state; cgroup event are system-wide mode only.
3482          *
3483          * Since cgroup events are CPU events, we must schedule these in before
3484          * we schedule in the task events.
3485          */
3486         if (atomic_read(this_cpu_ptr(&perf_cgroup_events)))
3487                 perf_cgroup_sched_in(prev, task);
3488
3489         for_each_task_context_nr(ctxn) {
3490                 ctx = task->perf_event_ctxp[ctxn];
3491                 if (likely(!ctx))
3492                         continue;
3493
3494                 perf_event_context_sched_in(ctx, task);
3495         }
3496
3497         if (atomic_read(&nr_switch_events))
3498                 perf_event_switch(task, prev, true);
3499
3500         if (__this_cpu_read(perf_sched_cb_usages))
3501                 perf_pmu_sched_task(prev, task, true);
3502 }
3503
3504 static u64 perf_calculate_period(struct perf_event *event, u64 nsec, u64 count)
3505 {
3506         u64 frequency = event->attr.sample_freq;
3507         u64 sec = NSEC_PER_SEC;
3508         u64 divisor, dividend;
3509
3510         int count_fls, nsec_fls, frequency_fls, sec_fls;
3511
3512         count_fls = fls64(count);
3513         nsec_fls = fls64(nsec);
3514         frequency_fls = fls64(frequency);
3515         sec_fls = 30;
3516
3517         /*
3518          * We got @count in @nsec, with a target of sample_freq HZ
3519          * the target period becomes:
3520          *
3521          *             @count * 10^9
3522          * period = -------------------
3523          *          @nsec * sample_freq
3524          *
3525          */
3526
3527         /*
3528          * Reduce accuracy by one bit such that @a and @b converge
3529          * to a similar magnitude.
3530          */
3531 #define REDUCE_FLS(a, b)                \
3532 do {                                    \
3533         if (a##_fls > b##_fls) {        \
3534                 a >>= 1;                \
3535                 a##_fls--;              \
3536         } else {                        \
3537                 b >>= 1;                \
3538                 b##_fls--;              \
3539         }                               \
3540 } while (0)
3541
3542         /*
3543          * Reduce accuracy until either term fits in a u64, then proceed with
3544          * the other, so that finally we can do a u64/u64 division.
3545          */
3546         while (count_fls + sec_fls > 64 && nsec_fls + frequency_fls > 64) {
3547                 REDUCE_FLS(nsec, frequency);
3548                 REDUCE_FLS(sec, count);
3549         }
3550
3551         if (count_fls + sec_fls > 64) {
3552                 divisor = nsec * frequency;
3553
3554                 while (count_fls + sec_fls > 64) {
3555                         REDUCE_FLS(count, sec);
3556                         divisor >>= 1;
3557                 }
3558
3559                 dividend = count * sec;
3560         } else {
3561                 dividend = count * sec;
3562
3563                 while (nsec_fls + frequency_fls > 64) {
3564                         REDUCE_FLS(nsec, frequency);
3565                         dividend >>= 1;
3566                 }
3567
3568                 divisor = nsec * frequency;
3569         }
3570
3571         if (!divisor)
3572                 return dividend;
3573
3574         return div64_u64(dividend, divisor);
3575 }
3576
3577 static DEFINE_PER_CPU(int, perf_throttled_count);
3578 static DEFINE_PER_CPU(u64, perf_throttled_seq);
3579
3580 static void perf_adjust_period(struct perf_event *event, u64 nsec, u64 count, bool disable)
3581 {
3582         struct hw_perf_event *hwc = &event->hw;
3583         s64 period, sample_period;
3584         s64 delta;
3585
3586         period = perf_calculate_period(event, nsec, count);
3587
3588         delta = (s64)(period - hwc->sample_period);
3589         delta = (delta + 7) / 8; /* low pass filter */
3590
3591         sample_period = hwc->sample_period + delta;
3592
3593         if (!sample_period)
3594                 sample_period = 1;
3595
3596         hwc->sample_period = sample_period;
3597
3598         if (local64_read(&hwc->period_left) > 8*sample_period) {
3599                 if (disable)
3600                         event->pmu->stop(event, PERF_EF_UPDATE);
3601
3602                 local64_set(&hwc->period_left, 0);
3603
3604                 if (disable)
3605                         event->pmu->start(event, PERF_EF_RELOAD);
3606         }
3607 }
3608
3609 /*
3610  * combine freq adjustment with unthrottling to avoid two passes over the
3611  * events. At the same time, make sure, having freq events does not change
3612  * the rate of unthrottling as that would introduce bias.
3613  */
3614 static void perf_adjust_freq_unthr_context(struct perf_event_context *ctx,
3615                                            int needs_unthr)
3616 {
3617         struct perf_event *event;
3618         struct hw_perf_event *hwc;
3619         u64 now, period = TICK_NSEC;
3620         s64 delta;
3621
3622         /*
3623          * only need to iterate over all events iff:
3624          * - context have events in frequency mode (needs freq adjust)
3625          * - there are events to unthrottle on this cpu
3626          */
3627         if (!(ctx->nr_freq || needs_unthr))
3628                 return;
3629
3630         raw_spin_lock(&ctx->lock);
3631         perf_pmu_disable(ctx->pmu);
3632
3633         list_for_each_entry_rcu(event, &ctx->event_list, event_entry) {
3634                 if (event->state != PERF_EVENT_STATE_ACTIVE)
3635                         continue;
3636
3637                 if (!event_fi