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