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