Merge branch 'perf-urgent-for-linus' of git://git.kernel.org/pub/scm/linux/kernel...
[muen/linux.git] / kernel / events / core.c
1 /*
2  * Performance events core code:
3  *
4  *  Copyright (C) 2008 Thomas Gleixner <tglx@linutronix.de>
5  *  Copyright (C) 2008-2011 Red Hat, Inc., Ingo Molnar
6  *  Copyright (C) 2008-2011 Red Hat, Inc., Peter Zijlstra
7  *  Copyright  ©  2009 Paul Mackerras, IBM Corp. <paulus@au1.ibm.com>
8  *
9  * For licensing details see kernel-base/COPYING
10  */
11
12 #include <linux/fs.h>
13 #include <linux/mm.h>
14 #include <linux/cpu.h>
15 #include <linux/smp.h>
16 #include <linux/idr.h>
17 #include <linux/file.h>
18 #include <linux/poll.h>
19 #include <linux/slab.h>
20 #include <linux/hash.h>
21 #include <linux/tick.h>
22 #include <linux/sysfs.h>
23 #include <linux/dcache.h>
24 #include <linux/percpu.h>
25 #include <linux/ptrace.h>
26 #include <linux/reboot.h>
27 #include <linux/vmstat.h>
28 #include <linux/device.h>
29 #include <linux/export.h>
30 #include <linux/vmalloc.h>
31 #include <linux/hardirq.h>
32 #include <linux/rculist.h>
33 #include <linux/uaccess.h>
34 #include <linux/syscalls.h>
35 #include <linux/anon_inodes.h>
36 #include <linux/kernel_stat.h>
37 #include <linux/cgroup.h>
38 #include <linux/perf_event.h>
39 #include <linux/trace_events.h>
40 #include <linux/hw_breakpoint.h>
41 #include <linux/mm_types.h>
42 #include <linux/module.h>
43 #include <linux/mman.h>
44 #include <linux/compat.h>
45 #include <linux/bpf.h>
46 #include <linux/filter.h>
47 #include <linux/namei.h>
48 #include <linux/parser.h>
49 #include <linux/sched/clock.h>
50 #include <linux/sched/mm.h>
51 #include <linux/proc_ns.h>
52 #include <linux/mount.h>
53
54 #include "internal.h"
55
56 #include <asm/irq_regs.h>
57
58 typedef int (*remote_function_f)(void *);
59
60 struct remote_function_call {
61         struct task_struct      *p;
62         remote_function_f       func;
63         void                    *info;
64         int                     ret;
65 };
66
67 static void remote_function(void *data)
68 {
69         struct remote_function_call *tfc = data;
70         struct task_struct *p = tfc->p;
71
72         if (p) {
73                 /* -EAGAIN */
74                 if (task_cpu(p) != smp_processor_id())
75                         return;
76
77                 /*
78                  * Now that we're on right CPU with IRQs disabled, we can test
79                  * if we hit the right task without races.
80                  */
81
82                 tfc->ret = -ESRCH; /* No such (running) process */
83                 if (p != current)
84                         return;
85         }
86
87         tfc->ret = tfc->func(tfc->info);
88 }
89
90 /**
91  * task_function_call - call a function on the cpu on which a task runs
92  * @p:          the task to evaluate
93  * @func:       the function to be called
94  * @info:       the function call argument
95  *
96  * Calls the function @func when the task is currently running. This might
97  * be on the current CPU, which just calls the function directly
98  *
99  * returns: @func return value, or
100  *          -ESRCH  - when the process isn't running
101  *          -EAGAIN - when the process moved away
102  */
103 static int
104 task_function_call(struct task_struct *p, remote_function_f func, void *info)
105 {
106         struct remote_function_call data = {
107                 .p      = p,
108                 .func   = func,
109                 .info   = info,
110                 .ret    = -EAGAIN,
111         };
112         int ret;
113
114         do {
115                 ret = smp_call_function_single(task_cpu(p), remote_function, &data, 1);
116                 if (!ret)
117                         ret = data.ret;
118         } while (ret == -EAGAIN);
119
120         return ret;
121 }
122
123 /**
124  * cpu_function_call - call a function on the cpu
125  * @func:       the function to be called
126  * @info:       the function call argument
127  *
128  * Calls the function @func on the remote cpu.
129  *
130  * returns: @func return value or -ENXIO when the cpu is offline
131  */
132 static int cpu_function_call(int cpu, remote_function_f func, void *info)
133 {
134         struct remote_function_call data = {
135                 .p      = NULL,
136                 .func   = func,
137                 .info   = info,
138                 .ret    = -ENXIO, /* No such CPU */
139         };
140
141         smp_call_function_single(cpu, remote_function, &data, 1);
142
143         return data.ret;
144 }
145
146 static inline struct perf_cpu_context *
147 __get_cpu_context(struct perf_event_context *ctx)
148 {
149         return this_cpu_ptr(ctx->pmu->pmu_cpu_context);
150 }
151
152 static void perf_ctx_lock(struct perf_cpu_context *cpuctx,
153                           struct perf_event_context *ctx)
154 {
155         raw_spin_lock(&cpuctx->ctx.lock);
156         if (ctx)
157                 raw_spin_lock(&ctx->lock);
158 }
159
160 static void perf_ctx_unlock(struct perf_cpu_context *cpuctx,
161                             struct perf_event_context *ctx)
162 {
163         if (ctx)
164                 raw_spin_unlock(&ctx->lock);
165         raw_spin_unlock(&cpuctx->ctx.lock);
166 }
167
168 #define TASK_TOMBSTONE ((void *)-1L)
169
170 static bool is_kernel_event(struct perf_event *event)
171 {
172         return READ_ONCE(event->owner) == TASK_TOMBSTONE;
173 }
174
175 /*
176  * On task ctx scheduling...
177  *
178  * When !ctx->nr_events a task context will not be scheduled. This means
179  * we can disable the scheduler hooks (for performance) without leaving
180  * pending task ctx state.
181  *
182  * This however results in two special cases:
183  *
184  *  - removing the last event from a task ctx; this is relatively straight
185  *    forward and is done in __perf_remove_from_context.
186  *
187  *  - adding the first event to a task ctx; this is tricky because we cannot
188  *    rely on ctx->is_active and therefore cannot use event_function_call().
189  *    See perf_install_in_context().
190  *
191  * If ctx->nr_events, then ctx->is_active and cpuctx->task_ctx are set.
192  */
193
194 typedef void (*event_f)(struct perf_event *, struct perf_cpu_context *,
195                         struct perf_event_context *, void *);
196
197 struct event_function_struct {
198         struct perf_event *event;
199         event_f func;
200         void *data;
201 };
202
203 static int event_function(void *info)
204 {
205         struct event_function_struct *efs = info;
206         struct perf_event *event = efs->event;
207         struct perf_event_context *ctx = event->ctx;
208         struct perf_cpu_context *cpuctx = __get_cpu_context(ctx);
209         struct perf_event_context *task_ctx = cpuctx->task_ctx;
210         int ret = 0;
211
212         WARN_ON_ONCE(!irqs_disabled());
213
214         perf_ctx_lock(cpuctx, task_ctx);
215         /*
216          * Since we do the IPI call without holding ctx->lock things can have
217          * changed, double check we hit the task we set out to hit.
218          */
219         if (ctx->task) {
220                 if (ctx->task != current) {
221                         ret = -ESRCH;
222                         goto unlock;
223                 }
224
225                 /*
226                  * We only use event_function_call() on established contexts,
227                  * and event_function() is only ever called when active (or
228                  * rather, we'll have bailed in task_function_call() or the
229                  * above ctx->task != current test), therefore we must have
230                  * ctx->is_active here.
231                  */
232                 WARN_ON_ONCE(!ctx->is_active);
233                 /*
234                  * And since we have ctx->is_active, cpuctx->task_ctx must
235                  * match.
236                  */
237                 WARN_ON_ONCE(task_ctx != ctx);
238         } else {
239                 WARN_ON_ONCE(&cpuctx->ctx != ctx);
240         }
241
242         efs->func(event, cpuctx, ctx, efs->data);
243 unlock:
244         perf_ctx_unlock(cpuctx, task_ctx);
245
246         return ret;
247 }
248
249 static void event_function_call(struct perf_event *event, event_f func, void *data)
250 {
251         struct perf_event_context *ctx = event->ctx;
252         struct task_struct *task = READ_ONCE(ctx->task); /* verified in event_function */
253         struct event_function_struct efs = {
254                 .event = event,
255                 .func = func,
256                 .data = data,
257         };
258
259         if (!event->parent) {
260                 /*
261                  * If this is a !child event, we must hold ctx::mutex to
262                  * stabilize the the event->ctx relation. See
263                  * perf_event_ctx_lock().
264                  */
265                 lockdep_assert_held(&ctx->mutex);
266         }
267
268         if (!task) {
269                 cpu_function_call(event->cpu, event_function, &efs);
270                 return;
271         }
272
273         if (task == TASK_TOMBSTONE)
274                 return;
275
276 again:
277         if (!task_function_call(task, event_function, &efs))
278                 return;
279
280         raw_spin_lock_irq(&ctx->lock);
281         /*
282          * Reload the task pointer, it might have been changed by
283          * a concurrent perf_event_context_sched_out().
284          */
285         task = ctx->task;
286         if (task == TASK_TOMBSTONE) {
287                 raw_spin_unlock_irq(&ctx->lock);
288                 return;
289         }
290         if (ctx->is_active) {
291                 raw_spin_unlock_irq(&ctx->lock);
292                 goto again;
293         }
294         func(event, NULL, ctx, data);
295         raw_spin_unlock_irq(&ctx->lock);
296 }
297
298 /*
299  * Similar to event_function_call() + event_function(), but hard assumes IRQs
300  * are already disabled and we're on the right CPU.
301  */
302 static void event_function_local(struct perf_event *event, event_f func, void *data)
303 {
304         struct perf_event_context *ctx = event->ctx;
305         struct perf_cpu_context *cpuctx = __get_cpu_context(ctx);
306         struct task_struct *task = READ_ONCE(ctx->task);
307         struct perf_event_context *task_ctx = NULL;
308
309         WARN_ON_ONCE(!irqs_disabled());
310
311         if (task) {
312                 if (task == TASK_TOMBSTONE)
313                         return;
314
315                 task_ctx = ctx;
316         }
317
318         perf_ctx_lock(cpuctx, task_ctx);
319
320         task = ctx->task;
321         if (task == TASK_TOMBSTONE)
322                 goto unlock;
323
324         if (task) {
325                 /*
326                  * We must be either inactive or active and the right task,
327                  * otherwise we're screwed, since we cannot IPI to somewhere
328                  * else.
329                  */
330                 if (ctx->is_active) {
331                         if (WARN_ON_ONCE(task != current))
332                                 goto unlock;
333
334                         if (WARN_ON_ONCE(cpuctx->task_ctx != ctx))
335                                 goto unlock;
336                 }
337         } else {
338                 WARN_ON_ONCE(&cpuctx->ctx != ctx);
339         }
340
341         func(event, cpuctx, ctx, data);
342 unlock:
343         perf_ctx_unlock(cpuctx, task_ctx);
344 }
345
346 #define PERF_FLAG_ALL (PERF_FLAG_FD_NO_GROUP |\
347                        PERF_FLAG_FD_OUTPUT  |\
348                        PERF_FLAG_PID_CGROUP |\
349                        PERF_FLAG_FD_CLOEXEC)
350
351 /*
352  * branch priv levels that need permission checks
353  */
354 #define PERF_SAMPLE_BRANCH_PERM_PLM \
355         (PERF_SAMPLE_BRANCH_KERNEL |\
356          PERF_SAMPLE_BRANCH_HV)
357
358 enum event_type_t {
359         EVENT_FLEXIBLE = 0x1,
360         EVENT_PINNED = 0x2,
361         EVENT_TIME = 0x4,
362         /* see ctx_resched() for details */
363         EVENT_CPU = 0x8,
364         EVENT_ALL = EVENT_FLEXIBLE | EVENT_PINNED,
365 };
366
367 /*
368  * perf_sched_events : >0 events exist
369  * perf_cgroup_events: >0 per-cpu cgroup events exist on this cpu
370  */
371
372 static void perf_sched_delayed(struct work_struct *work);
373 DEFINE_STATIC_KEY_FALSE(perf_sched_events);
374 static DECLARE_DELAYED_WORK(perf_sched_work, perf_sched_delayed);
375 static DEFINE_MUTEX(perf_sched_mutex);
376 static atomic_t perf_sched_count;
377
378 static DEFINE_PER_CPU(atomic_t, perf_cgroup_events);
379 static DEFINE_PER_CPU(int, perf_sched_cb_usages);
380 static DEFINE_PER_CPU(struct pmu_event_list, pmu_sb_events);
381
382 static atomic_t nr_mmap_events __read_mostly;
383 static atomic_t nr_comm_events __read_mostly;
384 static atomic_t nr_namespaces_events __read_mostly;
385 static atomic_t nr_task_events __read_mostly;
386 static atomic_t nr_freq_events __read_mostly;
387 static atomic_t nr_switch_events __read_mostly;
388
389 static LIST_HEAD(pmus);
390 static DEFINE_MUTEX(pmus_lock);
391 static struct srcu_struct pmus_srcu;
392 static cpumask_var_t perf_online_mask;
393
394 /*
395  * perf event paranoia level:
396  *  -1 - not paranoid at all
397  *   0 - disallow raw tracepoint access for unpriv
398  *   1 - disallow cpu events for unpriv
399  *   2 - disallow kernel profiling for unpriv
400  */
401 int sysctl_perf_event_paranoid __read_mostly = 2;
402
403 /* Minimum for 512 kiB + 1 user control page */
404 int sysctl_perf_event_mlock __read_mostly = 512 + (PAGE_SIZE / 1024); /* 'free' kiB per user */
405
406 /*
407  * max perf event sample rate
408  */
409 #define DEFAULT_MAX_SAMPLE_RATE         100000
410 #define DEFAULT_SAMPLE_PERIOD_NS        (NSEC_PER_SEC / DEFAULT_MAX_SAMPLE_RATE)
411 #define DEFAULT_CPU_TIME_MAX_PERCENT    25
412
413 int sysctl_perf_event_sample_rate __read_mostly = DEFAULT_MAX_SAMPLE_RATE;
414
415 static int max_samples_per_tick __read_mostly   = DIV_ROUND_UP(DEFAULT_MAX_SAMPLE_RATE, HZ);
416 static int perf_sample_period_ns __read_mostly  = DEFAULT_SAMPLE_PERIOD_NS;
417
418 static int perf_sample_allowed_ns __read_mostly =
419         DEFAULT_SAMPLE_PERIOD_NS * DEFAULT_CPU_TIME_MAX_PERCENT / 100;
420
421 static void update_perf_cpu_limits(void)
422 {
423         u64 tmp = perf_sample_period_ns;
424
425         tmp *= sysctl_perf_cpu_time_max_percent;
426         tmp = div_u64(tmp, 100);
427         if (!tmp)
428                 tmp = 1;
429
430         WRITE_ONCE(perf_sample_allowed_ns, tmp);
431 }
432
433 static int perf_rotate_context(struct perf_cpu_context *cpuctx);
434
435 int perf_proc_update_handler(struct ctl_table *table, int write,
436                 void __user *buffer, size_t *lenp,
437                 loff_t *ppos)
438 {
439         int ret = proc_dointvec_minmax(table, write, buffer, lenp, ppos);
440
441         if (ret || !write)
442                 return ret;
443
444         /*
445          * If throttling is disabled don't allow the write:
446          */
447         if (sysctl_perf_cpu_time_max_percent == 100 ||
448             sysctl_perf_cpu_time_max_percent == 0)
449                 return -EINVAL;
450
451         max_samples_per_tick = DIV_ROUND_UP(sysctl_perf_event_sample_rate, HZ);
452         perf_sample_period_ns = NSEC_PER_SEC / sysctl_perf_event_sample_rate;
453         update_perf_cpu_limits();
454
455         return 0;
456 }
457
458 int sysctl_perf_cpu_time_max_percent __read_mostly = DEFAULT_CPU_TIME_MAX_PERCENT;
459
460 int perf_cpu_time_max_percent_handler(struct ctl_table *table, int write,
461                                 void __user *buffer, size_t *lenp,
462                                 loff_t *ppos)
463 {
464         int ret = proc_dointvec_minmax(table, write, buffer, lenp, ppos);
465
466         if (ret || !write)
467                 return ret;
468
469         if (sysctl_perf_cpu_time_max_percent == 100 ||
470             sysctl_perf_cpu_time_max_percent == 0) {
471                 printk(KERN_WARNING
472                        "perf: Dynamic interrupt throttling disabled, can hang your system!\n");
473                 WRITE_ONCE(perf_sample_allowed_ns, 0);
474         } else {
475                 update_perf_cpu_limits();
476         }
477
478         return 0;
479 }
480
481 /*
482  * perf samples are done in some very critical code paths (NMIs).
483  * If they take too much CPU time, the system can lock up and not
484  * get any real work done.  This will drop the sample rate when
485  * we detect that events are taking too long.
486  */
487 #define NR_ACCUMULATED_SAMPLES 128
488 static DEFINE_PER_CPU(u64, running_sample_length);
489
490 static u64 __report_avg;
491 static u64 __report_allowed;
492
493 static void perf_duration_warn(struct irq_work *w)
494 {
495         printk_ratelimited(KERN_INFO
496                 "perf: interrupt took too long (%lld > %lld), lowering "
497                 "kernel.perf_event_max_sample_rate to %d\n",
498                 __report_avg, __report_allowed,
499                 sysctl_perf_event_sample_rate);
500 }
501
502 static DEFINE_IRQ_WORK(perf_duration_work, perf_duration_warn);
503
504 void perf_sample_event_took(u64 sample_len_ns)
505 {
506         u64 max_len = READ_ONCE(perf_sample_allowed_ns);
507         u64 running_len;
508         u64 avg_len;
509         u32 max;
510
511         if (max_len == 0)
512                 return;
513
514         /* Decay the counter by 1 average sample. */
515         running_len = __this_cpu_read(running_sample_length);
516         running_len -= running_len/NR_ACCUMULATED_SAMPLES;
517         running_len += sample_len_ns;
518         __this_cpu_write(running_sample_length, running_len);
519
520         /*
521          * Note: this will be biased artifically low until we have
522          * seen NR_ACCUMULATED_SAMPLES. Doing it this way keeps us
523          * from having to maintain a count.
524          */
525         avg_len = running_len/NR_ACCUMULATED_SAMPLES;
526         if (avg_len <= max_len)
527                 return;
528
529         __report_avg = avg_len;
530         __report_allowed = max_len;
531
532         /*
533          * Compute a throttle threshold 25% below the current duration.
534          */
535         avg_len += avg_len / 4;
536         max = (TICK_NSEC / 100) * sysctl_perf_cpu_time_max_percent;
537         if (avg_len < max)
538                 max /= (u32)avg_len;
539         else
540                 max = 1;
541
542         WRITE_ONCE(perf_sample_allowed_ns, avg_len);
543         WRITE_ONCE(max_samples_per_tick, max);
544
545         sysctl_perf_event_sample_rate = max * HZ;
546         perf_sample_period_ns = NSEC_PER_SEC / sysctl_perf_event_sample_rate;
547
548         if (!irq_work_queue(&perf_duration_work)) {
549                 early_printk("perf: interrupt took too long (%lld > %lld), lowering "
550                              "kernel.perf_event_max_sample_rate to %d\n",
551                              __report_avg, __report_allowed,
552                              sysctl_perf_event_sample_rate);
553         }
554 }
555
556 static atomic64_t perf_event_id;
557
558 static void cpu_ctx_sched_out(struct perf_cpu_context *cpuctx,
559                               enum event_type_t event_type);
560
561 static void cpu_ctx_sched_in(struct perf_cpu_context *cpuctx,
562                              enum event_type_t event_type,
563                              struct task_struct *task);
564
565 static void update_context_time(struct perf_event_context *ctx);
566 static u64 perf_event_time(struct perf_event *event);
567
568 void __weak perf_event_print_debug(void)        { }
569
570 extern __weak const char *perf_pmu_name(void)
571 {
572         return "pmu";
573 }
574
575 static inline u64 perf_clock(void)
576 {
577         return local_clock();
578 }
579
580 static inline u64 perf_event_clock(struct perf_event *event)
581 {
582         return event->clock();
583 }
584
585 #ifdef CONFIG_CGROUP_PERF
586
587 static inline bool
588 perf_cgroup_match(struct perf_event *event)
589 {
590         struct perf_event_context *ctx = event->ctx;
591         struct perf_cpu_context *cpuctx = __get_cpu_context(ctx);
592
593         /* @event doesn't care about cgroup */
594         if (!event->cgrp)
595                 return true;
596
597         /* wants specific cgroup scope but @cpuctx isn't associated with any */
598         if (!cpuctx->cgrp)
599                 return false;
600
601         /*
602          * Cgroup scoping is recursive.  An event enabled for a cgroup is
603          * also enabled for all its descendant cgroups.  If @cpuctx's
604          * cgroup is a descendant of @event's (the test covers identity
605          * case), it's a match.
606          */
607         return cgroup_is_descendant(cpuctx->cgrp->css.cgroup,
608                                     event->cgrp->css.cgroup);
609 }
610
611 static inline void perf_detach_cgroup(struct perf_event *event)
612 {
613         css_put(&event->cgrp->css);
614         event->cgrp = NULL;
615 }
616
617 static inline int is_cgroup_event(struct perf_event *event)
618 {
619         return event->cgrp != NULL;
620 }
621
622 static inline u64 perf_cgroup_event_time(struct perf_event *event)
623 {
624         struct perf_cgroup_info *t;
625
626         t = per_cpu_ptr(event->cgrp->info, event->cpu);
627         return t->time;
628 }
629
630 static inline void __update_cgrp_time(struct perf_cgroup *cgrp)
631 {
632         struct perf_cgroup_info *info;
633         u64 now;
634
635         now = perf_clock();
636
637         info = this_cpu_ptr(cgrp->info);
638
639         info->time += now - info->timestamp;
640         info->timestamp = now;
641 }
642
643 static inline void update_cgrp_time_from_cpuctx(struct perf_cpu_context *cpuctx)
644 {
645         struct perf_cgroup *cgrp_out = cpuctx->cgrp;
646         if (cgrp_out)
647                 __update_cgrp_time(cgrp_out);
648 }
649
650 static inline void update_cgrp_time_from_event(struct perf_event *event)
651 {
652         struct perf_cgroup *cgrp;
653
654         /*
655          * ensure we access cgroup data only when needed and
656          * when we know the cgroup is pinned (css_get)
657          */
658         if (!is_cgroup_event(event))
659                 return;
660
661         cgrp = perf_cgroup_from_task(current, event->ctx);
662         /*
663          * Do not update time when cgroup is not active
664          */
665         if (cgrp == event->cgrp)
666                 __update_cgrp_time(event->cgrp);
667 }
668
669 static inline void
670 perf_cgroup_set_timestamp(struct task_struct *task,
671                           struct perf_event_context *ctx)
672 {
673         struct perf_cgroup *cgrp;
674         struct perf_cgroup_info *info;
675
676         /*
677          * ctx->lock held by caller
678          * ensure we do not access cgroup data
679          * unless we have the cgroup pinned (css_get)
680          */
681         if (!task || !ctx->nr_cgroups)
682                 return;
683
684         cgrp = perf_cgroup_from_task(task, ctx);
685         info = this_cpu_ptr(cgrp->info);
686         info->timestamp = ctx->timestamp;
687 }
688
689 static DEFINE_PER_CPU(struct list_head, cgrp_cpuctx_list);
690
691 #define PERF_CGROUP_SWOUT       0x1 /* cgroup switch out every event */
692 #define PERF_CGROUP_SWIN        0x2 /* cgroup switch in events based on task */
693
694 /*
695  * reschedule events based on the cgroup constraint of task.
696  *
697  * mode SWOUT : schedule out everything
698  * mode SWIN : schedule in based on cgroup for next
699  */
700 static void perf_cgroup_switch(struct task_struct *task, int mode)
701 {
702         struct perf_cpu_context *cpuctx;
703         struct list_head *list;
704         unsigned long flags;
705
706         /*
707          * Disable interrupts and preemption to avoid this CPU's
708          * cgrp_cpuctx_entry to change under us.
709          */
710         local_irq_save(flags);
711
712         list = this_cpu_ptr(&cgrp_cpuctx_list);
713         list_for_each_entry(cpuctx, list, cgrp_cpuctx_entry) {
714                 WARN_ON_ONCE(cpuctx->ctx.nr_cgroups == 0);
715
716                 perf_ctx_lock(cpuctx, cpuctx->task_ctx);
717                 perf_pmu_disable(cpuctx->ctx.pmu);
718
719                 if (mode & PERF_CGROUP_SWOUT) {
720                         cpu_ctx_sched_out(cpuctx, EVENT_ALL);
721                         /*
722                          * must not be done before ctxswout due
723                          * to event_filter_match() in event_sched_out()
724                          */
725                         cpuctx->cgrp = NULL;
726                 }
727
728                 if (mode & PERF_CGROUP_SWIN) {
729                         WARN_ON_ONCE(cpuctx->cgrp);
730                         /*
731                          * set cgrp before ctxsw in to allow
732                          * event_filter_match() to not have to pass
733                          * task around
734                          * we pass the cpuctx->ctx to perf_cgroup_from_task()
735                          * because cgorup events are only per-cpu
736                          */
737                         cpuctx->cgrp = perf_cgroup_from_task(task,
738                                                              &cpuctx->ctx);
739                         cpu_ctx_sched_in(cpuctx, EVENT_ALL, task);
740                 }
741                 perf_pmu_enable(cpuctx->ctx.pmu);
742                 perf_ctx_unlock(cpuctx, cpuctx->task_ctx);
743         }
744
745         local_irq_restore(flags);
746 }
747
748 static inline void perf_cgroup_sched_out(struct task_struct *task,
749                                          struct task_struct *next)
750 {
751         struct perf_cgroup *cgrp1;
752         struct perf_cgroup *cgrp2 = NULL;
753
754         rcu_read_lock();
755         /*
756          * we come here when we know perf_cgroup_events > 0
757          * we do not need to pass the ctx here because we know
758          * we are holding the rcu lock
759          */
760         cgrp1 = perf_cgroup_from_task(task, NULL);
761         cgrp2 = perf_cgroup_from_task(next, NULL);
762
763         /*
764          * only schedule out current cgroup events if we know
765          * that we are switching to a different cgroup. Otherwise,
766          * do no touch the cgroup events.
767          */
768         if (cgrp1 != cgrp2)
769                 perf_cgroup_switch(task, PERF_CGROUP_SWOUT);
770
771         rcu_read_unlock();
772 }
773
774 static inline void perf_cgroup_sched_in(struct task_struct *prev,
775                                         struct task_struct *task)
776 {
777         struct perf_cgroup *cgrp1;
778         struct perf_cgroup *cgrp2 = NULL;
779
780         rcu_read_lock();
781         /*
782          * we come here when we know perf_cgroup_events > 0
783          * we do not need to pass the ctx here because we know
784          * we are holding the rcu lock
785          */
786         cgrp1 = perf_cgroup_from_task(task, NULL);
787         cgrp2 = perf_cgroup_from_task(prev, NULL);
788
789         /*
790          * only need to schedule in cgroup events if we are changing
791          * cgroup during ctxsw. Cgroup events were not scheduled
792          * out of ctxsw out if that was not the case.
793          */
794         if (cgrp1 != cgrp2)
795                 perf_cgroup_switch(task, PERF_CGROUP_SWIN);
796
797         rcu_read_unlock();
798 }
799
800 static inline int perf_cgroup_connect(int fd, struct perf_event *event,
801                                       struct perf_event_attr *attr,
802                                       struct perf_event *group_leader)
803 {
804         struct perf_cgroup *cgrp;
805         struct cgroup_subsys_state *css;
806         struct fd f = fdget(fd);
807         int ret = 0;
808
809         if (!f.file)
810                 return -EBADF;
811
812         css = css_tryget_online_from_dir(f.file->f_path.dentry,
813                                          &perf_event_cgrp_subsys);
814         if (IS_ERR(css)) {
815                 ret = PTR_ERR(css);
816                 goto out;
817         }
818
819         cgrp = container_of(css, struct perf_cgroup, css);
820         event->cgrp = cgrp;
821
822         /*
823          * all events in a group must monitor
824          * the same cgroup because a task belongs
825          * to only one perf cgroup at a time
826          */
827         if (group_leader && group_leader->cgrp != cgrp) {
828                 perf_detach_cgroup(event);
829                 ret = -EINVAL;
830         }
831 out:
832         fdput(f);
833         return ret;
834 }
835
836 static inline void
837 perf_cgroup_set_shadow_time(struct perf_event *event, u64 now)
838 {
839         struct perf_cgroup_info *t;
840         t = per_cpu_ptr(event->cgrp->info, event->cpu);
841         event->shadow_ctx_time = now - t->timestamp;
842 }
843
844 static inline void
845 perf_cgroup_defer_enabled(struct perf_event *event)
846 {
847         /*
848          * when the current task's perf cgroup does not match
849          * the event's, we need to remember to call the
850          * perf_mark_enable() function the first time a task with
851          * a matching perf cgroup is scheduled in.
852          */
853         if (is_cgroup_event(event) && !perf_cgroup_match(event))
854                 event->cgrp_defer_enabled = 1;
855 }
856
857 static inline void
858 perf_cgroup_mark_enabled(struct perf_event *event,
859                          struct perf_event_context *ctx)
860 {
861         struct perf_event *sub;
862         u64 tstamp = perf_event_time(event);
863
864         if (!event->cgrp_defer_enabled)
865                 return;
866
867         event->cgrp_defer_enabled = 0;
868
869         event->tstamp_enabled = tstamp - event->total_time_enabled;
870         list_for_each_entry(sub, &event->sibling_list, group_entry) {
871                 if (sub->state >= PERF_EVENT_STATE_INACTIVE) {
872                         sub->tstamp_enabled = tstamp - sub->total_time_enabled;
873                         sub->cgrp_defer_enabled = 0;
874                 }
875         }
876 }
877
878 /*
879  * Update cpuctx->cgrp so that it is set when first cgroup event is added and
880  * cleared when last cgroup event is removed.
881  */
882 static inline void
883 list_update_cgroup_event(struct perf_event *event,
884                          struct perf_event_context *ctx, bool add)
885 {
886         struct perf_cpu_context *cpuctx;
887         struct list_head *cpuctx_entry;
888
889         if (!is_cgroup_event(event))
890                 return;
891
892         if (add && ctx->nr_cgroups++)
893                 return;
894         else if (!add && --ctx->nr_cgroups)
895                 return;
896         /*
897          * Because cgroup events are always per-cpu events,
898          * this will always be called from the right CPU.
899          */
900         cpuctx = __get_cpu_context(ctx);
901         cpuctx_entry = &cpuctx->cgrp_cpuctx_entry;
902         /* cpuctx->cgrp is NULL unless a cgroup event is active in this CPU .*/
903         if (add) {
904                 list_add(cpuctx_entry, this_cpu_ptr(&cgrp_cpuctx_list));
905                 if (perf_cgroup_from_task(current, ctx) == event->cgrp)
906                         cpuctx->cgrp = event->cgrp;
907         } else {
908                 list_del(cpuctx_entry);
909                 cpuctx->cgrp = NULL;
910         }
911 }
912
913 #else /* !CONFIG_CGROUP_PERF */
914
915 static inline bool
916 perf_cgroup_match(struct perf_event *event)
917 {
918         return true;
919 }
920
921 static inline void perf_detach_cgroup(struct perf_event *event)
922 {}
923
924 static inline int is_cgroup_event(struct perf_event *event)
925 {
926         return 0;
927 }
928
929 static inline void update_cgrp_time_from_event(struct perf_event *event)
930 {
931 }
932
933 static inline void update_cgrp_time_from_cpuctx(struct perf_cpu_context *cpuctx)
934 {
935 }
936
937 static inline void perf_cgroup_sched_out(struct task_struct *task,
938                                          struct task_struct *next)
939 {
940 }
941
942 static inline void perf_cgroup_sched_in(struct task_struct *prev,
943                                         struct task_struct *task)
944 {
945 }
946
947 static inline int perf_cgroup_connect(pid_t pid, struct perf_event *event,
948                                       struct perf_event_attr *attr,
949                                       struct perf_event *group_leader)
950 {
951         return -EINVAL;
952 }
953
954 static inline void
955 perf_cgroup_set_timestamp(struct task_struct *task,
956                           struct perf_event_context *ctx)
957 {
958 }
959
960 void
961 perf_cgroup_switch(struct task_struct *task, struct task_struct *next)
962 {
963 }
964
965 static inline void
966 perf_cgroup_set_shadow_time(struct perf_event *event, u64 now)
967 {
968 }
969
970 static inline u64 perf_cgroup_event_time(struct perf_event *event)
971 {
972         return 0;
973 }
974
975 static inline void
976 perf_cgroup_defer_enabled(struct perf_event *event)
977 {
978 }
979
980 static inline void
981 perf_cgroup_mark_enabled(struct perf_event *event,
982                          struct perf_event_context *ctx)
983 {
984 }
985
986 static inline void
987 list_update_cgroup_event(struct perf_event *event,
988                          struct perf_event_context *ctx, bool add)
989 {
990 }
991
992 #endif
993
994 /*
995  * set default to be dependent on timer tick just
996  * like original code
997  */
998 #define PERF_CPU_HRTIMER (1000 / HZ)
999 /*
1000  * function must be called with interrupts disabled
1001  */
1002 static enum hrtimer_restart perf_mux_hrtimer_handler(struct hrtimer *hr)
1003 {
1004         struct perf_cpu_context *cpuctx;
1005         int rotations = 0;
1006
1007         WARN_ON(!irqs_disabled());
1008
1009         cpuctx = container_of(hr, struct perf_cpu_context, hrtimer);
1010         rotations = perf_rotate_context(cpuctx);
1011
1012         raw_spin_lock(&cpuctx->hrtimer_lock);
1013         if (rotations)
1014                 hrtimer_forward_now(hr, cpuctx->hrtimer_interval);
1015         else
1016                 cpuctx->hrtimer_active = 0;
1017         raw_spin_unlock(&cpuctx->hrtimer_lock);
1018
1019         return rotations ? HRTIMER_RESTART : HRTIMER_NORESTART;
1020 }
1021
1022 static void __perf_mux_hrtimer_init(struct perf_cpu_context *cpuctx, int cpu)
1023 {
1024         struct hrtimer *timer = &cpuctx->hrtimer;
1025         struct pmu *pmu = cpuctx->ctx.pmu;
1026         u64 interval;
1027
1028         /* no multiplexing needed for SW PMU */
1029         if (pmu->task_ctx_nr == perf_sw_context)
1030                 return;
1031
1032         /*
1033          * check default is sane, if not set then force to
1034          * default interval (1/tick)
1035          */
1036         interval = pmu->hrtimer_interval_ms;
1037         if (interval < 1)
1038                 interval = pmu->hrtimer_interval_ms = PERF_CPU_HRTIMER;
1039
1040         cpuctx->hrtimer_interval = ns_to_ktime(NSEC_PER_MSEC * interval);
1041
1042         raw_spin_lock_init(&cpuctx->hrtimer_lock);
1043         hrtimer_init(timer, CLOCK_MONOTONIC, HRTIMER_MODE_ABS_PINNED);
1044         timer->function = perf_mux_hrtimer_handler;
1045 }
1046
1047 static int perf_mux_hrtimer_restart(struct perf_cpu_context *cpuctx)
1048 {
1049         struct hrtimer *timer = &cpuctx->hrtimer;
1050         struct pmu *pmu = cpuctx->ctx.pmu;
1051         unsigned long flags;
1052
1053         /* not for SW PMU */
1054         if (pmu->task_ctx_nr == perf_sw_context)
1055                 return 0;
1056
1057         raw_spin_lock_irqsave(&cpuctx->hrtimer_lock, flags);
1058         if (!cpuctx->hrtimer_active) {
1059                 cpuctx->hrtimer_active = 1;
1060                 hrtimer_forward_now(timer, cpuctx->hrtimer_interval);
1061                 hrtimer_start_expires(timer, HRTIMER_MODE_ABS_PINNED);
1062         }
1063         raw_spin_unlock_irqrestore(&cpuctx->hrtimer_lock, flags);
1064
1065         return 0;
1066 }
1067
1068 void perf_pmu_disable(struct pmu *pmu)
1069 {
1070         int *count = this_cpu_ptr(pmu->pmu_disable_count);
1071         if (!(*count)++)
1072                 pmu->pmu_disable(pmu);
1073 }
1074
1075 void perf_pmu_enable(struct pmu *pmu)
1076 {
1077         int *count = this_cpu_ptr(pmu->pmu_disable_count);
1078         if (!--(*count))
1079                 pmu->pmu_enable(pmu);
1080 }
1081
1082 static DEFINE_PER_CPU(struct list_head, active_ctx_list);
1083
1084 /*
1085  * perf_event_ctx_activate(), perf_event_ctx_deactivate(), and
1086  * perf_event_task_tick() are fully serialized because they're strictly cpu
1087  * affine and perf_event_ctx{activate,deactivate} are called with IRQs
1088  * disabled, while perf_event_task_tick is called from IRQ context.
1089  */
1090 static void perf_event_ctx_activate(struct perf_event_context *ctx)
1091 {
1092         struct list_head *head = this_cpu_ptr(&active_ctx_list);
1093
1094         WARN_ON(!irqs_disabled());
1095
1096         WARN_ON(!list_empty(&ctx->active_ctx_list));
1097
1098         list_add(&ctx->active_ctx_list, head);
1099 }
1100
1101 static void perf_event_ctx_deactivate(struct perf_event_context *ctx)
1102 {
1103         WARN_ON(!irqs_disabled());
1104
1105         WARN_ON(list_empty(&ctx->active_ctx_list));
1106
1107         list_del_init(&ctx->active_ctx_list);
1108 }
1109
1110 static void get_ctx(struct perf_event_context *ctx)
1111 {
1112         WARN_ON(!atomic_inc_not_zero(&ctx->refcount));
1113 }
1114
1115 static void free_ctx(struct rcu_head *head)
1116 {
1117         struct perf_event_context *ctx;
1118
1119         ctx = container_of(head, struct perf_event_context, rcu_head);
1120         kfree(ctx->task_ctx_data);
1121         kfree(ctx);
1122 }
1123
1124 static void put_ctx(struct perf_event_context *ctx)
1125 {
1126         if (atomic_dec_and_test(&ctx->refcount)) {
1127                 if (ctx->parent_ctx)
1128                         put_ctx(ctx->parent_ctx);
1129                 if (ctx->task && ctx->task != TASK_TOMBSTONE)
1130                         put_task_struct(ctx->task);
1131                 call_rcu(&ctx->rcu_head, free_ctx);
1132         }
1133 }
1134
1135 /*
1136  * Because of perf_event::ctx migration in sys_perf_event_open::move_group and
1137  * perf_pmu_migrate_context() we need some magic.
1138  *
1139  * Those places that change perf_event::ctx will hold both
1140  * perf_event_ctx::mutex of the 'old' and 'new' ctx value.
1141  *
1142  * Lock ordering is by mutex address. There are two other sites where
1143  * perf_event_context::mutex nests and those are:
1144  *
1145  *  - perf_event_exit_task_context()    [ child , 0 ]
1146  *      perf_event_exit_event()
1147  *        put_event()                   [ parent, 1 ]
1148  *
1149  *  - perf_event_init_context()         [ parent, 0 ]
1150  *      inherit_task_group()
1151  *        inherit_group()
1152  *          inherit_event()
1153  *            perf_event_alloc()
1154  *              perf_init_event()
1155  *                perf_try_init_event() [ child , 1 ]
1156  *
1157  * While it appears there is an obvious deadlock here -- the parent and child
1158  * nesting levels are inverted between the two. This is in fact safe because
1159  * life-time rules separate them. That is an exiting task cannot fork, and a
1160  * spawning task cannot (yet) exit.
1161  *
1162  * But remember that that these are parent<->child context relations, and
1163  * migration does not affect children, therefore these two orderings should not
1164  * interact.
1165  *
1166  * The change in perf_event::ctx does not affect children (as claimed above)
1167  * because the sys_perf_event_open() case will install a new event and break
1168  * the ctx parent<->child relation, and perf_pmu_migrate_context() is only
1169  * concerned with cpuctx and that doesn't have children.
1170  *
1171  * The places that change perf_event::ctx will issue:
1172  *
1173  *   perf_remove_from_context();
1174  *   synchronize_rcu();
1175  *   perf_install_in_context();
1176  *
1177  * to affect the change. The remove_from_context() + synchronize_rcu() should
1178  * quiesce the event, after which we can install it in the new location. This
1179  * means that only external vectors (perf_fops, prctl) can perturb the event
1180  * while in transit. Therefore all such accessors should also acquire
1181  * perf_event_context::mutex to serialize against this.
1182  *
1183  * However; because event->ctx can change while we're waiting to acquire
1184  * ctx->mutex we must be careful and use the below perf_event_ctx_lock()
1185  * function.
1186  *
1187  * Lock order:
1188  *    cred_guard_mutex
1189  *      task_struct::perf_event_mutex
1190  *        perf_event_context::mutex
1191  *          perf_event::child_mutex;
1192  *            perf_event_context::lock
1193  *          perf_event::mmap_mutex
1194  *          mmap_sem
1195  */
1196 static struct perf_event_context *
1197 perf_event_ctx_lock_nested(struct perf_event *event, int nesting)
1198 {
1199         struct perf_event_context *ctx;
1200
1201 again:
1202         rcu_read_lock();
1203         ctx = ACCESS_ONCE(event->ctx);
1204         if (!atomic_inc_not_zero(&ctx->refcount)) {
1205                 rcu_read_unlock();
1206                 goto again;
1207         }
1208         rcu_read_unlock();
1209
1210         mutex_lock_nested(&ctx->mutex, nesting);
1211         if (event->ctx != ctx) {
1212                 mutex_unlock(&ctx->mutex);
1213                 put_ctx(ctx);
1214                 goto again;
1215         }
1216
1217         return ctx;
1218 }
1219
1220 static inline struct perf_event_context *
1221 perf_event_ctx_lock(struct perf_event *event)
1222 {
1223         return perf_event_ctx_lock_nested(event, 0);
1224 }
1225
1226 static void perf_event_ctx_unlock(struct perf_event *event,
1227                                   struct perf_event_context *ctx)
1228 {
1229         mutex_unlock(&ctx->mutex);
1230         put_ctx(ctx);
1231 }
1232
1233 /*
1234  * This must be done under the ctx->lock, such as to serialize against
1235  * context_equiv(), therefore we cannot call put_ctx() since that might end up
1236  * calling scheduler related locks and ctx->lock nests inside those.
1237  */
1238 static __must_check struct perf_event_context *
1239 unclone_ctx(struct perf_event_context *ctx)
1240 {
1241         struct perf_event_context *parent_ctx = ctx->parent_ctx;
1242
1243         lockdep_assert_held(&ctx->lock);
1244
1245         if (parent_ctx)
1246                 ctx->parent_ctx = NULL;
1247         ctx->generation++;
1248
1249         return parent_ctx;
1250 }
1251
1252 static u32 perf_event_pid(struct perf_event *event, struct task_struct *p)
1253 {
1254         /*
1255          * only top level events have the pid namespace they were created in
1256          */
1257         if (event->parent)
1258                 event = event->parent;
1259
1260         return task_tgid_nr_ns(p, event->ns);
1261 }
1262
1263 static u32 perf_event_tid(struct perf_event *event, struct task_struct *p)
1264 {
1265         /*
1266          * only top level events have the pid namespace they were created in
1267          */
1268         if (event->parent)
1269                 event = event->parent;
1270
1271         return task_pid_nr_ns(p, event->ns);
1272 }
1273
1274 /*
1275  * If we inherit events we want to return the parent event id
1276  * to userspace.
1277  */
1278 static u64 primary_event_id(struct perf_event *event)
1279 {
1280         u64 id = event->id;
1281
1282         if (event->parent)
1283                 id = event->parent->id;
1284
1285         return id;
1286 }
1287
1288 /*
1289  * Get the perf_event_context for a task and lock it.
1290  *
1291  * This has to cope with with the fact that until it is locked,
1292  * the context could get moved to another task.
1293  */
1294 static struct perf_event_context *
1295 perf_lock_task_context(struct task_struct *task, int ctxn, unsigned long *flags)
1296 {
1297         struct perf_event_context *ctx;
1298
1299 retry:
1300         /*
1301          * One of the few rules of preemptible RCU is that one cannot do
1302          * rcu_read_unlock() while holding a scheduler (or nested) lock when
1303          * part of the read side critical section was irqs-enabled -- see
1304          * rcu_read_unlock_special().
1305          *
1306          * Since ctx->lock nests under rq->lock we must ensure the entire read
1307          * side critical section has interrupts disabled.
1308          */
1309         local_irq_save(*flags);
1310         rcu_read_lock();
1311         ctx = rcu_dereference(task->perf_event_ctxp[ctxn]);
1312         if (ctx) {
1313                 /*
1314                  * If this context is a clone of another, it might
1315                  * get swapped for another underneath us by
1316                  * perf_event_task_sched_out, though the
1317                  * rcu_read_lock() protects us from any context
1318                  * getting freed.  Lock the context and check if it
1319                  * got swapped before we could get the lock, and retry
1320                  * if so.  If we locked the right context, then it
1321                  * can't get swapped on us any more.
1322                  */
1323                 raw_spin_lock(&ctx->lock);
1324                 if (ctx != rcu_dereference(task->perf_event_ctxp[ctxn])) {
1325                         raw_spin_unlock(&ctx->lock);
1326                         rcu_read_unlock();
1327                         local_irq_restore(*flags);
1328                         goto retry;
1329                 }
1330
1331                 if (ctx->task == TASK_TOMBSTONE ||
1332                     !atomic_inc_not_zero(&ctx->refcount)) {
1333                         raw_spin_unlock(&ctx->lock);
1334                         ctx = NULL;
1335                 } else {
1336                         WARN_ON_ONCE(ctx->task != task);
1337                 }
1338         }
1339         rcu_read_unlock();
1340         if (!ctx)
1341                 local_irq_restore(*flags);
1342         return ctx;
1343 }
1344
1345 /*
1346  * Get the context for a task and increment its pin_count so it
1347  * can't get swapped to another task.  This also increments its
1348  * reference count so that the context can't get freed.
1349  */
1350 static struct perf_event_context *
1351 perf_pin_task_context(struct task_struct *task, int ctxn)
1352 {
1353         struct perf_event_context *ctx;
1354         unsigned long flags;
1355
1356         ctx = perf_lock_task_context(task, ctxn, &flags);
1357         if (ctx) {
1358                 ++ctx->pin_count;
1359                 raw_spin_unlock_irqrestore(&ctx->lock, flags);
1360         }
1361         return ctx;
1362 }
1363
1364 static void perf_unpin_context(struct perf_event_context *ctx)
1365 {
1366         unsigned long flags;
1367
1368         raw_spin_lock_irqsave(&ctx->lock, flags);
1369         --ctx->pin_count;
1370         raw_spin_unlock_irqrestore(&ctx->lock, flags);
1371 }
1372
1373 /*
1374  * Update the record of the current time in a context.
1375  */
1376 static void update_context_time(struct perf_event_context *ctx)
1377 {
1378         u64 now = perf_clock();
1379
1380         ctx->time += now - ctx->timestamp;
1381         ctx->timestamp = now;
1382 }
1383
1384 static u64 perf_event_time(struct perf_event *event)
1385 {
1386         struct perf_event_context *ctx = event->ctx;
1387
1388         if (is_cgroup_event(event))
1389                 return perf_cgroup_event_time(event);
1390
1391         return ctx ? ctx->time : 0;
1392 }
1393
1394 /*
1395  * Update the total_time_enabled and total_time_running fields for a event.
1396  */
1397 static void update_event_times(struct perf_event *event)
1398 {
1399         struct perf_event_context *ctx = event->ctx;
1400         u64 run_end;
1401
1402         lockdep_assert_held(&ctx->lock);
1403
1404         if (event->state < PERF_EVENT_STATE_INACTIVE ||
1405             event->group_leader->state < PERF_EVENT_STATE_INACTIVE)
1406                 return;
1407
1408         /*
1409          * in cgroup mode, time_enabled represents
1410          * the time the event was enabled AND active
1411          * tasks were in the monitored cgroup. This is
1412          * independent of the activity of the context as
1413          * there may be a mix of cgroup and non-cgroup events.
1414          *
1415          * That is why we treat cgroup events differently
1416          * here.
1417          */
1418         if (is_cgroup_event(event))
1419                 run_end = perf_cgroup_event_time(event);
1420         else if (ctx->is_active)
1421                 run_end = ctx->time;
1422         else
1423                 run_end = event->tstamp_stopped;
1424
1425         event->total_time_enabled = run_end - event->tstamp_enabled;
1426
1427         if (event->state == PERF_EVENT_STATE_INACTIVE)
1428                 run_end = event->tstamp_stopped;
1429         else
1430                 run_end = perf_event_time(event);
1431
1432         event->total_time_running = run_end - event->tstamp_running;
1433
1434 }
1435
1436 /*
1437  * Update total_time_enabled and total_time_running for all events in a group.
1438  */
1439 static void update_group_times(struct perf_event *leader)
1440 {
1441         struct perf_event *event;
1442
1443         update_event_times(leader);
1444         list_for_each_entry(event, &leader->sibling_list, group_entry)
1445                 update_event_times(event);
1446 }
1447
1448 static enum event_type_t get_event_type(struct perf_event *event)
1449 {
1450         struct perf_event_context *ctx = event->ctx;
1451         enum event_type_t event_type;
1452
1453         lockdep_assert_held(&ctx->lock);
1454
1455         /*
1456          * It's 'group type', really, because if our group leader is
1457          * pinned, so are we.
1458          */
1459         if (event->group_leader != event)
1460                 event = event->group_leader;
1461
1462         event_type = event->attr.pinned ? EVENT_PINNED : EVENT_FLEXIBLE;
1463         if (!ctx->task)
1464                 event_type |= EVENT_CPU;
1465
1466         return event_type;
1467 }
1468
1469 static struct list_head *
1470 ctx_group_list(struct perf_event *event, struct perf_event_context *ctx)
1471 {
1472         if (event->attr.pinned)
1473                 return &ctx->pinned_groups;
1474         else
1475                 return &ctx->flexible_groups;
1476 }
1477
1478 /*
1479  * Add a event from the lists for its context.
1480  * Must be called with ctx->mutex and ctx->lock held.
1481  */
1482 static void
1483 list_add_event(struct perf_event *event, struct perf_event_context *ctx)
1484 {
1485         lockdep_assert_held(&ctx->lock);
1486
1487         WARN_ON_ONCE(event->attach_state & PERF_ATTACH_CONTEXT);
1488         event->attach_state |= PERF_ATTACH_CONTEXT;
1489
1490         /*
1491          * If we're a stand alone event or group leader, we go to the context
1492          * list, group events are kept attached to the group so that
1493          * perf_group_detach can, at all times, locate all siblings.
1494          */
1495         if (event->group_leader == event) {
1496                 struct list_head *list;
1497
1498                 event->group_caps = event->event_caps;
1499
1500                 list = ctx_group_list(event, ctx);
1501                 list_add_tail(&event->group_entry, list);
1502         }
1503
1504         list_update_cgroup_event(event, ctx, true);
1505
1506         list_add_rcu(&event->event_entry, &ctx->event_list);
1507         ctx->nr_events++;
1508         if (event->attr.inherit_stat)
1509                 ctx->nr_stat++;
1510
1511         ctx->generation++;
1512 }
1513
1514 /*
1515  * Initialize event state based on the perf_event_attr::disabled.
1516  */
1517 static inline void perf_event__state_init(struct perf_event *event)
1518 {
1519         event->state = event->attr.disabled ? PERF_EVENT_STATE_OFF :
1520                                               PERF_EVENT_STATE_INACTIVE;
1521 }
1522
1523 static void __perf_event_read_size(struct perf_event *event, int nr_siblings)
1524 {
1525         int entry = sizeof(u64); /* value */
1526         int size = 0;
1527         int nr = 1;
1528
1529         if (event->attr.read_format & PERF_FORMAT_TOTAL_TIME_ENABLED)
1530                 size += sizeof(u64);
1531
1532         if (event->attr.read_format & PERF_FORMAT_TOTAL_TIME_RUNNING)
1533                 size += sizeof(u64);
1534
1535         if (event->attr.read_format & PERF_FORMAT_ID)
1536                 entry += sizeof(u64);
1537
1538         if (event->attr.read_format & PERF_FORMAT_GROUP) {
1539                 nr += nr_siblings;
1540                 size += sizeof(u64);
1541         }
1542
1543         size += entry * nr;
1544         event->read_size = size;
1545 }
1546
1547 static void __perf_event_header_size(struct perf_event *event, u64 sample_type)
1548 {
1549         struct perf_sample_data *data;
1550         u16 size = 0;
1551
1552         if (sample_type & PERF_SAMPLE_IP)
1553                 size += sizeof(data->ip);
1554
1555         if (sample_type & PERF_SAMPLE_ADDR)
1556                 size += sizeof(data->addr);
1557
1558         if (sample_type & PERF_SAMPLE_PERIOD)
1559                 size += sizeof(data->period);
1560
1561         if (sample_type & PERF_SAMPLE_WEIGHT)
1562                 size += sizeof(data->weight);
1563
1564         if (sample_type & PERF_SAMPLE_READ)
1565                 size += event->read_size;
1566
1567         if (sample_type & PERF_SAMPLE_DATA_SRC)
1568                 size += sizeof(data->data_src.val);
1569
1570         if (sample_type & PERF_SAMPLE_TRANSACTION)
1571                 size += sizeof(data->txn);
1572
1573         event->header_size = size;
1574 }
1575
1576 /*
1577  * Called at perf_event creation and when events are attached/detached from a
1578  * group.
1579  */
1580 static void perf_event__header_size(struct perf_event *event)
1581 {
1582         __perf_event_read_size(event,
1583                                event->group_leader->nr_siblings);
1584         __perf_event_header_size(event, event->attr.sample_type);
1585 }
1586
1587 static void perf_event__id_header_size(struct perf_event *event)
1588 {
1589         struct perf_sample_data *data;
1590         u64 sample_type = event->attr.sample_type;
1591         u16 size = 0;
1592
1593         if (sample_type & PERF_SAMPLE_TID)
1594                 size += sizeof(data->tid_entry);
1595
1596         if (sample_type & PERF_SAMPLE_TIME)
1597                 size += sizeof(data->time);
1598
1599         if (sample_type & PERF_SAMPLE_IDENTIFIER)
1600                 size += sizeof(data->id);
1601
1602         if (sample_type & PERF_SAMPLE_ID)
1603                 size += sizeof(data->id);
1604
1605         if (sample_type & PERF_SAMPLE_STREAM_ID)
1606                 size += sizeof(data->stream_id);
1607
1608         if (sample_type & PERF_SAMPLE_CPU)
1609                 size += sizeof(data->cpu_entry);
1610
1611         event->id_header_size = size;
1612 }
1613
1614 static bool perf_event_validate_size(struct perf_event *event)
1615 {
1616         /*
1617          * The values computed here will be over-written when we actually
1618          * attach the event.
1619          */
1620         __perf_event_read_size(event, event->group_leader->nr_siblings + 1);
1621         __perf_event_header_size(event, event->attr.sample_type & ~PERF_SAMPLE_READ);
1622         perf_event__id_header_size(event);
1623
1624         /*
1625          * Sum the lot; should not exceed the 64k limit we have on records.
1626          * Conservative limit to allow for callchains and other variable fields.
1627          */
1628         if (event->read_size + event->header_size +
1629             event->id_header_size + sizeof(struct perf_event_header) >= 16*1024)
1630                 return false;
1631
1632         return true;
1633 }
1634
1635 static void perf_group_attach(struct perf_event *event)
1636 {
1637         struct perf_event *group_leader = event->group_leader, *pos;
1638
1639         lockdep_assert_held(&event->ctx->lock);
1640
1641         /*
1642          * We can have double attach due to group movement in perf_event_open.
1643          */
1644         if (event->attach_state & PERF_ATTACH_GROUP)
1645                 return;
1646
1647         event->attach_state |= PERF_ATTACH_GROUP;
1648
1649         if (group_leader == event)
1650                 return;
1651
1652         WARN_ON_ONCE(group_leader->ctx != event->ctx);
1653
1654         group_leader->group_caps &= event->event_caps;
1655
1656         list_add_tail(&event->group_entry, &group_leader->sibling_list);
1657         group_leader->nr_siblings++;
1658
1659         perf_event__header_size(group_leader);
1660
1661         list_for_each_entry(pos, &group_leader->sibling_list, group_entry)
1662                 perf_event__header_size(pos);
1663 }
1664
1665 /*
1666  * Remove a event from the lists for its context.
1667  * Must be called with ctx->mutex and ctx->lock held.
1668  */
1669 static void
1670 list_del_event(struct perf_event *event, struct perf_event_context *ctx)
1671 {
1672         WARN_ON_ONCE(event->ctx != ctx);
1673         lockdep_assert_held(&ctx->lock);
1674
1675         /*
1676          * We can have double detach due to exit/hot-unplug + close.
1677          */
1678         if (!(event->attach_state & PERF_ATTACH_CONTEXT))
1679                 return;
1680
1681         event->attach_state &= ~PERF_ATTACH_CONTEXT;
1682
1683         list_update_cgroup_event(event, ctx, false);
1684
1685         ctx->nr_events--;
1686         if (event->attr.inherit_stat)
1687                 ctx->nr_stat--;
1688
1689         list_del_rcu(&event->event_entry);
1690
1691         if (event->group_leader == event)
1692                 list_del_init(&event->group_entry);
1693
1694         update_group_times(event);
1695
1696         /*
1697          * If event was in error state, then keep it
1698          * that way, otherwise bogus counts will be
1699          * returned on read(). The only way to get out
1700          * of error state is by explicit re-enabling
1701          * of the event
1702          */
1703         if (event->state > PERF_EVENT_STATE_OFF)
1704                 event->state = PERF_EVENT_STATE_OFF;
1705
1706         ctx->generation++;
1707 }
1708
1709 static void perf_group_detach(struct perf_event *event)
1710 {
1711         struct perf_event *sibling, *tmp;
1712         struct list_head *list = NULL;
1713
1714         lockdep_assert_held(&event->ctx->lock);
1715
1716         /*
1717          * We can have double detach due to exit/hot-unplug + close.
1718          */
1719         if (!(event->attach_state & PERF_ATTACH_GROUP))
1720                 return;
1721
1722         event->attach_state &= ~PERF_ATTACH_GROUP;
1723
1724         /*
1725          * If this is a sibling, remove it from its group.
1726          */
1727         if (event->group_leader != event) {
1728                 list_del_init(&event->group_entry);
1729                 event->group_leader->nr_siblings--;
1730                 goto out;
1731         }
1732
1733         if (!list_empty(&event->group_entry))
1734                 list = &event->group_entry;
1735
1736         /*
1737          * If this was a group event with sibling events then
1738          * upgrade the siblings to singleton events by adding them
1739          * to whatever list we are on.
1740          */
1741         list_for_each_entry_safe(sibling, tmp, &event->sibling_list, group_entry) {
1742                 if (list)
1743                         list_move_tail(&sibling->group_entry, list);
1744                 sibling->group_leader = sibling;
1745
1746                 /* Inherit group flags from the previous leader */
1747                 sibling->group_caps = event->group_caps;
1748
1749                 WARN_ON_ONCE(sibling->ctx != event->ctx);
1750         }
1751
1752 out:
1753         perf_event__header_size(event->group_leader);
1754
1755         list_for_each_entry(tmp, &event->group_leader->sibling_list, group_entry)
1756                 perf_event__header_size(tmp);
1757 }
1758
1759 static bool is_orphaned_event(struct perf_event *event)
1760 {
1761         return event->state == PERF_EVENT_STATE_DEAD;
1762 }
1763
1764 static inline int __pmu_filter_match(struct perf_event *event)
1765 {
1766         struct pmu *pmu = event->pmu;
1767         return pmu->filter_match ? pmu->filter_match(event) : 1;
1768 }
1769
1770 /*
1771  * Check whether we should attempt to schedule an event group based on
1772  * PMU-specific filtering. An event group can consist of HW and SW events,
1773  * potentially with a SW leader, so we must check all the filters, to
1774  * determine whether a group is schedulable:
1775  */
1776 static inline int pmu_filter_match(struct perf_event *event)
1777 {
1778         struct perf_event *child;
1779
1780         if (!__pmu_filter_match(event))
1781                 return 0;
1782
1783         list_for_each_entry(child, &event->sibling_list, group_entry) {
1784                 if (!__pmu_filter_match(child))
1785                         return 0;
1786         }
1787
1788         return 1;
1789 }
1790
1791 static inline int
1792 event_filter_match(struct perf_event *event)
1793 {
1794         return (event->cpu == -1 || event->cpu == smp_processor_id()) &&
1795                perf_cgroup_match(event) && pmu_filter_match(event);
1796 }
1797
1798 static void
1799 event_sched_out(struct perf_event *event,
1800                   struct perf_cpu_context *cpuctx,
1801                   struct perf_event_context *ctx)
1802 {
1803         u64 tstamp = perf_event_time(event);
1804         u64 delta;
1805
1806         WARN_ON_ONCE(event->ctx != ctx);
1807         lockdep_assert_held(&ctx->lock);
1808
1809         /*
1810          * An event which could not be activated because of
1811          * filter mismatch still needs to have its timings
1812          * maintained, otherwise bogus information is return
1813          * via read() for time_enabled, time_running:
1814          */
1815         if (event->state == PERF_EVENT_STATE_INACTIVE &&
1816             !event_filter_match(event)) {
1817                 delta = tstamp - event->tstamp_stopped;
1818                 event->tstamp_running += delta;
1819                 event->tstamp_stopped = tstamp;
1820         }
1821
1822         if (event->state != PERF_EVENT_STATE_ACTIVE)
1823                 return;
1824
1825         perf_pmu_disable(event->pmu);
1826
1827         event->tstamp_stopped = tstamp;
1828         event->pmu->del(event, 0);
1829         event->oncpu = -1;
1830         event->state = PERF_EVENT_STATE_INACTIVE;
1831         if (event->pending_disable) {
1832                 event->pending_disable = 0;
1833                 event->state = PERF_EVENT_STATE_OFF;
1834         }
1835
1836         if (!is_software_event(event))
1837                 cpuctx->active_oncpu--;
1838         if (!--ctx->nr_active)
1839                 perf_event_ctx_deactivate(ctx);
1840         if (event->attr.freq && event->attr.sample_freq)
1841                 ctx->nr_freq--;
1842         if (event->attr.exclusive || !cpuctx->active_oncpu)
1843                 cpuctx->exclusive = 0;
1844
1845         perf_pmu_enable(event->pmu);
1846 }
1847
1848 static void
1849 group_sched_out(struct perf_event *group_event,
1850                 struct perf_cpu_context *cpuctx,
1851                 struct perf_event_context *ctx)
1852 {
1853         struct perf_event *event;
1854         int state = group_event->state;
1855
1856         perf_pmu_disable(ctx->pmu);
1857
1858         event_sched_out(group_event, cpuctx, ctx);
1859
1860         /*
1861          * Schedule out siblings (if any):
1862          */
1863         list_for_each_entry(event, &group_event->sibling_list, group_entry)
1864                 event_sched_out(event, cpuctx, ctx);
1865
1866         perf_pmu_enable(ctx->pmu);
1867
1868         if (state == PERF_EVENT_STATE_ACTIVE && group_event->attr.exclusive)
1869                 cpuctx->exclusive = 0;
1870 }
1871
1872 #define DETACH_GROUP    0x01UL
1873
1874 /*
1875  * Cross CPU call to remove a performance event
1876  *
1877  * We disable the event on the hardware level first. After that we
1878  * remove it from the context list.
1879  */
1880 static void
1881 __perf_remove_from_context(struct perf_event *event,
1882                            struct perf_cpu_context *cpuctx,
1883                            struct perf_event_context *ctx,
1884                            void *info)
1885 {
1886         unsigned long flags = (unsigned long)info;
1887
1888         event_sched_out(event, cpuctx, ctx);
1889         if (flags & DETACH_GROUP)
1890                 perf_group_detach(event);
1891         list_del_event(event, ctx);
1892
1893         if (!ctx->nr_events && ctx->is_active) {
1894                 ctx->is_active = 0;
1895                 if (ctx->task) {
1896                         WARN_ON_ONCE(cpuctx->task_ctx != ctx);
1897                         cpuctx->task_ctx = NULL;
1898                 }
1899         }
1900 }
1901
1902 /*
1903  * Remove the event from a task's (or a CPU's) list of events.
1904  *
1905  * If event->ctx is a cloned context, callers must make sure that
1906  * every task struct that event->ctx->task could possibly point to
1907  * remains valid.  This is OK when called from perf_release since
1908  * that only calls us on the top-level context, which can't be a clone.
1909  * When called from perf_event_exit_task, it's OK because the
1910  * context has been detached from its task.
1911  */
1912 static void perf_remove_from_context(struct perf_event *event, unsigned long flags)
1913 {
1914         struct perf_event_context *ctx = event->ctx;
1915
1916         lockdep_assert_held(&ctx->mutex);
1917
1918         event_function_call(event, __perf_remove_from_context, (void *)flags);
1919
1920         /*
1921          * The above event_function_call() can NO-OP when it hits
1922          * TASK_TOMBSTONE. In that case we must already have been detached
1923          * from the context (by perf_event_exit_event()) but the grouping
1924          * might still be in-tact.
1925          */
1926         WARN_ON_ONCE(event->attach_state & PERF_ATTACH_CONTEXT);
1927         if ((flags & DETACH_GROUP) &&
1928             (event->attach_state & PERF_ATTACH_GROUP)) {
1929                 /*
1930                  * Since in that case we cannot possibly be scheduled, simply
1931                  * detach now.
1932                  */
1933                 raw_spin_lock_irq(&ctx->lock);
1934                 perf_group_detach(event);
1935                 raw_spin_unlock_irq(&ctx->lock);
1936         }
1937 }
1938
1939 /*
1940  * Cross CPU call to disable a performance event
1941  */
1942 static void __perf_event_disable(struct perf_event *event,
1943                                  struct perf_cpu_context *cpuctx,
1944                                  struct perf_event_context *ctx,
1945                                  void *info)
1946 {
1947         if (event->state < PERF_EVENT_STATE_INACTIVE)
1948                 return;
1949
1950         update_context_time(ctx);
1951         update_cgrp_time_from_event(event);
1952         update_group_times(event);
1953         if (event == event->group_leader)
1954                 group_sched_out(event, cpuctx, ctx);
1955         else
1956                 event_sched_out(event, cpuctx, ctx);
1957         event->state = PERF_EVENT_STATE_OFF;
1958 }
1959
1960 /*
1961  * Disable a event.
1962  *
1963  * If event->ctx is a cloned context, callers must make sure that
1964  * every task struct that event->ctx->task could possibly point to
1965  * remains valid.  This condition is satisifed when called through
1966  * perf_event_for_each_child or perf_event_for_each because they
1967  * hold the top-level event's child_mutex, so any descendant that
1968  * goes to exit will block in perf_event_exit_event().
1969  *
1970  * When called from perf_pending_event it's OK because event->ctx
1971  * is the current context on this CPU and preemption is disabled,
1972  * hence we can't get into perf_event_task_sched_out for this context.
1973  */
1974 static void _perf_event_disable(struct perf_event *event)
1975 {
1976         struct perf_event_context *ctx = event->ctx;
1977
1978         raw_spin_lock_irq(&ctx->lock);
1979         if (event->state <= PERF_EVENT_STATE_OFF) {
1980                 raw_spin_unlock_irq(&ctx->lock);
1981                 return;
1982         }
1983         raw_spin_unlock_irq(&ctx->lock);
1984
1985         event_function_call(event, __perf_event_disable, NULL);
1986 }
1987
1988 void perf_event_disable_local(struct perf_event *event)
1989 {
1990         event_function_local(event, __perf_event_disable, NULL);
1991 }
1992
1993 /*
1994  * Strictly speaking kernel users cannot create groups and therefore this
1995  * interface does not need the perf_event_ctx_lock() magic.
1996  */
1997 void perf_event_disable(struct perf_event *event)
1998 {
1999         struct perf_event_context *ctx;
2000
2001         ctx = perf_event_ctx_lock(event);
2002         _perf_event_disable(event);
2003         perf_event_ctx_unlock(event, ctx);
2004 }
2005 EXPORT_SYMBOL_GPL(perf_event_disable);
2006
2007 void perf_event_disable_inatomic(struct perf_event *event)
2008 {
2009         event->pending_disable = 1;
2010         irq_work_queue(&event->pending);
2011 }
2012
2013 static void perf_set_shadow_time(struct perf_event *event,
2014                                  struct perf_event_context *ctx,
2015                                  u64 tstamp)
2016 {
2017         /*
2018          * use the correct time source for the time snapshot
2019          *
2020          * We could get by without this by leveraging the
2021          * fact that to get to this function, the caller
2022          * has most likely already called update_context_time()
2023          * and update_cgrp_time_xx() and thus both timestamp
2024          * are identical (or very close). Given that tstamp is,
2025          * already adjusted for cgroup, we could say that:
2026          *    tstamp - ctx->timestamp
2027          * is equivalent to
2028          *    tstamp - cgrp->timestamp.
2029          *
2030          * Then, in perf_output_read(), the calculation would
2031          * work with no changes because:
2032          * - event is guaranteed scheduled in
2033          * - no scheduled out in between
2034          * - thus the timestamp would be the same
2035          *
2036          * But this is a bit hairy.
2037          *
2038          * So instead, we have an explicit cgroup call to remain
2039          * within the time time source all along. We believe it
2040          * is cleaner and simpler to understand.
2041          */
2042         if (is_cgroup_event(event))
2043                 perf_cgroup_set_shadow_time(event, tstamp);
2044         else
2045                 event->shadow_ctx_time = tstamp - ctx->timestamp;
2046 }
2047
2048 #define MAX_INTERRUPTS (~0ULL)
2049
2050 static void perf_log_throttle(struct perf_event *event, int enable);
2051 static void perf_log_itrace_start(struct perf_event *event);
2052
2053 static int
2054 event_sched_in(struct perf_event *event,
2055                  struct perf_cpu_context *cpuctx,
2056                  struct perf_event_context *ctx)
2057 {
2058         u64 tstamp = perf_event_time(event);
2059         int ret = 0;
2060
2061         lockdep_assert_held(&ctx->lock);
2062
2063         if (event->state <= PERF_EVENT_STATE_OFF)
2064                 return 0;
2065
2066         WRITE_ONCE(event->oncpu, smp_processor_id());
2067         /*
2068          * Order event::oncpu write to happen before the ACTIVE state
2069          * is visible.
2070          */
2071         smp_wmb();
2072         WRITE_ONCE(event->state, PERF_EVENT_STATE_ACTIVE);
2073
2074         /*
2075          * Unthrottle events, since we scheduled we might have missed several
2076          * ticks already, also for a heavily scheduling task there is little
2077          * guarantee it'll get a tick in a timely manner.
2078          */
2079         if (unlikely(event->hw.interrupts == MAX_INTERRUPTS)) {
2080                 perf_log_throttle(event, 1);
2081                 event->hw.interrupts = 0;
2082         }
2083
2084         /*
2085          * The new state must be visible before we turn it on in the hardware:
2086          */
2087         smp_wmb();
2088
2089         perf_pmu_disable(event->pmu);
2090
2091         perf_set_shadow_time(event, ctx, tstamp);
2092
2093         perf_log_itrace_start(event);
2094
2095         if (event->pmu->add(event, PERF_EF_START)) {
2096                 event->state = PERF_EVENT_STATE_INACTIVE;
2097                 event->oncpu = -1;
2098                 ret = -EAGAIN;
2099                 goto out;
2100         }
2101
2102         event->tstamp_running += tstamp - event->tstamp_stopped;
2103
2104         if (!is_software_event(event))
2105                 cpuctx->active_oncpu++;
2106         if (!ctx->nr_active++)
2107                 perf_event_ctx_activate(ctx);
2108         if (event->attr.freq && event->attr.sample_freq)
2109                 ctx->nr_freq++;
2110
2111         if (event->attr.exclusive)
2112                 cpuctx->exclusive = 1;
2113
2114 out:
2115         perf_pmu_enable(event->pmu);
2116
2117         return ret;
2118 }
2119
2120 static int
2121 group_sched_in(struct perf_event *group_event,
2122                struct perf_cpu_context *cpuctx,
2123                struct perf_event_context *ctx)
2124 {
2125         struct perf_event *event, *partial_group = NULL;
2126         struct pmu *pmu = ctx->pmu;
2127         u64 now = ctx->time;
2128         bool simulate = false;
2129
2130         if (group_event->state == PERF_EVENT_STATE_OFF)
2131                 return 0;
2132
2133         pmu->start_txn(pmu, PERF_PMU_TXN_ADD);
2134
2135         if (event_sched_in(group_event, cpuctx, ctx)) {
2136                 pmu->cancel_txn(pmu);
2137                 perf_mux_hrtimer_restart(cpuctx);
2138                 return -EAGAIN;
2139         }
2140
2141         /*
2142          * Schedule in siblings as one group (if any):
2143          */
2144         list_for_each_entry(event, &group_event->sibling_list, group_entry) {
2145                 if (event_sched_in(event, cpuctx, ctx)) {
2146                         partial_group = event;
2147                         goto group_error;
2148                 }
2149         }
2150
2151         if (!pmu->commit_txn(pmu))
2152                 return 0;
2153
2154 group_error:
2155         /*
2156          * Groups can be scheduled in as one unit only, so undo any
2157          * partial group before returning:
2158          * The events up to the failed event are scheduled out normally,
2159          * tstamp_stopped will be updated.
2160          *
2161          * The failed events and the remaining siblings need to have
2162          * their timings updated as if they had gone thru event_sched_in()
2163          * and event_sched_out(). This is required to get consistent timings
2164          * across the group. This also takes care of the case where the group
2165          * could never be scheduled by ensuring tstamp_stopped is set to mark
2166          * the time the event was actually stopped, such that time delta
2167          * calculation in update_event_times() is correct.
2168          */
2169         list_for_each_entry(event, &group_event->sibling_list, group_entry) {
2170                 if (event == partial_group)
2171                         simulate = true;
2172
2173                 if (simulate) {
2174                         event->tstamp_running += now - event->tstamp_stopped;
2175                         event->tstamp_stopped = now;
2176                 } else {
2177                         event_sched_out(event, cpuctx, ctx);
2178                 }
2179         }
2180         event_sched_out(group_event, cpuctx, ctx);
2181
2182         pmu->cancel_txn(pmu);
2183
2184         perf_mux_hrtimer_restart(cpuctx);
2185
2186         return -EAGAIN;
2187 }
2188
2189 /*
2190  * Work out whether we can put this event group on the CPU now.
2191  */
2192 static int group_can_go_on(struct perf_event *event,
2193                            struct perf_cpu_context *cpuctx,
2194                            int can_add_hw)
2195 {
2196         /*
2197          * Groups consisting entirely of software events can always go on.
2198          */
2199         if (event->group_caps & PERF_EV_CAP_SOFTWARE)
2200                 return 1;
2201         /*
2202          * If an exclusive group is already on, no other hardware
2203          * events can go on.
2204          */
2205         if (cpuctx->exclusive)
2206                 return 0;
2207         /*
2208          * If this group is exclusive and there are already
2209          * events on the CPU, it can't go on.
2210          */
2211         if (event->attr.exclusive && cpuctx->active_oncpu)
2212                 return 0;
2213         /*
2214          * Otherwise, try to add it if all previous groups were able
2215          * to go on.
2216          */
2217         return can_add_hw;
2218 }
2219
2220 static void add_event_to_ctx(struct perf_event *event,
2221                                struct perf_event_context *ctx)
2222 {
2223         u64 tstamp = perf_event_time(event);
2224
2225         list_add_event(event, ctx);
2226         perf_group_attach(event);
2227         event->tstamp_enabled = tstamp;
2228         event->tstamp_running = tstamp;
2229         event->tstamp_stopped = tstamp;
2230 }
2231
2232 static void ctx_sched_out(struct perf_event_context *ctx,
2233                           struct perf_cpu_context *cpuctx,
2234                           enum event_type_t event_type);
2235 static void
2236 ctx_sched_in(struct perf_event_context *ctx,
2237              struct perf_cpu_context *cpuctx,
2238              enum event_type_t event_type,
2239              struct task_struct *task);
2240
2241 static void task_ctx_sched_out(struct perf_cpu_context *cpuctx,
2242                                struct perf_event_context *ctx,
2243                                enum event_type_t event_type)
2244 {
2245         if (!cpuctx->task_ctx)
2246                 return;
2247
2248         if (WARN_ON_ONCE(ctx != cpuctx->task_ctx))
2249                 return;
2250
2251         ctx_sched_out(ctx, cpuctx, event_type);
2252 }
2253
2254 static void perf_event_sched_in(struct perf_cpu_context *cpuctx,
2255                                 struct perf_event_context *ctx,
2256                                 struct task_struct *task)
2257 {
2258         cpu_ctx_sched_in(cpuctx, EVENT_PINNED, task);
2259         if (ctx)
2260                 ctx_sched_in(ctx, cpuctx, EVENT_PINNED, task);
2261         cpu_ctx_sched_in(cpuctx, EVENT_FLEXIBLE, task);
2262         if (ctx)
2263                 ctx_sched_in(ctx, cpuctx, EVENT_FLEXIBLE, task);
2264 }
2265
2266 /*
2267  * We want to maintain the following priority of scheduling:
2268  *  - CPU pinned (EVENT_CPU | EVENT_PINNED)
2269  *  - task pinned (EVENT_PINNED)
2270  *  - CPU flexible (EVENT_CPU | EVENT_FLEXIBLE)
2271  *  - task flexible (EVENT_FLEXIBLE).
2272  *
2273  * In order to avoid unscheduling and scheduling back in everything every
2274  * time an event is added, only do it for the groups of equal priority and
2275  * below.
2276  *
2277  * This can be called after a batch operation on task events, in which case
2278  * event_type is a bit mask of the types of events involved. For CPU events,
2279  * event_type is only either EVENT_PINNED or EVENT_FLEXIBLE.
2280  */
2281 static void ctx_resched(struct perf_cpu_context *cpuctx,
2282                         struct perf_event_context *task_ctx,
2283                         enum event_type_t event_type)
2284 {
2285         enum event_type_t ctx_event_type = event_type & EVENT_ALL;
2286         bool cpu_event = !!(event_type & EVENT_CPU);
2287
2288         /*
2289          * If pinned groups are involved, flexible groups also need to be
2290          * scheduled out.
2291          */
2292         if (event_type & EVENT_PINNED)
2293                 event_type |= EVENT_FLEXIBLE;
2294
2295         perf_pmu_disable(cpuctx->ctx.pmu);
2296         if (task_ctx)
2297                 task_ctx_sched_out(cpuctx, task_ctx, event_type);
2298
2299         /*
2300          * Decide which cpu ctx groups to schedule out based on the types
2301          * of events that caused rescheduling:
2302          *  - EVENT_CPU: schedule out corresponding groups;
2303          *  - EVENT_PINNED task events: schedule out EVENT_FLEXIBLE groups;
2304          *  - otherwise, do nothing more.
2305          */
2306         if (cpu_event)
2307                 cpu_ctx_sched_out(cpuctx, ctx_event_type);
2308         else if (ctx_event_type & EVENT_PINNED)
2309                 cpu_ctx_sched_out(cpuctx, EVENT_FLEXIBLE);
2310
2311         perf_event_sched_in(cpuctx, task_ctx, current);
2312         perf_pmu_enable(cpuctx->ctx.pmu);
2313 }
2314
2315 /*
2316  * Cross CPU call to install and enable a performance event
2317  *
2318  * Very similar to remote_function() + event_function() but cannot assume that
2319  * things like ctx->is_active and cpuctx->task_ctx are set.
2320  */
2321 static int  __perf_install_in_context(void *info)
2322 {
2323         struct perf_event *event = info;
2324         struct perf_event_context *ctx = event->ctx;
2325         struct perf_cpu_context *cpuctx = __get_cpu_context(ctx);
2326         struct perf_event_context *task_ctx = cpuctx->task_ctx;
2327         bool reprogram = true;
2328         int ret = 0;
2329
2330         raw_spin_lock(&cpuctx->ctx.lock);
2331         if (ctx->task) {
2332                 raw_spin_lock(&ctx->lock);
2333                 task_ctx = ctx;
2334
2335                 reprogram = (ctx->task == current);
2336
2337                 /*
2338                  * If the task is running, it must be running on this CPU,
2339                  * otherwise we cannot reprogram things.
2340                  *
2341                  * If its not running, we don't care, ctx->lock will
2342                  * serialize against it becoming runnable.
2343                  */
2344                 if (task_curr(ctx->task) && !reprogram) {
2345                         ret = -ESRCH;
2346                         goto unlock;
2347                 }
2348
2349                 WARN_ON_ONCE(reprogram && cpuctx->task_ctx && cpuctx->task_ctx != ctx);
2350         } else if (task_ctx) {
2351                 raw_spin_lock(&task_ctx->lock);
2352         }
2353
2354         if (reprogram) {
2355                 ctx_sched_out(ctx, cpuctx, EVENT_TIME);
2356                 add_event_to_ctx(event, ctx);
2357                 ctx_resched(cpuctx, task_ctx, get_event_type(event));
2358         } else {
2359                 add_event_to_ctx(event, ctx);
2360         }
2361
2362 unlock:
2363         perf_ctx_unlock(cpuctx, task_ctx);
2364
2365         return ret;
2366 }
2367
2368 /*
2369  * Attach a performance event to a context.
2370  *
2371  * Very similar to event_function_call, see comment there.
2372  */
2373 static void
2374 perf_install_in_context(struct perf_event_context *ctx,
2375                         struct perf_event *event,
2376                         int cpu)
2377 {
2378         struct task_struct *task = READ_ONCE(ctx->task);
2379
2380         lockdep_assert_held(&ctx->mutex);
2381
2382         if (event->cpu != -1)
2383                 event->cpu = cpu;
2384
2385         /*
2386          * Ensures that if we can observe event->ctx, both the event and ctx
2387          * will be 'complete'. See perf_iterate_sb_cpu().
2388          */
2389         smp_store_release(&event->ctx, ctx);
2390
2391         if (!task) {
2392                 cpu_function_call(cpu, __perf_install_in_context, event);
2393                 return;
2394         }
2395
2396         /*
2397          * Should not happen, we validate the ctx is still alive before calling.
2398          */
2399         if (WARN_ON_ONCE(task == TASK_TOMBSTONE))
2400                 return;
2401
2402         /*
2403          * Installing events is tricky because we cannot rely on ctx->is_active
2404          * to be set in case this is the nr_events 0 -> 1 transition.
2405          *
2406          * Instead we use task_curr(), which tells us if the task is running.
2407          * However, since we use task_curr() outside of rq::lock, we can race
2408          * against the actual state. This means the result can be wrong.
2409          *
2410          * If we get a false positive, we retry, this is harmless.
2411          *
2412          * If we get a false negative, things are complicated. If we are after
2413          * perf_event_context_sched_in() ctx::lock will serialize us, and the
2414          * value must be correct. If we're before, it doesn't matter since
2415          * perf_event_context_sched_in() will program the counter.
2416          *
2417          * However, this hinges on the remote context switch having observed
2418          * our task->perf_event_ctxp[] store, such that it will in fact take
2419          * ctx::lock in perf_event_context_sched_in().
2420          *
2421          * We do this by task_function_call(), if the IPI fails to hit the task
2422          * we know any future context switch of task must see the
2423          * perf_event_ctpx[] store.
2424          */
2425
2426         /*
2427          * This smp_mb() orders the task->perf_event_ctxp[] store with the
2428          * task_cpu() load, such that if the IPI then does not find the task
2429          * running, a future context switch of that task must observe the
2430          * store.
2431          */
2432         smp_mb();
2433 again:
2434         if (!task_function_call(task, __perf_install_in_context, event))
2435                 return;
2436
2437         raw_spin_lock_irq(&ctx->lock);
2438         task = ctx->task;
2439         if (WARN_ON_ONCE(task == TASK_TOMBSTONE)) {
2440                 /*
2441                  * Cannot happen because we already checked above (which also
2442                  * cannot happen), and we hold ctx->mutex, which serializes us
2443                  * against perf_event_exit_task_context().
2444                  */
2445                 raw_spin_unlock_irq(&ctx->lock);
2446                 return;
2447         }
2448         /*
2449          * If the task is not running, ctx->lock will avoid it becoming so,
2450          * thus we can safely install the event.
2451          */
2452         if (task_curr(task)) {
2453                 raw_spin_unlock_irq(&ctx->lock);
2454                 goto again;
2455         }
2456         add_event_to_ctx(event, ctx);
2457         raw_spin_unlock_irq(&ctx->lock);
2458 }
2459
2460 /*
2461  * Put a event into inactive state and update time fields.
2462  * Enabling the leader of a group effectively enables all
2463  * the group members that aren't explicitly disabled, so we
2464  * have to update their ->tstamp_enabled also.
2465  * Note: this works for group members as well as group leaders
2466  * since the non-leader members' sibling_lists will be empty.
2467  */
2468 static void __perf_event_mark_enabled(struct perf_event *event)
2469 {
2470         struct perf_event *sub;
2471         u64 tstamp = perf_event_time(event);
2472
2473         event->state = PERF_EVENT_STATE_INACTIVE;
2474         event->tstamp_enabled = tstamp - event->total_time_enabled;
2475         list_for_each_entry(sub, &event->sibling_list, group_entry) {
2476                 if (sub->state >= PERF_EVENT_STATE_INACTIVE)
2477                         sub->tstamp_enabled = tstamp - sub->total_time_enabled;
2478         }
2479 }
2480
2481 /*
2482  * Cross CPU call to enable a performance event
2483  */
2484 static void __perf_event_enable(struct perf_event *event,
2485                                 struct perf_cpu_context *cpuctx,
2486                                 struct perf_event_context *ctx,
2487                                 void *info)
2488 {
2489         struct perf_event *leader = event->group_leader;
2490         struct perf_event_context *task_ctx;
2491
2492         if (event->state >= PERF_EVENT_STATE_INACTIVE ||
2493             event->state <= PERF_EVENT_STATE_ERROR)
2494                 return;
2495
2496         if (ctx->is_active)
2497                 ctx_sched_out(ctx, cpuctx, EVENT_TIME);
2498
2499         __perf_event_mark_enabled(event);
2500
2501         if (!ctx->is_active)
2502                 return;
2503
2504         if (!event_filter_match(event)) {
2505                 if (is_cgroup_event(event))
2506                         perf_cgroup_defer_enabled(event);
2507                 ctx_sched_in(ctx, cpuctx, EVENT_TIME, current);
2508                 return;
2509         }
2510
2511         /*
2512          * If the event is in a group and isn't the group leader,
2513          * then don't put it on unless the group is on.
2514          */
2515         if (leader != event && leader->state != PERF_EVENT_STATE_ACTIVE) {
2516                 ctx_sched_in(ctx, cpuctx, EVENT_TIME, current);
2517                 return;
2518         }
2519
2520         task_ctx = cpuctx->task_ctx;
2521         if (ctx->task)
2522                 WARN_ON_ONCE(task_ctx != ctx);
2523
2524         ctx_resched(cpuctx, task_ctx, get_event_type(event));
2525 }
2526
2527 /*
2528  * Enable a event.
2529  *
2530  * If event->ctx is a cloned context, callers must make sure that
2531  * every task struct that event->ctx->task could possibly point to
2532  * remains valid.  This condition is satisfied when called through
2533  * perf_event_for_each_child or perf_event_for_each as described
2534  * for perf_event_disable.
2535  */
2536 static void _perf_event_enable(struct perf_event *event)
2537 {
2538         struct perf_event_context *ctx = event->ctx;
2539
2540         raw_spin_lock_irq(&ctx->lock);
2541         if (event->state >= PERF_EVENT_STATE_INACTIVE ||
2542             event->state <  PERF_EVENT_STATE_ERROR) {
2543                 raw_spin_unlock_irq(&ctx->lock);
2544                 return;
2545         }
2546
2547         /*
2548          * If the event is in error state, clear that first.
2549          *
2550          * That way, if we see the event in error state below, we know that it
2551          * has gone back into error state, as distinct from the task having
2552          * been scheduled away before the cross-call arrived.
2553          */
2554         if (event->state == PERF_EVENT_STATE_ERROR)
2555                 event->state = PERF_EVENT_STATE_OFF;
2556         raw_spin_unlock_irq(&ctx->lock);
2557
2558         event_function_call(event, __perf_event_enable, NULL);
2559 }
2560
2561 /*
2562  * See perf_event_disable();
2563  */
2564 void perf_event_enable(struct perf_event *event)
2565 {
2566         struct perf_event_context *ctx;
2567
2568         ctx = perf_event_ctx_lock(event);
2569         _perf_event_enable(event);
2570         perf_event_ctx_unlock(event, ctx);
2571 }
2572 EXPORT_SYMBOL_GPL(perf_event_enable);
2573
2574 struct stop_event_data {
2575         struct perf_event       *event;
2576         unsigned int            restart;
2577 };
2578
2579 static int __perf_event_stop(void *info)
2580 {
2581         struct stop_event_data *sd = info;
2582         struct perf_event *event = sd->event;
2583
2584         /* if it's already INACTIVE, do nothing */
2585         if (READ_ONCE(event->state) != PERF_EVENT_STATE_ACTIVE)
2586                 return 0;
2587
2588         /* matches smp_wmb() in event_sched_in() */
2589         smp_rmb();
2590
2591         /*
2592          * There is a window with interrupts enabled before we get here,
2593          * so we need to check again lest we try to stop another CPU's event.
2594          */
2595         if (READ_ONCE(event->oncpu) != smp_processor_id())
2596                 return -EAGAIN;
2597
2598         event->pmu->stop(event, PERF_EF_UPDATE);
2599
2600         /*
2601          * May race with the actual stop (through perf_pmu_output_stop()),
2602          * but it is only used for events with AUX ring buffer, and such
2603          * events will refuse to restart because of rb::aux_mmap_count==0,
2604          * see comments in perf_aux_output_begin().
2605          *
2606          * Since this is happening on a event-local CPU, no trace is lost
2607          * while restarting.
2608          */
2609         if (sd->restart)
2610                 event->pmu->start(event, 0);
2611
2612         return 0;
2613 }
2614
2615 static int perf_event_stop(struct perf_event *event, int restart)
2616 {
2617         struct stop_event_data sd = {
2618                 .event          = event,
2619                 .restart        = restart,
2620         };
2621         int ret = 0;
2622
2623         do {
2624                 if (READ_ONCE(event->state) != PERF_EVENT_STATE_ACTIVE)
2625                         return 0;
2626
2627                 /* matches smp_wmb() in event_sched_in() */
2628                 smp_rmb();
2629
2630                 /*
2631                  * We only want to restart ACTIVE events, so if the event goes
2632                  * inactive here (event->oncpu==-1), there's nothing more to do;
2633                  * fall through with ret==-ENXIO.
2634                  */
2635                 ret = cpu_function_call(READ_ONCE(event->oncpu),
2636                                         __perf_event_stop, &sd);
2637         } while (ret == -EAGAIN);
2638
2639         return ret;
2640 }
2641
2642 /*
2643  * In order to contain the amount of racy and tricky in the address filter
2644  * configuration management, it is a two part process:
2645  *
2646  * (p1) when userspace mappings change as a result of (1) or (2) or (3) below,
2647  *      we update the addresses of corresponding vmas in
2648  *      event::addr_filters_offs array and bump the event::addr_filters_gen;
2649  * (p2) when an event is scheduled in (pmu::add), it calls
2650  *      perf_event_addr_filters_sync() which calls pmu::addr_filters_sync()
2651  *      if the generation has changed since the previous call.
2652  *
2653  * If (p1) happens while the event is active, we restart it to force (p2).
2654  *
2655  * (1) perf_addr_filters_apply(): adjusting filters' offsets based on
2656  *     pre-existing mappings, called once when new filters arrive via SET_FILTER
2657  *     ioctl;
2658  * (2) perf_addr_filters_adjust(): adjusting filters' offsets based on newly
2659  *     registered mapping, called for every new mmap(), with mm::mmap_sem down
2660  *     for reading;
2661  * (3) perf_event_addr_filters_exec(): clearing filters' offsets in the process
2662  *     of exec.
2663  */
2664 void perf_event_addr_filters_sync(struct perf_event *event)
2665 {
2666         struct perf_addr_filters_head *ifh = perf_event_addr_filters(event);
2667
2668         if (!has_addr_filter(event))
2669                 return;
2670
2671         raw_spin_lock(&ifh->lock);
2672         if (event->addr_filters_gen != event->hw.addr_filters_gen) {
2673                 event->pmu->addr_filters_sync(event);
2674                 event->hw.addr_filters_gen = event->addr_filters_gen;
2675         }
2676         raw_spin_unlock(&ifh->lock);
2677 }
2678 EXPORT_SYMBOL_GPL(perf_event_addr_filters_sync);
2679
2680 static int _perf_event_refresh(struct perf_event *event, int refresh)
2681 {
2682         /*
2683          * not supported on inherited events
2684          */
2685         if (event->attr.inherit || !is_sampling_event(event))
2686                 return -EINVAL;
2687
2688         atomic_add(refresh, &event->event_limit);
2689         _perf_event_enable(event);
2690
2691         return 0;
2692 }
2693
2694 /*
2695  * See perf_event_disable()
2696  */
2697 int perf_event_refresh(struct perf_event *event, int refresh)
2698 {
2699         struct perf_event_context *ctx;
2700         int ret;
2701
2702         ctx = perf_event_ctx_lock(event);
2703         ret = _perf_event_refresh(event, refresh);
2704         perf_event_ctx_unlock(event, ctx);
2705
2706         return ret;
2707 }
2708 EXPORT_SYMBOL_GPL(perf_event_refresh);
2709
2710 static void ctx_sched_out(struct perf_event_context *ctx,
2711                           struct perf_cpu_context *cpuctx,
2712                           enum event_type_t event_type)
2713 {
2714         int is_active = ctx->is_active;
2715         struct perf_event *event;
2716
2717         lockdep_assert_held(&ctx->lock);
2718
2719         if (likely(!ctx->nr_events)) {
2720                 /*
2721                  * See __perf_remove_from_context().
2722                  */
2723                 WARN_ON_ONCE(ctx->is_active);
2724                 if (ctx->task)
2725                         WARN_ON_ONCE(cpuctx->task_ctx);
2726                 return;
2727         }
2728
2729         ctx->is_active &= ~event_type;
2730         if (!(ctx->is_active & EVENT_ALL))
2731                 ctx->is_active = 0;
2732
2733         if (ctx->task) {
2734                 WARN_ON_ONCE(cpuctx->task_ctx != ctx);
2735                 if (!ctx->is_active)
2736                         cpuctx->task_ctx = NULL;
2737         }
2738
2739         /*
2740          * Always update time if it was set; not only when it changes.
2741          * Otherwise we can 'forget' to update time for any but the last
2742          * context we sched out. For example:
2743          *
2744          *   ctx_sched_out(.event_type = EVENT_FLEXIBLE)
2745          *   ctx_sched_out(.event_type = EVENT_PINNED)
2746          *
2747          * would only update time for the pinned events.
2748          */
2749         if (is_active & EVENT_TIME) {
2750                 /* update (and stop) ctx time */
2751                 update_context_time(ctx);
2752                 update_cgrp_time_from_cpuctx(cpuctx);
2753         }
2754
2755         is_active ^= ctx->is_active; /* changed bits */
2756
2757         if (!ctx->nr_active || !(is_active & EVENT_ALL))
2758                 return;
2759
2760         perf_pmu_disable(ctx->pmu);
2761         if (is_active & EVENT_PINNED) {
2762                 list_for_each_entry(event, &ctx->pinned_groups, group_entry)
2763                         group_sched_out(event, cpuctx, ctx);
2764         }
2765
2766         if (is_active & EVENT_FLEXIBLE) {
2767                 list_for_each_entry(event, &ctx->flexible_groups, group_entry)
2768                         group_sched_out(event, cpuctx, ctx);
2769         }
2770         perf_pmu_enable(ctx->pmu);
2771 }
2772
2773 /*
2774  * Test whether two contexts are equivalent, i.e. whether they have both been
2775  * cloned from the same version of the same context.
2776  *
2777  * Equivalence is measured using a generation number in the context that is
2778  * incremented on each modification to it; see unclone_ctx(), list_add_event()
2779  * and list_del_event().
2780  */
2781 static int context_equiv(struct perf_event_context *ctx1,
2782                          struct perf_event_context *ctx2)
2783 {
2784         lockdep_assert_held(&ctx1->lock);
2785         lockdep_assert_held(&ctx2->lock);
2786
2787         /* Pinning disables the swap optimization */
2788         if (ctx1->pin_count || ctx2->pin_count)
2789                 return 0;
2790
2791         /* If ctx1 is the parent of ctx2 */
2792         if (ctx1 == ctx2->parent_ctx && ctx1->generation == ctx2->parent_gen)
2793                 return 1;
2794
2795         /* If ctx2 is the parent of ctx1 */
2796         if (ctx1->parent_ctx == ctx2 && ctx1->parent_gen == ctx2->generation)
2797                 return 1;
2798
2799         /*
2800          * If ctx1 and ctx2 have the same parent; we flatten the parent
2801          * hierarchy, see perf_event_init_context().
2802          */
2803         if (ctx1->parent_ctx && ctx1->parent_ctx == ctx2->parent_ctx &&
2804                         ctx1->parent_gen == ctx2->parent_gen)
2805                 return 1;
2806
2807         /* Unmatched */
2808         return 0;
2809 }
2810
2811 static void __perf_event_sync_stat(struct perf_event *event,
2812                                      struct perf_event *next_event)
2813 {
2814         u64 value;
2815
2816         if (!event->attr.inherit_stat)
2817                 return;
2818
2819         /*
2820          * Update the event value, we cannot use perf_event_read()
2821          * because we're in the middle of a context switch and have IRQs
2822          * disabled, which upsets smp_call_function_single(), however
2823          * we know the event must be on the current CPU, therefore we
2824          * don't need to use it.
2825          */
2826         switch (event->state) {
2827         case PERF_EVENT_STATE_ACTIVE:
2828                 event->pmu->read(event);
2829                 /* fall-through */
2830
2831         case PERF_EVENT_STATE_INACTIVE:
2832                 update_event_times(event);
2833                 break;
2834
2835         default:
2836                 break;
2837         }
2838
2839         /*
2840          * In order to keep per-task stats reliable we need to flip the event
2841          * values when we flip the contexts.
2842          */
2843         value = local64_read(&next_event->count);
2844         value = local64_xchg(&event->count, value);
2845         local64_set(&next_event->count, value);
2846
2847         swap(event->total_time_enabled, next_event->total_time_enabled);
2848         swap(event->total_time_running, next_event->total_time_running);
2849
2850         /*
2851          * Since we swizzled the values, update the user visible data too.
2852          */
2853         perf_event_update_userpage(event);
2854         perf_event_update_userpage(next_event);
2855 }
2856
2857 static void perf_event_sync_stat(struct perf_event_context *ctx,
2858                                    struct perf_event_context *next_ctx)
2859 {
2860         struct perf_event *event, *next_event;
2861
2862         if (!ctx->nr_stat)
2863                 return;
2864
2865         update_context_time(ctx);
2866
2867         event = list_first_entry(&ctx->event_list,
2868                                    struct perf_event, event_entry);
2869
2870         next_event = list_first_entry(&next_ctx->event_list,
2871                                         struct perf_event, event_entry);
2872
2873         while (&event->event_entry != &ctx->event_list &&
2874                &next_event->event_entry != &next_ctx->event_list) {
2875
2876                 __perf_event_sync_stat(event, next_event);
2877
2878                 event = list_next_entry(event, event_entry);
2879                 next_event = list_next_entry(next_event, event_entry);
2880         }
2881 }
2882
2883 static void perf_event_context_sched_out(struct task_struct *task, int ctxn,
2884                                          struct task_struct *next)
2885 {
2886         struct perf_event_context *ctx = task->perf_event_ctxp[ctxn];
2887         struct perf_event_context *next_ctx;
2888         struct perf_event_context *parent, *next_parent;
2889         struct perf_cpu_context *cpuctx;
2890         int do_switch = 1;
2891
2892         if (likely(!ctx))
2893                 return;
2894
2895         cpuctx = __get_cpu_context(ctx);
2896         if (!cpuctx->task_ctx)
2897                 return;
2898
2899         rcu_read_lock();
2900         next_ctx = next->perf_event_ctxp[ctxn];
2901         if (!next_ctx)
2902                 goto unlock;
2903
2904         parent = rcu_dereference(ctx->parent_ctx);
2905         next_parent = rcu_dereference(next_ctx->parent_ctx);
2906
2907         /* If neither context have a parent context; they cannot be clones. */
2908         if (!parent && !next_parent)
2909                 goto unlock;
2910
2911         if (next_parent == ctx || next_ctx == parent || next_parent == parent) {
2912                 /*
2913                  * Looks like the two contexts are clones, so we might be
2914                  * able to optimize the context switch.  We lock both
2915                  * contexts and check that they are clones under the
2916                  * lock (including re-checking that neither has been
2917                  * uncloned in the meantime).  It doesn't matter which
2918                  * order we take the locks because no other cpu could
2919                  * be trying to lock both of these tasks.
2920                  */
2921                 raw_spin_lock(&ctx->lock);
2922                 raw_spin_lock_nested(&next_ctx->lock, SINGLE_DEPTH_NESTING);
2923                 if (context_equiv(ctx, next_ctx)) {
2924                         WRITE_ONCE(ctx->task, next);
2925                         WRITE_ONCE(next_ctx->task, task);
2926
2927                         swap(ctx->task_ctx_data, next_ctx->task_ctx_data);
2928
2929                         /*
2930                          * RCU_INIT_POINTER here is safe because we've not
2931                          * modified the ctx and the above modification of
2932                          * ctx->task and ctx->task_ctx_data are immaterial
2933                          * since those values are always verified under
2934                          * ctx->lock which we're now holding.
2935                          */
2936                         RCU_INIT_POINTER(task->perf_event_ctxp[ctxn], next_ctx);
2937                         RCU_INIT_POINTER(next->perf_event_ctxp[ctxn], ctx);
2938
2939                         do_switch = 0;
2940
2941                         perf_event_sync_stat(ctx, next_ctx);
2942                 }
2943                 raw_spin_unlock(&next_ctx->lock);
2944                 raw_spin_unlock(&ctx->lock);
2945         }
2946 unlock:
2947         rcu_read_unlock();
2948
2949         if (do_switch) {
2950                 raw_spin_lock(&ctx->lock);
2951                 task_ctx_sched_out(cpuctx, ctx, EVENT_ALL);
2952                 raw_spin_unlock(&ctx->lock);
2953         }
2954 }
2955
2956 static DEFINE_PER_CPU(struct list_head, sched_cb_list);
2957
2958 void perf_sched_cb_dec(struct pmu *pmu)
2959 {
2960         struct perf_cpu_context *cpuctx = this_cpu_ptr(pmu->pmu_cpu_context);
2961
2962         this_cpu_dec(perf_sched_cb_usages);
2963
2964         if (!--cpuctx->sched_cb_usage)
2965                 list_del(&cpuctx->sched_cb_entry);
2966 }
2967
2968
2969 void perf_sched_cb_inc(struct pmu *pmu)
2970 {
2971         struct perf_cpu_context *cpuctx = this_cpu_ptr(pmu->pmu_cpu_context);
2972
2973         if (!cpuctx->sched_cb_usage++)
2974                 list_add(&cpuctx->sched_cb_entry, this_cpu_ptr(&sched_cb_list));
2975
2976         this_cpu_inc(perf_sched_cb_usages);
2977 }
2978
2979 /*
2980  * This function provides the context switch callback to the lower code
2981  * layer. It is invoked ONLY when the context switch callback is enabled.
2982  *
2983  * This callback is relevant even to per-cpu events; for example multi event
2984  * PEBS requires this to provide PID/TID information. This requires we flush
2985  * all queued PEBS records before we context switch to a new task.
2986  */
2987 static void perf_pmu_sched_task(struct task_struct *prev,
2988                                 struct task_struct *next,
2989                                 bool sched_in)
2990 {
2991         struct perf_cpu_context *cpuctx;
2992         struct pmu *pmu;
2993
2994         if (prev == next)
2995                 return;
2996
2997         list_for_each_entry(cpuctx, this_cpu_ptr(&sched_cb_list), sched_cb_entry) {
2998                 pmu = cpuctx->ctx.pmu; /* software PMUs will not have sched_task */
2999
3000                 if (WARN_ON_ONCE(!pmu->sched_task))
3001                         continue;
3002
3003                 perf_ctx_lock(cpuctx, cpuctx->task_ctx);
3004                 perf_pmu_disable(pmu);
3005
3006                 pmu->sched_task(cpuctx->task_ctx, sched_in);
3007
3008                 perf_pmu_enable(pmu);
3009                 perf_ctx_unlock(cpuctx, cpuctx->task_ctx);
3010         }
3011 }
3012
3013 static void perf_event_switch(struct task_struct *task,
3014                               struct task_struct *next_prev, bool sched_in);
3015
3016 #define for_each_task_context_nr(ctxn)                                  \
3017         for ((ctxn) = 0; (ctxn) < perf_nr_task_contexts; (ctxn)++)
3018
3019 /*
3020  * Called from scheduler to remove the events of the current task,
3021  * with interrupts disabled.
3022  *
3023  * We stop each event and update the event value in event->count.
3024  *
3025  * This does not protect us against NMI, but disable()
3026  * sets the disabled bit in the control field of event _before_
3027  * accessing the event control register. If a NMI hits, then it will
3028  * not restart the event.
3029  */
3030 void __perf_event_task_sched_out(struct task_struct *task,
3031                                  struct task_struct *next)
3032 {
3033         int ctxn;
3034
3035         if (__this_cpu_read(perf_sched_cb_usages))
3036                 perf_pmu_sched_task(task, next, false);
3037
3038         if (atomic_read(&nr_switch_events))
3039                 perf_event_switch(task, next, false);
3040
3041         for_each_task_context_nr(ctxn)
3042                 perf_event_context_sched_out(task, ctxn, next);
3043
3044         /*
3045          * if cgroup events exist on this CPU, then we need
3046          * to check if we have to switch out PMU state.
3047          * cgroup event are system-wide mode only
3048          */
3049         if (atomic_read(this_cpu_ptr(&perf_cgroup_events)))
3050                 perf_cgroup_sched_out(task, next);
3051 }
3052
3053 /*
3054  * Called with IRQs disabled
3055  */
3056 static void cpu_ctx_sched_out(struct perf_cpu_context *cpuctx,
3057                               enum event_type_t event_type)
3058 {
3059         ctx_sched_out(&cpuctx->ctx, cpuctx, event_type);
3060 }
3061
3062 static void
3063 ctx_pinned_sched_in(struct perf_event_context *ctx,
3064                     struct perf_cpu_context *cpuctx)
3065 {
3066         struct perf_event *event;
3067
3068         list_for_each_entry(event, &ctx->pinned_groups, group_entry) {
3069                 if (event->state <= PERF_EVENT_STATE_OFF)
3070                         continue;
3071                 if (!event_filter_match(event))
3072                         continue;
3073
3074                 /* may need to reset tstamp_enabled */
3075                 if (is_cgroup_event(event))
3076                         perf_cgroup_mark_enabled(event, ctx);
3077
3078                 if (group_can_go_on(event, cpuctx, 1))
3079                         group_sched_in(event, cpuctx, ctx);
3080
3081                 /*
3082                  * If this pinned group hasn't been scheduled,
3083                  * put it in error state.
3084                  */
3085                 if (event->state == PERF_EVENT_STATE_INACTIVE) {
3086                         update_group_times(event);
3087                         event->state = PERF_EVENT_STATE_ERROR;
3088                 }
3089         }
3090 }
3091
3092 static void
3093 ctx_flexible_sched_in(struct perf_event_context *ctx,
3094                       struct perf_cpu_context *cpuctx)
3095 {
3096         struct perf_event *event;
3097         int can_add_hw = 1;
3098
3099         list_for_each_entry(event, &ctx->flexible_groups, group_entry) {
3100                 /* Ignore events in OFF or ERROR state */
3101                 if (event->state <= PERF_EVENT_STATE_OFF)
3102                         continue;
3103                 /*
3104                  * Listen to the 'cpu' scheduling filter constraint
3105                  * of events:
3106                  */
3107                 if (!event_filter_match(event))
3108                         continue;
3109
3110                 /* may need to reset tstamp_enabled */
3111                 if (is_cgroup_event(event))
3112                         perf_cgroup_mark_enabled(event, ctx);
3113
3114                 if (group_can_go_on(event, cpuctx, can_add_hw)) {
3115                         if (group_sched_in(event, cpuctx, ctx))
3116                                 can_add_hw = 0;
3117                 }
3118         }
3119 }
3120
3121 static void
3122 ctx_sched_in(struct perf_event_context *ctx,
3123              struct perf_cpu_context *cpuctx,
3124              enum event_type_t event_type,
3125              struct task_struct *task)
3126 {
3127         int is_active = ctx->is_active;
3128         u64 now;
3129
3130         lockdep_assert_held(&ctx->lock);
3131
3132         if (likely(!ctx->nr_events))
3133                 return;
3134
3135         ctx->is_active |= (event_type | EVENT_TIME);
3136         if (ctx->task) {
3137                 if (!is_active)
3138                         cpuctx->task_ctx = ctx;
3139                 else
3140                         WARN_ON_ONCE(cpuctx->task_ctx != ctx);
3141         }
3142
3143         is_active ^= ctx->is_active; /* changed bits */
3144
3145         if (is_active & EVENT_TIME) {
3146                 /* start ctx time */
3147                 now = perf_clock();
3148                 ctx->timestamp = now;
3149                 perf_cgroup_set_timestamp(task, ctx);
3150         }
3151
3152         /*
3153          * First go through the list and put on any pinned groups
3154          * in order to give them the best chance of going on.
3155          */
3156         if (is_active & EVENT_PINNED)
3157                 ctx_pinned_sched_in(ctx, cpuctx);
3158
3159         /* Then walk through the lower prio flexible groups */
3160         if (is_active & EVENT_FLEXIBLE)
3161                 ctx_flexible_sched_in(ctx, cpuctx);
3162 }
3163
3164 static void cpu_ctx_sched_in(struct perf_cpu_context *cpuctx,
3165                              enum event_type_t event_type,
3166                              struct task_struct *task)
3167 {
3168         struct perf_event_context *ctx = &cpuctx->ctx;
3169
3170         ctx_sched_in(ctx, cpuctx, event_type, task);
3171 }
3172
3173 static void perf_event_context_sched_in(struct perf_event_context *ctx,
3174                                         struct task_struct *task)
3175 {
3176         struct perf_cpu_context *cpuctx;
3177
3178         cpuctx = __get_cpu_context(ctx);
3179         if (cpuctx->task_ctx == ctx)
3180                 return;
3181
3182         perf_ctx_lock(cpuctx, ctx);
3183         perf_pmu_disable(ctx->pmu);
3184         /*
3185          * We want to keep the following priority order:
3186          * cpu pinned (that don't need to move), task pinned,
3187          * cpu flexible, task flexible.
3188          *
3189          * However, if task's ctx is not carrying any pinned
3190          * events, no need to flip the cpuctx's events around.
3191          */
3192         if (!list_empty(&ctx->pinned_groups))
3193                 cpu_ctx_sched_out(cpuctx, EVENT_FLEXIBLE);
3194         perf_event_sched_in(cpuctx, ctx, task);
3195         perf_pmu_enable(ctx->pmu);
3196         perf_ctx_unlock(cpuctx, ctx);
3197 }
3198
3199 /*
3200  * Called from scheduler to add the events of the current task
3201  * with interrupts disabled.
3202  *
3203  * We restore the event value and then enable it.
3204  *
3205  * This does not protect us against NMI, but enable()
3206  * sets the enabled bit in the control field of event _before_
3207  * accessing the event control register. If a NMI hits, then it will
3208  * keep the event running.
3209  */
3210 void __perf_event_task_sched_in(struct task_struct *prev,
3211                                 struct task_struct *task)
3212 {
3213         struct perf_event_context *ctx;
3214         int ctxn;
3215
3216         /*
3217          * If cgroup events exist on this CPU, then we need to check if we have
3218          * to switch in PMU state; cgroup event are system-wide mode only.
3219          *
3220          * Since cgroup events are CPU events, we must schedule these in before
3221          * we schedule in the task events.
3222          */
3223         if (atomic_read(this_cpu_ptr(&perf_cgroup_events)))
3224                 perf_cgroup_sched_in(prev, task);
3225
3226         for_each_task_context_nr(ctxn) {
3227                 ctx = task->perf_event_ctxp[ctxn];
3228                 if (likely(!ctx))
3229                         continue;
3230
3231                 perf_event_context_sched_in(ctx, task);
3232         }
3233
3234         if (atomic_read(&nr_switch_events))
3235                 perf_event_switch(task, prev, true);
3236
3237         if (__this_cpu_read(perf_sched_cb_usages))
3238                 perf_pmu_sched_task(prev, task, true);
3239 }
3240
3241 static u64 perf_calculate_period(struct perf_event *event, u64 nsec, u64 count)
3242 {
3243         u64 frequency = event->attr.sample_freq;
3244         u64 sec = NSEC_PER_SEC;
3245         u64 divisor, dividend;
3246
3247         int count_fls, nsec_fls, frequency_fls, sec_fls;
3248
3249         count_fls = fls64(count);
3250         nsec_fls = fls64(nsec);
3251         frequency_fls = fls64(frequency);
3252         sec_fls = 30;
3253
3254         /*
3255          * We got @count in @nsec, with a target of sample_freq HZ
3256          * the target period becomes:
3257          *
3258          *             @count * 10^9
3259          * period = -------------------
3260          *          @nsec * sample_freq
3261          *
3262          */
3263
3264         /*
3265          * Reduce accuracy by one bit such that @a and @b converge
3266          * to a similar magnitude.
3267          */
3268 #define REDUCE_FLS(a, b)                \
3269 do {                                    \
3270         if (a##_fls > b##_fls) {        \
3271                 a >>= 1;                \
3272                 a##_fls--;              \
3273         } else {                        \
3274                 b >>= 1;                \
3275                 b##_fls--;              \
3276         }                               \
3277 } while (0)
3278
3279         /*
3280          * Reduce accuracy until either term fits in a u64, then proceed with
3281          * the other, so that finally we can do a u64/u64 division.
3282          */
3283         while (count_fls + sec_fls > 64 && nsec_fls + frequency_fls > 64) {
3284                 REDUCE_FLS(nsec, frequency);
3285                 REDUCE_FLS(sec, count);
3286         }
3287
3288         if (count_fls + sec_fls > 64) {
3289                 divisor = nsec * frequency;
3290
3291                 while (count_fls + sec_fls > 64) {
3292                         REDUCE_FLS(count, sec);
3293                         divisor >>= 1;
3294                 }
3295
3296                 dividend = count * sec;
3297         } else {
3298                 dividend = count * sec;
3299
3300                 while (nsec_fls + frequency_fls > 64) {
3301                         REDUCE_FLS(nsec, frequency);
3302                         dividend >>= 1;
3303                 }
3304
3305                 divisor = nsec * frequency;
3306         }
3307
3308         if (!divisor)
3309                 return dividend;
3310
3311         return div64_u64(dividend, divisor);
3312 }
3313
3314 static DEFINE_PER_CPU(int, perf_throttled_count);
3315 static DEFINE_PER_CPU(u64, perf_throttled_seq);
3316
3317 static void perf_adjust_period(struct perf_event *event, u64 nsec, u64 count, bool disable)
3318 {
3319         struct hw_perf_event *hwc = &event->hw;
3320         s64 period, sample_period;
3321         s64 delta;
3322
3323         period = perf_calculate_period(event, nsec, count);
3324
3325         delta = (s64)(period - hwc->sample_period);
3326         delta = (delta + 7) / 8; /* low pass filter */
3327
3328         sample_period = hwc->sample_period + delta;
3329
3330         if (!sample_period)
3331                 sample_period = 1;
3332
3333         hwc->sample_period = sample_period;
3334
3335         if (local64_read(&hwc->period_left) > 8*sample_period) {
3336                 if (disable)
3337                         event->pmu->stop(event, PERF_EF_UPDATE);
3338
3339                 local64_set(&hwc->period_left, 0);
3340
3341                 if (disable)
3342                         event->pmu->start(event, PERF_EF_RELOAD);
3343         }
3344 }
3345
3346 /*
3347  * combine freq adjustment with unthrottling to avoid two passes over the
3348  * events. At the same time, make sure, having freq events does not change
3349  * the rate of unthrottling as that would introduce bias.
3350  */
3351 static void perf_adjust_freq_unthr_context(struct perf_event_context *ctx,
3352                                            int needs_unthr)
3353 {
3354         struct perf_event *event;
3355         struct hw_perf_event *hwc;
3356         u64 now, period = TICK_NSEC;
3357         s64 delta;
3358
3359         /*
3360          * only need to iterate over all events iff:
3361          * - context have events in frequency mode (needs freq adjust)
3362          * - there are events to unthrottle on this cpu
3363          */
3364         if (!(ctx->nr_freq || needs_unthr))
3365                 return;
3366
3367         raw_spin_lock(&ctx->lock);
3368         perf_pmu_disable(ctx->pmu);
3369
3370         list_for_each_entry_rcu(event, &ctx->event_list, event_entry) {
3371                 if (event->state != PERF_EVENT_STATE_ACTIVE)
3372                         continue;
3373
3374                 if (!event_filter_match(event))
3375                         continue;
3376
3377                 perf_pmu_disable(event->pmu);
3378
3379                 hwc = &event->hw;
3380
3381                 if (hwc->interrupts == MAX_INTERRUPTS) {
3382                         hwc->interrupts = 0;
3383                         perf_log_throttle(event, 1);
3384                         event->pmu->start(event, 0);
3385                 }
3386
3387                 if (!event->attr.freq || !event->attr.sample_freq)
3388                         goto next;
3389
3390                 /*
3391                  * stop the event and update event->count
3392                  */
3393                 event->pmu->stop(event, PERF_EF_UPDATE);
3394
3395                 now = local64_read(&event->count);
3396                 delta = now - hwc->freq_count_stamp;
3397                 hwc->freq_count_stamp = now;
3398
3399                 /*
3400                  * restart the event
3401                  * reload only if value has changed
3402                  * we have stopped the event so tell that
3403                  * to perf_adjust_period() to avoid stopping it
3404                  * twice.
3405                  */
3406                 if (delta > 0)
3407                         perf_adjust_period(event, period, delta, false);
3408
3409                 event->pmu->start(event, delta > 0 ? PERF_EF_RELOAD : 0);
3410         next:
3411                 perf_pmu_enable(event->pmu);
3412         }
3413
3414         perf_pmu_enable(ctx->pmu);
3415         raw_spin_unlock(&ctx->lock);
3416 }
3417
3418 /*
3419  * Round-robin a context's events:
3420  */
3421 static void rotate_ctx(struct perf_event_context *ctx)
3422 {
3423         /*
3424          * Rotate the first entry last of non-pinned groups. Rotation might be
3425          * disabled by the inheritance code.
3426          */
3427         if (!ctx->rotate_disable)
3428                 list_rotate_left(&ctx->flexible_groups);
3429 }
3430
3431 static int perf_rotate_context(struct perf_cpu_context *cpuctx)
3432 {
3433         struct perf_event_context *ctx = NULL;
3434         int rotate = 0;
3435
3436         if (cpuctx->ctx.nr_events) {
3437                 if (cpuctx->ctx.nr_events != cpuctx->ctx.nr_active)
3438                         rotate = 1;
3439         }
3440
3441         ctx = cpuctx->task_ctx;
3442         if (ctx && ctx->nr_events) {
3443                 if (ctx->nr_events != ctx->nr_active)
3444                         rotate = 1;
3445         }
3446
3447         if (!rotate)
3448                 goto done;
3449
3450         perf_ctx_lock(cpuctx, cpuctx->task_ctx);
3451         perf_pmu_disable(cpuctx->ctx.pmu);
3452
3453         cpu_ctx_sched_out(cpuctx, EVENT_FLEXIBLE);
3454         if (ctx)
3455                 ctx_sched_out(ctx, cpuctx, EVENT_FLEXIBLE);
3456
3457         rotate_ctx(&cpuctx->ctx);
3458         if (ctx)
3459                 rotate_ctx(ctx);
3460
3461         perf_event_sched_in(cpuctx, ctx, current);
3462
3463         perf_pmu_enable(cpuctx->ctx.pmu);
3464         perf_ctx_unlock(cpuctx, cpuctx->task_ctx);
3465 done:
3466
3467         return rotate;
3468 }
3469
3470 void perf_event_task_tick(void)
3471 {
3472         struct list_head *head = this_cpu_ptr(&active_ctx_list);
3473         struct perf_event_context *ctx, *tmp;
3474         int throttled;
3475
3476         WARN_ON(!irqs_disabled());
3477
3478         __this_cpu_inc(perf_throttled_seq);
3479         throttled = __this_cpu_xchg(perf_throttled_count, 0);
3480         tick_dep_clear_cpu(smp_processor_id(), TICK_DEP_BIT_PERF_EVENTS);
3481
3482         list_for_each_entry_safe(ctx, tmp, head, active_ctx_list)
3483                 perf_adjust_freq_unthr_context(ctx, throttled);
3484 }
3485
3486 static int event_enable_on_exec(struct perf_event *event,
3487                                 struct perf_event_context *ctx)
3488 {
3489         if (!event->attr.enable_on_exec)
3490                 return 0;
3491
3492         event->attr.enable_on_exec = 0;
3493         if (event->state >= PERF_EVENT_STATE_INACTIVE)
3494                 return 0;
3495
3496         __perf_event_mark_enabled(event);
3497
3498         return 1;
3499 }
3500
3501 /*
3502  * Enable all of a task's events that have been marked enable-on-exec.
3503  * This expects task == current.
3504  */
3505 static void perf_event_enable_on_exec(int ctxn)
3506 {
3507         struct perf_event_context *ctx, *clone_ctx = NULL;
3508         enum event_type_t event_type = 0;
3509         struct perf_cpu_context *cpuctx;
3510         struct perf_event *event;
3511         unsigned long flags;
3512         int enabled = 0;
3513
3514         local_irq_save(flags);
3515         ctx = current->perf_event_ctxp[ctxn];
3516         if (!ctx || !ctx->nr_events)
3517                 goto out;
3518
3519         cpuctx = __get_cpu_context(ctx);
3520         perf_ctx_lock(cpuctx, ctx);
3521         ctx_sched_out(ctx, cpuctx, EVENT_TIME);
3522         list_for_each_entry(event, &ctx->event_list, event_entry) {
3523                 enabled |= event_enable_on_exec(event, ctx);
3524                 event_type |= get_event_type(event);
3525         }
3526
3527         /*
3528          * Unclone and reschedule this context if we enabled any event.
3529          */
3530         if (enabled) {
3531                 clone_ctx = unclone_ctx(ctx);
3532                 ctx_resched(cpuctx, ctx, event_type);
3533         } else {
3534                 ctx_sched_in(ctx, cpuctx, EVENT_TIME, current);
3535         }
3536         perf_ctx_unlock(cpuctx, ctx);
3537
3538 out:
3539         local_irq_restore(flags);
3540
3541         if (clone_ctx)
3542                 put_ctx(clone_ctx);
3543 }
3544
3545 struct perf_read_data {
3546         struct perf_event *event;
3547         bool group;
3548         int ret;
3549 };
3550
3551 static int __perf_event_read_cpu(struct perf_event *event, int event_cpu)
3552 {
3553         u16 local_pkg, event_pkg;
3554
3555         if (event->group_caps & PERF_EV_CAP_READ_ACTIVE_PKG) {
3556                 int local_cpu = smp_processor_id();
3557
3558                 event_pkg = topology_physical_package_id(event_cpu);
3559                 local_pkg = topology_physical_package_id(local_cpu);
3560
3561                 if (event_pkg == local_pkg)
3562                         return local_cpu;
3563         }
3564
3565         return event_cpu;
3566 }
3567
3568 /*
3569  * Cross CPU call to read the hardware event
3570  */
3571 static void __perf_event_read(void *info)
3572 {
3573         struct perf_read_data *data = info;
3574         struct perf_event *sub, *event = data->event;
3575         struct perf_event_context *ctx = event->ctx;
3576         struct perf_cpu_context *cpuctx = __get_cpu_context(ctx);
3577         struct pmu *pmu = event->pmu;
3578
3579         /*
3580          * If this is a task context, we need to check whether it is
3581          * the current task context of this cpu.  If not it has been
3582          * scheduled out before the smp call arrived.  In that case
3583          * event->count would have been updated to a recent sample
3584          * when the event was scheduled out.
3585          */
3586         if (ctx->task && cpuctx->task_ctx != ctx)
3587                 return;
3588
3589         raw_spin_lock(&ctx->lock);
3590         if (ctx->is_active) {
3591                 update_context_time(ctx);
3592                 update_cgrp_time_from_event(event);
3593         }
3594
3595         update_event_times(event);
3596         if (event->state != PERF_EVENT_STATE_ACTIVE)
3597                 goto unlock;
3598
3599         if (!data->group) {
3600                 pmu->read(event);
3601                 data->ret = 0;
3602                 goto unlock;
3603         }
3604
3605         pmu->start_txn(pmu, PERF_PMU_TXN_READ);
3606
3607         pmu->read(event);
3608
3609         list_for_each_entry(sub, &event->sibling_list, group_entry) {
3610                 update_event_times(sub);
3611                 if (sub->state == PERF_EVENT_STATE_ACTIVE) {
3612                         /*
3613                          * Use sibling's PMU rather than @event's since
3614                          * sibling could be on different (eg: software) PMU.
3615                          */
3616                         sub->pmu->read(sub);
3617                 }
3618         }
3619
3620         data->ret = pmu->commit_txn(pmu);
3621
3622 unlock:
3623         raw_spin_unlock(&ctx->lock);