Merge branch 'tip/perf/urgent' of git://git.kernel.org/pub/scm/linux/kernel/git/roste...
[linux-2.6.git] / kernel / perf_event.c
1 /*
2  * Performance events core code:
3  *
4  *  Copyright (C) 2008 Thomas Gleixner <tglx@linutronix.de>
5  *  Copyright (C) 2008-2009 Red Hat, Inc., Ingo Molnar
6  *  Copyright (C) 2008-2009 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/file.h>
17 #include <linux/poll.h>
18 #include <linux/slab.h>
19 #include <linux/hash.h>
20 #include <linux/sysfs.h>
21 #include <linux/dcache.h>
22 #include <linux/percpu.h>
23 #include <linux/ptrace.h>
24 #include <linux/vmstat.h>
25 #include <linux/vmalloc.h>
26 #include <linux/hardirq.h>
27 #include <linux/rculist.h>
28 #include <linux/uaccess.h>
29 #include <linux/syscalls.h>
30 #include <linux/anon_inodes.h>
31 #include <linux/kernel_stat.h>
32 #include <linux/perf_event.h>
33 #include <linux/ftrace_event.h>
34 #include <linux/hw_breakpoint.h>
35
36 #include <asm/irq_regs.h>
37
38 /*
39  * Each CPU has a list of per CPU events:
40  */
41 static DEFINE_PER_CPU(struct perf_cpu_context, perf_cpu_context);
42
43 int perf_max_events __read_mostly = 1;
44 static int perf_reserved_percpu __read_mostly;
45 static int perf_overcommit __read_mostly = 1;
46
47 static atomic_t nr_events __read_mostly;
48 static atomic_t nr_mmap_events __read_mostly;
49 static atomic_t nr_comm_events __read_mostly;
50 static atomic_t nr_task_events __read_mostly;
51
52 /*
53  * perf event paranoia level:
54  *  -1 - not paranoid at all
55  *   0 - disallow raw tracepoint access for unpriv
56  *   1 - disallow cpu events for unpriv
57  *   2 - disallow kernel profiling for unpriv
58  */
59 int sysctl_perf_event_paranoid __read_mostly = 1;
60
61 int sysctl_perf_event_mlock __read_mostly = 512; /* 'free' kb per user */
62
63 /*
64  * max perf event sample rate
65  */
66 int sysctl_perf_event_sample_rate __read_mostly = 100000;
67
68 static atomic64_t perf_event_id;
69
70 /*
71  * Lock for (sysadmin-configurable) event reservations:
72  */
73 static DEFINE_SPINLOCK(perf_resource_lock);
74
75 /*
76  * Architecture provided APIs - weak aliases:
77  */
78 extern __weak const struct pmu *hw_perf_event_init(struct perf_event *event)
79 {
80         return NULL;
81 }
82
83 void __weak hw_perf_disable(void)               { barrier(); }
84 void __weak hw_perf_enable(void)                { barrier(); }
85
86 void __weak perf_event_print_debug(void)        { }
87
88 static DEFINE_PER_CPU(int, perf_disable_count);
89
90 void perf_disable(void)
91 {
92         if (!__get_cpu_var(perf_disable_count)++)
93                 hw_perf_disable();
94 }
95
96 void perf_enable(void)
97 {
98         if (!--__get_cpu_var(perf_disable_count))
99                 hw_perf_enable();
100 }
101
102 static void get_ctx(struct perf_event_context *ctx)
103 {
104         WARN_ON(!atomic_inc_not_zero(&ctx->refcount));
105 }
106
107 static void free_ctx(struct rcu_head *head)
108 {
109         struct perf_event_context *ctx;
110
111         ctx = container_of(head, struct perf_event_context, rcu_head);
112         kfree(ctx);
113 }
114
115 static void put_ctx(struct perf_event_context *ctx)
116 {
117         if (atomic_dec_and_test(&ctx->refcount)) {
118                 if (ctx->parent_ctx)
119                         put_ctx(ctx->parent_ctx);
120                 if (ctx->task)
121                         put_task_struct(ctx->task);
122                 call_rcu(&ctx->rcu_head, free_ctx);
123         }
124 }
125
126 static void unclone_ctx(struct perf_event_context *ctx)
127 {
128         if (ctx->parent_ctx) {
129                 put_ctx(ctx->parent_ctx);
130                 ctx->parent_ctx = NULL;
131         }
132 }
133
134 /*
135  * If we inherit events we want to return the parent event id
136  * to userspace.
137  */
138 static u64 primary_event_id(struct perf_event *event)
139 {
140         u64 id = event->id;
141
142         if (event->parent)
143                 id = event->parent->id;
144
145         return id;
146 }
147
148 /*
149  * Get the perf_event_context for a task and lock it.
150  * This has to cope with with the fact that until it is locked,
151  * the context could get moved to another task.
152  */
153 static struct perf_event_context *
154 perf_lock_task_context(struct task_struct *task, unsigned long *flags)
155 {
156         struct perf_event_context *ctx;
157
158         rcu_read_lock();
159  retry:
160         ctx = rcu_dereference(task->perf_event_ctxp);
161         if (ctx) {
162                 /*
163                  * If this context is a clone of another, it might
164                  * get swapped for another underneath us by
165                  * perf_event_task_sched_out, though the
166                  * rcu_read_lock() protects us from any context
167                  * getting freed.  Lock the context and check if it
168                  * got swapped before we could get the lock, and retry
169                  * if so.  If we locked the right context, then it
170                  * can't get swapped on us any more.
171                  */
172                 raw_spin_lock_irqsave(&ctx->lock, *flags);
173                 if (ctx != rcu_dereference(task->perf_event_ctxp)) {
174                         raw_spin_unlock_irqrestore(&ctx->lock, *flags);
175                         goto retry;
176                 }
177
178                 if (!atomic_inc_not_zero(&ctx->refcount)) {
179                         raw_spin_unlock_irqrestore(&ctx->lock, *flags);
180                         ctx = NULL;
181                 }
182         }
183         rcu_read_unlock();
184         return ctx;
185 }
186
187 /*
188  * Get the context for a task and increment its pin_count so it
189  * can't get swapped to another task.  This also increments its
190  * reference count so that the context can't get freed.
191  */
192 static struct perf_event_context *perf_pin_task_context(struct task_struct *task)
193 {
194         struct perf_event_context *ctx;
195         unsigned long flags;
196
197         ctx = perf_lock_task_context(task, &flags);
198         if (ctx) {
199                 ++ctx->pin_count;
200                 raw_spin_unlock_irqrestore(&ctx->lock, flags);
201         }
202         return ctx;
203 }
204
205 static void perf_unpin_context(struct perf_event_context *ctx)
206 {
207         unsigned long flags;
208
209         raw_spin_lock_irqsave(&ctx->lock, flags);
210         --ctx->pin_count;
211         raw_spin_unlock_irqrestore(&ctx->lock, flags);
212         put_ctx(ctx);
213 }
214
215 static inline u64 perf_clock(void)
216 {
217         return local_clock();
218 }
219
220 /*
221  * Update the record of the current time in a context.
222  */
223 static void update_context_time(struct perf_event_context *ctx)
224 {
225         u64 now = perf_clock();
226
227         ctx->time += now - ctx->timestamp;
228         ctx->timestamp = now;
229 }
230
231 /*
232  * Update the total_time_enabled and total_time_running fields for a event.
233  */
234 static void update_event_times(struct perf_event *event)
235 {
236         struct perf_event_context *ctx = event->ctx;
237         u64 run_end;
238
239         if (event->state < PERF_EVENT_STATE_INACTIVE ||
240             event->group_leader->state < PERF_EVENT_STATE_INACTIVE)
241                 return;
242
243         if (ctx->is_active)
244                 run_end = ctx->time;
245         else
246                 run_end = event->tstamp_stopped;
247
248         event->total_time_enabled = run_end - event->tstamp_enabled;
249
250         if (event->state == PERF_EVENT_STATE_INACTIVE)
251                 run_end = event->tstamp_stopped;
252         else
253                 run_end = ctx->time;
254
255         event->total_time_running = run_end - event->tstamp_running;
256 }
257
258 /*
259  * Update total_time_enabled and total_time_running for all events in a group.
260  */
261 static void update_group_times(struct perf_event *leader)
262 {
263         struct perf_event *event;
264
265         update_event_times(leader);
266         list_for_each_entry(event, &leader->sibling_list, group_entry)
267                 update_event_times(event);
268 }
269
270 static struct list_head *
271 ctx_group_list(struct perf_event *event, struct perf_event_context *ctx)
272 {
273         if (event->attr.pinned)
274                 return &ctx->pinned_groups;
275         else
276                 return &ctx->flexible_groups;
277 }
278
279 /*
280  * Add a event from the lists for its context.
281  * Must be called with ctx->mutex and ctx->lock held.
282  */
283 static void
284 list_add_event(struct perf_event *event, struct perf_event_context *ctx)
285 {
286         WARN_ON_ONCE(event->attach_state & PERF_ATTACH_CONTEXT);
287         event->attach_state |= PERF_ATTACH_CONTEXT;
288
289         /*
290          * If we're a stand alone event or group leader, we go to the context
291          * list, group events are kept attached to the group so that
292          * perf_group_detach can, at all times, locate all siblings.
293          */
294         if (event->group_leader == event) {
295                 struct list_head *list;
296
297                 if (is_software_event(event))
298                         event->group_flags |= PERF_GROUP_SOFTWARE;
299
300                 list = ctx_group_list(event, ctx);
301                 list_add_tail(&event->group_entry, list);
302         }
303
304         list_add_rcu(&event->event_entry, &ctx->event_list);
305         ctx->nr_events++;
306         if (event->attr.inherit_stat)
307                 ctx->nr_stat++;
308 }
309
310 static void perf_group_attach(struct perf_event *event)
311 {
312         struct perf_event *group_leader = event->group_leader;
313
314         WARN_ON_ONCE(event->attach_state & PERF_ATTACH_GROUP);
315         event->attach_state |= PERF_ATTACH_GROUP;
316
317         if (group_leader == event)
318                 return;
319
320         if (group_leader->group_flags & PERF_GROUP_SOFTWARE &&
321                         !is_software_event(event))
322                 group_leader->group_flags &= ~PERF_GROUP_SOFTWARE;
323
324         list_add_tail(&event->group_entry, &group_leader->sibling_list);
325         group_leader->nr_siblings++;
326 }
327
328 /*
329  * Remove a event from the lists for its context.
330  * Must be called with ctx->mutex and ctx->lock held.
331  */
332 static void
333 list_del_event(struct perf_event *event, struct perf_event_context *ctx)
334 {
335         /*
336          * We can have double detach due to exit/hot-unplug + close.
337          */
338         if (!(event->attach_state & PERF_ATTACH_CONTEXT))
339                 return;
340
341         event->attach_state &= ~PERF_ATTACH_CONTEXT;
342
343         ctx->nr_events--;
344         if (event->attr.inherit_stat)
345                 ctx->nr_stat--;
346
347         list_del_rcu(&event->event_entry);
348
349         if (event->group_leader == event)
350                 list_del_init(&event->group_entry);
351
352         update_group_times(event);
353
354         /*
355          * If event was in error state, then keep it
356          * that way, otherwise bogus counts will be
357          * returned on read(). The only way to get out
358          * of error state is by explicit re-enabling
359          * of the event
360          */
361         if (event->state > PERF_EVENT_STATE_OFF)
362                 event->state = PERF_EVENT_STATE_OFF;
363 }
364
365 static void perf_group_detach(struct perf_event *event)
366 {
367         struct perf_event *sibling, *tmp;
368         struct list_head *list = NULL;
369
370         /*
371          * We can have double detach due to exit/hot-unplug + close.
372          */
373         if (!(event->attach_state & PERF_ATTACH_GROUP))
374                 return;
375
376         event->attach_state &= ~PERF_ATTACH_GROUP;
377
378         /*
379          * If this is a sibling, remove it from its group.
380          */
381         if (event->group_leader != event) {
382                 list_del_init(&event->group_entry);
383                 event->group_leader->nr_siblings--;
384                 return;
385         }
386
387         if (!list_empty(&event->group_entry))
388                 list = &event->group_entry;
389
390         /*
391          * If this was a group event with sibling events then
392          * upgrade the siblings to singleton events by adding them
393          * to whatever list we are on.
394          */
395         list_for_each_entry_safe(sibling, tmp, &event->sibling_list, group_entry) {
396                 if (list)
397                         list_move_tail(&sibling->group_entry, list);
398                 sibling->group_leader = sibling;
399
400                 /* Inherit group flags from the previous leader */
401                 sibling->group_flags = event->group_flags;
402         }
403 }
404
405 static void
406 event_sched_out(struct perf_event *event,
407                   struct perf_cpu_context *cpuctx,
408                   struct perf_event_context *ctx)
409 {
410         if (event->state != PERF_EVENT_STATE_ACTIVE)
411                 return;
412
413         event->state = PERF_EVENT_STATE_INACTIVE;
414         if (event->pending_disable) {
415                 event->pending_disable = 0;
416                 event->state = PERF_EVENT_STATE_OFF;
417         }
418         event->tstamp_stopped = ctx->time;
419         event->pmu->disable(event);
420         event->oncpu = -1;
421
422         if (!is_software_event(event))
423                 cpuctx->active_oncpu--;
424         ctx->nr_active--;
425         if (event->attr.exclusive || !cpuctx->active_oncpu)
426                 cpuctx->exclusive = 0;
427 }
428
429 static void
430 group_sched_out(struct perf_event *group_event,
431                 struct perf_cpu_context *cpuctx,
432                 struct perf_event_context *ctx)
433 {
434         struct perf_event *event;
435
436         if (group_event->state != PERF_EVENT_STATE_ACTIVE)
437                 return;
438
439         event_sched_out(group_event, cpuctx, ctx);
440
441         /*
442          * Schedule out siblings (if any):
443          */
444         list_for_each_entry(event, &group_event->sibling_list, group_entry)
445                 event_sched_out(event, cpuctx, ctx);
446
447         if (group_event->attr.exclusive)
448                 cpuctx->exclusive = 0;
449 }
450
451 /*
452  * Cross CPU call to remove a performance event
453  *
454  * We disable the event on the hardware level first. After that we
455  * remove it from the context list.
456  */
457 static void __perf_event_remove_from_context(void *info)
458 {
459         struct perf_cpu_context *cpuctx = &__get_cpu_var(perf_cpu_context);
460         struct perf_event *event = info;
461         struct perf_event_context *ctx = event->ctx;
462
463         /*
464          * If this is a task context, we need to check whether it is
465          * the current task context of this cpu. If not it has been
466          * scheduled out before the smp call arrived.
467          */
468         if (ctx->task && cpuctx->task_ctx != ctx)
469                 return;
470
471         raw_spin_lock(&ctx->lock);
472         /*
473          * Protect the list operation against NMI by disabling the
474          * events on a global level.
475          */
476         perf_disable();
477
478         event_sched_out(event, cpuctx, ctx);
479
480         list_del_event(event, ctx);
481
482         if (!ctx->task) {
483                 /*
484                  * Allow more per task events with respect to the
485                  * reservation:
486                  */
487                 cpuctx->max_pertask =
488                         min(perf_max_events - ctx->nr_events,
489                             perf_max_events - perf_reserved_percpu);
490         }
491
492         perf_enable();
493         raw_spin_unlock(&ctx->lock);
494 }
495
496
497 /*
498  * Remove the event from a task's (or a CPU's) list of events.
499  *
500  * Must be called with ctx->mutex held.
501  *
502  * CPU events are removed with a smp call. For task events we only
503  * call when the task is on a CPU.
504  *
505  * If event->ctx is a cloned context, callers must make sure that
506  * every task struct that event->ctx->task could possibly point to
507  * remains valid.  This is OK when called from perf_release since
508  * that only calls us on the top-level context, which can't be a clone.
509  * When called from perf_event_exit_task, it's OK because the
510  * context has been detached from its task.
511  */
512 static void perf_event_remove_from_context(struct perf_event *event)
513 {
514         struct perf_event_context *ctx = event->ctx;
515         struct task_struct *task = ctx->task;
516
517         if (!task) {
518                 /*
519                  * Per cpu events are removed via an smp call and
520                  * the removal is always successful.
521                  */
522                 smp_call_function_single(event->cpu,
523                                          __perf_event_remove_from_context,
524                                          event, 1);
525                 return;
526         }
527
528 retry:
529         task_oncpu_function_call(task, __perf_event_remove_from_context,
530                                  event);
531
532         raw_spin_lock_irq(&ctx->lock);
533         /*
534          * If the context is active we need to retry the smp call.
535          */
536         if (ctx->nr_active && !list_empty(&event->group_entry)) {
537                 raw_spin_unlock_irq(&ctx->lock);
538                 goto retry;
539         }
540
541         /*
542          * The lock prevents that this context is scheduled in so we
543          * can remove the event safely, if the call above did not
544          * succeed.
545          */
546         if (!list_empty(&event->group_entry))
547                 list_del_event(event, ctx);
548         raw_spin_unlock_irq(&ctx->lock);
549 }
550
551 /*
552  * Cross CPU call to disable a performance event
553  */
554 static void __perf_event_disable(void *info)
555 {
556         struct perf_event *event = info;
557         struct perf_cpu_context *cpuctx = &__get_cpu_var(perf_cpu_context);
558         struct perf_event_context *ctx = event->ctx;
559
560         /*
561          * If this is a per-task event, need to check whether this
562          * event's task is the current task on this cpu.
563          */
564         if (ctx->task && cpuctx->task_ctx != ctx)
565                 return;
566
567         raw_spin_lock(&ctx->lock);
568
569         /*
570          * If the event is on, turn it off.
571          * If it is in error state, leave it in error state.
572          */
573         if (event->state >= PERF_EVENT_STATE_INACTIVE) {
574                 update_context_time(ctx);
575                 update_group_times(event);
576                 if (event == event->group_leader)
577                         group_sched_out(event, cpuctx, ctx);
578                 else
579                         event_sched_out(event, cpuctx, ctx);
580                 event->state = PERF_EVENT_STATE_OFF;
581         }
582
583         raw_spin_unlock(&ctx->lock);
584 }
585
586 /*
587  * Disable a event.
588  *
589  * If event->ctx is a cloned context, callers must make sure that
590  * every task struct that event->ctx->task could possibly point to
591  * remains valid.  This condition is satisifed when called through
592  * perf_event_for_each_child or perf_event_for_each because they
593  * hold the top-level event's child_mutex, so any descendant that
594  * goes to exit will block in sync_child_event.
595  * When called from perf_pending_event it's OK because event->ctx
596  * is the current context on this CPU and preemption is disabled,
597  * hence we can't get into perf_event_task_sched_out for this context.
598  */
599 void perf_event_disable(struct perf_event *event)
600 {
601         struct perf_event_context *ctx = event->ctx;
602         struct task_struct *task = ctx->task;
603
604         if (!task) {
605                 /*
606                  * Disable the event on the cpu that it's on
607                  */
608                 smp_call_function_single(event->cpu, __perf_event_disable,
609                                          event, 1);
610                 return;
611         }
612
613  retry:
614         task_oncpu_function_call(task, __perf_event_disable, event);
615
616         raw_spin_lock_irq(&ctx->lock);
617         /*
618          * If the event is still active, we need to retry the cross-call.
619          */
620         if (event->state == PERF_EVENT_STATE_ACTIVE) {
621                 raw_spin_unlock_irq(&ctx->lock);
622                 goto retry;
623         }
624
625         /*
626          * Since we have the lock this context can't be scheduled
627          * in, so we can change the state safely.
628          */
629         if (event->state == PERF_EVENT_STATE_INACTIVE) {
630                 update_group_times(event);
631                 event->state = PERF_EVENT_STATE_OFF;
632         }
633
634         raw_spin_unlock_irq(&ctx->lock);
635 }
636
637 static int
638 event_sched_in(struct perf_event *event,
639                  struct perf_cpu_context *cpuctx,
640                  struct perf_event_context *ctx)
641 {
642         if (event->state <= PERF_EVENT_STATE_OFF)
643                 return 0;
644
645         event->state = PERF_EVENT_STATE_ACTIVE;
646         event->oncpu = smp_processor_id();
647         /*
648          * The new state must be visible before we turn it on in the hardware:
649          */
650         smp_wmb();
651
652         if (event->pmu->enable(event)) {
653                 event->state = PERF_EVENT_STATE_INACTIVE;
654                 event->oncpu = -1;
655                 return -EAGAIN;
656         }
657
658         event->tstamp_running += ctx->time - event->tstamp_stopped;
659
660         if (!is_software_event(event))
661                 cpuctx->active_oncpu++;
662         ctx->nr_active++;
663
664         if (event->attr.exclusive)
665                 cpuctx->exclusive = 1;
666
667         return 0;
668 }
669
670 static int
671 group_sched_in(struct perf_event *group_event,
672                struct perf_cpu_context *cpuctx,
673                struct perf_event_context *ctx)
674 {
675         struct perf_event *event, *partial_group = NULL;
676         const struct pmu *pmu = group_event->pmu;
677         bool txn = false;
678
679         if (group_event->state == PERF_EVENT_STATE_OFF)
680                 return 0;
681
682         /* Check if group transaction availabe */
683         if (pmu->start_txn)
684                 txn = true;
685
686         if (txn)
687                 pmu->start_txn(pmu);
688
689         if (event_sched_in(group_event, cpuctx, ctx)) {
690                 if (txn)
691                         pmu->cancel_txn(pmu);
692                 return -EAGAIN;
693         }
694
695         /*
696          * Schedule in siblings as one group (if any):
697          */
698         list_for_each_entry(event, &group_event->sibling_list, group_entry) {
699                 if (event_sched_in(event, cpuctx, ctx)) {
700                         partial_group = event;
701                         goto group_error;
702                 }
703         }
704
705         if (!txn || !pmu->commit_txn(pmu))
706                 return 0;
707
708 group_error:
709         /*
710          * Groups can be scheduled in as one unit only, so undo any
711          * partial group before returning:
712          */
713         list_for_each_entry(event, &group_event->sibling_list, group_entry) {
714                 if (event == partial_group)
715                         break;
716                 event_sched_out(event, cpuctx, ctx);
717         }
718         event_sched_out(group_event, cpuctx, ctx);
719
720         if (txn)
721                 pmu->cancel_txn(pmu);
722
723         return -EAGAIN;
724 }
725
726 /*
727  * Work out whether we can put this event group on the CPU now.
728  */
729 static int group_can_go_on(struct perf_event *event,
730                            struct perf_cpu_context *cpuctx,
731                            int can_add_hw)
732 {
733         /*
734          * Groups consisting entirely of software events can always go on.
735          */
736         if (event->group_flags & PERF_GROUP_SOFTWARE)
737                 return 1;
738         /*
739          * If an exclusive group is already on, no other hardware
740          * events can go on.
741          */
742         if (cpuctx->exclusive)
743                 return 0;
744         /*
745          * If this group is exclusive and there are already
746          * events on the CPU, it can't go on.
747          */
748         if (event->attr.exclusive && cpuctx->active_oncpu)
749                 return 0;
750         /*
751          * Otherwise, try to add it if all previous groups were able
752          * to go on.
753          */
754         return can_add_hw;
755 }
756
757 static void add_event_to_ctx(struct perf_event *event,
758                                struct perf_event_context *ctx)
759 {
760         list_add_event(event, ctx);
761         perf_group_attach(event);
762         event->tstamp_enabled = ctx->time;
763         event->tstamp_running = ctx->time;
764         event->tstamp_stopped = ctx->time;
765 }
766
767 /*
768  * Cross CPU call to install and enable a performance event
769  *
770  * Must be called with ctx->mutex held
771  */
772 static void __perf_install_in_context(void *info)
773 {
774         struct perf_cpu_context *cpuctx = &__get_cpu_var(perf_cpu_context);
775         struct perf_event *event = info;
776         struct perf_event_context *ctx = event->ctx;
777         struct perf_event *leader = event->group_leader;
778         int err;
779
780         /*
781          * If this is a task context, we need to check whether it is
782          * the current task context of this cpu. If not it has been
783          * scheduled out before the smp call arrived.
784          * Or possibly this is the right context but it isn't
785          * on this cpu because it had no events.
786          */
787         if (ctx->task && cpuctx->task_ctx != ctx) {
788                 if (cpuctx->task_ctx || ctx->task != current)
789                         return;
790                 cpuctx->task_ctx = ctx;
791         }
792
793         raw_spin_lock(&ctx->lock);
794         ctx->is_active = 1;
795         update_context_time(ctx);
796
797         /*
798          * Protect the list operation against NMI by disabling the
799          * events on a global level. NOP for non NMI based events.
800          */
801         perf_disable();
802
803         add_event_to_ctx(event, ctx);
804
805         if (event->cpu != -1 && event->cpu != smp_processor_id())
806                 goto unlock;
807
808         /*
809          * Don't put the event on if it is disabled or if
810          * it is in a group and the group isn't on.
811          */
812         if (event->state != PERF_EVENT_STATE_INACTIVE ||
813             (leader != event && leader->state != PERF_EVENT_STATE_ACTIVE))
814                 goto unlock;
815
816         /*
817          * An exclusive event can't go on if there are already active
818          * hardware events, and no hardware event can go on if there
819          * is already an exclusive event on.
820          */
821         if (!group_can_go_on(event, cpuctx, 1))
822                 err = -EEXIST;
823         else
824                 err = event_sched_in(event, cpuctx, ctx);
825
826         if (err) {
827                 /*
828                  * This event couldn't go on.  If it is in a group
829                  * then we have to pull the whole group off.
830                  * If the event group is pinned then put it in error state.
831                  */
832                 if (leader != event)
833                         group_sched_out(leader, cpuctx, ctx);
834                 if (leader->attr.pinned) {
835                         update_group_times(leader);
836                         leader->state = PERF_EVENT_STATE_ERROR;
837                 }
838         }
839
840         if (!err && !ctx->task && cpuctx->max_pertask)
841                 cpuctx->max_pertask--;
842
843  unlock:
844         perf_enable();
845
846         raw_spin_unlock(&ctx->lock);
847 }
848
849 /*
850  * Attach a performance event to a context
851  *
852  * First we add the event to the list with the hardware enable bit
853  * in event->hw_config cleared.
854  *
855  * If the event is attached to a task which is on a CPU we use a smp
856  * call to enable it in the task context. The task might have been
857  * scheduled away, but we check this in the smp call again.
858  *
859  * Must be called with ctx->mutex held.
860  */
861 static void
862 perf_install_in_context(struct perf_event_context *ctx,
863                         struct perf_event *event,
864                         int cpu)
865 {
866         struct task_struct *task = ctx->task;
867
868         if (!task) {
869                 /*
870                  * Per cpu events are installed via an smp call and
871                  * the install is always successful.
872                  */
873                 smp_call_function_single(cpu, __perf_install_in_context,
874                                          event, 1);
875                 return;
876         }
877
878 retry:
879         task_oncpu_function_call(task, __perf_install_in_context,
880                                  event);
881
882         raw_spin_lock_irq(&ctx->lock);
883         /*
884          * we need to retry the smp call.
885          */
886         if (ctx->is_active && list_empty(&event->group_entry)) {
887                 raw_spin_unlock_irq(&ctx->lock);
888                 goto retry;
889         }
890
891         /*
892          * The lock prevents that this context is scheduled in so we
893          * can add the event safely, if it the call above did not
894          * succeed.
895          */
896         if (list_empty(&event->group_entry))
897                 add_event_to_ctx(event, ctx);
898         raw_spin_unlock_irq(&ctx->lock);
899 }
900
901 /*
902  * Put a event into inactive state and update time fields.
903  * Enabling the leader of a group effectively enables all
904  * the group members that aren't explicitly disabled, so we
905  * have to update their ->tstamp_enabled also.
906  * Note: this works for group members as well as group leaders
907  * since the non-leader members' sibling_lists will be empty.
908  */
909 static void __perf_event_mark_enabled(struct perf_event *event,
910                                         struct perf_event_context *ctx)
911 {
912         struct perf_event *sub;
913
914         event->state = PERF_EVENT_STATE_INACTIVE;
915         event->tstamp_enabled = ctx->time - event->total_time_enabled;
916         list_for_each_entry(sub, &event->sibling_list, group_entry)
917                 if (sub->state >= PERF_EVENT_STATE_INACTIVE)
918                         sub->tstamp_enabled =
919                                 ctx->time - sub->total_time_enabled;
920 }
921
922 /*
923  * Cross CPU call to enable a performance event
924  */
925 static void __perf_event_enable(void *info)
926 {
927         struct perf_event *event = info;
928         struct perf_cpu_context *cpuctx = &__get_cpu_var(perf_cpu_context);
929         struct perf_event_context *ctx = event->ctx;
930         struct perf_event *leader = event->group_leader;
931         int err;
932
933         /*
934          * If this is a per-task event, need to check whether this
935          * event's task is the current task on this cpu.
936          */
937         if (ctx->task && cpuctx->task_ctx != ctx) {
938                 if (cpuctx->task_ctx || ctx->task != current)
939                         return;
940                 cpuctx->task_ctx = ctx;
941         }
942
943         raw_spin_lock(&ctx->lock);
944         ctx->is_active = 1;
945         update_context_time(ctx);
946
947         if (event->state >= PERF_EVENT_STATE_INACTIVE)
948                 goto unlock;
949         __perf_event_mark_enabled(event, ctx);
950
951         if (event->cpu != -1 && event->cpu != smp_processor_id())
952                 goto unlock;
953
954         /*
955          * If the event is in a group and isn't the group leader,
956          * then don't put it on unless the group is on.
957          */
958         if (leader != event && leader->state != PERF_EVENT_STATE_ACTIVE)
959                 goto unlock;
960
961         if (!group_can_go_on(event, cpuctx, 1)) {
962                 err = -EEXIST;
963         } else {
964                 perf_disable();
965                 if (event == leader)
966                         err = group_sched_in(event, cpuctx, ctx);
967                 else
968                         err = event_sched_in(event, cpuctx, ctx);
969                 perf_enable();
970         }
971
972         if (err) {
973                 /*
974                  * If this event can't go on and it's part of a
975                  * group, then the whole group has to come off.
976                  */
977                 if (leader != event)
978                         group_sched_out(leader, cpuctx, ctx);
979                 if (leader->attr.pinned) {
980                         update_group_times(leader);
981                         leader->state = PERF_EVENT_STATE_ERROR;
982                 }
983         }
984
985  unlock:
986         raw_spin_unlock(&ctx->lock);
987 }
988
989 /*
990  * Enable a event.
991  *
992  * If event->ctx is a cloned context, callers must make sure that
993  * every task struct that event->ctx->task could possibly point to
994  * remains valid.  This condition is satisfied when called through
995  * perf_event_for_each_child or perf_event_for_each as described
996  * for perf_event_disable.
997  */
998 void perf_event_enable(struct perf_event *event)
999 {
1000         struct perf_event_context *ctx = event->ctx;
1001         struct task_struct *task = ctx->task;
1002
1003         if (!task) {
1004                 /*
1005                  * Enable the event on the cpu that it's on
1006                  */
1007                 smp_call_function_single(event->cpu, __perf_event_enable,
1008                                          event, 1);
1009                 return;
1010         }
1011
1012         raw_spin_lock_irq(&ctx->lock);
1013         if (event->state >= PERF_EVENT_STATE_INACTIVE)
1014                 goto out;
1015
1016         /*
1017          * If the event is in error state, clear that first.
1018          * That way, if we see the event in error state below, we
1019          * know that it has gone back into error state, as distinct
1020          * from the task having been scheduled away before the
1021          * cross-call arrived.
1022          */
1023         if (event->state == PERF_EVENT_STATE_ERROR)
1024                 event->state = PERF_EVENT_STATE_OFF;
1025
1026  retry:
1027         raw_spin_unlock_irq(&ctx->lock);
1028         task_oncpu_function_call(task, __perf_event_enable, event);
1029
1030         raw_spin_lock_irq(&ctx->lock);
1031
1032         /*
1033          * If the context is active and the event is still off,
1034          * we need to retry the cross-call.
1035          */
1036         if (ctx->is_active && event->state == PERF_EVENT_STATE_OFF)
1037                 goto retry;
1038
1039         /*
1040          * Since we have the lock this context can't be scheduled
1041          * in, so we can change the state safely.
1042          */
1043         if (event->state == PERF_EVENT_STATE_OFF)
1044                 __perf_event_mark_enabled(event, ctx);
1045
1046  out:
1047         raw_spin_unlock_irq(&ctx->lock);
1048 }
1049
1050 static int perf_event_refresh(struct perf_event *event, int refresh)
1051 {
1052         /*
1053          * not supported on inherited events
1054          */
1055         if (event->attr.inherit)
1056                 return -EINVAL;
1057
1058         atomic_add(refresh, &event->event_limit);
1059         perf_event_enable(event);
1060
1061         return 0;
1062 }
1063
1064 enum event_type_t {
1065         EVENT_FLEXIBLE = 0x1,
1066         EVENT_PINNED = 0x2,
1067         EVENT_ALL = EVENT_FLEXIBLE | EVENT_PINNED,
1068 };
1069
1070 static void ctx_sched_out(struct perf_event_context *ctx,
1071                           struct perf_cpu_context *cpuctx,
1072                           enum event_type_t event_type)
1073 {
1074         struct perf_event *event;
1075
1076         raw_spin_lock(&ctx->lock);
1077         ctx->is_active = 0;
1078         if (likely(!ctx->nr_events))
1079                 goto out;
1080         update_context_time(ctx);
1081
1082         perf_disable();
1083         if (!ctx->nr_active)
1084                 goto out_enable;
1085
1086         if (event_type & EVENT_PINNED)
1087                 list_for_each_entry(event, &ctx->pinned_groups, group_entry)
1088                         group_sched_out(event, cpuctx, ctx);
1089
1090         if (event_type & EVENT_FLEXIBLE)
1091                 list_for_each_entry(event, &ctx->flexible_groups, group_entry)
1092                         group_sched_out(event, cpuctx, ctx);
1093
1094  out_enable:
1095         perf_enable();
1096  out:
1097         raw_spin_unlock(&ctx->lock);
1098 }
1099
1100 /*
1101  * Test whether two contexts are equivalent, i.e. whether they
1102  * have both been cloned from the same version of the same context
1103  * and they both have the same number of enabled events.
1104  * If the number of enabled events is the same, then the set
1105  * of enabled events should be the same, because these are both
1106  * inherited contexts, therefore we can't access individual events
1107  * in them directly with an fd; we can only enable/disable all
1108  * events via prctl, or enable/disable all events in a family
1109  * via ioctl, which will have the same effect on both contexts.
1110  */
1111 static int context_equiv(struct perf_event_context *ctx1,
1112                          struct perf_event_context *ctx2)
1113 {
1114         return ctx1->parent_ctx && ctx1->parent_ctx == ctx2->parent_ctx
1115                 && ctx1->parent_gen == ctx2->parent_gen
1116                 && !ctx1->pin_count && !ctx2->pin_count;
1117 }
1118
1119 static void __perf_event_sync_stat(struct perf_event *event,
1120                                      struct perf_event *next_event)
1121 {
1122         u64 value;
1123
1124         if (!event->attr.inherit_stat)
1125                 return;
1126
1127         /*
1128          * Update the event value, we cannot use perf_event_read()
1129          * because we're in the middle of a context switch and have IRQs
1130          * disabled, which upsets smp_call_function_single(), however
1131          * we know the event must be on the current CPU, therefore we
1132          * don't need to use it.
1133          */
1134         switch (event->state) {
1135         case PERF_EVENT_STATE_ACTIVE:
1136                 event->pmu->read(event);
1137                 /* fall-through */
1138
1139         case PERF_EVENT_STATE_INACTIVE:
1140                 update_event_times(event);
1141                 break;
1142
1143         default:
1144                 break;
1145         }
1146
1147         /*
1148          * In order to keep per-task stats reliable we need to flip the event
1149          * values when we flip the contexts.
1150          */
1151         value = local64_read(&next_event->count);
1152         value = local64_xchg(&event->count, value);
1153         local64_set(&next_event->count, value);
1154
1155         swap(event->total_time_enabled, next_event->total_time_enabled);
1156         swap(event->total_time_running, next_event->total_time_running);
1157
1158         /*
1159          * Since we swizzled the values, update the user visible data too.
1160          */
1161         perf_event_update_userpage(event);
1162         perf_event_update_userpage(next_event);
1163 }
1164
1165 #define list_next_entry(pos, member) \
1166         list_entry(pos->member.next, typeof(*pos), member)
1167
1168 static void perf_event_sync_stat(struct perf_event_context *ctx,
1169                                    struct perf_event_context *next_ctx)
1170 {
1171         struct perf_event *event, *next_event;
1172
1173         if (!ctx->nr_stat)
1174                 return;
1175
1176         update_context_time(ctx);
1177
1178         event = list_first_entry(&ctx->event_list,
1179                                    struct perf_event, event_entry);
1180
1181         next_event = list_first_entry(&next_ctx->event_list,
1182                                         struct perf_event, event_entry);
1183
1184         while (&event->event_entry != &ctx->event_list &&
1185                &next_event->event_entry != &next_ctx->event_list) {
1186
1187                 __perf_event_sync_stat(event, next_event);
1188
1189                 event = list_next_entry(event, event_entry);
1190                 next_event = list_next_entry(next_event, event_entry);
1191         }
1192 }
1193
1194 /*
1195  * Called from scheduler to remove the events of the current task,
1196  * with interrupts disabled.
1197  *
1198  * We stop each event and update the event value in event->count.
1199  *
1200  * This does not protect us against NMI, but disable()
1201  * sets the disabled bit in the control field of event _before_
1202  * accessing the event control register. If a NMI hits, then it will
1203  * not restart the event.
1204  */
1205 void perf_event_task_sched_out(struct task_struct *task,
1206                                  struct task_struct *next)
1207 {
1208         struct perf_cpu_context *cpuctx = &__get_cpu_var(perf_cpu_context);
1209         struct perf_event_context *ctx = task->perf_event_ctxp;
1210         struct perf_event_context *next_ctx;
1211         struct perf_event_context *parent;
1212         int do_switch = 1;
1213
1214         perf_sw_event(PERF_COUNT_SW_CONTEXT_SWITCHES, 1, 1, NULL, 0);
1215
1216         if (likely(!ctx || !cpuctx->task_ctx))
1217                 return;
1218
1219         rcu_read_lock();
1220         parent = rcu_dereference(ctx->parent_ctx);
1221         next_ctx = next->perf_event_ctxp;
1222         if (parent && next_ctx &&
1223             rcu_dereference(next_ctx->parent_ctx) == parent) {
1224                 /*
1225                  * Looks like the two contexts are clones, so we might be
1226                  * able to optimize the context switch.  We lock both
1227                  * contexts and check that they are clones under the
1228                  * lock (including re-checking that neither has been
1229                  * uncloned in the meantime).  It doesn't matter which
1230                  * order we take the locks because no other cpu could
1231                  * be trying to lock both of these tasks.
1232                  */
1233                 raw_spin_lock(&ctx->lock);
1234                 raw_spin_lock_nested(&next_ctx->lock, SINGLE_DEPTH_NESTING);
1235                 if (context_equiv(ctx, next_ctx)) {
1236                         /*
1237                          * XXX do we need a memory barrier of sorts
1238                          * wrt to rcu_dereference() of perf_event_ctxp
1239                          */
1240                         task->perf_event_ctxp = next_ctx;
1241                         next->perf_event_ctxp = ctx;
1242                         ctx->task = next;
1243                         next_ctx->task = task;
1244                         do_switch = 0;
1245
1246                         perf_event_sync_stat(ctx, next_ctx);
1247                 }
1248                 raw_spin_unlock(&next_ctx->lock);
1249                 raw_spin_unlock(&ctx->lock);
1250         }
1251         rcu_read_unlock();
1252
1253         if (do_switch) {
1254                 ctx_sched_out(ctx, cpuctx, EVENT_ALL);
1255                 cpuctx->task_ctx = NULL;
1256         }
1257 }
1258
1259 static void task_ctx_sched_out(struct perf_event_context *ctx,
1260                                enum event_type_t event_type)
1261 {
1262         struct perf_cpu_context *cpuctx = &__get_cpu_var(perf_cpu_context);
1263
1264         if (!cpuctx->task_ctx)
1265                 return;
1266
1267         if (WARN_ON_ONCE(ctx != cpuctx->task_ctx))
1268                 return;
1269
1270         ctx_sched_out(ctx, cpuctx, event_type);
1271         cpuctx->task_ctx = NULL;
1272 }
1273
1274 /*
1275  * Called with IRQs disabled
1276  */
1277 static void __perf_event_task_sched_out(struct perf_event_context *ctx)
1278 {
1279         task_ctx_sched_out(ctx, EVENT_ALL);
1280 }
1281
1282 /*
1283  * Called with IRQs disabled
1284  */
1285 static void cpu_ctx_sched_out(struct perf_cpu_context *cpuctx,
1286                               enum event_type_t event_type)
1287 {
1288         ctx_sched_out(&cpuctx->ctx, cpuctx, event_type);
1289 }
1290
1291 static void
1292 ctx_pinned_sched_in(struct perf_event_context *ctx,
1293                     struct perf_cpu_context *cpuctx)
1294 {
1295         struct perf_event *event;
1296
1297         list_for_each_entry(event, &ctx->pinned_groups, group_entry) {
1298                 if (event->state <= PERF_EVENT_STATE_OFF)
1299                         continue;
1300                 if (event->cpu != -1 && event->cpu != smp_processor_id())
1301                         continue;
1302
1303                 if (group_can_go_on(event, cpuctx, 1))
1304                         group_sched_in(event, cpuctx, ctx);
1305
1306                 /*
1307                  * If this pinned group hasn't been scheduled,
1308                  * put it in error state.
1309                  */
1310                 if (event->state == PERF_EVENT_STATE_INACTIVE) {
1311                         update_group_times(event);
1312                         event->state = PERF_EVENT_STATE_ERROR;
1313                 }
1314         }
1315 }
1316
1317 static void
1318 ctx_flexible_sched_in(struct perf_event_context *ctx,
1319                       struct perf_cpu_context *cpuctx)
1320 {
1321         struct perf_event *event;
1322         int can_add_hw = 1;
1323
1324         list_for_each_entry(event, &ctx->flexible_groups, group_entry) {
1325                 /* Ignore events in OFF or ERROR state */
1326                 if (event->state <= PERF_EVENT_STATE_OFF)
1327                         continue;
1328                 /*
1329                  * Listen to the 'cpu' scheduling filter constraint
1330                  * of events:
1331                  */
1332                 if (event->cpu != -1 && event->cpu != smp_processor_id())
1333                         continue;
1334
1335                 if (group_can_go_on(event, cpuctx, can_add_hw))
1336                         if (group_sched_in(event, cpuctx, ctx))
1337                                 can_add_hw = 0;
1338         }
1339 }
1340
1341 static void
1342 ctx_sched_in(struct perf_event_context *ctx,
1343              struct perf_cpu_context *cpuctx,
1344              enum event_type_t event_type)
1345 {
1346         raw_spin_lock(&ctx->lock);
1347         ctx->is_active = 1;
1348         if (likely(!ctx->nr_events))
1349                 goto out;
1350
1351         ctx->timestamp = perf_clock();
1352
1353         perf_disable();
1354
1355         /*
1356          * First go through the list and put on any pinned groups
1357          * in order to give them the best chance of going on.
1358          */
1359         if (event_type & EVENT_PINNED)
1360                 ctx_pinned_sched_in(ctx, cpuctx);
1361
1362         /* Then walk through the lower prio flexible groups */
1363         if (event_type & EVENT_FLEXIBLE)
1364                 ctx_flexible_sched_in(ctx, cpuctx);
1365
1366         perf_enable();
1367  out:
1368         raw_spin_unlock(&ctx->lock);
1369 }
1370
1371 static void cpu_ctx_sched_in(struct perf_cpu_context *cpuctx,
1372                              enum event_type_t event_type)
1373 {
1374         struct perf_event_context *ctx = &cpuctx->ctx;
1375
1376         ctx_sched_in(ctx, cpuctx, event_type);
1377 }
1378
1379 static void task_ctx_sched_in(struct task_struct *task,
1380                               enum event_type_t event_type)
1381 {
1382         struct perf_cpu_context *cpuctx = &__get_cpu_var(perf_cpu_context);
1383         struct perf_event_context *ctx = task->perf_event_ctxp;
1384
1385         if (likely(!ctx))
1386                 return;
1387         if (cpuctx->task_ctx == ctx)
1388                 return;
1389         ctx_sched_in(ctx, cpuctx, event_type);
1390         cpuctx->task_ctx = ctx;
1391 }
1392 /*
1393  * Called from scheduler to add the events of the current task
1394  * with interrupts disabled.
1395  *
1396  * We restore the event value and then enable it.
1397  *
1398  * This does not protect us against NMI, but enable()
1399  * sets the enabled bit in the control field of event _before_
1400  * accessing the event control register. If a NMI hits, then it will
1401  * keep the event running.
1402  */
1403 void perf_event_task_sched_in(struct task_struct *task)
1404 {
1405         struct perf_cpu_context *cpuctx = &__get_cpu_var(perf_cpu_context);
1406         struct perf_event_context *ctx = task->perf_event_ctxp;
1407
1408         if (likely(!ctx))
1409                 return;
1410
1411         if (cpuctx->task_ctx == ctx)
1412                 return;
1413
1414         perf_disable();
1415
1416         /*
1417          * We want to keep the following priority order:
1418          * cpu pinned (that don't need to move), task pinned,
1419          * cpu flexible, task flexible.
1420          */
1421         cpu_ctx_sched_out(cpuctx, EVENT_FLEXIBLE);
1422
1423         ctx_sched_in(ctx, cpuctx, EVENT_PINNED);
1424         cpu_ctx_sched_in(cpuctx, EVENT_FLEXIBLE);
1425         ctx_sched_in(ctx, cpuctx, EVENT_FLEXIBLE);
1426
1427         cpuctx->task_ctx = ctx;
1428
1429         perf_enable();
1430 }
1431
1432 #define MAX_INTERRUPTS (~0ULL)
1433
1434 static void perf_log_throttle(struct perf_event *event, int enable);
1435
1436 static u64 perf_calculate_period(struct perf_event *event, u64 nsec, u64 count)
1437 {
1438         u64 frequency = event->attr.sample_freq;
1439         u64 sec = NSEC_PER_SEC;
1440         u64 divisor, dividend;
1441
1442         int count_fls, nsec_fls, frequency_fls, sec_fls;
1443
1444         count_fls = fls64(count);
1445         nsec_fls = fls64(nsec);
1446         frequency_fls = fls64(frequency);
1447         sec_fls = 30;
1448
1449         /*
1450          * We got @count in @nsec, with a target of sample_freq HZ
1451          * the target period becomes:
1452          *
1453          *             @count * 10^9
1454          * period = -------------------
1455          *          @nsec * sample_freq
1456          *
1457          */
1458
1459         /*
1460          * Reduce accuracy by one bit such that @a and @b converge
1461          * to a similar magnitude.
1462          */
1463 #define REDUCE_FLS(a, b)                \
1464 do {                                    \
1465         if (a##_fls > b##_fls) {        \
1466                 a >>= 1;                \
1467                 a##_fls--;              \
1468         } else {                        \
1469                 b >>= 1;                \
1470                 b##_fls--;              \
1471         }                               \
1472 } while (0)
1473
1474         /*
1475          * Reduce accuracy until either term fits in a u64, then proceed with
1476          * the other, so that finally we can do a u64/u64 division.
1477          */
1478         while (count_fls + sec_fls > 64 && nsec_fls + frequency_fls > 64) {
1479                 REDUCE_FLS(nsec, frequency);
1480                 REDUCE_FLS(sec, count);
1481         }
1482
1483         if (count_fls + sec_fls > 64) {
1484                 divisor = nsec * frequency;
1485
1486                 while (count_fls + sec_fls > 64) {
1487                         REDUCE_FLS(count, sec);
1488                         divisor >>= 1;
1489                 }
1490
1491                 dividend = count * sec;
1492         } else {
1493                 dividend = count * sec;
1494
1495                 while (nsec_fls + frequency_fls > 64) {
1496                         REDUCE_FLS(nsec, frequency);
1497                         dividend >>= 1;
1498                 }
1499
1500                 divisor = nsec * frequency;
1501         }
1502
1503         if (!divisor)
1504                 return dividend;
1505
1506         return div64_u64(dividend, divisor);
1507 }
1508
1509 static void perf_event_stop(struct perf_event *event)
1510 {
1511         if (!event->pmu->stop)
1512                 return event->pmu->disable(event);
1513
1514         return event->pmu->stop(event);
1515 }
1516
1517 static int perf_event_start(struct perf_event *event)
1518 {
1519         if (!event->pmu->start)
1520                 return event->pmu->enable(event);
1521
1522         return event->pmu->start(event);
1523 }
1524
1525 static void perf_adjust_period(struct perf_event *event, u64 nsec, u64 count)
1526 {
1527         struct hw_perf_event *hwc = &event->hw;
1528         s64 period, sample_period;
1529         s64 delta;
1530
1531         period = perf_calculate_period(event, nsec, count);
1532
1533         delta = (s64)(period - hwc->sample_period);
1534         delta = (delta + 7) / 8; /* low pass filter */
1535
1536         sample_period = hwc->sample_period + delta;
1537
1538         if (!sample_period)
1539                 sample_period = 1;
1540
1541         hwc->sample_period = sample_period;
1542
1543         if (local64_read(&hwc->period_left) > 8*sample_period) {
1544                 perf_disable();
1545                 perf_event_stop(event);
1546                 local64_set(&hwc->period_left, 0);
1547                 perf_event_start(event);
1548                 perf_enable();
1549         }
1550 }
1551
1552 static void perf_ctx_adjust_freq(struct perf_event_context *ctx)
1553 {
1554         struct perf_event *event;
1555         struct hw_perf_event *hwc;
1556         u64 interrupts, now;
1557         s64 delta;
1558
1559         raw_spin_lock(&ctx->lock);
1560         list_for_each_entry_rcu(event, &ctx->event_list, event_entry) {
1561                 if (event->state != PERF_EVENT_STATE_ACTIVE)
1562                         continue;
1563
1564                 if (event->cpu != -1 && event->cpu != smp_processor_id())
1565                         continue;
1566
1567                 hwc = &event->hw;
1568
1569                 interrupts = hwc->interrupts;
1570                 hwc->interrupts = 0;
1571
1572                 /*
1573                  * unthrottle events on the tick
1574                  */
1575                 if (interrupts == MAX_INTERRUPTS) {
1576                         perf_log_throttle(event, 1);
1577                         perf_disable();
1578                         event->pmu->unthrottle(event);
1579                         perf_enable();
1580                 }
1581
1582                 if (!event->attr.freq || !event->attr.sample_freq)
1583                         continue;
1584
1585                 perf_disable();
1586                 event->pmu->read(event);
1587                 now = local64_read(&event->count);
1588                 delta = now - hwc->freq_count_stamp;
1589                 hwc->freq_count_stamp = now;
1590
1591                 if (delta > 0)
1592                         perf_adjust_period(event, TICK_NSEC, delta);
1593                 perf_enable();
1594         }
1595         raw_spin_unlock(&ctx->lock);
1596 }
1597
1598 /*
1599  * Round-robin a context's events:
1600  */
1601 static void rotate_ctx(struct perf_event_context *ctx)
1602 {
1603         raw_spin_lock(&ctx->lock);
1604
1605         /* Rotate the first entry last of non-pinned groups */
1606         list_rotate_left(&ctx->flexible_groups);
1607
1608         raw_spin_unlock(&ctx->lock);
1609 }
1610
1611 void perf_event_task_tick(struct task_struct *curr)
1612 {
1613         struct perf_cpu_context *cpuctx;
1614         struct perf_event_context *ctx;
1615         int rotate = 0;
1616
1617         if (!atomic_read(&nr_events))
1618                 return;
1619
1620         cpuctx = &__get_cpu_var(perf_cpu_context);
1621         if (cpuctx->ctx.nr_events &&
1622             cpuctx->ctx.nr_events != cpuctx->ctx.nr_active)
1623                 rotate = 1;
1624
1625         ctx = curr->perf_event_ctxp;
1626         if (ctx && ctx->nr_events && ctx->nr_events != ctx->nr_active)
1627                 rotate = 1;
1628
1629         perf_ctx_adjust_freq(&cpuctx->ctx);
1630         if (ctx)
1631                 perf_ctx_adjust_freq(ctx);
1632
1633         if (!rotate)
1634                 return;
1635
1636         perf_disable();
1637         cpu_ctx_sched_out(cpuctx, EVENT_FLEXIBLE);
1638         if (ctx)
1639                 task_ctx_sched_out(ctx, EVENT_FLEXIBLE);
1640
1641         rotate_ctx(&cpuctx->ctx);
1642         if (ctx)
1643                 rotate_ctx(ctx);
1644
1645         cpu_ctx_sched_in(cpuctx, EVENT_FLEXIBLE);
1646         if (ctx)
1647                 task_ctx_sched_in(curr, EVENT_FLEXIBLE);
1648         perf_enable();
1649 }
1650
1651 static int event_enable_on_exec(struct perf_event *event,
1652                                 struct perf_event_context *ctx)
1653 {
1654         if (!event->attr.enable_on_exec)
1655                 return 0;
1656
1657         event->attr.enable_on_exec = 0;
1658         if (event->state >= PERF_EVENT_STATE_INACTIVE)
1659                 return 0;
1660
1661         __perf_event_mark_enabled(event, ctx);
1662
1663         return 1;
1664 }
1665
1666 /*
1667  * Enable all of a task's events that have been marked enable-on-exec.
1668  * This expects task == current.
1669  */
1670 static void perf_event_enable_on_exec(struct task_struct *task)
1671 {
1672         struct perf_event_context *ctx;
1673         struct perf_event *event;
1674         unsigned long flags;
1675         int enabled = 0;
1676         int ret;
1677
1678         local_irq_save(flags);
1679         ctx = task->perf_event_ctxp;
1680         if (!ctx || !ctx->nr_events)
1681                 goto out;
1682
1683         __perf_event_task_sched_out(ctx);
1684
1685         raw_spin_lock(&ctx->lock);
1686
1687         list_for_each_entry(event, &ctx->pinned_groups, group_entry) {
1688                 ret = event_enable_on_exec(event, ctx);
1689                 if (ret)
1690                         enabled = 1;
1691         }
1692
1693         list_for_each_entry(event, &ctx->flexible_groups, group_entry) {
1694                 ret = event_enable_on_exec(event, ctx);
1695                 if (ret)
1696                         enabled = 1;
1697         }
1698
1699         /*
1700          * Unclone this context if we enabled any event.
1701          */
1702         if (enabled)
1703                 unclone_ctx(ctx);
1704
1705         raw_spin_unlock(&ctx->lock);
1706
1707         perf_event_task_sched_in(task);
1708  out:
1709         local_irq_restore(flags);
1710 }
1711
1712 /*
1713  * Cross CPU call to read the hardware event
1714  */
1715 static void __perf_event_read(void *info)
1716 {
1717         struct perf_cpu_context *cpuctx = &__get_cpu_var(perf_cpu_context);
1718         struct perf_event *event = info;
1719         struct perf_event_context *ctx = event->ctx;
1720
1721         /*
1722          * If this is a task context, we need to check whether it is
1723          * the current task context of this cpu.  If not it has been
1724          * scheduled out before the smp call arrived.  In that case
1725          * event->count would have been updated to a recent sample
1726          * when the event was scheduled out.
1727          */
1728         if (ctx->task && cpuctx->task_ctx != ctx)
1729                 return;
1730
1731         raw_spin_lock(&ctx->lock);
1732         update_context_time(ctx);
1733         update_event_times(event);
1734         raw_spin_unlock(&ctx->lock);
1735
1736         event->pmu->read(event);
1737 }
1738
1739 static inline u64 perf_event_count(struct perf_event *event)
1740 {
1741         return local64_read(&event->count) + atomic64_read(&event->child_count);
1742 }
1743
1744 static u64 perf_event_read(struct perf_event *event)
1745 {
1746         /*
1747          * If event is enabled and currently active on a CPU, update the
1748          * value in the event structure:
1749          */
1750         if (event->state == PERF_EVENT_STATE_ACTIVE) {
1751                 smp_call_function_single(event->oncpu,
1752                                          __perf_event_read, event, 1);
1753         } else if (event->state == PERF_EVENT_STATE_INACTIVE) {
1754                 struct perf_event_context *ctx = event->ctx;
1755                 unsigned long flags;
1756
1757                 raw_spin_lock_irqsave(&ctx->lock, flags);
1758                 update_context_time(ctx);
1759                 update_event_times(event);
1760                 raw_spin_unlock_irqrestore(&ctx->lock, flags);
1761         }
1762
1763         return perf_event_count(event);
1764 }
1765
1766 /*
1767  * Callchain support
1768  */
1769
1770 struct callchain_cpus_entries {
1771         struct rcu_head                 rcu_head;
1772         struct perf_callchain_entry     *cpu_entries[0];
1773 };
1774
1775 static DEFINE_PER_CPU(int, callchain_recursion[PERF_NR_CONTEXTS]);
1776 static atomic_t nr_callchain_events;
1777 static DEFINE_MUTEX(callchain_mutex);
1778 struct callchain_cpus_entries *callchain_cpus_entries;
1779
1780
1781 __weak void perf_callchain_kernel(struct perf_callchain_entry *entry,
1782                                   struct pt_regs *regs)
1783 {
1784 }
1785
1786 __weak void perf_callchain_user(struct perf_callchain_entry *entry,
1787                                 struct pt_regs *regs)
1788 {
1789 }
1790
1791 static void release_callchain_buffers_rcu(struct rcu_head *head)
1792 {
1793         struct callchain_cpus_entries *entries;
1794         int cpu;
1795
1796         entries = container_of(head, struct callchain_cpus_entries, rcu_head);
1797
1798         for_each_possible_cpu(cpu)
1799                 kfree(entries->cpu_entries[cpu]);
1800
1801         kfree(entries);
1802 }
1803
1804 static void release_callchain_buffers(void)
1805 {
1806         struct callchain_cpus_entries *entries;
1807
1808         entries = callchain_cpus_entries;
1809         rcu_assign_pointer(callchain_cpus_entries, NULL);
1810         call_rcu(&entries->rcu_head, release_callchain_buffers_rcu);
1811 }
1812
1813 static int alloc_callchain_buffers(void)
1814 {
1815         int cpu;
1816         int size;
1817         struct callchain_cpus_entries *entries;
1818
1819         /*
1820          * We can't use the percpu allocation API for data that can be
1821          * accessed from NMI. Use a temporary manual per cpu allocation
1822          * until that gets sorted out.
1823          */
1824         size = sizeof(*entries) + sizeof(struct perf_callchain_entry *) *
1825                 num_possible_cpus();
1826
1827         entries = kzalloc(size, GFP_KERNEL);
1828         if (!entries)
1829                 return -ENOMEM;
1830
1831         size = sizeof(struct perf_callchain_entry) * PERF_NR_CONTEXTS;
1832
1833         for_each_possible_cpu(cpu) {
1834                 entries->cpu_entries[cpu] = kmalloc_node(size, GFP_KERNEL,
1835                                                          cpu_to_node(cpu));
1836                 if (!entries->cpu_entries[cpu])
1837                         goto fail;
1838         }
1839
1840         rcu_assign_pointer(callchain_cpus_entries, entries);
1841
1842         return 0;
1843
1844 fail:
1845         for_each_possible_cpu(cpu)
1846                 kfree(entries->cpu_entries[cpu]);
1847         kfree(entries);
1848
1849         return -ENOMEM;
1850 }
1851
1852 static int get_callchain_buffers(void)
1853 {
1854         int err = 0;
1855         int count;
1856
1857         mutex_lock(&callchain_mutex);
1858
1859         count = atomic_inc_return(&nr_callchain_events);
1860         if (WARN_ON_ONCE(count < 1)) {
1861                 err = -EINVAL;
1862                 goto exit;
1863         }
1864
1865         if (count > 1) {
1866                 /* If the allocation failed, give up */
1867                 if (!callchain_cpus_entries)
1868                         err = -ENOMEM;
1869                 goto exit;
1870         }
1871
1872         err = alloc_callchain_buffers();
1873         if (err)
1874                 release_callchain_buffers();
1875 exit:
1876         mutex_unlock(&callchain_mutex);
1877
1878         return err;
1879 }
1880
1881 static void put_callchain_buffers(void)
1882 {
1883         if (atomic_dec_and_mutex_lock(&nr_callchain_events, &callchain_mutex)) {
1884                 release_callchain_buffers();
1885                 mutex_unlock(&callchain_mutex);
1886         }
1887 }
1888
1889 static int get_recursion_context(int *recursion)
1890 {
1891         int rctx;
1892
1893         if (in_nmi())
1894                 rctx = 3;
1895         else if (in_irq())
1896                 rctx = 2;
1897         else if (in_softirq())
1898                 rctx = 1;
1899         else
1900                 rctx = 0;
1901
1902         if (recursion[rctx])
1903                 return -1;
1904
1905         recursion[rctx]++;
1906         barrier();
1907
1908         return rctx;
1909 }
1910
1911 static inline void put_recursion_context(int *recursion, int rctx)
1912 {
1913         barrier();
1914         recursion[rctx]--;
1915 }
1916
1917 static struct perf_callchain_entry *get_callchain_entry(int *rctx)
1918 {
1919         int cpu;
1920         struct callchain_cpus_entries *entries;
1921
1922         *rctx = get_recursion_context(__get_cpu_var(callchain_recursion));
1923         if (*rctx == -1)
1924                 return NULL;
1925
1926         entries = rcu_dereference(callchain_cpus_entries);
1927         if (!entries)
1928                 return NULL;
1929
1930         cpu = smp_processor_id();
1931
1932         return &entries->cpu_entries[cpu][*rctx];
1933 }
1934
1935 static void
1936 put_callchain_entry(int rctx)
1937 {
1938         put_recursion_context(__get_cpu_var(callchain_recursion), rctx);
1939 }
1940
1941 static struct perf_callchain_entry *perf_callchain(struct pt_regs *regs)
1942 {
1943         int rctx;
1944         struct perf_callchain_entry *entry;
1945
1946
1947         entry = get_callchain_entry(&rctx);
1948         if (rctx == -1)
1949                 return NULL;
1950
1951         if (!entry)
1952                 goto exit_put;
1953
1954         entry->nr = 0;
1955
1956         if (!user_mode(regs)) {
1957                 perf_callchain_store(entry, PERF_CONTEXT_KERNEL);
1958                 perf_callchain_kernel(entry, regs);
1959                 if (current->mm)
1960                         regs = task_pt_regs(current);
1961                 else
1962                         regs = NULL;
1963         }
1964
1965         if (regs) {
1966                 perf_callchain_store(entry, PERF_CONTEXT_USER);
1967                 perf_callchain_user(entry, regs);
1968         }
1969
1970 exit_put:
1971         put_callchain_entry(rctx);
1972
1973         return entry;
1974 }
1975
1976 /*
1977  * Initialize the perf_event context in a task_struct:
1978  */
1979 static void
1980 __perf_event_init_context(struct perf_event_context *ctx,
1981                             struct task_struct *task)
1982 {
1983         raw_spin_lock_init(&ctx->lock);
1984         mutex_init(&ctx->mutex);
1985         INIT_LIST_HEAD(&ctx->pinned_groups);
1986         INIT_LIST_HEAD(&ctx->flexible_groups);
1987         INIT_LIST_HEAD(&ctx->event_list);
1988         atomic_set(&ctx->refcount, 1);
1989         ctx->task = task;
1990 }
1991
1992 static struct perf_event_context *find_get_context(pid_t pid, int cpu)
1993 {
1994         struct perf_event_context *ctx;
1995         struct perf_cpu_context *cpuctx;
1996         struct task_struct *task;
1997         unsigned long flags;
1998         int err;
1999
2000         if (pid == -1 && cpu != -1) {
2001                 /* Must be root to operate on a CPU event: */
2002                 if (perf_paranoid_cpu() && !capable(CAP_SYS_ADMIN))
2003                         return ERR_PTR(-EACCES);
2004
2005                 if (cpu < 0 || cpu >= nr_cpumask_bits)
2006                         return ERR_PTR(-EINVAL);
2007
2008                 /*
2009                  * We could be clever and allow to attach a event to an
2010                  * offline CPU and activate it when the CPU comes up, but
2011                  * that's for later.
2012                  */
2013                 if (!cpu_online(cpu))
2014                         return ERR_PTR(-ENODEV);
2015
2016                 cpuctx = &per_cpu(perf_cpu_context, cpu);
2017                 ctx = &cpuctx->ctx;
2018                 get_ctx(ctx);
2019
2020                 return ctx;
2021         }
2022
2023         rcu_read_lock();
2024         if (!pid)
2025                 task = current;
2026         else
2027                 task = find_task_by_vpid(pid);
2028         if (task)
2029                 get_task_struct(task);
2030         rcu_read_unlock();
2031
2032         if (!task)
2033                 return ERR_PTR(-ESRCH);
2034
2035         /*
2036          * Can't attach events to a dying task.
2037          */
2038         err = -ESRCH;
2039         if (task->flags & PF_EXITING)
2040                 goto errout;
2041
2042         /* Reuse ptrace permission checks for now. */
2043         err = -EACCES;
2044         if (!ptrace_may_access(task, PTRACE_MODE_READ))
2045                 goto errout;
2046
2047  retry:
2048         ctx = perf_lock_task_context(task, &flags);
2049         if (ctx) {
2050                 unclone_ctx(ctx);
2051                 raw_spin_unlock_irqrestore(&ctx->lock, flags);
2052         }
2053
2054         if (!ctx) {
2055                 ctx = kzalloc(sizeof(struct perf_event_context), GFP_KERNEL);
2056                 err = -ENOMEM;
2057                 if (!ctx)
2058                         goto errout;
2059                 __perf_event_init_context(ctx, task);
2060                 get_ctx(ctx);
2061                 if (cmpxchg(&task->perf_event_ctxp, NULL, ctx)) {
2062                         /*
2063                          * We raced with some other task; use
2064                          * the context they set.
2065                          */
2066                         kfree(ctx);
2067                         goto retry;
2068                 }
2069                 get_task_struct(task);
2070         }
2071
2072         put_task_struct(task);
2073         return ctx;
2074
2075  errout:
2076         put_task_struct(task);
2077         return ERR_PTR(err);
2078 }
2079
2080 static void perf_event_free_filter(struct perf_event *event);
2081
2082 static void free_event_rcu(struct rcu_head *head)
2083 {
2084         struct perf_event *event;
2085
2086         event = container_of(head, struct perf_event, rcu_head);
2087         if (event->ns)
2088                 put_pid_ns(event->ns);
2089         perf_event_free_filter(event);
2090         kfree(event);
2091 }
2092
2093 static void perf_pending_sync(struct perf_event *event);
2094 static void perf_buffer_put(struct perf_buffer *buffer);
2095
2096 static void free_event(struct perf_event *event)
2097 {
2098         perf_pending_sync(event);
2099
2100         if (!event->parent) {
2101                 atomic_dec(&nr_events);
2102                 if (event->attr.mmap || event->attr.mmap_data)
2103                         atomic_dec(&nr_mmap_events);
2104                 if (event->attr.comm)
2105                         atomic_dec(&nr_comm_events);
2106                 if (event->attr.task)
2107                         atomic_dec(&nr_task_events);
2108                 if (event->attr.sample_type & PERF_SAMPLE_CALLCHAIN)
2109                         put_callchain_buffers();
2110         }
2111
2112         if (event->buffer) {
2113                 perf_buffer_put(event->buffer);
2114                 event->buffer = NULL;
2115         }
2116
2117         if (event->destroy)
2118                 event->destroy(event);
2119
2120         put_ctx(event->ctx);
2121         call_rcu(&event->rcu_head, free_event_rcu);
2122 }
2123
2124 int perf_event_release_kernel(struct perf_event *event)
2125 {
2126         struct perf_event_context *ctx = event->ctx;
2127
2128         /*
2129          * Remove from the PMU, can't get re-enabled since we got
2130          * here because the last ref went.
2131          */
2132         perf_event_disable(event);
2133
2134         WARN_ON_ONCE(ctx->parent_ctx);
2135         /*
2136          * There are two ways this annotation is useful:
2137          *
2138          *  1) there is a lock recursion from perf_event_exit_task
2139          *     see the comment there.
2140          *
2141          *  2) there is a lock-inversion with mmap_sem through
2142          *     perf_event_read_group(), which takes faults while
2143          *     holding ctx->mutex, however this is called after
2144          *     the last filedesc died, so there is no possibility
2145          *     to trigger the AB-BA case.
2146          */
2147         mutex_lock_nested(&ctx->mutex, SINGLE_DEPTH_NESTING);
2148         raw_spin_lock_irq(&ctx->lock);
2149         perf_group_detach(event);
2150         list_del_event(event, ctx);
2151         raw_spin_unlock_irq(&ctx->lock);
2152         mutex_unlock(&ctx->mutex);
2153
2154         mutex_lock(&event->owner->perf_event_mutex);
2155         list_del_init(&event->owner_entry);
2156         mutex_unlock(&event->owner->perf_event_mutex);
2157         put_task_struct(event->owner);
2158
2159         free_event(event);
2160
2161         return 0;
2162 }
2163 EXPORT_SYMBOL_GPL(perf_event_release_kernel);
2164
2165 /*
2166  * Called when the last reference to the file is gone.
2167  */
2168 static int perf_release(struct inode *inode, struct file *file)
2169 {
2170         struct perf_event *event = file->private_data;
2171
2172         file->private_data = NULL;
2173
2174         return perf_event_release_kernel(event);
2175 }
2176
2177 static int perf_event_read_size(struct perf_event *event)
2178 {
2179         int entry = sizeof(u64); /* value */
2180         int size = 0;
2181         int nr = 1;
2182
2183         if (event->attr.read_format & PERF_FORMAT_TOTAL_TIME_ENABLED)
2184                 size += sizeof(u64);
2185
2186         if (event->attr.read_format & PERF_FORMAT_TOTAL_TIME_RUNNING)
2187                 size += sizeof(u64);
2188
2189         if (event->attr.read_format & PERF_FORMAT_ID)
2190                 entry += sizeof(u64);
2191
2192         if (event->attr.read_format & PERF_FORMAT_GROUP) {
2193                 nr += event->group_leader->nr_siblings;
2194                 size += sizeof(u64);
2195         }
2196
2197         size += entry * nr;
2198
2199         return size;
2200 }
2201
2202 u64 perf_event_read_value(struct perf_event *event, u64 *enabled, u64 *running)
2203 {
2204         struct perf_event *child;
2205         u64 total = 0;
2206
2207         *enabled = 0;
2208         *running = 0;
2209
2210         mutex_lock(&event->child_mutex);
2211         total += perf_event_read(event);
2212         *enabled += event->total_time_enabled +
2213                         atomic64_read(&event->child_total_time_enabled);
2214         *running += event->total_time_running +
2215                         atomic64_read(&event->child_total_time_running);
2216
2217         list_for_each_entry(child, &event->child_list, child_list) {
2218                 total += perf_event_read(child);
2219                 *enabled += child->total_time_enabled;
2220                 *running += child->total_time_running;
2221         }
2222         mutex_unlock(&event->child_mutex);
2223
2224         return total;
2225 }
2226 EXPORT_SYMBOL_GPL(perf_event_read_value);
2227
2228 static int perf_event_read_group(struct perf_event *event,
2229                                    u64 read_format, char __user *buf)
2230 {
2231         struct perf_event *leader = event->group_leader, *sub;
2232         int n = 0, size = 0, ret = -EFAULT;
2233         struct perf_event_context *ctx = leader->ctx;
2234         u64 values[5];
2235         u64 count, enabled, running;
2236
2237         mutex_lock(&ctx->mutex);
2238         count = perf_event_read_value(leader, &enabled, &running);
2239
2240         values[n++] = 1 + leader->nr_siblings;
2241         if (read_format & PERF_FORMAT_TOTAL_TIME_ENABLED)
2242                 values[n++] = enabled;
2243         if (read_format & PERF_FORMAT_TOTAL_TIME_RUNNING)
2244                 values[n++] = running;
2245         values[n++] = count;
2246         if (read_format & PERF_FORMAT_ID)
2247                 values[n++] = primary_event_id(leader);
2248
2249         size = n * sizeof(u64);
2250
2251         if (copy_to_user(buf, values, size))
2252                 goto unlock;
2253
2254         ret = size;
2255
2256         list_for_each_entry(sub, &leader->sibling_list, group_entry) {
2257                 n = 0;
2258
2259                 values[n++] = perf_event_read_value(sub, &enabled, &running);
2260                 if (read_format & PERF_FORMAT_ID)
2261                         values[n++] = primary_event_id(sub);
2262
2263                 size = n * sizeof(u64);
2264
2265                 if (copy_to_user(buf + ret, values, size)) {
2266                         ret = -EFAULT;
2267                         goto unlock;
2268                 }
2269
2270                 ret += size;
2271         }
2272 unlock:
2273         mutex_unlock(&ctx->mutex);
2274
2275         return ret;
2276 }
2277
2278 static int perf_event_read_one(struct perf_event *event,
2279                                  u64 read_format, char __user *buf)
2280 {
2281         u64 enabled, running;
2282         u64 values[4];
2283         int n = 0;
2284
2285         values[n++] = perf_event_read_value(event, &enabled, &running);
2286         if (read_format & PERF_FORMAT_TOTAL_TIME_ENABLED)
2287                 values[n++] = enabled;
2288         if (read_format & PERF_FORMAT_TOTAL_TIME_RUNNING)
2289                 values[n++] = running;
2290         if (read_format & PERF_FORMAT_ID)
2291                 values[n++] = primary_event_id(event);
2292
2293         if (copy_to_user(buf, values, n * sizeof(u64)))
2294                 return -EFAULT;
2295
2296         return n * sizeof(u64);
2297 }
2298
2299 /*
2300  * Read the performance event - simple non blocking version for now
2301  */
2302 static ssize_t
2303 perf_read_hw(struct perf_event *event, char __user *buf, size_t count)
2304 {
2305         u64 read_format = event->attr.read_format;
2306         int ret;
2307
2308         /*
2309          * Return end-of-file for a read on a event that is in
2310          * error state (i.e. because it was pinned but it couldn't be
2311          * scheduled on to the CPU at some point).
2312          */
2313         if (event->state == PERF_EVENT_STATE_ERROR)
2314                 return 0;
2315
2316         if (count < perf_event_read_size(event))
2317                 return -ENOSPC;
2318
2319         WARN_ON_ONCE(event->ctx->parent_ctx);
2320         if (read_format & PERF_FORMAT_GROUP)
2321                 ret = perf_event_read_group(event, read_format, buf);
2322         else
2323                 ret = perf_event_read_one(event, read_format, buf);
2324
2325         return ret;
2326 }
2327
2328 static ssize_t
2329 perf_read(struct file *file, char __user *buf, size_t count, loff_t *ppos)
2330 {
2331         struct perf_event *event = file->private_data;
2332
2333         return perf_read_hw(event, buf, count);
2334 }
2335
2336 static unsigned int perf_poll(struct file *file, poll_table *wait)
2337 {
2338         struct perf_event *event = file->private_data;
2339         struct perf_buffer *buffer;
2340         unsigned int events = POLL_HUP;
2341
2342         rcu_read_lock();
2343         buffer = rcu_dereference(event->buffer);
2344         if (buffer)
2345                 events = atomic_xchg(&buffer->poll, 0);
2346         rcu_read_unlock();
2347
2348         poll_wait(file, &event->waitq, wait);
2349
2350         return events;
2351 }
2352
2353 static void perf_event_reset(struct perf_event *event)
2354 {
2355         (void)perf_event_read(event);
2356         local64_set(&event->count, 0);
2357         perf_event_update_userpage(event);
2358 }
2359
2360 /*
2361  * Holding the top-level event's child_mutex means that any
2362  * descendant process that has inherited this event will block
2363  * in sync_child_event if it goes to exit, thus satisfying the
2364  * task existence requirements of perf_event_enable/disable.
2365  */
2366 static void perf_event_for_each_child(struct perf_event *event,
2367                                         void (*func)(struct perf_event *))
2368 {
2369         struct perf_event *child;
2370
2371         WARN_ON_ONCE(event->ctx->parent_ctx);
2372         mutex_lock(&event->child_mutex);
2373         func(event);
2374         list_for_each_entry(child, &event->child_list, child_list)
2375                 func(child);
2376         mutex_unlock(&event->child_mutex);
2377 }
2378
2379 static void perf_event_for_each(struct perf_event *event,
2380                                   void (*func)(struct perf_event *))
2381 {
2382         struct perf_event_context *ctx = event->ctx;
2383         struct perf_event *sibling;
2384
2385         WARN_ON_ONCE(ctx->parent_ctx);
2386         mutex_lock(&ctx->mutex);
2387         event = event->group_leader;
2388
2389         perf_event_for_each_child(event, func);
2390         func(event);
2391         list_for_each_entry(sibling, &event->sibling_list, group_entry)
2392                 perf_event_for_each_child(event, func);
2393         mutex_unlock(&ctx->mutex);
2394 }
2395
2396 static int perf_event_period(struct perf_event *event, u64 __user *arg)
2397 {
2398         struct perf_event_context *ctx = event->ctx;
2399         unsigned long size;
2400         int ret = 0;
2401         u64 value;
2402
2403         if (!event->attr.sample_period)
2404                 return -EINVAL;
2405
2406         size = copy_from_user(&value, arg, sizeof(value));
2407         if (size != sizeof(value))
2408                 return -EFAULT;
2409
2410         if (!value)
2411                 return -EINVAL;
2412
2413         raw_spin_lock_irq(&ctx->lock);
2414         if (event->attr.freq) {
2415                 if (value > sysctl_perf_event_sample_rate) {
2416                         ret = -EINVAL;
2417                         goto unlock;
2418                 }
2419
2420                 event->attr.sample_freq = value;
2421         } else {
2422                 event->attr.sample_period = value;
2423                 event->hw.sample_period = value;
2424         }
2425 unlock:
2426         raw_spin_unlock_irq(&ctx->lock);
2427
2428         return ret;
2429 }
2430
2431 static const struct file_operations perf_fops;
2432
2433 static struct perf_event *perf_fget_light(int fd, int *fput_needed)
2434 {
2435         struct file *file;
2436
2437         file = fget_light(fd, fput_needed);
2438         if (!file)
2439                 return ERR_PTR(-EBADF);
2440
2441         if (file->f_op != &perf_fops) {
2442                 fput_light(file, *fput_needed);
2443                 *fput_needed = 0;
2444                 return ERR_PTR(-EBADF);
2445         }
2446
2447         return file->private_data;
2448 }
2449
2450 static int perf_event_set_output(struct perf_event *event,
2451                                  struct perf_event *output_event);
2452 static int perf_event_set_filter(struct perf_event *event, void __user *arg);
2453
2454 static long perf_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
2455 {
2456         struct perf_event *event = file->private_data;
2457         void (*func)(struct perf_event *);
2458         u32 flags = arg;
2459
2460         switch (cmd) {
2461         case PERF_EVENT_IOC_ENABLE:
2462                 func = perf_event_enable;
2463                 break;
2464         case PERF_EVENT_IOC_DISABLE:
2465                 func = perf_event_disable;
2466                 break;
2467         case PERF_EVENT_IOC_RESET:
2468                 func = perf_event_reset;
2469                 break;
2470
2471         case PERF_EVENT_IOC_REFRESH:
2472                 return perf_event_refresh(event, arg);
2473
2474         case PERF_EVENT_IOC_PERIOD:
2475                 return perf_event_period(event, (u64 __user *)arg);
2476
2477         case PERF_EVENT_IOC_SET_OUTPUT:
2478         {
2479                 struct perf_event *output_event = NULL;
2480                 int fput_needed = 0;
2481                 int ret;
2482
2483                 if (arg != -1) {
2484                         output_event = perf_fget_light(arg, &fput_needed);
2485                         if (IS_ERR(output_event))
2486                                 return PTR_ERR(output_event);
2487                 }
2488
2489                 ret = perf_event_set_output(event, output_event);
2490                 if (output_event)
2491                         fput_light(output_event->filp, fput_needed);
2492
2493                 return ret;
2494         }
2495
2496         case PERF_EVENT_IOC_SET_FILTER:
2497                 return perf_event_set_filter(event, (void __user *)arg);
2498
2499         default:
2500                 return -ENOTTY;
2501         }
2502
2503         if (flags & PERF_IOC_FLAG_GROUP)
2504                 perf_event_for_each(event, func);
2505         else
2506                 perf_event_for_each_child(event, func);
2507
2508         return 0;
2509 }
2510
2511 int perf_event_task_enable(void)
2512 {
2513         struct perf_event *event;
2514
2515         mutex_lock(&current->perf_event_mutex);
2516         list_for_each_entry(event, &current->perf_event_list, owner_entry)
2517                 perf_event_for_each_child(event, perf_event_enable);
2518         mutex_unlock(&current->perf_event_mutex);
2519
2520         return 0;
2521 }
2522
2523 int perf_event_task_disable(void)
2524 {
2525         struct perf_event *event;
2526
2527         mutex_lock(&current->perf_event_mutex);
2528         list_for_each_entry(event, &current->perf_event_list, owner_entry)
2529                 perf_event_for_each_child(event, perf_event_disable);
2530         mutex_unlock(&current->perf_event_mutex);
2531
2532         return 0;
2533 }
2534
2535 #ifndef PERF_EVENT_INDEX_OFFSET
2536 # define PERF_EVENT_INDEX_OFFSET 0
2537 #endif
2538
2539 static int perf_event_index(struct perf_event *event)
2540 {
2541         if (event->state != PERF_EVENT_STATE_ACTIVE)
2542                 return 0;
2543
2544         return event->hw.idx + 1 - PERF_EVENT_INDEX_OFFSET;
2545 }
2546
2547 /*
2548  * Callers need to ensure there can be no nesting of this function, otherwise
2549  * the seqlock logic goes bad. We can not serialize this because the arch
2550  * code calls this from NMI context.
2551  */
2552 void perf_event_update_userpage(struct perf_event *event)
2553 {
2554         struct perf_event_mmap_page *userpg;
2555         struct perf_buffer *buffer;
2556
2557         rcu_read_lock();
2558         buffer = rcu_dereference(event->buffer);
2559         if (!buffer)
2560                 goto unlock;
2561
2562         userpg = buffer->user_page;
2563
2564         /*
2565          * Disable preemption so as to not let the corresponding user-space
2566          * spin too long if we get preempted.
2567          */
2568         preempt_disable();
2569         ++userpg->lock;
2570         barrier();
2571         userpg->index = perf_event_index(event);
2572         userpg->offset = perf_event_count(event);
2573         if (event->state == PERF_EVENT_STATE_ACTIVE)
2574                 userpg->offset -= local64_read(&event->hw.prev_count);
2575
2576         userpg->time_enabled = event->total_time_enabled +
2577                         atomic64_read(&event->child_total_time_enabled);
2578
2579         userpg->time_running = event->total_time_running +
2580                         atomic64_read(&event->child_total_time_running);
2581
2582         barrier();
2583         ++userpg->lock;
2584         preempt_enable();
2585 unlock:
2586         rcu_read_unlock();
2587 }
2588
2589 static unsigned long perf_data_size(struct perf_buffer *buffer);
2590
2591 static void
2592 perf_buffer_init(struct perf_buffer *buffer, long watermark, int flags)
2593 {
2594         long max_size = perf_data_size(buffer);
2595
2596         if (watermark)
2597                 buffer->watermark = min(max_size, watermark);
2598
2599         if (!buffer->watermark)
2600                 buffer->watermark = max_size / 2;
2601
2602         if (flags & PERF_BUFFER_WRITABLE)
2603                 buffer->writable = 1;
2604
2605         atomic_set(&buffer->refcount, 1);
2606 }
2607
2608 #ifndef CONFIG_PERF_USE_VMALLOC
2609
2610 /*
2611  * Back perf_mmap() with regular GFP_KERNEL-0 pages.
2612  */
2613
2614 static struct page *
2615 perf_mmap_to_page(struct perf_buffer *buffer, unsigned long pgoff)
2616 {
2617         if (pgoff > buffer->nr_pages)
2618                 return NULL;
2619
2620         if (pgoff == 0)
2621                 return virt_to_page(buffer->user_page);
2622
2623         return virt_to_page(buffer->data_pages[pgoff - 1]);
2624 }
2625
2626 static void *perf_mmap_alloc_page(int cpu)
2627 {
2628         struct page *page;
2629         int node;
2630
2631         node = (cpu == -1) ? cpu : cpu_to_node(cpu);
2632         page = alloc_pages_node(node, GFP_KERNEL | __GFP_ZERO, 0);
2633         if (!page)
2634                 return NULL;
2635
2636         return page_address(page);
2637 }
2638
2639 static struct perf_buffer *
2640 perf_buffer_alloc(int nr_pages, long watermark, int cpu, int flags)
2641 {
2642         struct perf_buffer *buffer;
2643         unsigned long size;
2644         int i;
2645
2646         size = sizeof(struct perf_buffer);
2647         size += nr_pages * sizeof(void *);
2648
2649         buffer = kzalloc(size, GFP_KERNEL);
2650         if (!buffer)
2651                 goto fail;
2652
2653         buffer->user_page = perf_mmap_alloc_page(cpu);
2654         if (!buffer->user_page)
2655                 goto fail_user_page;
2656
2657         for (i = 0; i < nr_pages; i++) {
2658                 buffer->data_pages[i] = perf_mmap_alloc_page(cpu);
2659                 if (!buffer->data_pages[i])
2660                         goto fail_data_pages;
2661         }
2662
2663         buffer->nr_pages = nr_pages;
2664
2665         perf_buffer_init(buffer, watermark, flags);
2666
2667         return buffer;
2668
2669 fail_data_pages:
2670         for (i--; i >= 0; i--)
2671                 free_page((unsigned long)buffer->data_pages[i]);
2672
2673         free_page((unsigned long)buffer->user_page);
2674
2675 fail_user_page:
2676         kfree(buffer);
2677
2678 fail:
2679         return NULL;
2680 }
2681
2682 static void perf_mmap_free_page(unsigned long addr)
2683 {
2684         struct page *page = virt_to_page((void *)addr);
2685
2686         page->mapping = NULL;
2687         __free_page(page);
2688 }
2689
2690 static void perf_buffer_free(struct perf_buffer *buffer)
2691 {
2692         int i;
2693
2694         perf_mmap_free_page((unsigned long)buffer->user_page);
2695         for (i = 0; i < buffer->nr_pages; i++)
2696                 perf_mmap_free_page((unsigned long)buffer->data_pages[i]);
2697         kfree(buffer);
2698 }
2699
2700 static inline int page_order(struct perf_buffer *buffer)
2701 {
2702         return 0;
2703 }
2704
2705 #else
2706
2707 /*
2708  * Back perf_mmap() with vmalloc memory.
2709  *
2710  * Required for architectures that have d-cache aliasing issues.
2711  */
2712
2713 static inline int page_order(struct perf_buffer *buffer)
2714 {
2715         return buffer->page_order;
2716 }
2717
2718 static struct page *
2719 perf_mmap_to_page(struct perf_buffer *buffer, unsigned long pgoff)
2720 {
2721         if (pgoff > (1UL << page_order(buffer)))
2722                 return NULL;
2723
2724         return vmalloc_to_page((void *)buffer->user_page + pgoff * PAGE_SIZE);
2725 }
2726
2727 static void perf_mmap_unmark_page(void *addr)
2728 {
2729         struct page *page = vmalloc_to_page(addr);
2730
2731         page->mapping = NULL;
2732 }
2733
2734 static void perf_buffer_free_work(struct work_struct *work)
2735 {
2736         struct perf_buffer *buffer;
2737         void *base;
2738         int i, nr;
2739
2740         buffer = container_of(work, struct perf_buffer, work);
2741         nr = 1 << page_order(buffer);
2742
2743         base = buffer->user_page;
2744         for (i = 0; i < nr + 1; i++)
2745                 perf_mmap_unmark_page(base + (i * PAGE_SIZE));
2746
2747         vfree(base);
2748         kfree(buffer);
2749 }
2750
2751 static void perf_buffer_free(struct perf_buffer *buffer)
2752 {
2753         schedule_work(&buffer->work);
2754 }
2755
2756 static struct perf_buffer *
2757 perf_buffer_alloc(int nr_pages, long watermark, int cpu, int flags)
2758 {
2759         struct perf_buffer *buffer;
2760         unsigned long size;
2761         void *all_buf;
2762
2763         size = sizeof(struct perf_buffer);
2764         size += sizeof(void *);
2765
2766         buffer = kzalloc(size, GFP_KERNEL);
2767         if (!buffer)
2768                 goto fail;
2769
2770         INIT_WORK(&buffer->work, perf_buffer_free_work);
2771
2772         all_buf = vmalloc_user((nr_pages + 1) * PAGE_SIZE);
2773         if (!all_buf)
2774                 goto fail_all_buf;
2775
2776         buffer->user_page = all_buf;
2777         buffer->data_pages[0] = all_buf + PAGE_SIZE;
2778         buffer->page_order = ilog2(nr_pages);
2779         buffer->nr_pages = 1;
2780
2781         perf_buffer_init(buffer, watermark, flags);
2782
2783         return buffer;
2784
2785 fail_all_buf:
2786         kfree(buffer);
2787
2788 fail:
2789         return NULL;
2790 }
2791
2792 #endif
2793
2794 static unsigned long perf_data_size(struct perf_buffer *buffer)
2795 {
2796         return buffer->nr_pages << (PAGE_SHIFT + page_order(buffer));
2797 }
2798
2799 static int perf_mmap_fault(struct vm_area_struct *vma, struct vm_fault *vmf)
2800 {
2801         struct perf_event *event = vma->vm_file->private_data;
2802         struct perf_buffer *buffer;
2803         int ret = VM_FAULT_SIGBUS;
2804
2805         if (vmf->flags & FAULT_FLAG_MKWRITE) {
2806                 if (vmf->pgoff == 0)
2807                         ret = 0;
2808                 return ret;
2809         }
2810
2811         rcu_read_lock();
2812         buffer = rcu_dereference(event->buffer);
2813         if (!buffer)
2814                 goto unlock;
2815
2816         if (vmf->pgoff && (vmf->flags & FAULT_FLAG_WRITE))
2817                 goto unlock;
2818
2819         vmf->page = perf_mmap_to_page(buffer, vmf->pgoff);
2820         if (!vmf->page)
2821                 goto unlock;
2822
2823         get_page(vmf->page);
2824         vmf->page->mapping = vma->vm_file->f_mapping;
2825         vmf->page->index   = vmf->pgoff;
2826
2827         ret = 0;
2828 unlock:
2829         rcu_read_unlock();
2830
2831         return ret;
2832 }
2833
2834 static void perf_buffer_free_rcu(struct rcu_head *rcu_head)
2835 {
2836         struct perf_buffer *buffer;
2837
2838         buffer = container_of(rcu_head, struct perf_buffer, rcu_head);
2839         perf_buffer_free(buffer);
2840 }
2841
2842 static struct perf_buffer *perf_buffer_get(struct perf_event *event)
2843 {
2844         struct perf_buffer *buffer;
2845
2846         rcu_read_lock();
2847         buffer = rcu_dereference(event->buffer);
2848         if (buffer) {
2849                 if (!atomic_inc_not_zero(&buffer->refcount))
2850                         buffer = NULL;
2851         }
2852         rcu_read_unlock();
2853
2854         return buffer;
2855 }
2856
2857 static void perf_buffer_put(struct perf_buffer *buffer)
2858 {
2859         if (!atomic_dec_and_test(&buffer->refcount))
2860                 return;
2861
2862         call_rcu(&buffer->rcu_head, perf_buffer_free_rcu);
2863 }
2864
2865 static void perf_mmap_open(struct vm_area_struct *vma)
2866 {
2867         struct perf_event *event = vma->vm_file->private_data;
2868
2869         atomic_inc(&event->mmap_count);
2870 }
2871
2872 static void perf_mmap_close(struct vm_area_struct *vma)
2873 {
2874         struct perf_event *event = vma->vm_file->private_data;
2875
2876         if (atomic_dec_and_mutex_lock(&event->mmap_count, &event->mmap_mutex)) {
2877                 unsigned long size = perf_data_size(event->buffer);
2878                 struct user_struct *user = event->mmap_user;
2879                 struct perf_buffer *buffer = event->buffer;
2880
2881                 atomic_long_sub((size >> PAGE_SHIFT) + 1, &user->locked_vm);
2882                 vma->vm_mm->locked_vm -= event->mmap_locked;
2883                 rcu_assign_pointer(event->buffer, NULL);
2884                 mutex_unlock(&event->mmap_mutex);
2885
2886                 perf_buffer_put(buffer);
2887                 free_uid(user);
2888         }
2889 }
2890
2891 static const struct vm_operations_struct perf_mmap_vmops = {
2892         .open           = perf_mmap_open,
2893         .close          = perf_mmap_close,
2894         .fault          = perf_mmap_fault,
2895         .page_mkwrite   = perf_mmap_fault,
2896 };
2897
2898 static int perf_mmap(struct file *file, struct vm_area_struct *vma)
2899 {
2900         struct perf_event *event = file->private_data;
2901         unsigned long user_locked, user_lock_limit;
2902         struct user_struct *user = current_user();
2903         unsigned long locked, lock_limit;
2904         struct perf_buffer *buffer;
2905         unsigned long vma_size;
2906         unsigned long nr_pages;
2907         long user_extra, extra;
2908         int ret = 0, flags = 0;
2909
2910         /*
2911          * Don't allow mmap() of inherited per-task counters. This would
2912          * create a performance issue due to all children writing to the
2913          * same buffer.
2914          */
2915         if (event->cpu == -1 && event->attr.inherit)
2916                 return -EINVAL;
2917
2918         if (!(vma->vm_flags & VM_SHARED))
2919                 return -EINVAL;
2920
2921         vma_size = vma->vm_end - vma->vm_start;
2922         nr_pages = (vma_size / PAGE_SIZE) - 1;
2923
2924         /*
2925          * If we have buffer pages ensure they're a power-of-two number, so we
2926          * can do bitmasks instead of modulo.
2927          */
2928         if (nr_pages != 0 && !is_power_of_2(nr_pages))
2929                 return -EINVAL;
2930
2931         if (vma_size != PAGE_SIZE * (1 + nr_pages))
2932                 return -EINVAL;
2933
2934         if (vma->vm_pgoff != 0)
2935                 return -EINVAL;
2936
2937         WARN_ON_ONCE(event->ctx->parent_ctx);
2938         mutex_lock(&event->mmap_mutex);
2939         if (event->buffer) {
2940                 if (event->buffer->nr_pages == nr_pages)
2941                         atomic_inc(&event->buffer->refcount);
2942                 else
2943                         ret = -EINVAL;
2944                 goto unlock;
2945         }
2946
2947         user_extra = nr_pages + 1;
2948         user_lock_limit = sysctl_perf_event_mlock >> (PAGE_SHIFT - 10);
2949
2950         /*
2951          * Increase the limit linearly with more CPUs:
2952          */
2953         user_lock_limit *= num_online_cpus();
2954
2955         user_locked = atomic_long_read(&user->locked_vm) + user_extra;
2956
2957         extra = 0;
2958         if (user_locked > user_lock_limit)
2959                 extra = user_locked - user_lock_limit;
2960
2961         lock_limit = rlimit(RLIMIT_MEMLOCK);
2962         lock_limit >>= PAGE_SHIFT;
2963         locked = vma->vm_mm->locked_vm + extra;
2964
2965         if ((locked > lock_limit) && perf_paranoid_tracepoint_raw() &&
2966                 !capable(CAP_IPC_LOCK)) {
2967                 ret = -EPERM;
2968                 goto unlock;
2969         }
2970
2971         WARN_ON(event->buffer);
2972
2973         if (vma->vm_flags & VM_WRITE)
2974                 flags |= PERF_BUFFER_WRITABLE;
2975
2976         buffer = perf_buffer_alloc(nr_pages, event->attr.wakeup_watermark,
2977                                    event->cpu, flags);
2978         if (!buffer) {
2979                 ret = -ENOMEM;
2980                 goto unlock;
2981         }
2982         rcu_assign_pointer(event->buffer, buffer);
2983
2984         atomic_long_add(user_extra, &user->locked_vm);
2985         event->mmap_locked = extra;
2986         event->mmap_user = get_current_user();
2987         vma->vm_mm->locked_vm += event->mmap_locked;
2988
2989 unlock:
2990         if (!ret)
2991                 atomic_inc(&event->mmap_count);
2992         mutex_unlock(&event->mmap_mutex);
2993
2994         vma->vm_flags |= VM_RESERVED;
2995         vma->vm_ops = &perf_mmap_vmops;
2996
2997         return ret;
2998 }
2999
3000 static int perf_fasync(int fd, struct file *filp, int on)
3001 {
3002         struct inode *inode = filp->f_path.dentry->d_inode;
3003         struct perf_event *event = filp->private_data;
3004         int retval;
3005
3006         mutex_lock(&inode->i_mutex);
3007         retval = fasync_helper(fd, filp, on, &event->fasync);
3008         mutex_unlock(&inode->i_mutex);
3009
3010         if (retval < 0)
3011                 return retval;
3012
3013         return 0;
3014 }
3015
3016 static const struct file_operations perf_fops = {
3017         .llseek                 = no_llseek,
3018         .release                = perf_release,
3019         .read                   = perf_read,
3020         .poll                   = perf_poll,
3021         .unlocked_ioctl         = perf_ioctl,
3022         .compat_ioctl           = perf_ioctl,
3023         .mmap                   = perf_mmap,
3024         .fasync                 = perf_fasync,
3025 };
3026
3027 /*
3028  * Perf event wakeup
3029  *
3030  * If there's data, ensure we set the poll() state and publish everything
3031  * to user-space before waking everybody up.
3032  */
3033
3034 void perf_event_wakeup(struct perf_event *event)
3035 {
3036         wake_up_all(&event->waitq);
3037
3038         if (event->pending_kill) {
3039                 kill_fasync(&event->fasync, SIGIO, event->pending_kill);
3040                 event->pending_kill = 0;
3041         }
3042 }
3043
3044 /*
3045  * Pending wakeups
3046  *
3047  * Handle the case where we need to wakeup up from NMI (or rq->lock) context.
3048  *
3049  * The NMI bit means we cannot possibly take locks. Therefore, maintain a
3050  * single linked list and use cmpxchg() to add entries lockless.
3051  */
3052
3053 static void perf_pending_event(struct perf_pending_entry *entry)
3054 {
3055         struct perf_event *event = container_of(entry,
3056                         struct perf_event, pending);
3057
3058         if (event->pending_disable) {
3059                 event->pending_disable = 0;
3060                 __perf_event_disable(event);
3061         }
3062
3063         if (event->pending_wakeup) {
3064                 event->pending_wakeup = 0;
3065                 perf_event_wakeup(event);
3066         }
3067 }
3068
3069 #define PENDING_TAIL ((struct perf_pending_entry *)-1UL)
3070
3071 static DEFINE_PER_CPU(struct perf_pending_entry *, perf_pending_head) = {
3072         PENDING_TAIL,
3073 };
3074
3075 static void perf_pending_queue(struct perf_pending_entry *entry,
3076                                void (*func)(struct perf_pending_entry *))
3077 {
3078         struct perf_pending_entry **head;
3079
3080         if (cmpxchg(&entry->next, NULL, PENDING_TAIL) != NULL)
3081                 return;
3082
3083         entry->func = func;
3084
3085         head = &get_cpu_var(perf_pending_head);
3086
3087         do {
3088                 entry->next = *head;
3089         } while (cmpxchg(head, entry->next, entry) != entry->next);
3090
3091         set_perf_event_pending();
3092
3093         put_cpu_var(perf_pending_head);
3094 }
3095
3096 static int __perf_pending_run(void)
3097 {
3098         struct perf_pending_entry *list;
3099         int nr = 0;
3100
3101         list = xchg(&__get_cpu_var(perf_pending_head), PENDING_TAIL);
3102         while (list != PENDING_TAIL) {
3103                 void (*func)(struct perf_pending_entry *);
3104                 struct perf_pending_entry *entry = list;
3105
3106                 list = list->next;
3107
3108                 func = entry->func;
3109                 entry->next = NULL;
3110                 /*
3111                  * Ensure we observe the unqueue before we issue the wakeup,
3112                  * so that we won't be waiting forever.
3113                  * -- see perf_not_pending().
3114                  */
3115                 smp_wmb();
3116
3117                 func(entry);
3118                 nr++;
3119         }
3120
3121         return nr;
3122 }
3123
3124 static inline int perf_not_pending(struct perf_event *event)
3125 {
3126         /*
3127          * If we flush on whatever cpu we run, there is a chance we don't
3128          * need to wait.
3129          */
3130         get_cpu();
3131         __perf_pending_run();
3132         put_cpu();
3133
3134         /*
3135          * Ensure we see the proper queue state before going to sleep
3136          * so that we do not miss the wakeup. -- see perf_pending_handle()
3137          */
3138         smp_rmb();
3139         return event->pending.next == NULL;
3140 }
3141
3142 static void perf_pending_sync(struct perf_event *event)
3143 {
3144         wait_event(event->waitq, perf_not_pending(event));
3145 }
3146
3147 void perf_event_do_pending(void)
3148 {
3149         __perf_pending_run();
3150 }
3151
3152 /*
3153  * We assume there is only KVM supporting the callbacks.
3154  * Later on, we might change it to a list if there is
3155  * another virtualization implementation supporting the callbacks.
3156  */
3157 struct perf_guest_info_callbacks *perf_guest_cbs;
3158
3159 int perf_register_guest_info_callbacks(struct perf_guest_info_callbacks *cbs)
3160 {
3161         perf_guest_cbs = cbs;
3162         return 0;
3163 }
3164 EXPORT_SYMBOL_GPL(perf_register_guest_info_callbacks);
3165
3166 int perf_unregister_guest_info_callbacks(struct perf_guest_info_callbacks *cbs)
3167 {
3168         perf_guest_cbs = NULL;
3169         return 0;
3170 }
3171 EXPORT_SYMBOL_GPL(perf_unregister_guest_info_callbacks);
3172
3173 /*
3174  * Output
3175  */
3176 static bool perf_output_space(struct perf_buffer *buffer, unsigned long tail,
3177                               unsigned long offset, unsigned long head)
3178 {
3179         unsigned long mask;
3180
3181         if (!buffer->writable)
3182                 return true;
3183
3184         mask = perf_data_size(buffer) - 1;
3185
3186         offset = (offset - tail) & mask;
3187         head   = (head   - tail) & mask;
3188
3189         if ((int)(head - offset) < 0)
3190                 return false;
3191
3192         return true;
3193 }
3194
3195 static void perf_output_wakeup(struct perf_output_handle *handle)
3196 {
3197         atomic_set(&handle->buffer->poll, POLL_IN);
3198
3199         if (handle->nmi) {
3200                 handle->event->pending_wakeup = 1;
3201                 perf_pending_queue(&handle->event->pending,
3202                                    perf_pending_event);
3203         } else
3204                 perf_event_wakeup(handle->event);
3205 }
3206
3207 /*
3208  * We need to ensure a later event_id doesn't publish a head when a former
3209  * event isn't done writing. However since we need to deal with NMIs we
3210  * cannot fully serialize things.
3211  *
3212  * We only publish the head (and generate a wakeup) when the outer-most
3213  * event completes.
3214  */
3215 static void perf_output_get_handle(struct perf_output_handle *handle)
3216 {
3217         struct perf_buffer *buffer = handle->buffer;
3218
3219         preempt_disable();
3220         local_inc(&buffer->nest);
3221         handle->wakeup = local_read(&buffer->wakeup);
3222 }
3223
3224 static void perf_output_put_handle(struct perf_output_handle *handle)
3225 {
3226         struct perf_buffer *buffer = handle->buffer;
3227         unsigned long head;
3228
3229 again:
3230         head = local_read(&buffer->head);
3231
3232         /*
3233          * IRQ/NMI can happen here, which means we can miss a head update.
3234          */
3235
3236         if (!local_dec_and_test(&buffer->nest))
3237                 goto out;
3238
3239         /*
3240          * Publish the known good head. Rely on the full barrier implied
3241          * by atomic_dec_and_test() order the buffer->head read and this
3242          * write.
3243          */
3244         buffer->user_page->data_head = head;
3245
3246         /*
3247          * Now check if we missed an update, rely on the (compiler)
3248          * barrier in atomic_dec_and_test() to re-read buffer->head.
3249          */
3250         if (unlikely(head != local_read(&buffer->head))) {
3251                 local_inc(&buffer->nest);
3252                 goto again;
3253         }
3254
3255         if (handle->wakeup != local_read(&buffer->wakeup))
3256                 perf_output_wakeup(handle);
3257
3258  out:
3259         preempt_enable();
3260 }
3261
3262 __always_inline void perf_output_copy(struct perf_output_handle *handle,
3263                       const void *buf, unsigned int len)
3264 {
3265         do {
3266                 unsigned long size = min_t(unsigned long, handle->size, len);
3267
3268                 memcpy(handle->addr, buf, size);
3269
3270                 len -= size;
3271                 handle->addr += size;
3272                 buf += size;
3273                 handle->size -= size;
3274                 if (!handle->size) {
3275                         struct perf_buffer *buffer = handle->buffer;
3276
3277                         handle->page++;
3278                         handle->page &= buffer->nr_pages - 1;
3279                         handle->addr = buffer->data_pages[handle->page];
3280                         handle->size = PAGE_SIZE << page_order(buffer);
3281                 }
3282         } while (len);
3283 }
3284
3285 int perf_output_begin(struct perf_output_handle *handle,
3286                       struct perf_event *event, unsigned int size,
3287                       int nmi, int sample)
3288 {
3289         struct perf_buffer *buffer;
3290         unsigned long tail, offset, head;
3291         int have_lost;
3292         struct {
3293                 struct perf_event_header header;
3294                 u64                      id;
3295                 u64                      lost;
3296         } lost_event;
3297
3298         rcu_read_lock();
3299         /*
3300          * For inherited events we send all the output towards the parent.
3301          */
3302         if (event->parent)
3303                 event = event->parent;
3304
3305         buffer = rcu_dereference(event->buffer);
3306         if (!buffer)
3307                 goto out;
3308
3309         handle->buffer  = buffer;
3310         handle->event   = event;
3311         handle->nmi     = nmi;
3312         handle->sample  = sample;
3313
3314         if (!buffer->nr_pages)
3315                 goto out;
3316
3317         have_lost = local_read(&buffer->lost);
3318         if (have_lost)
3319                 size += sizeof(lost_event);
3320
3321         perf_output_get_handle(handle);
3322
3323         do {
3324                 /*
3325                  * Userspace could choose to issue a mb() before updating the
3326                  * tail pointer. So that all reads will be completed before the
3327                  * write is issued.
3328                  */
3329                 tail = ACCESS_ONCE(buffer->user_page->data_tail);
3330                 smp_rmb();
3331                 offset = head = local_read(&buffer->head);
3332                 head += size;
3333                 if (unlikely(!perf_output_space(buffer, tail, offset, head)))
3334                         goto fail;
3335         } while (local_cmpxchg(&buffer->head, offset, head) != offset);
3336
3337         if (head - local_read(&buffer->wakeup) > buffer->watermark)
3338                 local_add(buffer->watermark, &buffer->wakeup);
3339
3340         handle->page = offset >> (PAGE_SHIFT + page_order(buffer));
3341         handle->page &= buffer->nr_pages - 1;
3342         handle->size = offset & ((PAGE_SIZE << page_order(buffer)) - 1);
3343         handle->addr = buffer->data_pages[handle->page];
3344         handle->addr += handle->size;
3345         handle->size = (PAGE_SIZE << page_order(buffer)) - handle->size;
3346
3347         if (have_lost) {
3348                 lost_event.header.type = PERF_RECORD_LOST;
3349                 lost_event.header.misc = 0;
3350                 lost_event.header.size = sizeof(lost_event);
3351                 lost_event.id          = event->id;
3352                 lost_event.lost        = local_xchg(&buffer->lost, 0);
3353
3354                 perf_output_put(handle, lost_event);
3355         }
3356
3357         return 0;
3358
3359 fail:
3360         local_inc(&buffer->lost);
3361         perf_output_put_handle(handle);
3362 out:
3363         rcu_read_unlock();
3364
3365         return -ENOSPC;
3366 }
3367
3368 void perf_output_end(struct perf_output_handle *handle)
3369 {
3370         struct perf_event *event = handle->event;
3371         struct perf_buffer *buffer = handle->buffer;
3372
3373         int wakeup_events = event->attr.wakeup_events;
3374
3375         if (handle->sample && wakeup_events) {
3376                 int events = local_inc_return(&buffer->events);
3377                 if (events >= wakeup_events) {
3378                         local_sub(wakeup_events, &buffer->events);
3379                         local_inc(&buffer->wakeup);
3380                 }
3381         }
3382
3383         perf_output_put_handle(handle);
3384         rcu_read_unlock();
3385 }
3386
3387 static u32 perf_event_pid(struct perf_event *event, struct task_struct *p)
3388 {
3389         /*
3390          * only top level events have the pid namespace they were created in
3391          */
3392         if (event->parent)
3393                 event = event->parent;
3394
3395         return task_tgid_nr_ns(p, event->ns);
3396 }
3397
3398 static u32 perf_event_tid(struct perf_event *event, struct task_struct *p)
3399 {
3400         /*
3401          * only top level events have the pid namespace they were created in
3402          */
3403         if (event->parent)
3404                 event = event->parent;
3405
3406         return task_pid_nr_ns(p, event->ns);
3407 }
3408
3409 static void perf_output_read_one(struct perf_output_handle *handle,
3410                                  struct perf_event *event)
3411 {
3412         u64 read_format = event->attr.read_format;
3413         u64 values[4];
3414         int n = 0;
3415
3416         values[n++] = perf_event_count(event);
3417         if (read_format & PERF_FORMAT_TOTAL_TIME_ENABLED) {
3418                 values[n++] = event->total_time_enabled +
3419                         atomic64_read(&event->child_total_time_enabled);
3420         }
3421         if (read_format & PERF_FORMAT_TOTAL_TIME_RUNNING) {
3422                 values[n++] = event->total_time_running +
3423                         atomic64_read(&event->child_total_time_running);
3424         }
3425         if (read_format & PERF_FORMAT_ID)
3426                 values[n++] = primary_event_id(event);
3427
3428         perf_output_copy(handle, values, n * sizeof(u64));
3429 }
3430
3431 /*
3432  * XXX PERF_FORMAT_GROUP vs inherited events seems difficult.
3433  */
3434 static void perf_output_read_group(struct perf_output_handle *handle,
3435                             struct perf_event *event)
3436 {
3437         struct perf_event *leader = event->group_leader, *sub;
3438         u64 read_format = event->attr.read_format;
3439         u64 values[5];
3440         int n = 0;
3441
3442         values[n++] = 1 + leader->nr_siblings;
3443
3444         if (read_format & PERF_FORMAT_TOTAL_TIME_ENABLED)
3445                 values[n++] = leader->total_time_enabled;
3446
3447         if (read_format & PERF_FORMAT_TOTAL_TIME_RUNNING)
3448                 values[n++] = leader->total_time_running;
3449
3450         if (leader != event)
3451                 leader->pmu->read(leader);
3452
3453         values[n++] = perf_event_count(leader);
3454         if (read_format & PERF_FORMAT_ID)
3455                 values[n++] = primary_event_id(leader);
3456
3457         perf_output_copy(handle, values, n * sizeof(u64));
3458
3459         list_for_each_entry(sub, &leader->sibling_list, group_entry) {
3460                 n = 0;
3461
3462                 if (sub != event)
3463                         sub->pmu->read(sub);
3464
3465                 values[n++] = perf_event_count(sub);
3466                 if (read_format & PERF_FORMAT_ID)
3467                         values[n++] = primary_event_id(sub);
3468
3469                 perf_output_copy(handle, values, n * sizeof(u64));
3470         }
3471 }
3472
3473 static void perf_output_read(struct perf_output_handle *handle,
3474                              struct perf_event *event)
3475 {
3476         if (event->attr.read_format & PERF_FORMAT_GROUP)
3477                 perf_output_read_group(handle, event);
3478         else
3479                 perf_output_read_one(handle, event);
3480 }
3481
3482 void perf_output_sample(struct perf_output_handle *handle,
3483                         struct perf_event_header *header,
3484                         struct perf_sample_data *data,
3485                         struct perf_event *event)
3486 {
3487         u64 sample_type = data->type;
3488
3489         perf_output_put(handle, *header);
3490
3491         if (sample_type & PERF_SAMPLE_IP)
3492                 perf_output_put(handle, data->ip);
3493
3494         if (sample_type & PERF_SAMPLE_TID)
3495                 perf_output_put(handle, data->tid_entry);
3496
3497         if (sample_type & PERF_SAMPLE_TIME)
3498                 perf_output_put(handle, data->time);
3499
3500         if (sample_type & PERF_SAMPLE_ADDR)
3501                 perf_output_put(handle, data->addr);
3502
3503         if (sample_type & PERF_SAMPLE_ID)
3504                 perf_output_put(handle, data->id);
3505
3506         if (sample_type & PERF_SAMPLE_STREAM_ID)
3507                 perf_output_put(handle, data->stream_id);
3508
3509         if (sample_type & PERF_SAMPLE_CPU)
3510                 perf_output_put(handle, data->cpu_entry);
3511
3512         if (sample_type & PERF_SAMPLE_PERIOD)
3513                 perf_output_put(handle, data->period);
3514
3515         if (sample_type & PERF_SAMPLE_READ)
3516                 perf_output_read(handle, event);
3517
3518         if (sample_type & PERF_SAMPLE_CALLCHAIN) {
3519                 if (data->callchain) {
3520                         int size = 1;
3521
3522                         if (data->callchain)
3523                                 size += data->callchain->nr;
3524
3525                         size *= sizeof(u64);
3526
3527                         perf_output_copy(handle, data->callchain, size);
3528                 } else {
3529                         u64 nr = 0;
3530                         perf_output_put(handle, nr);
3531                 }
3532         }
3533
3534         if (sample_type & PERF_SAMPLE_RAW) {
3535                 if (data->raw) {
3536                         perf_output_put(handle, data->raw->size);
3537                         perf_output_copy(handle, data->raw->data,
3538                                          data->raw->size);
3539                 } else {
3540                         struct {
3541                                 u32     size;
3542                                 u32     data;
3543                         } raw = {
3544                                 .size = sizeof(u32),
3545                                 .data = 0,
3546                         };
3547                         perf_output_put(handle, raw);
3548                 }
3549         }
3550 }
3551
3552 void perf_prepare_sample(struct perf_event_header *header,
3553                          struct perf_sample_data *data,
3554                          struct perf_event *event,
3555                          struct pt_regs *regs)
3556 {
3557         u64 sample_type = event->attr.sample_type;
3558
3559         data->type = sample_type;
3560
3561         header->type = PERF_RECORD_SAMPLE;
3562         header->size = sizeof(*header);
3563
3564         header->misc = 0;
3565         header->misc |= perf_misc_flags(regs);
3566
3567         if (sample_type & PERF_SAMPLE_IP) {
3568                 data->ip = perf_instruction_pointer(regs);
3569
3570                 header->size += sizeof(data->ip);
3571         }
3572
3573         if (sample_type & PERF_SAMPLE_TID) {
3574                 /* namespace issues */
3575                 data->tid_entry.pid = perf_event_pid(event, current);
3576                 data->tid_entry.tid = perf_event_tid(event, current);
3577
3578                 header->size += sizeof(data->tid_entry);
3579         }
3580