perf_counter.c 110 KB
Newer Older
1 2 3
/*
 * Performance counter core code
 *
4 5 6
 *  Copyright (C) 2008 Thomas Gleixner <tglx@linutronix.de>
 *  Copyright (C) 2008-2009 Red Hat, Inc., Ingo Molnar
 *  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 15
#include <linux/cpu.h>
#include <linux/smp.h>
16
#include <linux/file.h>
17 18
#include <linux/poll.h>
#include <linux/sysfs.h>
19
#include <linux/dcache.h>
20
#include <linux/percpu.h>
21
#include <linux/ptrace.h>
22 23 24
#include <linux/vmstat.h>
#include <linux/hardirq.h>
#include <linux/rculist.h>
25 26 27
#include <linux/uaccess.h>
#include <linux/syscalls.h>
#include <linux/anon_inodes.h>
28
#include <linux/kernel_stat.h>
29 30
#include <linux/perf_counter.h>

31 32
#include <asm/irq_regs.h>

33 34 35 36 37
/*
 * Each CPU has a list of per CPU counters:
 */
DEFINE_PER_CPU(struct perf_cpu_context, perf_cpu_context);

38
int perf_max_counters __read_mostly = 1;
39 40 41
static int perf_reserved_percpu __read_mostly;
static int perf_overcommit __read_mostly = 1;

42
static atomic_t nr_counters __read_mostly;
43 44
static atomic_t nr_mmap_counters __read_mostly;
static atomic_t nr_comm_counters __read_mostly;
45
static atomic_t nr_task_counters __read_mostly;
46

47
/*
48 49 50 51
 * perf counter paranoia level:
 *  0 - not paranoid
 *  1 - disallow cpu counters to unpriv
 *  2 - disallow kernel profiling to unpriv
52
 */
53
int sysctl_perf_counter_paranoid __read_mostly;
54 55 56 57 58 59 60 61 62 63 64

static inline bool perf_paranoid_cpu(void)
{
	return sysctl_perf_counter_paranoid > 0;
}

static inline bool perf_paranoid_kernel(void)
{
	return sysctl_perf_counter_paranoid > 1;
}

65
int sysctl_perf_counter_mlock __read_mostly = 512; /* 'free' kb per user */
66 67 68 69 70

/*
 * max perf counter sample rate
 */
int sysctl_perf_counter_sample_rate __read_mostly = 100000;
71

72 73
static atomic64_t perf_counter_id;

74
/*
75
 * Lock for (sysadmin-configurable) counter reservations:
76
 */
77
static DEFINE_SPINLOCK(perf_resource_lock);
78 79 80 81

/*
 * Architecture provided APIs - weak aliases:
 */
82
extern __weak const struct pmu *hw_perf_counter_init(struct perf_counter *counter)
83
{
84
	return NULL;
85 86
}

87 88 89
void __weak hw_perf_disable(void)		{ barrier(); }
void __weak hw_perf_enable(void)		{ barrier(); }

90
void __weak hw_perf_counter_setup(int cpu)	{ barrier(); }
91
void __weak hw_perf_counter_setup_online(int cpu)	{ barrier(); }
92 93 94

int __weak
hw_perf_group_sched_in(struct perf_counter *group_leader,
95 96 97 98 99
	       struct perf_cpu_context *cpuctx,
	       struct perf_counter_context *ctx, int cpu)
{
	return 0;
}
100

101 102
void __weak perf_counter_print_debug(void)	{ }

103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126
static DEFINE_PER_CPU(int, disable_count);

void __perf_disable(void)
{
	__get_cpu_var(disable_count)++;
}

bool __perf_enable(void)
{
	return !--__get_cpu_var(disable_count);
}

void perf_disable(void)
{
	__perf_disable();
	hw_perf_disable();
}

void perf_enable(void)
{
	if (__perf_enable())
		hw_perf_enable();
}

127 128
static void get_ctx(struct perf_counter_context *ctx)
{
129
	WARN_ON(!atomic_inc_not_zero(&ctx->refcount));
130 131
}

132 133 134 135 136 137 138 139
static void free_ctx(struct rcu_head *head)
{
	struct perf_counter_context *ctx;

	ctx = container_of(head, struct perf_counter_context, rcu_head);
	kfree(ctx);
}

140 141
static void put_ctx(struct perf_counter_context *ctx)
{
142 143 144
	if (atomic_dec_and_test(&ctx->refcount)) {
		if (ctx->parent_ctx)
			put_ctx(ctx->parent_ctx);
145 146 147
		if (ctx->task)
			put_task_struct(ctx->task);
		call_rcu(&ctx->rcu_head, free_ctx);
148
	}
149 150
}

151 152 153 154 155 156 157 158
static void unclone_ctx(struct perf_counter_context *ctx)
{
	if (ctx->parent_ctx) {
		put_ctx(ctx->parent_ctx);
		ctx->parent_ctx = NULL;
	}
}

159 160 161 162 163 164 165 166 167 168 169 170 171 172
/*
 * If we inherit counters we want to return the parent counter id
 * to userspace.
 */
static u64 primary_counter_id(struct perf_counter *counter)
{
	u64 id = counter->id;

	if (counter->parent)
		id = counter->parent->id;

	return id;
}

173 174 175 176 177
/*
 * Get the perf_counter_context for a task and lock it.
 * This has to cope with with the fact that until it is locked,
 * the context could get moved to another task.
 */
178 179
static struct perf_counter_context *
perf_lock_task_context(struct task_struct *task, unsigned long *flags)
180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201
{
	struct perf_counter_context *ctx;

	rcu_read_lock();
 retry:
	ctx = rcu_dereference(task->perf_counter_ctxp);
	if (ctx) {
		/*
		 * If this context is a clone of another, it might
		 * get swapped for another underneath us by
		 * perf_counter_task_sched_out, though the
		 * rcu_read_lock() protects us from any context
		 * getting freed.  Lock the context and check if it
		 * got swapped before we could get the lock, and retry
		 * if so.  If we locked the right context, then it
		 * can't get swapped on us any more.
		 */
		spin_lock_irqsave(&ctx->lock, *flags);
		if (ctx != rcu_dereference(task->perf_counter_ctxp)) {
			spin_unlock_irqrestore(&ctx->lock, *flags);
			goto retry;
		}
202 203 204 205 206

		if (!atomic_inc_not_zero(&ctx->refcount)) {
			spin_unlock_irqrestore(&ctx->lock, *flags);
			ctx = NULL;
		}
207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239
	}
	rcu_read_unlock();
	return ctx;
}

/*
 * Get the context for a task and increment its pin_count so it
 * can't get swapped to another task.  This also increments its
 * reference count so that the context can't get freed.
 */
static struct perf_counter_context *perf_pin_task_context(struct task_struct *task)
{
	struct perf_counter_context *ctx;
	unsigned long flags;

	ctx = perf_lock_task_context(task, &flags);
	if (ctx) {
		++ctx->pin_count;
		spin_unlock_irqrestore(&ctx->lock, flags);
	}
	return ctx;
}

static void perf_unpin_context(struct perf_counter_context *ctx)
{
	unsigned long flags;

	spin_lock_irqsave(&ctx->lock, flags);
	--ctx->pin_count;
	spin_unlock_irqrestore(&ctx->lock, flags);
	put_ctx(ctx);
}

240 241 242 243
/*
 * Add a counter from the lists for its context.
 * Must be called with ctx->mutex and ctx->lock held.
 */
244 245 246 247 248 249 250 251 252 253
static void
list_add_counter(struct perf_counter *counter, struct perf_counter_context *ctx)
{
	struct perf_counter *group_leader = counter->group_leader;

	/*
	 * Depending on whether it is a standalone or sibling counter,
	 * add it straight to the context's counter list, or to the group
	 * leader's sibling list:
	 */
254
	if (group_leader == counter)
255
		list_add_tail(&counter->list_entry, &ctx->counter_list);
256
	else {
257
		list_add_tail(&counter->list_entry, &group_leader->sibling_list);
258 259
		group_leader->nr_siblings++;
	}
260 261

	list_add_rcu(&counter->event_entry, &ctx->event_list);
262
	ctx->nr_counters++;
263 264
	if (counter->attr.inherit_stat)
		ctx->nr_stat++;
265 266
}

267 268
/*
 * Remove a counter from the lists for its context.
269
 * Must be called with ctx->mutex and ctx->lock held.
270
 */
271 272 273 274 275
static void
list_del_counter(struct perf_counter *counter, struct perf_counter_context *ctx)
{
	struct perf_counter *sibling, *tmp;

276 277
	if (list_empty(&counter->list_entry))
		return;
278
	ctx->nr_counters--;
279 280
	if (counter->attr.inherit_stat)
		ctx->nr_stat--;
281

282
	list_del_init(&counter->list_entry);
283
	list_del_rcu(&counter->event_entry);
284

285 286 287
	if (counter->group_leader != counter)
		counter->group_leader->nr_siblings--;

288 289 290 291 292 293 294 295
	/*
	 * If this was a group counter with sibling counters then
	 * upgrade the siblings to singleton counters by adding them
	 * to the context list directly:
	 */
	list_for_each_entry_safe(sibling, tmp,
				 &counter->sibling_list, list_entry) {

296
		list_move_tail(&sibling->list_entry, &ctx->counter_list);
297 298 299 300
		sibling->group_leader = sibling;
	}
}

301 302 303 304 305 306 307 308 309
static void
counter_sched_out(struct perf_counter *counter,
		  struct perf_cpu_context *cpuctx,
		  struct perf_counter_context *ctx)
{
	if (counter->state != PERF_COUNTER_STATE_ACTIVE)
		return;

	counter->state = PERF_COUNTER_STATE_INACTIVE;
310
	counter->tstamp_stopped = ctx->time;
311
	counter->pmu->disable(counter);
312 313 314 315 316
	counter->oncpu = -1;

	if (!is_software_counter(counter))
		cpuctx->active_oncpu--;
	ctx->nr_active--;
317
	if (counter->attr.exclusive || !cpuctx->active_oncpu)
318 319 320
		cpuctx->exclusive = 0;
}

321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338
static void
group_sched_out(struct perf_counter *group_counter,
		struct perf_cpu_context *cpuctx,
		struct perf_counter_context *ctx)
{
	struct perf_counter *counter;

	if (group_counter->state != PERF_COUNTER_STATE_ACTIVE)
		return;

	counter_sched_out(group_counter, cpuctx, ctx);

	/*
	 * Schedule out siblings (if any):
	 */
	list_for_each_entry(counter, &group_counter->sibling_list, list_entry)
		counter_sched_out(counter, cpuctx, ctx);

339
	if (group_counter->attr.exclusive)
340 341 342
		cpuctx->exclusive = 0;
}

343 344 345 346 347 348
/*
 * Cross CPU call to remove a performance counter
 *
 * We disable the counter on the hardware level first. After that we
 * remove it from the context list.
 */
349
static void __perf_counter_remove_from_context(void *info)
350 351 352 353 354 355 356 357 358 359
{
	struct perf_cpu_context *cpuctx = &__get_cpu_var(perf_cpu_context);
	struct perf_counter *counter = info;
	struct perf_counter_context *ctx = counter->ctx;

	/*
	 * If this is a task context, we need to check whether it is
	 * the current task context of this cpu. If not it has been
	 * scheduled out before the smp call arrived.
	 */
360
	if (ctx->task && cpuctx->task_ctx != ctx)
361 362
		return;

363
	spin_lock(&ctx->lock);
364 365 366 367 368
	/*
	 * Protect the list operation against NMI by disabling the
	 * counters on a global level.
	 */
	perf_disable();
369

370 371
	counter_sched_out(counter, cpuctx, ctx);

372
	list_del_counter(counter, ctx);
373 374 375 376 377 378 379 380 381 382 383

	if (!ctx->task) {
		/*
		 * Allow more per task counters with respect to the
		 * reservation:
		 */
		cpuctx->max_pertask =
			min(perf_max_counters - ctx->nr_counters,
			    perf_max_counters - perf_reserved_percpu);
	}

384
	perf_enable();
385
	spin_unlock(&ctx->lock);
386 387 388 389 390 391
}


/*
 * Remove the counter from a task's (or a CPU's) list of counters.
 *
392
 * Must be called with ctx->mutex held.
393 394 395
 *
 * CPU counters are removed with a smp call. For task counters we only
 * call when the task is on a CPU.
396 397 398 399 400 401 402
 *
 * If counter->ctx is a cloned context, callers must make sure that
 * every task struct that counter->ctx->task could possibly point to
 * remains valid.  This is OK when called from perf_release since
 * that only calls us on the top-level context, which can't be a clone.
 * When called from perf_counter_exit_task, it's OK because the
 * context has been detached from its task.
403
 */
404
static void perf_counter_remove_from_context(struct perf_counter *counter)
405 406 407 408 409 410 411 412 413 414
{
	struct perf_counter_context *ctx = counter->ctx;
	struct task_struct *task = ctx->task;

	if (!task) {
		/*
		 * Per cpu counters are removed via an smp call and
		 * the removal is always sucessful.
		 */
		smp_call_function_single(counter->cpu,
415
					 __perf_counter_remove_from_context,
416 417 418 419 420
					 counter, 1);
		return;
	}

retry:
421
	task_oncpu_function_call(task, __perf_counter_remove_from_context,
422 423 424 425 426 427
				 counter);

	spin_lock_irq(&ctx->lock);
	/*
	 * If the context is active we need to retry the smp call.
	 */
428
	if (ctx->nr_active && !list_empty(&counter->list_entry)) {
429 430 431 432 433 434
		spin_unlock_irq(&ctx->lock);
		goto retry;
	}

	/*
	 * The lock prevents that this context is scheduled in so we
435
	 * can remove the counter safely, if the call above did not
436 437
	 * succeed.
	 */
438 439
	if (!list_empty(&counter->list_entry)) {
		list_del_counter(counter, ctx);
440 441 442 443
	}
	spin_unlock_irq(&ctx->lock);
}

444
static inline u64 perf_clock(void)
445
{
446
	return cpu_clock(smp_processor_id());
447 448 449 450 451
}

/*
 * Update the record of the current time in a context.
 */
452
static void update_context_time(struct perf_counter_context *ctx)
453
{
454 455 456 457
	u64 now = perf_clock();

	ctx->time += now - ctx->timestamp;
	ctx->timestamp = now;
458 459 460 461 462 463 464 465 466 467
}

/*
 * Update the total_time_enabled and total_time_running fields for a counter.
 */
static void update_counter_times(struct perf_counter *counter)
{
	struct perf_counter_context *ctx = counter->ctx;
	u64 run_end;

468 469 470 471 472 473 474 475 476 477 478
	if (counter->state < PERF_COUNTER_STATE_INACTIVE)
		return;

	counter->total_time_enabled = ctx->time - counter->tstamp_enabled;

	if (counter->state == PERF_COUNTER_STATE_INACTIVE)
		run_end = counter->tstamp_stopped;
	else
		run_end = ctx->time;

	counter->total_time_running = run_end - counter->tstamp_running;
479 480 481 482 483 484 485 486 487 488 489 490 491 492
}

/*
 * Update total_time_enabled and total_time_running for all counters in a group.
 */
static void update_group_times(struct perf_counter *leader)
{
	struct perf_counter *counter;

	update_counter_times(leader);
	list_for_each_entry(counter, &leader->sibling_list, list_entry)
		update_counter_times(counter);
}

493 494 495 496 497 498 499 500 501 502 503 504 505
/*
 * Cross CPU call to disable a performance counter
 */
static void __perf_counter_disable(void *info)
{
	struct perf_counter *counter = info;
	struct perf_cpu_context *cpuctx = &__get_cpu_var(perf_cpu_context);
	struct perf_counter_context *ctx = counter->ctx;

	/*
	 * If this is a per-task counter, need to check whether this
	 * counter's task is the current task on this cpu.
	 */
506
	if (ctx->task && cpuctx->task_ctx != ctx)
507 508
		return;

509
	spin_lock(&ctx->lock);
510 511 512 513 514 515

	/*
	 * If the counter is on, turn it off.
	 * If it is in error state, leave it in error state.
	 */
	if (counter->state >= PERF_COUNTER_STATE_INACTIVE) {
516
		update_context_time(ctx);
517
		update_counter_times(counter);
518 519 520 521 522 523 524
		if (counter == counter->group_leader)
			group_sched_out(counter, cpuctx, ctx);
		else
			counter_sched_out(counter, cpuctx, ctx);
		counter->state = PERF_COUNTER_STATE_OFF;
	}

525
	spin_unlock(&ctx->lock);
526 527 528 529
}

/*
 * Disable a counter.
530 531 532 533 534 535 536 537 538 539
 *
 * If counter->ctx is a cloned context, callers must make sure that
 * every task struct that counter->ctx->task could possibly point to
 * remains valid.  This condition is satisifed when called through
 * perf_counter_for_each_child or perf_counter_for_each because they
 * hold the top-level counter's child_mutex, so any descendant that
 * goes to exit will block in sync_child_counter.
 * When called from perf_pending_counter it's OK because counter->ctx
 * is the current context on this CPU and preemption is disabled,
 * hence we can't get into perf_counter_task_sched_out for this context.
540 541 542 543 544 545 546 547 548 549 550 551 552 553 554 555 556 557 558 559 560 561 562 563 564 565 566 567 568 569 570
 */
static void perf_counter_disable(struct perf_counter *counter)
{
	struct perf_counter_context *ctx = counter->ctx;
	struct task_struct *task = ctx->task;

	if (!task) {
		/*
		 * Disable the counter on the cpu that it's on
		 */
		smp_call_function_single(counter->cpu, __perf_counter_disable,
					 counter, 1);
		return;
	}

 retry:
	task_oncpu_function_call(task, __perf_counter_disable, counter);

	spin_lock_irq(&ctx->lock);
	/*
	 * If the counter is still active, we need to retry the cross-call.
	 */
	if (counter->state == PERF_COUNTER_STATE_ACTIVE) {
		spin_unlock_irq(&ctx->lock);
		goto retry;
	}

	/*
	 * Since we have the lock this context can't be scheduled
	 * in, so we can change the state safely.
	 */
571 572
	if (counter->state == PERF_COUNTER_STATE_INACTIVE) {
		update_counter_times(counter);
573
		counter->state = PERF_COUNTER_STATE_OFF;
574
	}
575 576 577 578

	spin_unlock_irq(&ctx->lock);
}

579 580 581 582 583 584
static int
counter_sched_in(struct perf_counter *counter,
		 struct perf_cpu_context *cpuctx,
		 struct perf_counter_context *ctx,
		 int cpu)
{
585
	if (counter->state <= PERF_COUNTER_STATE_OFF)
586 587 588 589 590 591 592 593 594
		return 0;

	counter->state = PERF_COUNTER_STATE_ACTIVE;
	counter->oncpu = cpu;	/* TODO: put 'cpu' into cpuctx->cpu */
	/*
	 * The new state must be visible before we turn it on in the hardware:
	 */
	smp_wmb();

595
	if (counter->pmu->enable(counter)) {
596 597 598 599 600
		counter->state = PERF_COUNTER_STATE_INACTIVE;
		counter->oncpu = -1;
		return -EAGAIN;
	}

601
	counter->tstamp_running += ctx->time - counter->tstamp_stopped;
602

603 604
	if (!is_software_counter(counter))
		cpuctx->active_oncpu++;
605 606
	ctx->nr_active++;

607
	if (counter->attr.exclusive)
608 609
		cpuctx->exclusive = 1;

610 611 612
	return 0;
}

613 614 615 616 617 618 619 620 621 622 623 624 625 626 627 628 629 630 631 632 633 634 635 636 637 638 639 640 641 642 643 644 645 646 647 648 649 650 651 652 653 654 655 656 657 658
static int
group_sched_in(struct perf_counter *group_counter,
	       struct perf_cpu_context *cpuctx,
	       struct perf_counter_context *ctx,
	       int cpu)
{
	struct perf_counter *counter, *partial_group;
	int ret;

	if (group_counter->state == PERF_COUNTER_STATE_OFF)
		return 0;

	ret = hw_perf_group_sched_in(group_counter, cpuctx, ctx, cpu);
	if (ret)
		return ret < 0 ? ret : 0;

	if (counter_sched_in(group_counter, cpuctx, ctx, cpu))
		return -EAGAIN;

	/*
	 * Schedule in siblings as one group (if any):
	 */
	list_for_each_entry(counter, &group_counter->sibling_list, list_entry) {
		if (counter_sched_in(counter, cpuctx, ctx, cpu)) {
			partial_group = counter;
			goto group_error;
		}
	}

	return 0;

group_error:
	/*
	 * Groups can be scheduled in as one unit only, so undo any
	 * partial group before returning:
	 */
	list_for_each_entry(counter, &group_counter->sibling_list, list_entry) {
		if (counter == partial_group)
			break;
		counter_sched_out(counter, cpuctx, ctx);
	}
	counter_sched_out(group_counter, cpuctx, ctx);

	return -EAGAIN;
}

659 660 661 662 663 664 665 666 667 668
/*
 * Return 1 for a group consisting entirely of software counters,
 * 0 if the group contains any hardware counters.
 */
static int is_software_only_group(struct perf_counter *leader)
{
	struct perf_counter *counter;

	if (!is_software_counter(leader))
		return 0;
669

670 671 672
	list_for_each_entry(counter, &leader->sibling_list, list_entry)
		if (!is_software_counter(counter))
			return 0;
673

674 675 676 677 678 679 680 681 682 683 684 685 686 687 688 689 690 691 692 693 694 695 696 697 698
	return 1;
}

/*
 * Work out whether we can put this counter group on the CPU now.
 */
static int group_can_go_on(struct perf_counter *counter,
			   struct perf_cpu_context *cpuctx,
			   int can_add_hw)
{
	/*
	 * Groups consisting entirely of software counters can always go on.
	 */
	if (is_software_only_group(counter))
		return 1;
	/*
	 * If an exclusive group is already on, no other hardware
	 * counters can go on.
	 */
	if (cpuctx->exclusive)
		return 0;
	/*
	 * If this group is exclusive and there are already
	 * counters on the CPU, it can't go on.
	 */
699
	if (counter->attr.exclusive && cpuctx->active_oncpu)
700 701 702 703 704 705 706 707
		return 0;
	/*
	 * Otherwise, try to add it if all previous groups were able
	 * to go on.
	 */
	return can_add_hw;
}

708 709 710 711
static void add_counter_to_ctx(struct perf_counter *counter,
			       struct perf_counter_context *ctx)
{
	list_add_counter(counter, ctx);
712 713 714
	counter->tstamp_enabled = ctx->time;
	counter->tstamp_running = ctx->time;
	counter->tstamp_stopped = ctx->time;
715 716
}

717
/*
718
 * Cross CPU call to install and enable a performance counter
719 720
 *
 * Must be called with ctx->mutex held
721 722 723 724 725 726
 */
static void __perf_install_in_context(void *info)
{
	struct perf_cpu_context *cpuctx = &__get_cpu_var(perf_cpu_context);
	struct perf_counter *counter = info;
	struct perf_counter_context *ctx = counter->ctx;
727
	struct perf_counter *leader = counter->group_leader;
728
	int cpu = smp_processor_id();
729
	int err;
730 731 732 733 734

	/*
	 * If this is a task context, we need to check whether it is
	 * the current task context of this cpu. If not it has been
	 * scheduled out before the smp call arrived.
735 736
	 * Or possibly this is the right context but it isn't
	 * on this cpu because it had no counters.
737
	 */
738
	if (ctx->task && cpuctx->task_ctx != ctx) {
739
		if (cpuctx->task_ctx || ctx->task != current)
740 741 742
			return;
		cpuctx->task_ctx = ctx;
	}
743

744
	spin_lock(&ctx->lock);
745
	ctx->is_active = 1;
746
	update_context_time(ctx);
747 748 749 750 751

	/*
	 * Protect the list operation against NMI by disabling the
	 * counters on a global level. NOP for non NMI based counters.
	 */
752
	perf_disable();
753

754
	add_counter_to_ctx(counter, ctx);
755

756 757 758 759 760 761 762 763
	/*
	 * Don't put the counter on if it is disabled or if
	 * it is in a group and the group isn't on.
	 */
	if (counter->state != PERF_COUNTER_STATE_INACTIVE ||
	    (leader != counter && leader->state != PERF_COUNTER_STATE_ACTIVE))
		goto unlock;

764 765 766 767 768
	/*
	 * An exclusive counter can't go on if there are already active
	 * hardware counters, and no hardware counter can go on if there
	 * is already an exclusive counter on.
	 */
769
	if (!group_can_go_on(counter, cpuctx, 1))
770 771 772 773
		err = -EEXIST;
	else
		err = counter_sched_in(counter, cpuctx, ctx, cpu);

774 775 776 777 778 779 780 781
	if (err) {
		/*
		 * This counter couldn't go on.  If it is in a group
		 * then we have to pull the whole group off.
		 * If the counter group is pinned then put it in error state.
		 */
		if (leader != counter)
			group_sched_out(leader, cpuctx, ctx);
782
		if (leader->attr.pinned) {
783
			update_group_times(leader);
784
			leader->state = PERF_COUNTER_STATE_ERROR;
785
		}
786
	}
787

788
	if (!err && !ctx->task && cpuctx->max_pertask)
789 790
		cpuctx->max_pertask--;

791
 unlock:
792
	perf_enable();
793

794
	spin_unlock(&ctx->lock);
795 796 797 798 799 800 801 802 803 804 805
}

/*
 * Attach a performance counter to a context
 *
 * First we add the counter to the list with the hardware enable bit
 * in counter->hw_config cleared.
 *
 * If the counter is attached to a task which is on a CPU we use a smp
 * call to enable it in the task context. The task might have been
 * scheduled away, but we check this in the smp call again.
806 807
 *
 * Must be called with ctx->mutex held.
808 809 810 811 812 813 814 815 816 817 818 819 820 821 822 823 824 825 826 827 828 829 830 831 832 833
 */
static void
perf_install_in_context(struct perf_counter_context *ctx,
			struct perf_counter *counter,
			int cpu)
{
	struct task_struct *task = ctx->task;

	if (!task) {
		/*
		 * Per cpu counters are installed via an smp call and
		 * the install is always sucessful.
		 */
		smp_call_function_single(cpu, __perf_install_in_context,
					 counter, 1);
		return;
	}

retry:
	task_oncpu_function_call(task, __perf_install_in_context,
				 counter);

	spin_lock_irq(&ctx->lock);
	/*
	 * we need to retry the smp call.
	 */
834
	if (ctx->is_active && list_empty(&counter->list_entry)) {
835 836 837 838 839 840 841 842 843
		spin_unlock_irq(&ctx->lock);
		goto retry;
	}

	/*
	 * The lock prevents that this context is scheduled in so we
	 * can add the counter safely, if it the call above did not
	 * succeed.
	 */
844 845
	if (list_empty(&counter->list_entry))
		add_counter_to_ctx(counter, ctx);
846 847 848
	spin_unlock_irq(&ctx->lock);
}

849 850 851 852
/*
 * Cross CPU call to enable a performance counter
 */
static void __perf_counter_enable(void *info)
853
{
854 855 856 857 858
	struct perf_counter *counter = info;
	struct perf_cpu_context *cpuctx = &__get_cpu_var(perf_cpu_context);
	struct perf_counter_context *ctx = counter->ctx;
	struct perf_counter *leader = counter->group_leader;
	int err;
859

860 861 862 863
	/*
	 * If this is a per-task counter, need to check whether this
	 * counter's task is the current task on this cpu.
	 */
864
	if (ctx->task && cpuctx->task_ctx != ctx) {
865
		if (cpuctx->task_ctx || ctx->task != current)
866 867 868
			return;
		cpuctx->task_ctx = ctx;
	}
869

870
	spin_lock(&ctx->lock);
871
	ctx->is_active = 1;
872
	update_context_time(ctx);
873 874 875 876

	if (counter->state >= PERF_COUNTER_STATE_INACTIVE)
		goto unlock;
	counter->state = PERF_COUNTER_STATE_INACTIVE;
877
	counter->tstamp_enabled = ctx->time - counter->total_time_enabled;
878 879

	/*
880 881
	 * If the counter is in a group and isn't the group leader,
	 * then don't put it on unless the group is on.
882
	 */
883 884
	if (leader != counter && leader->state != PERF_COUNTER_STATE_ACTIVE)
		goto unlock;
885

886
	if (!group_can_go_on(counter, cpuctx, 1)) {
887
		err = -EEXIST;
888
	} else {
889
		perf_disable();
890 891 892 893 894 895
		if (counter == leader)
			err = group_sched_in(counter, cpuctx, ctx,
					     smp_processor_id());
		else
			err = counter_sched_in(counter, cpuctx, ctx,
					       smp_processor_id());
896
		perf_enable();
897
	}
898 899 900 901 902 903 904 905

	if (err) {
		/*
		 * If this counter can't go on and it's part of a
		 * group, then the whole group has to come off.
		 */
		if (leader != counter)
			group_sched_out(leader, cpuctx, ctx);
906
		if (leader->attr.pinned) {
907
			update_group_times(leader);
908
			leader->state = PERF_COUNTER_STATE_ERROR;
909
		}
910 911 912
	}

 unlock:
913
	spin_unlock(&ctx->lock);
914 915 916 917
}

/*
 * Enable a counter.
918 919 920 921 922 923
 *
 * If counter->ctx is a cloned context, callers must make sure that
 * every task struct that counter->ctx->task could possibly point to
 * remains valid.  This condition is satisfied when called through
 * perf_counter_for_each_child or perf_counter_for_each as described
 * for perf_counter_disable.
924 925 926 927 928 929 930 931 932 933 934 935 936 937 938 939 940 941 942 943 944 945 946 947 948 949 950 951 952 953 954 955 956 957 958 959 960 961 962 963 964 965 966 967 968 969
 */
static void perf_counter_enable(struct perf_counter *counter)
{
	struct perf_counter_context *ctx = counter->ctx;
	struct task_struct *task = ctx->task;

	if (!task) {
		/*
		 * Enable the counter on the cpu that it's on
		 */
		smp_call_function_single(counter->cpu, __perf_counter_enable,
					 counter, 1);
		return;
	}

	spin_lock_irq(&ctx->lock);
	if (counter->state >= PERF_COUNTER_STATE_INACTIVE)
		goto out;

	/*
	 * If the counter is in error state, clear that first.
	 * That way, if we see the counter in error state below, we
	 * know that it has gone back into error state, as distinct
	 * from the task having been scheduled away before the
	 * cross-call arrived.
	 */
	if (counter->state == PERF_COUNTER_STATE_ERROR)
		counter->state = PERF_COUNTER_STATE_OFF;

 retry:
	spin_unlock_irq(&ctx->lock);
	task_oncpu_function_call(task, __perf_counter_enable, counter);

	spin_lock_irq(&ctx->lock);

	/*
	 * If the context is active and the counter is still off,
	 * we need to retry the cross-call.
	 */
	if (ctx->is_active && counter->state == PERF_COUNTER_STATE_OFF)
		goto retry;

	/*
	 * Since we have the lock this context can't be scheduled
	 * in, so we can change the state safely.
	 */
970
	if (counter->state == PERF_COUNTER_STATE_OFF) {
971
		counter->state = PERF_COUNTER_STATE_INACTIVE;
972 973
		counter->tstamp_enabled =
			ctx->time - counter->total_time_enabled;
974
	}
975 976 977 978
 out:
	spin_unlock_irq(&ctx->lock);
}

979
static int perf_counter_refresh(struct perf_counter *counter, int refresh)
980
{
981 982 983
	/*
	 * not supported on inherited counters
	 */
984
	if (counter->attr.inherit)
985 986
		return -EINVAL;

987 988
	atomic_add(refresh, &counter->event_limit);
	perf_counter_enable(counter);
989 990

	return 0;
991 992
}

993 994 995 996 997
void __perf_counter_sched_out(struct perf_counter_context *ctx,
			      struct perf_cpu_context *cpuctx)
{
	struct perf_counter *counter;

998 999
	spin_lock(&ctx->lock);
	ctx->is_active = 0;
1000
	if (likely(!ctx->nr_counters))
1001
		goto out;
1002
	update_context_time(ctx);
1003

1004
	perf_disable();
1005
	if (ctx->nr_active) {
1006 1007 1008 1009 1010 1011
		list_for_each_entry(counter, &ctx->counter_list, list_entry) {
			if (counter != counter->group_leader)
				counter_sched_out(counter, cpuctx, ctx);
			else
				group_sched_out(counter, cpuctx, ctx);
		}
1012
	}
1013
	perf_enable();
1014
 out:
1015 1016 1017
	spin_unlock(&ctx->lock);
}

1018 1019 1020 1021 1022 1023 1024 1025 1026 1027 1028 1029 1030 1031 1032
/*
 * Test whether two contexts are equivalent, i.e. whether they
 * have both been cloned from the same version of the same context
 * and they both have the same number of enabled counters.
 * If the number of enabled counters is the same, then the set
 * of enabled counters should be the same, because these are both
 * inherited contexts, therefore we can't access individual counters
 * in them directly with an fd; we can only enable/disable all
 * counters via prctl, or enable/disable all counters in a family
 * via ioctl, which will have the same effect on both contexts.
 */
static int context_equiv(struct perf_counter_context *ctx1,
			 struct perf_counter_context *ctx2)
{
	return ctx1->parent_ctx && ctx1->parent_ctx == ctx2->parent_ctx
1033
		&& ctx1->parent_gen == ctx2->parent_gen
1034
		&& !ctx1->pin_count && !ctx2->pin_count;
1035 1036
}

1037 1038 1039 1040 1041 1042 1043 1044 1045 1046 1047 1048 1049 1050 1051 1052 1053 1054 1055 1056 1057 1058 1059 1060 1061 1062 1063 1064 1065 1066 1067 1068 1069 1070 1071 1072 1073 1074
static void __perf_counter_read(void *counter);

static void __perf_counter_sync_stat(struct perf_counter *counter,
				     struct perf_counter *next_counter)
{
	u64 value;

	if (!counter->attr.inherit_stat)
		return;

	/*
	 * Update the counter value, we cannot use perf_counter_read()
	 * because we're in the middle of a context switch and have IRQs
	 * disabled, which upsets smp_call_function_single(), however
	 * we know the counter must be on the current CPU, therefore we
	 * don't need to use it.
	 */
	switch (counter->state) {
	case PERF_COUNTER_STATE_ACTIVE:
		__perf_counter_read(counter);
		break;

	case PERF_COUNTER_STATE_INACTIVE:
		update_counter_times(counter);
		break;

	default:
		break;
	}

	/*
	 * In order to keep per-task stats reliable we need to flip the counter
	 * values when we flip the contexts.
	 */
	value = atomic64_read(&next_counter->count);
	value = atomic64_xchg(&counter->count, value);
	atomic64_set(&next_counter->count, value);

1075 1076 1077
	swap(counter->total_time_enabled, next_counter->total_time_enabled);
	swap(counter->total_time_running, next_counter->total_time_running);

1078
	/*
1079
	 * Since we swizzled the values, update the user visible data too.
1080
	 */
1081 1082
	perf_counter_update_userpage(counter);
	perf_counter_update_userpage(next_counter);
1083 1084 1085 1086 1087 1088 1089 1090 1091 1092 1093 1094 1095 1096 1097 1098 1099 1100 1101 1102 1103 1104 1105 1106 1107
}

#define list_next_entry(pos, member) \
	list_entry(pos->member.next, typeof(*pos), member)

static void perf_counter_sync_stat(struct perf_counter_context *ctx,
				   struct perf_counter_context *next_ctx)
{
	struct perf_counter *counter, *next_counter;

	if (!ctx->nr_stat)
		return;

	counter = list_first_entry(&ctx->event_list,
				   struct perf_counter, event_entry);

	next_counter = list_first_entry(&next_ctx->event_list,
					struct perf_counter, event_entry);

	while (&counter->event_entry != &ctx->event_list &&
	       &next_counter->event_entry != &next_ctx->event_list) {

		__perf_counter_sync_stat(counter, next_counter);

		counter = list_next_entry(counter, event_entry);
1108
		next_counter = list_next_entry(next_counter, event_entry);
1109 1110 1111
	}
}

1112 1113 1114 1115 1116 1117
/*
 * Called from scheduler to remove the counters of the current task,
 * with interrupts disabled.
 *
 * We stop each counter and update the counter value in counter->count.
 *
Ingo Molnar's avatar
Ingo Molnar committed
1118
 * This does not protect us against NMI, but disable()
1119 1120 1121 1122
 * sets the disabled bit in the control field of counter _before_
 * accessing the counter control register. If a NMI hits, then it will
 * not restart the counter.
 */
1123 1124
void perf_counter_task_sched_out(struct task_struct *task,
				 struct task_struct *next, int cpu)
1125 1126
{
	struct perf_cpu_context *cpuctx = &per_cpu(perf_cpu_context, cpu);
1127
	struct perf_counter_context *ctx = task->perf_counter_ctxp;
1128
	struct perf_counter_context *next_ctx;
1129
	struct perf_counter_context *parent;
1130
	struct pt_regs *regs;
1131
	int do_switch = 1;
1132

1133
	regs = task_pt_regs(task);
1134
	perf_swcounter_event(PERF_COUNT_SW_CONTEXT_SWITCHES, 1, 1, regs, 0);
1135

1136
	if (likely(!ctx || !cpuctx->task_ctx))
1137 1138
		return;

1139
	update_context_time(ctx);
1140 1141 1142

	rcu_read_lock();
	parent = rcu_dereference(ctx->parent_ctx);
1143
	next_ctx = next->perf_counter_ctxp;
1144 1145 1146 1147 1148 1149 1150 1151 1152 1153 1154 1155 1156 1157
	if (parent && next_ctx &&
	    rcu_dereference(next_ctx->parent_ctx) == parent) {
		/*
		 * Looks like the two contexts are clones, so we might be
		 * able to optimize the context switch.  We lock both
		 * contexts and check that they are clones under the
		 * lock (including re-checking that neither has been
		 * uncloned in the meantime).  It doesn't matter which
		 * order we take the locks because no other cpu could
		 * be trying to lock both of these tasks.
		 */
		spin_lock(&ctx->lock);
		spin_lock_nested(&next_ctx->lock, SINGLE_DEPTH_NESTING);
		if (context_equiv(ctx, next_ctx)) {
1158 1159 1160 1161
			/*
			 * XXX do we need a memory barrier of sorts
			 * wrt to rcu_dereference() of perf_counter_ctxp
			 */
1162 1163 1164 1165 1166
			task->perf_counter_ctxp = next_ctx;
			next->perf_counter_ctxp = ctx;
			ctx->task = next;
			next_ctx->task = task;
			do_switch = 0;
1167 1168

			perf_counter_sync_stat(ctx, next_ctx);
1169 1170 1171
		}
		spin_unlock(&next_ctx->lock);
		spin_unlock(&ctx->lock);
1172
	}
1173
	rcu_read_unlock();
1174

1175 1176 1177 1178
	if (do_switch) {
		__perf_counter_sched_out(ctx, cpuctx);
		cpuctx->task_ctx = NULL;
	}
1179 1180
}

1181 1182 1183
/*
 * Called with IRQs disabled
 */
1184 1185 1186 1187
static void __perf_counter_task_sched_out(struct perf_counter_context *ctx)
{
	struct perf_cpu_context *cpuctx = &__get_cpu_var(perf_cpu_context);

1188 1189
	if (!cpuctx->task_ctx)
		return;
1190 1191 1192 1193

	if (WARN_ON_ONCE(ctx != cpuctx->task_ctx))
		return;

1194 1195 1196 1197
	__perf_counter_sched_out(ctx, cpuctx);
	cpuctx->task_ctx = NULL;
}

1198 1199 1200
/*
 * Called with IRQs disabled
 */
1201
static void perf_counter_cpu_sched_out(struct perf_cpu_context *cpuctx)
1202
{
1203
	__perf_counter_sched_out(&cpuctx->ctx, cpuctx);
1204 1205
}

1206 1207 1208
static void
__perf_counter_sched_in(struct perf_counter_context *ctx,
			struct perf_cpu_context *cpuctx, int cpu)
1209 1210
{
	struct perf_counter *counter;
1211
	int can_add_hw = 1;
1212

1213 1214
	spin_lock(&ctx->lock);
	ctx->is_active = 1;
1215
	if (likely(!ctx->nr_counters))
1216
		goto out;
1217

1218
	ctx->timestamp = perf_clock();
1219

1220
	perf_disable();
1221 1222 1223 1224 1225 1226 1227

	/*
	 * First go through the list and put on any pinned groups
	 * in order to give them the best chance of going on.
	 */
	list_for_each_entry(counter, &ctx->counter_list, list_entry) {
		if (counter->state <= PERF_COUNTER_STATE_OFF ||
1228
		    !counter->attr.pinned)
1229 1230 1231 1232
			continue;
		if (counter->cpu != -1 && counter->cpu != cpu)
			continue;

1233 1234 1235 1236 1237 1238
		if (counter != counter->group_leader)
			counter_sched_in(counter, cpuctx, ctx, cpu);
		else {
			if (group_can_go_on(counter, cpuctx, 1))
				group_sched_in(counter, cpuctx, ctx, cpu);
		}
1239 1240 1241 1242 1243

		/*
		 * If this pinned group hasn't been scheduled,
		 * put it in error state.
		 */
1244 1245
		if (counter->state == PERF_COUNTER_STATE_INACTIVE) {
			update_group_times(counter);
1246
			counter->state = PERF_COUNTER_STATE_ERROR;
1247
		}
1248 1249
	}

1250
	list_for_each_entry(counter, &ctx->counter_list, list_entry) {
1251 1252 1253 1254 1255
		/*
		 * Ignore counters in OFF or ERROR state, and
		 * ignore pinned counters since we did them already.
		 */
		if (counter->state <= PERF_COUNTER_STATE_OFF ||
1256
		    counter->attr.pinned)
1257 1258
			continue;

1259 1260 1261 1262
		/*
		 * Listen to the 'cpu' scheduling filter constraint
		 * of counters:
		 */
1263 1264 1265
		if (counter->cpu != -1 && counter->cpu != cpu)
			continue;

1266 1267
		if (counter != counter->group_leader) {
			if (counter_sched_in(counter, cpuctx, ctx, cpu))
1268
				can_add_hw = 0;
1269 1270 1271 1272 1273
		} else {
			if (group_can_go_on(counter, cpuctx, can_add_hw)) {
				if (group_sched_in(counter, cpuctx, ctx, cpu))
					can_add_hw = 0;
			}
1274
		}
1275
	}
1276
	perf_enable();
1277
 out:
1278
	spin_unlock(&ctx->lock);
1279 1280 1281 1282 1283 1284 1285 1286 1287 1288 1289 1290 1291 1292 1293 1294
}

/*
 * Called from scheduler to add the counters of the current task
 * with interrupts disabled.
 *
 * We restore the counter value and then enable it.
 *
 * This does not protect us against NMI, but enable()
 * sets the enabled bit in the control field of counter _before_
 * accessing the counter control register. If a NMI hits, then it will
 * keep the counter running.
 */
void perf_counter_task_sched_in(struct task_struct *task, int cpu)
{
	struct perf_cpu_context *cpuctx = &per_cpu(perf_cpu_context, cpu);
1295
	struct perf_counter_context *ctx = task->perf_counter_ctxp;
1296

1297 1298
	if (likely(!ctx))
		return;
1299 1300
	if (cpuctx->task_ctx == ctx)
		return;
1301
	__perf_counter_sched_in(ctx, cpuctx, cpu);
1302 1303 1304
	cpuctx->task_ctx = ctx;
}

1305 1306 1307 1308 1309 1310 1311
static void perf_counter_cpu_sched_in(struct perf_cpu_context *cpuctx, int cpu)
{
	struct perf_counter_context *ctx = &cpuctx->ctx;

	__perf_counter_sched_in(ctx, cpuctx, cpu);
}

1312 1313 1314
#define MAX_INTERRUPTS (~0ULL)

static void perf_log_throttle(struct perf_counter *counter, int enable);
1315

1316 1317 1318 1319 1320 1321 1322 1323 1324 1325 1326 1327 1328 1329 1330 1331 1332 1333 1334 1335 1336
static void perf_adjust_period(struct perf_counter *counter, u64 events)
{
	struct hw_perf_counter *hwc = &counter->hw;
	u64 period, sample_period;
	s64 delta;

	events *= hwc->sample_period;
	period = div64_u64(events, counter->attr.sample_freq);

	delta = (s64)(period - hwc->sample_period);
	delta = (delta + 7) / 8; /* low pass filter */

	sample_period = hwc->sample_period + delta;

	if (!sample_period)
		sample_period = 1;

	hwc->sample_period = sample_period;
}

static void perf_ctx_adjust_freq(struct perf_counter_context *ctx)
1337 1338
{
	struct perf_counter *counter;
1339
	struct hw_perf_counter *hwc;
1340
	u64 interrupts, freq;
1341 1342 1343 1344 1345 1346

	spin_lock(&ctx->lock);
	list_for_each_entry(counter, &ctx->counter_list, list_entry) {
		if (counter->state != PERF_COUNTER_STATE_ACTIVE)
			continue;

1347 1348 1349 1350
		hwc = &counter->hw;

		interrupts = hwc->interrupts;
		hwc->interrupts = 0;
1351

1352 1353 1354
		/*
		 * unthrottle counters on the tick
		 */
1355 1356 1357
		if (interrupts == MAX_INTERRUPTS) {
			perf_log_throttle(counter, 1);
			counter->pmu->unthrottle(counter);
1358
			interrupts = 2*sysctl_perf_counter_sample_rate/HZ;
1359 1360
		}

1361
		if (!counter->attr.freq || !counter->attr.sample_freq)
1362 1363
			continue;

1364 1365 1366
		/*
		 * if the specified freq < HZ then we need to skip ticks
		 */
1367 1368 1369 1370 1371 1372 1373 1374 1375 1376 1377 1378 1379 1380 1381
		if (counter->attr.sample_freq < HZ) {
			freq = counter->attr.sample_freq;

			hwc->freq_count += freq;
			hwc->freq_interrupts += interrupts;

			if (hwc->freq_count < HZ)
				continue;

			interrupts = hwc->freq_interrupts;
			hwc->freq_interrupts = 0;
			hwc->freq_count -= HZ;
		} else
			freq = HZ;

1382
		perf_adjust_period(counter, freq * interrupts);
1383

1384 1385 1386 1387 1388 1389 1390 1391
		/*
		 * In order to avoid being stalled by an (accidental) huge
		 * sample period, force reset the sample period if we didn't
		 * get any events in this freq period.
		 */
		if (!interrupts) {
			perf_disable();
			counter->pmu->disable(counter);
1392
			atomic64_set(&hwc->period_left, 0);
1393 1394 1395
			counter->pmu->enable(counter);
			perf_enable();
		}
1396 1397 1398 1399
	}
	spin_unlock(&ctx->lock);
}

1400 1401 1402 1403
/*
 * Round-robin a context's counters:
 */
static void rotate_ctx(struct perf_counter_context *ctx)
1404 1405 1406
{
	struct perf_counter *counter;

1407
	if (!ctx->nr_counters)
1408 1409 1410 1411
		return;

	spin_lock(&ctx->lock);
	/*
1412
	 * Rotate the first entry last (works just fine for group counters too):
1413
	 */
1414
	perf_disable();
1415
	list_for_each_entry(counter, &ctx->counter_list, list_entry) {
1416
		list_move_tail(&counter->list_entry, &ctx->counter_list);
1417 1418
		break;
	}
1419
	perf_enable();
1420 1421

	spin_unlock(&ctx->lock);
1422 1423 1424 1425
}

void perf_counter_task_tick(struct task_struct *curr, int cpu)
{
1426 1427 1428 1429 1430 1431 1432
	struct perf_cpu_context *cpuctx;
	struct perf_counter_context *ctx;

	if (!atomic_read(&nr_counters))
		return;

	cpuctx = &per_cpu(perf_cpu_context, cpu);
1433
	ctx = curr->perf_counter_ctxp;
1434

1435
	perf_ctx_adjust_freq(&cpuctx->ctx);
1436
	if (ctx)
1437
		perf_ctx_adjust_freq(ctx);
1438

1439
	perf_counter_cpu_sched_out(cpuctx);
1440 1441
	if (ctx)
		__perf_counter_task_sched_out(ctx);
1442

1443
	rotate_ctx(&cpuctx->ctx);
1444 1445
	if (ctx)
		rotate_ctx(ctx);
1446

1447
	perf_counter_cpu_sched_in(cpuctx, cpu);
1448 1449
	if (ctx)
		perf_counter_task_sched_in(curr, cpu);
1450 1451
}

1452 1453 1454 1455 1456 1457 1458 1459 1460 1461 1462 1463 1464 1465 1466 1467 1468 1469 1470 1471 1472 1473 1474 1475 1476 1477 1478 1479 1480 1481 1482 1483 1484 1485 1486
/*
 * Enable all of a task's counters that have been marked enable-on-exec.
 * This expects task == current.
 */
static void perf_counter_enable_on_exec(struct task_struct *task)
{
	struct perf_counter_context *ctx;
	struct perf_counter *counter;
	unsigned long flags;
	int enabled = 0;

	local_irq_save(flags);
	ctx = task->perf_counter_ctxp;
	if (!ctx || !ctx->nr_counters)
		goto out;

	__perf_counter_task_sched_out(ctx);

	spin_lock(&ctx->lock);

	list_for_each_entry(counter, &ctx->counter_list, list_entry) {
		if (!counter->attr.enable_on_exec)
			continue;
		counter->attr.enable_on_exec = 0;
		if (counter->state >= PERF_COUNTER_STATE_INACTIVE)
			continue;
		counter->state = PERF_COUNTER_STATE_INACTIVE;
		counter->tstamp_enabled =
			ctx->time - counter->total_time_enabled;
		enabled = 1;
	}

	/*
	 * Unclone this context if we enabled any counter.
	 */
1487 1488
	if (enabled)
		unclone_ctx(ctx);
1489 1490 1491 1492 1493 1494 1495 1496

	spin_unlock(&ctx->lock);

	perf_counter_task_sched_in(task, smp_processor_id());
 out:
	local_irq_restore(flags);
}

1497 1498 1499
/*
 * Cross CPU call to read the hardware counter
 */
1500
static void __perf_counter_read(void *info)
1501
{
Ingo Molnar's avatar
Ingo Molnar committed
1502
	struct perf_counter *counter = info;
1503
	struct perf_counter_context *ctx = counter->ctx;
1504
	unsigned long flags;
Ingo Molnar's avatar
Ingo Molnar committed
1505

1506
	local_irq_save(flags);
1507
	if (ctx->is_active)
1508
		update_context_time(ctx);
1509
	counter->pmu->read(counter);
1510
	update_counter_times(counter);
1511
	local_irq_restore(flags);
1512 1513
}

1514
static u64 perf_counter_read(struct perf_counter *counter)
1515 1516 1517 1518 1519
{
	/*
	 * If counter is enabled and currently active on a CPU, update the
	 * value in the counter structure:
	 */
1520
	if (counter->state == PERF_COUNTER_STATE_ACTIVE) {
1521
		smp_call_function_single(counter->oncpu,
1522
					 __perf_counter_read, counter, 1);
1523 1524
	} else if (counter->state == PERF_COUNTER_STATE_INACTIVE) {
		update_counter_times(counter);
1525 1526
	}

1527
	return atomic64_read(&counter->count);
1528 1529
}

1530 1531 1532 1533 1534 1535 1536 1537 1538 1539 1540 1541 1542 1543 1544 1545
/*
 * Initialize the perf_counter context in a task_struct:
 */
static void
__perf_counter_init_context(struct perf_counter_context *ctx,
			    struct task_struct *task)
{
	memset(ctx, 0, sizeof(*ctx));
	spin_lock_init(&ctx->lock);
	mutex_init(&ctx->mutex);
	INIT_LIST_HEAD(&ctx->counter_list);
	INIT_LIST_HEAD(&ctx->event_list);
	atomic_set(&ctx->refcount, 1);
	ctx->task = task;
}

1546 1547
static struct perf_counter_context *find_get_context(pid_t pid, int cpu)
{
1548 1549
	struct perf_counter_context *ctx;
	struct perf_cpu_context *cpuctx;
1550
	struct task_struct *task;
1551
	unsigned long flags;
1552
	int err;
1553 1554 1555 1556 1557 1558

	/*
	 * If cpu is not a wildcard then this is a percpu counter:
	 */
	if (cpu != -1) {
		/* Must be root to operate on a CPU counter: */
1559
		if (perf_paranoid_cpu() && !capable(CAP_SYS_ADMIN))
1560 1561 1562 1563 1564 1565 1566 1567 1568 1569 1570 1571 1572 1573 1574
			return ERR_PTR(-EACCES);

		if (cpu < 0 || cpu > num_possible_cpus())
			return ERR_PTR(-EINVAL);

		/*
		 * We could be clever and allow to attach a counter to an
		 * offline CPU and activate it when the CPU comes up, but
		 * that's for later.
		 */
		if (!cpu_isset(cpu, cpu_online_map))
			return ERR_PTR(-ENODEV);

		cpuctx = &per_cpu(perf_cpu_context, cpu);
		ctx = &cpuctx->ctx;
1575
		get_ctx(ctx);
1576 1577 1578 1579 1580 1581 1582 1583 1584 1585 1586 1587 1588 1589 1590 1591

		return ctx;
	}

	rcu_read_lock();
	if (!pid)
		task = current;
	else
		task = find_task_by_vpid(pid);
	if (task)
		get_task_struct(task);
	rcu_read_unlock();

	if (!task)
		return ERR_PTR(-ESRCH);

1592 1593 1594 1595 1596 1597 1598
	/*
	 * Can't attach counters to a dying task.
	 */
	err = -ESRCH;
	if (task->flags & PF_EXITING)
		goto errout;

1599
	/* Reuse ptrace permission checks for now. */
1600 1601 1602 1603 1604
	err = -EACCES;
	if (!ptrace_may_access(task, PTRACE_MODE_READ))
		goto errout;

 retry:
1605
	ctx = perf_lock_task_context(task, &flags);
1606
	if (ctx) {
1607
		unclone_ctx(ctx);
1608
		spin_unlock_irqrestore(&ctx->lock, flags);
1609 1610
	}

1611 1612
	if (!ctx) {
		ctx = kmalloc(sizeof(struct perf_counter_context), GFP_KERNEL);
1613 1614 1615
		err = -ENOMEM;
		if (!ctx)
			goto errout;
1616
		__perf_counter_init_context(ctx, task);
1617 1618
		get_ctx(ctx);
		if (cmpxchg(&task->perf_counter_ctxp, NULL, ctx)) {
1619 1620 1621 1622 1623
			/*
			 * We raced with some other task; use
			 * the context they set.
			 */
			kfree(ctx);
1624
			goto retry;
1625
		}
1626
		get_task_struct(task);
1627 1628
	}

1629
	put_task_struct(task);
1630
	return ctx;
1631 1632 1633 1634

 errout:
	put_task_struct(task);
	return ERR_PTR(err);
1635 1636
}

1637 1638 1639 1640 1641
static void free_counter_rcu(struct rcu_head *head)
{
	struct perf_counter *counter;

	counter = container_of(head, struct perf_counter, rcu_head);
1642 1643
	if (counter->ns)
		put_pid_ns(counter->ns);
1644 1645 1646
	kfree(counter);
}

1647 1648
static void perf_pending_sync(struct perf_counter *counter);

1649 1650
static void free_counter(struct perf_counter *counter)
{
1651 1652
	perf_pending_sync(counter);

1653 1654 1655 1656 1657 1658
	if (!counter->parent) {
		atomic_dec(&nr_counters);
		if (counter->attr.mmap)
			atomic_dec(&nr_mmap_counters);
		if (counter->attr.comm)
			atomic_dec(&nr_comm_counters);
1659 1660
		if (counter->attr.task)
			atomic_dec(&nr_task_counters);
1661
	}
1662

1663 1664 1665
	if (counter->destroy)
		counter->destroy(counter);

1666
	put_ctx(counter->ctx);
1667 1668 1669
	call_rcu(&counter->rcu_head, free_counter_rcu);
}

1670 1671 1672 1673 1674 1675 1676 1677 1678 1679
/*
 * Called when the last reference to the file is gone.
 */
static int perf_release(struct inode *inode, struct file *file)
{
	struct perf_counter *counter = file->private_data;
	struct perf_counter_context *ctx = counter->ctx;

	file->private_data = NULL;

1680
	WARN_ON_ONCE(ctx->parent_ctx);
1681
	mutex_lock(&ctx->mutex);
1682
	perf_counter_remove_from_context(counter);
1683
	mutex_unlock(&ctx->mutex);
1684

1685 1686 1687 1688 1689
	mutex_lock(&counter->owner->perf_counter_mutex);
	list_del_init(&counter->owner_entry);
	mutex_unlock(&counter->owner->perf_counter_mutex);
	put_task_struct(counter->owner);

1690
	free_counter(counter);
1691 1692 1693 1694

	return 0;
}

1695 1696 1697 1698 1699 1700 1701 1702 1703 1704 1705 1706
static u64 perf_counter_read_tree(struct perf_counter *counter)
{
	struct perf_counter *child;
	u64 total = 0;

	total += perf_counter_read(counter);
	list_for_each_entry(child, &counter->child_list, child_list)
		total += perf_counter_read(child);

	return total;
}

1707 1708 1709 1710 1711 1712
/*
 * Read the performance counter - simple non blocking version for now
 */
static ssize_t
perf_read_hw(struct perf_counter *counter, char __user *buf, size_t count)
{
1713
	u64 values[4];
1714
	int n;
1715

1716 1717 1718 1719 1720 1721 1722 1723
	/*
	 * Return end-of-file for a read on a counter that is in
	 * error state (i.e. because it was pinned but it couldn't be
	 * scheduled on to the CPU at some point).
	 */
	if (counter->state == PERF_COUNTER_STATE_ERROR)
		return 0;

1724
	WARN_ON_ONCE(counter->ctx->parent_ctx);
1725
	mutex_lock(&counter->child_mutex);
1726
	values[0] = perf_counter_read_tree(counter);
1727
	n = 1;
1728
	if (counter->attr.read_format & PERF_FORMAT_TOTAL_TIME_ENABLED)
1729 1730
		values[n++] = counter->total_time_enabled +
			atomic64_read(&counter->child_total_time_enabled);
1731
	if (counter->attr.read_format & PERF_FORMAT_TOTAL_TIME_RUNNING)
1732 1733
		values[n++] = counter->total_time_running +
			atomic64_read(&counter->child_total_time_running);
1734
	if (counter->attr.read_format & PERF_FORMAT_ID)
1735
		values[n++] = primary_counter_id(counter);
1736
	mutex_unlock(&counter->child_mutex);
1737

1738 1739 1740 1741 1742 1743 1744 1745
	if (count < n * sizeof(u64))
		return -EINVAL;
	count = n * sizeof(u64);

	if (copy_to_user(buf, values, count))
		return -EFAULT;

	return count;
1746 1747 1748 1749 1750 1751 1752
}

static ssize_t
perf_read(struct file *file, char __user *buf, size_t count, loff_t *ppos)
{
	struct perf_counter *counter = file->private_data;

1753
	return perf_read_hw(counter, buf, count);
1754 1755 1756 1757 1758
}

static unsigned int perf_poll(struct file *file, poll_table *wait)
{
	struct perf_counter *counter = file->private_data;
1759
	struct perf_mmap_data *data;
1760
	unsigned int events = POLL_HUP;
1761 1762 1763 1764

	rcu_read_lock();
	data = rcu_dereference(counter->data);
	if (data)
1765
		events = atomic_xchg(&data->poll, 0);
1766
	rcu_read_unlock();
1767 1768 1769 1770 1771 1772

	poll_wait(file, &counter->waitq, wait);

	return events;
}

1773 1774
static void perf_counter_reset(struct perf_counter *counter)
{
1775
	(void)perf_counter_read(counter);
1776
	atomic64_set(&counter->count, 0);
1777 1778 1779
	perf_counter_update_userpage(counter);
}

1780 1781 1782 1783 1784 1785
/*
 * Holding the top-level counter's child_mutex means that any
 * descendant process that has inherited this counter will block
 * in sync_child_counter if it goes to exit, thus satisfying the
 * task existence requirements of perf_counter_enable/disable.
 */
1786 1787 1788 1789 1790
static void perf_counter_for_each_child(struct perf_counter *counter,
					void (*func)(struct perf_counter *))
{
	struct perf_counter *child;

1791
	WARN_ON_ONCE(counter->ctx->parent_ctx);
1792
	mutex_lock(&counter->child_mutex);
1793 1794 1795
	func(counter);
	list_for_each_entry(child, &counter->child_list, child_list)
		func(child);
1796
	mutex_unlock(&counter->child_mutex);
1797 1798 1799 1800 1801
}

static void perf_counter_for_each(struct perf_counter *counter,
				  void (*func)(struct perf_counter *))
{
1802 1803
	struct perf_counter_context *ctx = counter->ctx;
	struct perf_counter *sibling;
1804

1805 1806 1807 1808 1809 1810 1811 1812 1813
	WARN_ON_ONCE(ctx->parent_ctx);
	mutex_lock(&ctx->mutex);
	counter = counter->group_leader;

	perf_counter_for_each_child(counter, func);
	func(counter);
	list_for_each_entry(sibling, &counter->sibling_list, list_entry)
		perf_counter_for_each_child(counter, func);
	mutex_unlock(&ctx->mutex);
1814 1815
}

1816 1817 1818 1819 1820 1821 1822
static int perf_counter_period(struct perf_counter *counter, u64 __user *arg)
{
	struct perf_counter_context *ctx = counter->ctx;
	unsigned long size;
	int ret = 0;
	u64 value;

1823
	if (!counter->attr.sample_period)
1824 1825 1826 1827 1828 1829 1830 1831 1832 1833
		return -EINVAL;

	size = copy_from_user(&value, arg, sizeof(value));
	if (size != sizeof(value))
		return -EFAULT;

	if (!value)
		return -EINVAL;

	spin_lock_irq(&ctx->lock);
1834
	if (counter->attr.freq) {
1835
		if (value > sysctl_perf_counter_sample_rate) {
1836 1837 1838 1839
			ret = -EINVAL;
			goto unlock;
		}

1840
		counter->attr.sample_freq = value;
1841
	} else {
1842
		counter->attr.sample_period = value;
1843 1844 1845 1846 1847 1848 1849 1850
		counter->hw.sample_period = value;
	}
unlock:
	spin_unlock_irq(&ctx->lock);

	return ret;
}

1851 1852 1853
static long perf_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
{
	struct perf_counter *counter = file->private_data;
1854 1855
	void (*func)(struct perf_counter *);
	u32 flags = arg;
1856 1857 1858

	switch (cmd) {
	case PERF_COUNTER_IOC_ENABLE:
1859
		func = perf_counter_enable;
1860 1861
		break;
	case PERF_COUNTER_IOC_DISABLE:
1862
		func = perf_counter_disable;
1863
		break;
1864
	case PERF_COUNTER_IOC_RESET:
1865
		func = perf_counter_reset;
1866
		break;
1867 1868 1869

	case PERF_COUNTER_IOC_REFRESH:
		return perf_counter_refresh(counter, arg);
1870 1871 1872 1873

	case PERF_COUNTER_IOC_PERIOD:
		return perf_counter_period(counter, (u64 __user *)arg);

1874
	default:
1875
		return -ENOTTY;
1876
	}
1877 1878 1879 1880 1881 1882 1883

	if (flags & PERF_IOC_FLAG_GROUP)
		perf_counter_for_each(counter, func);
	else
		perf_counter_for_each_child(counter, func);

	return 0;
1884 1885
}

1886 1887 1888 1889 1890 1891 1892 1893 1894 1895 1896 1897 1898 1899 1900 1901 1902 1903 1904 1905 1906 1907 1908 1909
int perf_counter_task_enable(void)
{
	struct perf_counter *counter;

	mutex_lock(&current->perf_counter_mutex);
	list_for_each_entry(counter, &current->perf_counter_list, owner_entry)
		perf_counter_for_each_child(counter, perf_counter_enable);
	mutex_unlock(&current->perf_counter_mutex);

	return 0;
}

int perf_counter_task_disable(void)
{
	struct perf_counter *counter;

	mutex_lock(&current->perf_counter_mutex);
	list_for_each_entry(counter, &current->perf_counter_list, owner_entry)
		perf_counter_for_each_child(counter, perf_counter_disable);
	mutex_unlock(&current->perf_counter_mutex);

	return 0;
}

1910 1911 1912 1913 1914 1915 1916 1917
static int perf_counter_index(struct perf_counter *counter)
{
	if (counter->state != PERF_COUNTER_STATE_ACTIVE)
		return 0;

	return counter->hw.idx + 1 - PERF_COUNTER_INDEX_OFFSET;
}

1918 1919 1920 1921 1922 1923
/*
 * Callers need to ensure there can be no nesting of this function, otherwise
 * the seqlock logic goes bad. We can not serialize this because the arch
 * code calls this from NMI context.
 */
void perf_counter_update_userpage(struct perf_counter *counter)
1924
{
1925
	struct perf_counter_mmap_page *userpg;
1926
	struct perf_mmap_data *data;
1927 1928 1929 1930 1931 1932 1933

	rcu_read_lock();
	data = rcu_dereference(counter->data);
	if (!data)
		goto unlock;

	userpg = data->user_page;
1934

1935 1936 1937 1938 1939
	/*
	 * Disable preemption so as to not let the corresponding user-space
	 * spin too long if we get preempted.
	 */
	preempt_disable();
1940
	++userpg->lock;
1941
	barrier();
1942
	userpg->index = perf_counter_index(counter);
1943 1944 1945
	userpg->offset = atomic64_read(&counter->count);
	if (counter->state == PERF_COUNTER_STATE_ACTIVE)
		userpg->offset -= atomic64_read(&counter->hw.prev_count);
1946

1947 1948 1949 1950 1951 1952
	userpg->time_enabled = counter->total_time_enabled +
			atomic64_read(&counter->child_total_time_enabled);

	userpg->time_running = counter->total_time_running +
			atomic64_read(&counter->child_total_time_running);

1953
	barrier();
1954
	++userpg->lock;
1955
	preempt_enable();
1956
unlock:
1957
	rcu_read_unlock();
1958 1959 1960 1961 1962
}

static int perf_mmap_fault(struct vm_area_struct *vma, struct vm_fault *vmf)
{
	struct perf_counter *counter = vma->vm_file->private_data;
1963 1964 1965
	struct perf_mmap_data *data;
	int ret = VM_FAULT_SIGBUS;

1966 1967 1968 1969 1970 1971
	if (vmf->flags & FAULT_FLAG_MKWRITE) {
		if (vmf->pgoff == 0)
			ret = 0;
		return ret;
	}

1972 1973 1974 1975 1976 1977 1978 1979 1980
	rcu_read_lock();
	data = rcu_dereference(counter->data);
	if (!data)
		goto unlock;

	if (vmf->pgoff == 0) {
		vmf->page = virt_to_page(data->user_page);
	} else {
		int nr = vmf->pgoff - 1;
1981

1982 1983
		if ((unsigned)nr > data->nr_pages)
			goto unlock;
1984

1985 1986 1987
		if (vmf->flags & FAULT_FLAG_WRITE)
			goto unlock;

1988 1989
		vmf->page = virt_to_page(data->data_pages[nr]);
	}
1990

1991
	get_page(vmf->page);
1992 1993 1994
	vmf->page->mapping = vma->vm_file->f_mapping;
	vmf->page->index   = vmf->pgoff;

1995 1996 1997 1998 1999 2000 2001 2002 2003 2004 2005 2006 2007 2008 2009 2010 2011 2012 2013 2014 2015 2016 2017 2018 2019 2020 2021 2022 2023 2024 2025 2026 2027
	ret = 0;
unlock:
	rcu_read_unlock();

	return ret;
}

static int perf_mmap_data_alloc(struct perf_counter *counter, int nr_pages)
{
	struct perf_mmap_data *data;
	unsigned long size;
	int i;

	WARN_ON(atomic_read(&counter->mmap_count));

	size = sizeof(struct perf_mmap_data);
	size += nr_pages * sizeof(void *);

	data = kzalloc(size, GFP_KERNEL);
	if (!data)
		goto fail;

	data->user_page = (void *)get_zeroed_page(GFP_KERNEL);
	if (!data->user_page)
		goto fail_user_page;

	for (i = 0; i < nr_pages; i++) {
		data->data_pages[i] = (void *)get_zeroed_page(GFP_KERNEL);
		if (!data->data_pages[i])
			goto fail_data_pages;
	}

	data->nr_pages = nr_pages;
2028
	atomic_set(&data->lock, -1);
2029 2030 2031

	rcu_assign_pointer(counter->data, data);

2032
	return 0;
2033 2034 2035 2036 2037 2038 2039 2040 2041 2042 2043 2044 2045 2046

fail_data_pages:
	for (i--; i >= 0; i--)
		free_page((unsigned long)data->data_pages[i]);

	free_page((unsigned long)data->user_page);

fail_user_page:
	kfree(data);

fail:
	return -ENOMEM;
}

2047 2048
static void perf_mmap_free_page(unsigned long addr)
{
Kevin Cernekee's avatar
Kevin Cernekee committed
2049
	struct page *page = virt_to_page((void *)addr);
2050 2051 2052 2053 2054

	page->mapping = NULL;
	__free_page(page);
}

2055 2056
static void __perf_mmap_data_free(struct rcu_head *rcu_head)
{
2057
	struct perf_mmap_data *data;
2058 2059
	int i;

2060 2061
	data = container_of(rcu_head, struct perf_mmap_data, rcu_head);

2062
	perf_mmap_free_page((unsigned long)data->user_page);
2063
	for (i = 0; i < data->nr_pages; i++)
2064 2065
		perf_mmap_free_page((unsigned long)data->data_pages[i]);

2066 2067 2068 2069 2070 2071 2072 2073 2074 2075 2076 2077 2078 2079 2080 2081 2082 2083 2084 2085 2086 2087 2088 2089
	kfree(data);
}

static void perf_mmap_data_free(struct perf_counter *counter)
{
	struct perf_mmap_data *data = counter->data;

	WARN_ON(atomic_read(&counter->mmap_count));

	rcu_assign_pointer(counter->data, NULL);
	call_rcu(&data->rcu_head, __perf_mmap_data_free);
}

static void perf_mmap_open(struct vm_area_struct *vma)
{
	struct perf_counter *counter = vma->vm_file->private_data;

	atomic_inc(&counter->mmap_count);
}

static void perf_mmap_close(struct vm_area_struct *vma)
{
	struct perf_counter *counter = vma->vm_file->private_data;

2090
	WARN_ON_ONCE(counter->ctx->parent_ctx);
2091
	if (atomic_dec_and_mutex_lock(&counter->mmap_count, &counter->mmap_mutex)) {
2092 2093 2094
		struct user_struct *user = current_user();

		atomic_long_sub(counter->data->nr_pages + 1, &user->locked_vm);
2095
		vma->vm_mm->locked_vm -= counter->data->nr_locked;
2096 2097 2098
		perf_mmap_data_free(counter);
		mutex_unlock(&counter->mmap_mutex);
	}
2099 2100 2101
}

static struct vm_operations_struct perf_mmap_vmops = {
2102 2103 2104 2105
	.open		= perf_mmap_open,
	.close		= perf_mmap_close,
	.fault		= perf_mmap_fault,
	.page_mkwrite	= perf_mmap_fault,
2106 2107 2108 2109 2110
};

static int perf_mmap(struct file *file, struct vm_area_struct *vma)
{
	struct perf_counter *counter = file->private_data;
2111
	unsigned long user_locked, user_lock_limit;
2112
	struct user_struct *user = current_user();
2113
	unsigned long locked, lock_limit;
2114 2115
	unsigned long vma_size;
	unsigned long nr_pages;
2116
	long user_extra, extra;
2117
	int ret = 0;
2118

2119
	if (!(vma->vm_flags & VM_SHARED))
2120
		return -EINVAL;
2121 2122 2123 2124

	vma_size = vma->vm_end - vma->vm_start;
	nr_pages = (vma_size / PAGE_SIZE) - 1;

2125 2126 2127 2128 2129
	/*
	 * If we have data pages ensure they're a power-of-two number, so we
	 * can do bitmasks instead of modulo.
	 */
	if (nr_pages != 0 && !is_power_of_2(nr_pages))
2130 2131
		return -EINVAL;

2132
	if (vma_size != PAGE_SIZE * (1 + nr_pages))
2133 2134
		return -EINVAL;

2135 2136
	if (vma->vm_pgoff != 0)
		return -EINVAL;
2137

2138
	WARN_ON_ONCE(counter->ctx->parent_ctx);
2139 2140 2141 2142 2143 2144 2145
	mutex_lock(&counter->mmap_mutex);
	if (atomic_inc_not_zero(&counter->mmap_count)) {
		if (nr_pages != counter->data->nr_pages)
			ret = -EINVAL;
		goto unlock;
	}

2146 2147
	user_extra = nr_pages + 1;
	user_lock_limit = sysctl_perf_counter_mlock >> (PAGE_SHIFT - 10);
2148 2149 2150 2151 2152 2153

	/*
	 * Increase the limit linearly with more CPUs:
	 */
	user_lock_limit *= num_online_cpus();

2154
	user_locked = atomic_long_read(&user->locked_vm) + user_extra;
2155

2156 2157 2158
	extra = 0;
	if (user_locked > user_lock_limit)
		extra = user_locked - user_lock_limit;
2159 2160 2161

	lock_limit = current->signal->rlim[RLIMIT_MEMLOCK].rlim_cur;
	lock_limit >>= PAGE_SHIFT;
2162
	locked = vma->vm_mm->locked_vm + extra;
2163

2164 2165 2166 2167
	if ((locked > lock_limit) && !capable(CAP_IPC_LOCK)) {
		ret = -EPERM;
		goto unlock;
	}
2168 2169 2170

	WARN_ON(counter->data);
	ret = perf_mmap_data_alloc(counter, nr_pages);
2171 2172 2173 2174
	if (ret)
		goto unlock;

	atomic_set(&counter->mmap_count, 1);
2175
	atomic_long_add(user_extra, &user->locked_vm);
2176 2177
	vma->vm_mm->locked_vm += extra;
	counter->data->nr_locked = extra;
2178 2179 2180
	if (vma->vm_flags & VM_WRITE)
		counter->data->writable = 1;

2181
unlock:
2182
	mutex_unlock(&counter->mmap_mutex);
2183 2184 2185

	vma->vm_flags |= VM_RESERVED;
	vma->vm_ops = &perf_mmap_vmops;
2186 2187

	return ret;
2188 2189
}

Peter Zijlstra's avatar
Peter Zijlstra committed
2190 2191 2192
static int perf_fasync(int fd, struct file *filp, int on)
{
	struct inode *inode = filp->f_path.dentry->d_inode;
2193
	struct perf_counter *counter = filp->private_data;
Peter Zijlstra's avatar
Peter Zijlstra committed
2194 2195 2196 2197 2198 2199 2200 2201 2202 2203 2204 2205
	int retval;

	mutex_lock(&inode->i_mutex);
	retval = fasync_helper(fd, filp, on, &counter->fasync);
	mutex_unlock(&inode->i_mutex);

	if (retval < 0)
		return retval;

	return 0;
}

2206 2207 2208 2209
static const struct file_operations perf_fops = {
	.release		= perf_release,
	.read			= perf_read,
	.poll			= perf_poll,
2210 2211
	.unlocked_ioctl		= perf_ioctl,
	.compat_ioctl		= perf_ioctl,
2212
	.mmap			= perf_mmap,
Peter Zijlstra's avatar
Peter Zijlstra committed
2213
	.fasync			= perf_fasync,
2214 2215
};

2216 2217 2218 2219 2220 2221 2222 2223 2224 2225
/*
 * Perf counter wakeup
 *
 * If there's data, ensure we set the poll() state and publish everything
 * to user-space before waking everybody up.
 */

void perf_counter_wakeup(struct perf_counter *counter)
{
	wake_up_all(&counter->waitq);
2226 2227 2228 2229 2230

	if (counter->pending_kill) {
		kill_fasync(&counter->fasync, SIGIO, counter->pending_kill);
		counter->pending_kill = 0;
	}
2231 2232 2233 2234 2235 2236 2237 2238 2239 2240 2241
}

/*
 * Pending wakeups
 *
 * Handle the case where we need to wakeup up from NMI (or rq->lock) context.
 *
 * The NMI bit means we cannot possibly take locks. Therefore, maintain a
 * single linked list and use cmpxchg() to add entries lockless.
 */

2242 2243 2244 2245 2246 2247 2248 2249 2250 2251 2252 2253 2254 2255 2256 2257
static void perf_pending_counter(struct perf_pending_entry *entry)
{
	struct perf_counter *counter = container_of(entry,
			struct perf_counter, pending);

	if (counter->pending_disable) {
		counter->pending_disable = 0;
		perf_counter_disable(counter);
	}

	if (counter->pending_wakeup) {
		counter->pending_wakeup = 0;
		perf_counter_wakeup(counter);
	}
}

2258
#define PENDING_TAIL ((struct perf_pending_entry *)-1UL)
2259

2260
static DEFINE_PER_CPU(struct perf_pending_entry *, perf_pending_head) = {
2261 2262 2263
	PENDING_TAIL,
};

2264 2265
static void perf_pending_queue(struct perf_pending_entry *entry,
			       void (*func)(struct perf_pending_entry *))
2266
{
2267
	struct perf_pending_entry **head;
2268

2269
	if (cmpxchg(&entry->next, NULL, PENDING_TAIL) != NULL)
2270 2271
		return;

2272 2273 2274
	entry->func = func;

	head = &get_cpu_var(perf_pending_head);
2275 2276

	do {
2277 2278
		entry->next = *head;
	} while (cmpxchg(head, entry->next, entry) != entry->next);
2279 2280 2281

	set_perf_counter_pending();

2282
	put_cpu_var(perf_pending_head);
2283 2284 2285 2286
}

static int __perf_pending_run(void)
{
2287
	struct perf_pending_entry *list;
2288 2289
	int nr = 0;

2290
	list = xchg(&__get_cpu_var(perf_pending_head), PENDING_TAIL);
2291
	while (list != PENDING_TAIL) {
2292 2293
		void (*func)(struct perf_pending_entry *);
		struct perf_pending_entry *entry = list;
2294 2295 2296

		list = list->next;

2297 2298
		func = entry->func;
		entry->next = NULL;
2299 2300 2301 2302 2303 2304 2305
		/*
		 * Ensure we observe the unqueue before we issue the wakeup,
		 * so that we won't be waiting forever.
		 * -- see perf_not_pending().
		 */
		smp_wmb();

2306
		func(entry);
2307 2308 2309 2310 2311 2312 2313 2314 2315 2316 2317 2318 2319 2320 2321 2322 2323 2324 2325 2326 2327
		nr++;
	}

	return nr;
}

static inline int perf_not_pending(struct perf_counter *counter)
{
	/*
	 * If we flush on whatever cpu we run, there is a chance we don't
	 * need to wait.
	 */
	get_cpu();
	__perf_pending_run();
	put_cpu();

	/*
	 * Ensure we see the proper queue state before going to sleep
	 * so that we do not miss the wakeup. -- see perf_pending_handle()
	 */
	smp_rmb();
2328
	return counter->pending.next == NULL;
2329 2330 2331 2332 2333 2334 2335 2336 2337 2338 2339 2340
}

static void perf_pending_sync(struct perf_counter *counter)
{
	wait_event(counter->waitq, perf_not_pending(counter));
}

void perf_counter_do_pending(void)
{
	__perf_pending_run();
}

2341 2342 2343 2344
/*
 * Callchain support -- arch specific
 */

2345
__weak struct perf_callchain_entry *perf_callchain(struct pt_regs *regs)
2346 2347 2348 2349
{
	return NULL;
}

2350 2351 2352 2353
/*
 * Output
 */

2354 2355 2356
struct perf_output_handle {
	struct perf_counter	*counter;
	struct perf_mmap_data	*data;
2357 2358
	unsigned long		head;
	unsigned long		offset;
2359
	int			nmi;
2360
	int			sample;
2361 2362
	int			locked;
	unsigned long		flags;
2363 2364
};

2365 2366 2367 2368 2369 2370 2371 2372 2373 2374 2375 2376 2377 2378 2379 2380 2381 2382 2383 2384 2385 2386 2387 2388 2389 2390 2391
static bool perf_output_space(struct perf_mmap_data *data,
			      unsigned int offset, unsigned int head)
{
	unsigned long tail;
	unsigned long mask;

	if (!data->writable)
		return true;

	mask = (data->nr_pages << PAGE_SHIFT) - 1;
	/*
	 * Userspace could choose to issue a mb() before updating the tail
	 * pointer. So that all reads will be completed before the write is
	 * issued.
	 */
	tail = ACCESS_ONCE(data->user_page->data_tail);
	smp_rmb();

	offset = (offset - tail) & mask;
	head   = (head   - tail) & mask;

	if ((int)(head - offset) < 0)
		return false;

	return true;
}

2392
static void perf_output_wakeup(struct perf_output_handle *handle)
2393
{
2394 2395
	atomic_set(&handle->data->poll, POLL_IN);

2396
	if (handle->nmi) {
2397
		handle->counter->pending_wakeup = 1;
2398
		perf_pending_queue(&handle->counter->pending,
2399
				   perf_pending_counter);
2400
	} else
2401 2402 2403
		perf_counter_wakeup(handle->counter);
}

2404 2405 2406 2407 2408 2409 2410 2411 2412 2413 2414 2415 2416 2417 2418 2419 2420 2421 2422 2423 2424 2425 2426 2427 2428 2429
/*
 * Curious locking construct.
 *
 * We need to ensure a later event doesn't publish a head when a former
 * event isn't done writing. However since we need to deal with NMIs we
 * cannot fully serialize things.
 *
 * What we do is serialize between CPUs so we only have to deal with NMI
 * nesting on a single CPU.
 *
 * We only publish the head (and generate a wakeup) when the outer-most
 * event completes.
 */
static void perf_output_lock(struct perf_output_handle *handle)
{
	struct perf_mmap_data *data = handle->data;
	int cpu;

	handle->locked = 0;

	local_irq_save(handle->flags);
	cpu = smp_processor_id();

	if (in_nmi() && atomic_read(&data->lock) == cpu)
		return;

2430
	while (atomic_cmpxchg(&data->lock, -1, cpu) != -1)
2431 2432 2433 2434 2435 2436 2437 2438
		cpu_relax();

	handle->locked = 1;
}

static void perf_output_unlock(struct perf_output_handle *handle)
{
	struct perf_mmap_data *data = handle->data;
2439 2440
	unsigned long head;
	int cpu;
2441

2442
	data->done_head = data->head;
2443 2444 2445 2446 2447 2448 2449 2450 2451 2452

	if (!handle->locked)
		goto out;

again:
	/*
	 * The xchg implies a full barrier that ensures all writes are done
	 * before we publish the new head, matched by a rmb() in userspace when
	 * reading this position.
	 */
2453
	while ((head = atomic_long_xchg(&data->done_head, 0)))
2454 2455 2456
		data->user_page->data_head = head;

	/*
2457
	 * NMI can happen here, which means we can miss a done_head update.
2458 2459
	 */

2460
	cpu = atomic_xchg(&data->lock, -1);
2461 2462 2463 2464 2465
	WARN_ON_ONCE(cpu != smp_processor_id());

	/*
	 * Therefore we have to validate we did not indeed do so.
	 */
2466
	if (unlikely(atomic_long_read(&data->done_head))) {
2467 2468 2469
		/*
		 * Since we had it locked, we can lock it again.
		 */
2470
		while (atomic_cmpxchg(&data->lock, -1, cpu) != -1)
2471 2472 2473 2474 2475
			cpu_relax();

		goto again;
	}

2476
	if (atomic_xchg(&data->wakeup, 0))
2477 2478 2479 2480 2481
		perf_output_wakeup(handle);
out:
	local_irq_restore(handle->flags);
}

2482 2483 2484 2485 2486 2487 2488 2489 2490 2491 2492 2493 2494 2495 2496 2497 2498 2499 2500 2501 2502 2503 2504 2505 2506 2507 2508 2509 2510 2511 2512 2513 2514 2515 2516 2517 2518 2519 2520
static void perf_output_copy(struct perf_output_handle *handle,
			     const void *buf, unsigned int len)
{
	unsigned int pages_mask;
	unsigned int offset;
	unsigned int size;
	void **pages;

	offset		= handle->offset;
	pages_mask	= handle->data->nr_pages - 1;
	pages		= handle->data->data_pages;

	do {
		unsigned int page_offset;
		int nr;

		nr	    = (offset >> PAGE_SHIFT) & pages_mask;
		page_offset = offset & (PAGE_SIZE - 1);
		size	    = min_t(unsigned int, PAGE_SIZE - page_offset, len);

		memcpy(pages[nr] + page_offset, buf, size);

		len	    -= size;
		buf	    += size;
		offset	    += size;
	} while (len);

	handle->offset = offset;

	/*
	 * Check we didn't copy past our reservation window, taking the
	 * possible unsigned int wrap into account.
	 */
	WARN_ON_ONCE(((long)(handle->head - handle->offset)) < 0);
}

#define perf_output_put(handle, x) \
	perf_output_copy((handle), &(x), sizeof(x))

2521
static int perf_output_begin(struct perf_output_handle *handle,
2522
			     struct perf_counter *counter, unsigned int size,
2523
			     int nmi, int sample)
2524
{
2525
	struct perf_mmap_data *data;
2526
	unsigned int offset, head;
2527 2528 2529 2530 2531 2532
	int have_lost;
	struct {
		struct perf_event_header header;
		u64			 id;
		u64			 lost;
	} lost_event;
2533

2534 2535 2536 2537 2538 2539
	/*
	 * For inherited counters we send all the output towards the parent.
	 */
	if (counter->parent)
		counter = counter->parent;

2540 2541 2542 2543 2544
	rcu_read_lock();
	data = rcu_dereference(counter->data);
	if (!data)
		goto out;

2545 2546 2547 2548
	handle->data	= data;
	handle->counter	= counter;
	handle->nmi	= nmi;
	handle->sample	= sample;
2549

2550
	if (!data->nr_pages)
2551
		goto fail;
2552

2553 2554 2555 2556
	have_lost = atomic_read(&data->lost);
	if (have_lost)
		size += sizeof(lost_event);

2557 2558
	perf_output_lock(handle);

2559
	do {
2560
		offset = head = atomic_long_read(&data->head);
2561
		head += size;
2562 2563
		if (unlikely(!perf_output_space(data, offset, head)))
			goto fail;
2564
	} while (atomic_long_cmpxchg(&data->head, offset, head) != offset);
2565

2566
	handle->offset	= offset;
2567
	handle->head	= head;
2568 2569 2570

	if ((offset >> PAGE_SHIFT) != (head >> PAGE_SHIFT))
		atomic_set(&data->wakeup, 1);
2571

2572 2573 2574 2575 2576 2577 2578 2579 2580 2581
	if (have_lost) {
		lost_event.header.type = PERF_EVENT_LOST;
		lost_event.header.misc = 0;
		lost_event.header.size = sizeof(lost_event);
		lost_event.id          = counter->id;
		lost_event.lost        = atomic_xchg(&data->lost, 0);

		perf_output_put(handle, lost_event);
	}

2582
	return 0;
2583

2584
fail:
2585 2586
	atomic_inc(&data->lost);
	perf_output_unlock(handle);
2587 2588
out:
	rcu_read_unlock();
2589

2590 2591
	return -ENOSPC;
}
2592

2593
static void perf_output_end(struct perf_output_handle *handle)
2594
{
2595 2596 2597
	struct perf_counter *counter = handle->counter;
	struct perf_mmap_data *data = handle->data;

2598
	int wakeup_events = counter->attr.wakeup_events;
2599

2600
	if (handle->sample && wakeup_events) {
2601
		int events = atomic_inc_return(&data->events);
2602
		if (events >= wakeup_events) {
2603
			atomic_sub(wakeup_events, &data->events);
2604
			atomic_set(&data->wakeup, 1);
2605
		}
2606 2607 2608
	}

	perf_output_unlock(handle);
2609
	rcu_read_unlock();
2610 2611
}

2612 2613 2614 2615 2616 2617 2618 2619 2620 2621 2622 2623 2624 2625 2626 2627 2628 2629 2630 2631 2632 2633
static u32 perf_counter_pid(struct perf_counter *counter, struct task_struct *p)
{
	/*
	 * only top level counters have the pid namespace they were created in
	 */
	if (counter->parent)
		counter = counter->parent;

	return task_tgid_nr_ns(p, counter->ns);
}

static u32 perf_counter_tid(struct perf_counter *counter, struct task_struct *p)
{
	/*
	 * only top level counters have the pid namespace they were created in
	 */
	if (counter->parent)
		counter = counter->parent;

	return task_pid_nr_ns(p, counter->ns);
}

2634
void perf_counter_output(struct perf_counter *counter, int nmi,
2635
				struct perf_sample_data *data)
2636
{
2637
	int ret;
2638
	u64 sample_type = counter->attr.sample_type;
2639 2640 2641
	struct perf_output_handle handle;
	struct perf_event_header header;
	u64 ip;
2642
	struct {
2643
		u32 pid, tid;
2644
	} tid_entry;
2645
	struct {
2646
		u64 id;
2647 2648
		u64 counter;
	} group_entry;
2649
	struct perf_callchain_entry *callchain = NULL;
2650
	struct perf_raw_record *raw = NULL;
2651
	int callchain_size = 0;
2652
	u64 time;
2653 2654 2655
	struct {
		u32 cpu, reserved;
	} cpu_entry;
2656

2657
	header.type = PERF_EVENT_SAMPLE;
2658
	header.size = sizeof(header);
2659

2660
	header.misc = 0;
2661
	header.misc |= perf_misc_flags(data->regs);
2662

2663
	if (sample_type & PERF_SAMPLE_IP) {
2664
		ip = perf_instruction_pointer(data->regs);
2665 2666
		header.size += sizeof(ip);
	}
2667

2668
	if (sample_type & PERF_SAMPLE_TID) {
2669
		/* namespace issues */
2670 2671
		tid_entry.pid = perf_counter_pid(counter, current);
		tid_entry.tid = perf_counter_tid(counter, current);
2672 2673 2674 2675

		header.size += sizeof(tid_entry);
	}

2676
	if (sample_type & PERF_SAMPLE_TIME) {
2677 2678 2679 2680 2681 2682 2683 2684
		/*
		 * Maybe do better on x86 and provide cpu_clock_nmi()
		 */
		time = sched_clock();

		header.size += sizeof(u64);
	}

2685
	if (sample_type & PERF_SAMPLE_ADDR)
2686 2687
		header.size += sizeof(u64);

2688
	if (sample_type & PERF_SAMPLE_ID)
2689 2690
		header.size += sizeof(u64);

2691 2692 2693
	if (sample_type & PERF_SAMPLE_STREAM_ID)
		header.size += sizeof(u64);

2694
	if (sample_type & PERF_SAMPLE_CPU) {
2695 2696 2697
		header.size += sizeof(cpu_entry);

		cpu_entry.cpu = raw_smp_processor_id();
Arjan van de Ven's avatar
Arjan van de Ven committed
2698
		cpu_entry.reserved = 0;
2699 2700
	}

2701
	if (sample_type & PERF_SAMPLE_PERIOD)
2702 2703
		header.size += sizeof(u64);

2704
	if (sample_type & PERF_SAMPLE_GROUP) {
2705 2706 2707 2708
		header.size += sizeof(u64) +
			counter->nr_siblings * sizeof(group_entry);
	}

2709
	if (sample_type & PERF_SAMPLE_CALLCHAIN) {
2710
		callchain = perf_callchain(data->regs);
2711 2712

		if (callchain) {
2713
			callchain_size = (1 + callchain->nr) * sizeof(u64);
2714
			header.size += callchain_size;
2715 2716
		} else
			header.size += sizeof(u64);
2717 2718
	}

2719 2720 2721 2722
	if (sample_type & PERF_SAMPLE_RAW) {
		raw = data->raw;
		if (raw)
			header.size += raw->size;
2723 2724
	}

2725
	ret = perf_output_begin(&handle, counter, header.size, nmi, 1);
2726 2727
	if (ret)
		return;
2728

2729
	perf_output_put(&handle, header);
2730

2731
	if (sample_type & PERF_SAMPLE_IP)
2732
		perf_output_put(&handle, ip);
2733

2734
	if (sample_type & PERF_SAMPLE_TID)
2735
		perf_output_put(&handle, tid_entry);
2736

2737
	if (sample_type & PERF_SAMPLE_TIME)
2738 2739
		perf_output_put(&handle, time);

2740
	if (sample_type & PERF_SAMPLE_ADDR)
2741
		perf_output_put(&handle, data->addr);
2742

2743 2744 2745 2746 2747 2748 2749
	if (sample_type & PERF_SAMPLE_ID) {
		u64 id = primary_counter_id(counter);

		perf_output_put(&handle, id);
	}

	if (sample_type & PERF_SAMPLE_STREAM_ID)
2750
		perf_output_put(&handle, counter->id);
2751

2752
	if (sample_type & PERF_SAMPLE_CPU)
2753 2754
		perf_output_put(&handle, cpu_entry);

2755
	if (sample_type & PERF_SAMPLE_PERIOD)
2756
		perf_output_put(&handle, data->period);
2757

2758
	/*
2759
	 * XXX PERF_SAMPLE_GROUP vs inherited counters seems difficult.
2760
	 */
2761
	if (sample_type & PERF_SAMPLE_GROUP) {
2762 2763
		struct perf_counter *leader, *sub;
		u64 nr = counter->nr_siblings;
2764

2765
		perf_output_put(&handle, nr);
2766

2767 2768 2769
		leader = counter->group_leader;
		list_for_each_entry(sub, &leader->sibling_list, list_entry) {
			if (sub != counter)
2770
				sub->pmu->read(sub);
2771

2772
			group_entry.id = primary_counter_id(sub);
2773
			group_entry.counter = atomic64_read(&sub->count);
2774

2775 2776
			perf_output_put(&handle, group_entry);
		}
2777
	}
2778

2779 2780 2781 2782 2783 2784 2785 2786
	if (sample_type & PERF_SAMPLE_CALLCHAIN) {
		if (callchain)
			perf_output_copy(&handle, callchain, callchain_size);
		else {
			u64 nr = 0;
			perf_output_put(&handle, nr);
		}
	}
2787

2788 2789
	if ((sample_type & PERF_SAMPLE_RAW) && raw)
		perf_output_copy(&handle, raw->data, raw->size);
2790

2791
	perf_output_end(&handle);
2792 2793
}

2794 2795 2796 2797 2798 2799 2800 2801 2802 2803 2804 2805 2806 2807 2808 2809 2810 2811 2812 2813 2814 2815 2816 2817 2818 2819 2820 2821 2822 2823 2824 2825 2826 2827 2828 2829 2830 2831 2832 2833 2834 2835
/*
 * read event
 */

struct perf_read_event {
	struct perf_event_header	header;

	u32				pid;
	u32				tid;
	u64				value;
	u64				format[3];
};

static void
perf_counter_read_event(struct perf_counter *counter,
			struct task_struct *task)
{
	struct perf_output_handle handle;
	struct perf_read_event event = {
		.header = {
			.type = PERF_EVENT_READ,
			.misc = 0,
			.size = sizeof(event) - sizeof(event.format),
		},
		.pid = perf_counter_pid(counter, task),
		.tid = perf_counter_tid(counter, task),
		.value = atomic64_read(&counter->count),
	};
	int ret, i = 0;

	if (counter->attr.read_format & PERF_FORMAT_TOTAL_TIME_ENABLED) {
		event.header.size += sizeof(u64);
		event.format[i++] = counter->total_time_enabled;
	}

	if (counter->attr.read_format & PERF_FORMAT_TOTAL_TIME_RUNNING) {
		event.header.size += sizeof(u64);
		event.format[i++] = counter->total_time_running;
	}

	if (counter->attr.read_format & PERF_FORMAT_ID) {
		event.header.size += sizeof(u64);
2836
		event.format[i++] = primary_counter_id(counter);
2837 2838 2839 2840 2841 2842 2843 2844 2845 2846
	}

	ret = perf_output_begin(&handle, counter, event.header.size, 0, 0);
	if (ret)
		return;

	perf_output_copy(&handle, &event, event.header.size);
	perf_output_end(&handle);
}

2847
/*
2848 2849 2850
 * task tracking -- fork/exit
 *
 * enabled by: attr.comm | attr.mmap | attr.task
2851 2852
 */

2853
struct perf_task_event {
2854 2855
	struct task_struct		*task;
	struct perf_counter_context	*task_ctx;
2856 2857 2858 2859 2860 2861

	struct {
		struct perf_event_header	header;

		u32				pid;
		u32				ppid;
2862 2863
		u32				tid;
		u32				ptid;
2864 2865 2866
	} event;
};

2867 2868
static void perf_counter_task_output(struct perf_counter *counter,
				     struct perf_task_event *task_event)
2869 2870
{
	struct perf_output_handle handle;
2871 2872
	int size = task_event->event.header.size;
	struct task_struct *task = task_event->task;
2873 2874 2875 2876 2877
	int ret = perf_output_begin(&handle, counter, size, 0, 0);

	if (ret)
		return;

2878 2879
	task_event->event.pid = perf_counter_pid(counter, task);
	task_event->event.ppid = perf_counter_pid(counter, task->real_parent);
2880

2881 2882 2883 2884
	task_event->event.tid = perf_counter_tid(counter, task);
	task_event->event.ptid = perf_counter_tid(counter, task->real_parent);

	perf_output_put(&handle, task_event->event);
2885 2886 2887
	perf_output_end(&handle);
}

2888
static int perf_counter_task_match(struct perf_counter *counter)
2889
{
2890
	if (counter->attr.comm || counter->attr.mmap || counter->attr.task)
2891 2892 2893 2894 2895
		return 1;

	return 0;
}

2896 2897
static void perf_counter_task_ctx(struct perf_counter_context *ctx,
				  struct perf_task_event *task_event)
2898 2899 2900 2901 2902 2903 2904 2905
{
	struct perf_counter *counter;

	if (system_state != SYSTEM_RUNNING || list_empty(&ctx->event_list))
		return;

	rcu_read_lock();
	list_for_each_entry_rcu(counter, &ctx->event_list, event_entry) {
2906 2907
		if (perf_counter_task_match(counter))
			perf_counter_task_output(counter, task_event);
2908 2909 2910 2911
	}
	rcu_read_unlock();
}

2912
static void perf_counter_task_event(struct perf_task_event *task_event)
2913 2914
{
	struct perf_cpu_context *cpuctx;
2915
	struct perf_counter_context *ctx = task_event->task_ctx;
2916 2917

	cpuctx = &get_cpu_var(perf_cpu_context);
2918
	perf_counter_task_ctx(&cpuctx->ctx, task_event);
2919 2920 2921
	put_cpu_var(perf_cpu_context);

	rcu_read_lock();
2922 2923
	if (!ctx)
		ctx = rcu_dereference(task_event->task->perf_counter_ctxp);
2924
	if (ctx)
2925
		perf_counter_task_ctx(ctx, task_event);
2926 2927 2928
	rcu_read_unlock();
}

2929 2930 2931
static void perf_counter_task(struct task_struct *task,
			      struct perf_counter_context *task_ctx,
			      int new)
2932
{
2933
	struct perf_task_event task_event;
2934 2935

	if (!atomic_read(&nr_comm_counters) &&
2936 2937
	    !atomic_read(&nr_mmap_counters) &&
	    !atomic_read(&nr_task_counters))
2938 2939
		return;

2940
	task_event = (struct perf_task_event){
2941 2942 2943
		.task	  = task,
		.task_ctx = task_ctx,
		.event    = {
2944
			.header = {
2945
				.type = new ? PERF_EVENT_FORK : PERF_EVENT_EXIT,
2946
				.misc = 0,
2947
				.size = sizeof(task_event.event),
2948
			},
2949 2950
			/* .pid  */
			/* .ppid */
2951 2952
			/* .tid  */
			/* .ptid */
2953 2954 2955
		},
	};

2956 2957 2958 2959 2960
	perf_counter_task_event(&task_event);
}

void perf_counter_fork(struct task_struct *task)
{
2961
	perf_counter_task(task, NULL, 1);
2962 2963
}

2964 2965 2966 2967 2968
/*
 * comm tracking
 */

struct perf_comm_event {
2969 2970
	struct task_struct	*task;
	char			*comm;
2971 2972 2973 2974 2975 2976 2977 2978 2979 2980 2981 2982 2983 2984 2985 2986 2987 2988 2989 2990
	int			comm_size;

	struct {
		struct perf_event_header	header;

		u32				pid;
		u32				tid;
	} event;
};

static void perf_counter_comm_output(struct perf_counter *counter,
				     struct perf_comm_event *comm_event)
{
	struct perf_output_handle handle;
	int size = comm_event->event.header.size;
	int ret = perf_output_begin(&handle, counter, size, 0, 0);

	if (ret)
		return;

2991 2992 2993
	comm_event->event.pid = perf_counter_pid(counter, comm_event->task);
	comm_event->event.tid = perf_counter_tid(counter, comm_event->task);

2994 2995 2996 2997 2998 2999
	perf_output_put(&handle, comm_event->event);
	perf_output_copy(&handle, comm_event->comm,
				   comm_event->comm_size);
	perf_output_end(&handle);
}

3000
static int perf_counter_comm_match(struct perf_counter *counter)
3001
{
3002
	if (counter->attr.comm)
3003 3004 3005 3006 3007 3008 3009 3010 3011 3012 3013 3014 3015 3016 3017
		return 1;

	return 0;
}

static void perf_counter_comm_ctx(struct perf_counter_context *ctx,
				  struct perf_comm_event *comm_event)
{
	struct perf_counter *counter;

	if (system_state != SYSTEM_RUNNING || list_empty(&ctx->event_list))
		return;

	rcu_read_lock();
	list_for_each_entry_rcu(counter, &ctx->event_list, event_entry) {
3018
		if (perf_counter_comm_match(counter))
3019 3020 3021 3022 3023 3024 3025 3026
			perf_counter_comm_output(counter, comm_event);
	}
	rcu_read_unlock();
}

static void perf_counter_comm_event(struct perf_comm_event *comm_event)
{
	struct perf_cpu_context *cpuctx;
3027
	struct perf_counter_context *ctx;
3028
	unsigned int size;
3029
	char comm[TASK_COMM_LEN];
3030

3031 3032
	memset(comm, 0, sizeof(comm));
	strncpy(comm, comm_event->task->comm, sizeof(comm));
3033
	size = ALIGN(strlen(comm)+1, sizeof(u64));
3034 3035 3036 3037 3038 3039 3040 3041 3042

	comm_event->comm = comm;
	comm_event->comm_size = size;

	comm_event->event.header.size = sizeof(comm_event->event) + size;

	cpuctx = &get_cpu_var(perf_cpu_context);
	perf_counter_comm_ctx(&cpuctx->ctx, comm_event);
	put_cpu_var(perf_cpu_context);
3043 3044 3045 3046 3047 3048 3049 3050 3051 3052

	rcu_read_lock();
	/*
	 * doesn't really matter which of the child contexts the
	 * events ends up in.
	 */
	ctx = rcu_dereference(current->perf_counter_ctxp);
	if (ctx)
		perf_counter_comm_ctx(ctx, comm_event);
	rcu_read_unlock();
3053 3054 3055 3056
}

void perf_counter_comm(struct task_struct *task)
{
3057 3058
	struct perf_comm_event comm_event;

3059 3060 3061
	if (task->perf_counter_ctxp)
		perf_counter_enable_on_exec(task);

3062
	if (!atomic_read(&nr_comm_counters))
3063
		return;
3064

3065
	comm_event = (struct perf_comm_event){
3066
		.task	= task,
3067 3068
		/* .comm      */
		/* .comm_size */
3069
		.event  = {
3070 3071 3072 3073 3074 3075 3076
			.header = {
				.type = PERF_EVENT_COMM,
				.misc = 0,
				/* .size */
			},
			/* .pid */
			/* .tid */
3077 3078 3079 3080 3081 3082
		},
	};

	perf_counter_comm_event(&comm_event);
}

3083 3084 3085 3086 3087
/*
 * mmap tracking
 */

struct perf_mmap_event {
3088 3089 3090 3091
	struct vm_area_struct	*vma;

	const char		*file_name;
	int			file_size;
3092 3093 3094 3095 3096 3097 3098 3099 3100 3101 3102 3103 3104 3105 3106 3107 3108

	struct {
		struct perf_event_header	header;

		u32				pid;
		u32				tid;
		u64				start;
		u64				len;
		u64				pgoff;
	} event;
};

static void perf_counter_mmap_output(struct perf_counter *counter,
				     struct perf_mmap_event *mmap_event)
{
	struct perf_output_handle handle;
	int size = mmap_event->event.header.size;
3109
	int ret = perf_output_begin(&handle, counter, size, 0, 0);
3110 3111 3112 3113

	if (ret)
		return;

3114 3115 3116
	mmap_event->event.pid = perf_counter_pid(counter, current);
	mmap_event->event.tid = perf_counter_tid(counter, current);

3117 3118 3119
	perf_output_put(&handle, mmap_event->event);
	perf_output_copy(&handle, mmap_event->file_name,
				   mmap_event->file_size);
3120
	perf_output_end(&handle);
3121 3122 3123 3124 3125
}

static int perf_counter_mmap_match(struct perf_counter *counter,
				   struct perf_mmap_event *mmap_event)
{
3126
	if (counter->attr.mmap)
3127 3128 3129 3130 3131 3132 3133 3134 3135 3136 3137 3138 3139 3140 3141 3142 3143 3144 3145 3146 3147 3148 3149 3150
		return 1;

	return 0;
}

static void perf_counter_mmap_ctx(struct perf_counter_context *ctx,
				  struct perf_mmap_event *mmap_event)
{
	struct perf_counter *counter;

	if (system_state != SYSTEM_RUNNING || list_empty(&ctx->event_list))
		return;

	rcu_read_lock();
	list_for_each_entry_rcu(counter, &ctx->event_list, event_entry) {
		if (perf_counter_mmap_match(counter, mmap_event))
			perf_counter_mmap_output(counter, mmap_event);
	}
	rcu_read_unlock();
}

static void perf_counter_mmap_event(struct perf_mmap_event *mmap_event)
{
	struct perf_cpu_context *cpuctx;
3151
	struct perf_counter_context *ctx;
3152 3153
	struct vm_area_struct *vma = mmap_event->vma;
	struct file *file = vma->vm_file;
3154 3155 3156
	unsigned int size;
	char tmp[16];
	char *buf = NULL;
3157
	const char *name;
3158

3159 3160
	memset(tmp, 0, sizeof(tmp));

3161
	if (file) {
3162 3163 3164 3165 3166 3167
		/*
		 * d_path works from the end of the buffer backwards, so we
		 * need to add enough zero bytes after the string to handle
		 * the 64bit alignment we do later.
		 */
		buf = kzalloc(PATH_MAX + sizeof(u64), GFP_KERNEL);
3168 3169 3170 3171
		if (!buf) {
			name = strncpy(tmp, "//enomem", sizeof(tmp));
			goto got_name;
		}
3172
		name = d_path(&file->f_path, buf, PATH_MAX);
3173 3174 3175 3176 3177
		if (IS_ERR(name)) {
			name = strncpy(tmp, "//toolong", sizeof(tmp));
			goto got_name;
		}
	} else {
3178 3179 3180
		if (arch_vma_name(mmap_event->vma)) {
			name = strncpy(tmp, arch_vma_name(mmap_event->vma),
				       sizeof(tmp));
3181
			goto got_name;
3182
		}
3183 3184 3185 3186 3187 3188

		if (!vma->vm_mm) {
			name = strncpy(tmp, "[vdso]", sizeof(tmp));
			goto got_name;
		}

3189 3190 3191 3192 3193
		name = strncpy(tmp, "//anon", sizeof(tmp));
		goto got_name;
	}

got_name:
3194
	size = ALIGN(strlen(name)+1, sizeof(u64));
3195 3196 3197 3198 3199 3200 3201 3202 3203 3204

	mmap_event->file_name = name;
	mmap_event->file_size = size;

	mmap_event->event.header.size = sizeof(mmap_event->event) + size;

	cpuctx = &get_cpu_var(perf_cpu_context);
	perf_counter_mmap_ctx(&cpuctx->ctx, mmap_event);
	put_cpu_var(perf_cpu_context);

3205 3206 3207 3208 3209 3210 3211 3212 3213 3214
	rcu_read_lock();
	/*
	 * doesn't really matter which of the child contexts the
	 * events ends up in.
	 */
	ctx = rcu_dereference(current->perf_counter_ctxp);
	if (ctx)
		perf_counter_mmap_ctx(ctx, mmap_event);
	rcu_read_unlock();

3215 3216 3217
	kfree(buf);
}

3218
void __perf_counter_mmap(struct vm_area_struct *vma)
3219
{
3220 3221
	struct perf_mmap_event mmap_event;

3222
	if (!atomic_read(&nr_mmap_counters))
3223 3224 3225
		return;

	mmap_event = (struct perf_mmap_event){
3226
		.vma	= vma,
3227 3228
		/* .file_name */
		/* .file_size */
3229
		.event  = {
3230 3231 3232 3233 3234 3235 3236
			.header = {
				.type = PERF_EVENT_MMAP,
				.misc = 0,
				/* .size */
			},
			/* .pid */
			/* .tid */
3237 3238 3239
			.start  = vma->vm_start,
			.len    = vma->vm_end - vma->vm_start,
			.pgoff  = vma->vm_pgoff,
3240 3241 3242 3243 3244 3245
		},
	};

	perf_counter_mmap_event(&mmap_event);
}

3246 3247 3248 3249 3250 3251 3252 3253 3254 3255 3256 3257
/*
 * IRQ throttle logging
 */

static void perf_log_throttle(struct perf_counter *counter, int enable)
{
	struct perf_output_handle handle;
	int ret;

	struct {
		struct perf_event_header	header;
		u64				time;
3258
		u64				id;
3259
		u64				stream_id;
3260 3261
	} throttle_event = {
		.header = {
3262
			.type = PERF_EVENT_THROTTLE,
3263 3264 3265
			.misc = 0,
			.size = sizeof(throttle_event),
		},
3266 3267 3268
		.time		= sched_clock(),
		.id		= primary_counter_id(counter),
		.stream_id	= counter->id,
3269 3270
	};

3271 3272 3273
	if (enable)
		throttle_event.header.type = PERF_EVENT_UNTHROTTLE;

3274
	ret = perf_output_begin(&handle, counter, sizeof(throttle_event), 1, 0);
3275 3276 3277 3278 3279 3280 3281
	if (ret)
		return;

	perf_output_put(&handle, throttle_event);
	perf_output_end(&handle);
}

3282
/*
3283
 * Generic counter overflow handling, sampling.
3284 3285
 */

3286 3287
int perf_counter_overflow(struct perf_counter *counter, int nmi,
			  struct perf_sample_data *data)
3288
{
3289
	int events = atomic_read(&counter->event_limit);
3290
	int throttle = counter->pmu->unthrottle != NULL;
3291
	struct hw_perf_counter *hwc = &counter->hw;
3292 3293
	int ret = 0;

3294
	if (!throttle) {
3295
		hwc->interrupts++;
3296
	} else {
3297 3298
		if (hwc->interrupts != MAX_INTERRUPTS) {
			hwc->interrupts++;
3299 3300
			if (HZ * hwc->interrupts >
					(u64)sysctl_perf_counter_sample_rate) {
3301
				hwc->interrupts = MAX_INTERRUPTS;
3302 3303 3304 3305 3306 3307 3308 3309 3310
				perf_log_throttle(counter, 0);
				ret = 1;
			}
		} else {
			/*
			 * Keep re-disabling counters even though on the previous
			 * pass we disabled it - just in case we raced with a
			 * sched-in and the counter got enabled again:
			 */
3311 3312 3313
			ret = 1;
		}
	}
3314

3315 3316 3317 3318 3319 3320 3321 3322 3323 3324
	if (counter->attr.freq) {
		u64 now = sched_clock();
		s64 delta = now - hwc->freq_stamp;

		hwc->freq_stamp = now;

		if (delta > 0 && delta < TICK_NSEC)
			perf_adjust_period(counter, NSEC_PER_SEC / (int)delta);
	}

3325 3326 3327 3328 3329
	/*
	 * XXX event_limit might not quite work as expected on inherited
	 * counters
	 */

3330
	counter->pending_kill = POLL_IN;
3331 3332
	if (events && atomic_dec_and_test(&counter->event_limit)) {
		ret = 1;
3333
		counter->pending_kill = POLL_HUP;
3334 3335 3336 3337 3338 3339 3340 3341
		if (nmi) {
			counter->pending_disable = 1;
			perf_pending_queue(&counter->pending,
					   perf_pending_counter);
		} else
			perf_counter_disable(counter);
	}

3342
	perf_counter_output(counter, nmi, data);
3343
	return ret;
3344 3345
}

3346 3347 3348 3349
/*
 * Generic software counter infrastructure
 */

3350 3351 3352 3353 3354 3355 3356 3357
/*
 * We directly increment counter->count and keep a second value in
 * counter->hw.period_left to count intervals. This period counter
 * is kept in the range [-sample_period, 0] so that we can use the
 * sign as trigger.
 */

static u64 perf_swcounter_set_period(struct perf_counter *counter)
3358 3359
{
	struct hw_perf_counter *hwc = &counter->hw;
3360 3361 3362 3363 3364
	u64 period = hwc->last_period;
	u64 nr, offset;
	s64 old, val;

	hwc->last_period = hwc->sample_period;
3365 3366

again:
3367 3368 3369
	old = val = atomic64_read(&hwc->period_left);
	if (val < 0)
		return 0;
3370

3371 3372 3373 3374 3375
	nr = div64_u64(period + val, period);
	offset = nr * period;
	val -= offset;
	if (atomic64_cmpxchg(&hwc->period_left, old, val) != old)
		goto again;
3376

3377
	return nr;
3378 3379
}

3380 3381
static void perf_swcounter_overflow(struct perf_counter *counter,
				    int nmi, struct perf_sample_data *data)
3382 3383
{
	struct hw_perf_counter *hwc = &counter->hw;
3384
	u64 overflow;
3385

3386 3387
	data->period = counter->hw.last_period;
	overflow = perf_swcounter_set_period(counter);
3388

3389 3390
	if (hwc->interrupts == MAX_INTERRUPTS)
		return;
3391

3392 3393 3394 3395 3396 3397 3398 3399 3400
	for (; overflow; overflow--) {
		if (perf_counter_overflow(counter, nmi, data)) {
			/*
			 * We inhibit the overflow from happening when
			 * hwc->interrupts == MAX_INTERRUPTS.
			 */
			break;
		}
	}
3401 3402
}

3403
static void perf_swcounter_unthrottle(struct perf_counter *counter)
3404 3405
{
	/*
3406
	 * Nothing to do, we already reset hwc->interrupts.
3407
	 */
3408
}
3409

3410 3411 3412 3413
static void perf_swcounter_add(struct perf_counter *counter, u64 nr,
			       int nmi, struct perf_sample_data *data)
{
	struct hw_perf_counter *hwc = &counter->hw;
3414

3415
	atomic64_add(nr, &counter->count);
3416

3417 3418
	if (!hwc->sample_period)
		return;
3419

3420 3421
	if (!data->regs)
		return;
3422

3423 3424
	if (!atomic64_add_negative(nr, &hwc->period_left))
		perf_swcounter_overflow(counter, nmi, data);
3425 3426
}

3427 3428 3429 3430 3431 3432 3433 3434 3435 3436 3437 3438 3439 3440 3441 3442 3443 3444 3445 3446 3447 3448 3449 3450 3451 3452 3453 3454 3455 3456 3457 3458 3459 3460 3461 3462 3463 3464
static int perf_swcounter_is_counting(struct perf_counter *counter)
{
	struct perf_counter_context *ctx;
	unsigned long flags;
	int count;

	if (counter->state == PERF_COUNTER_STATE_ACTIVE)
		return 1;

	if (counter->state != PERF_COUNTER_STATE_INACTIVE)
		return 0;

	/*
	 * If the counter is inactive, it could be just because
	 * its task is scheduled out, or because it's in a group
	 * which could not go on the PMU.  We want to count in
	 * the first case but not the second.  If the context is
	 * currently active then an inactive software counter must
	 * be the second case.  If it's not currently active then
	 * we need to know whether the counter was active when the
	 * context was last active, which we can determine by
	 * comparing counter->tstamp_stopped with ctx->time.
	 *
	 * We are within an RCU read-side critical section,
	 * which protects the existence of *ctx.
	 */
	ctx = counter->ctx;
	spin_lock_irqsave(&ctx->lock, flags);
	count = 1;
	/* Re-check state now we have the lock */
	if (counter->state < PERF_COUNTER_STATE_INACTIVE ||
	    counter->ctx->is_active ||
	    counter->tstamp_stopped < ctx->time)
		count = 0;
	spin_unlock_irqrestore(&ctx->lock, flags);
	return count;
}

3465
static int perf_swcounter_match(struct perf_counter *counter,
Peter Zijlstra's avatar
Peter Zijlstra committed
3466
				enum perf_type_id type,
3467
				u32 event, struct pt_regs *regs)
3468
{
3469
	if (!perf_swcounter_is_counting(counter))
3470 3471
		return 0;

3472 3473 3474
	if (counter->attr.type != type)
		return 0;
	if (counter->attr.config != event)
3475 3476
		return 0;

3477
	if (regs) {
3478
		if (counter->attr.exclude_user && user_mode(regs))
3479
			return 0;
3480

3481
		if (counter->attr.exclude_kernel && !user_mode(regs))
3482 3483
			return 0;
	}
3484 3485 3486 3487 3488

	return 1;
}

static void perf_swcounter_ctx_event(struct perf_counter_context *ctx,
3489 3490 3491
				     enum perf_type_id type,
				     u32 event, u64 nr, int nmi,
				     struct perf_sample_data *data)
3492 3493 3494
{
	struct perf_counter *counter;

3495
	if (system_state != SYSTEM_RUNNING || list_empty(&ctx->event_list))
3496 3497
		return;

3498 3499
	rcu_read_lock();
	list_for_each_entry_rcu(counter, &ctx->event_list, event_entry) {
3500 3501
		if (perf_swcounter_match(counter, type, event, data->regs))
			perf_swcounter_add(counter, nr, nmi, data);
3502
	}
3503
	rcu_read_unlock();
3504 3505
}

3506 3507 3508 3509 3510 3511 3512 3513 3514 3515 3516 3517 3518 3519
static int *perf_swcounter_recursion_context(struct perf_cpu_context *cpuctx)
{
	if (in_nmi())
		return &cpuctx->recursion[3];

	if (in_irq())
		return &cpuctx->recursion[2];

	if (in_softirq())
		return &cpuctx->recursion[1];

	return &cpuctx->recursion[0];
}

3520 3521 3522
static void do_perf_swcounter_event(enum perf_type_id type, u32 event,
				    u64 nr, int nmi,
				    struct perf_sample_data *data)
3523 3524
{
	struct perf_cpu_context *cpuctx = &get_cpu_var(perf_cpu_context);
3525
	int *recursion = perf_swcounter_recursion_context(cpuctx);
3526
	struct perf_counter_context *ctx;
3527 3528 3529 3530 3531 3532

	if (*recursion)
		goto out;

	(*recursion)++;
	barrier();
3533

3534
	perf_swcounter_ctx_event(&cpuctx->ctx, type, event,
3535
				 nr, nmi, data);
3536 3537 3538 3539 3540 3541 3542
	rcu_read_lock();
	/*
	 * doesn't really matter which of the child contexts the
	 * events ends up in.
	 */
	ctx = rcu_dereference(current->perf_counter_ctxp);
	if (ctx)
3543
		perf_swcounter_ctx_event(ctx, type, event, nr, nmi, data);
3544
	rcu_read_unlock();
3545

3546 3547 3548 3549
	barrier();
	(*recursion)--;

out:
3550 3551 3552
	put_cpu_var(perf_cpu_context);
}

3553 3554
void __perf_swcounter_event(u32 event, u64 nr, int nmi,
			    struct pt_regs *regs, u64 addr)
3555
{
3556 3557 3558 3559 3560 3561
	struct perf_sample_data data = {
		.regs = regs,
		.addr = addr,
	};

	do_perf_swcounter_event(PERF_TYPE_SOFTWARE, event, nr, nmi, &data);
3562 3563
}

3564 3565 3566 3567 3568 3569
static void perf_swcounter_read(struct perf_counter *counter)
{
}

static int perf_swcounter_enable(struct perf_counter *counter)
{
3570 3571 3572 3573 3574 3575
	struct hw_perf_counter *hwc = &counter->hw;

	if (hwc->sample_period) {
		hwc->last_period = hwc->sample_period;
		perf_swcounter_set_period(counter);
	}
3576 3577 3578 3579 3580 3581 3582
	return 0;
}

static void perf_swcounter_disable(struct perf_counter *counter)
{
}

3583
static const struct pmu perf_ops_generic = {
3584 3585 3586
	.enable		= perf_swcounter_enable,
	.disable	= perf_swcounter_disable,
	.read		= perf_swcounter_read,
3587
	.unthrottle	= perf_swcounter_unthrottle,
3588 3589
};

3590 3591 3592 3593 3594 3595 3596 3597 3598 3599 3600 3601 3602 3603 3604 3605 3606 3607 3608 3609 3610 3611 3612 3613 3614 3615 3616 3617 3618 3619 3620 3621 3622 3623 3624
/*
 * hrtimer based swcounter callback
 */

static enum hrtimer_restart perf_swcounter_hrtimer(struct hrtimer *hrtimer)
{
	enum hrtimer_restart ret = HRTIMER_RESTART;
	struct perf_sample_data data;
	struct perf_counter *counter;
	u64 period;

	counter	= container_of(hrtimer, struct perf_counter, hw.hrtimer);
	counter->pmu->read(counter);

	data.addr = 0;
	data.regs = get_irq_regs();
	/*
	 * In case we exclude kernel IPs or are somehow not in interrupt
	 * context, provide the next best thing, the user IP.
	 */
	if ((counter->attr.exclude_kernel || !data.regs) &&
			!counter->attr.exclude_user)
		data.regs = task_pt_regs(current);

	if (data.regs) {
		if (perf_counter_overflow(counter, 0, &data))
			ret = HRTIMER_NORESTART;
	}

	period = max_t(u64, 10000, counter->hw.sample_period);
	hrtimer_forward_now(hrtimer, ns_to_ktime(period));

	return ret;
}

3625 3626 3627 3628
/*
 * Software counter: cpu wall time clock
 */

3629 3630 3631 3632 3633 3634 3635 3636 3637 3638 3639 3640
static void cpu_clock_perf_counter_update(struct perf_counter *counter)
{
	int cpu = raw_smp_processor_id();
	s64 prev;
	u64 now;

	now = cpu_clock(cpu);
	prev = atomic64_read(&counter->hw.prev_count);
	atomic64_set(&counter->hw.prev_count, now);
	atomic64_add(now - prev, &counter->count);
}

3641 3642 3643 3644 3645 3646
static int cpu_clock_perf_counter_enable(struct perf_counter *counter)
{
	struct hw_perf_counter *hwc = &counter->hw;
	int cpu = raw_smp_processor_id();

	atomic64_set(&hwc->prev_count, cpu_clock(cpu));
3647 3648
	hrtimer_init(&hwc->hrtimer, CLOCK_MONOTONIC, HRTIMER_MODE_REL);
	hwc->hrtimer.function = perf_swcounter_hrtimer;
3649 3650
	if (hwc->sample_period) {
		u64 period = max_t(u64, 10000, hwc->sample_period);
3651
		__hrtimer_start_range_ns(&hwc->hrtimer,
3652
				ns_to_ktime(period), 0,
3653 3654 3655 3656 3657 3658
				HRTIMER_MODE_REL, 0);
	}

	return 0;
}

3659 3660
static void cpu_clock_perf_counter_disable(struct perf_counter *counter)
{
3661
	if (counter->hw.sample_period)
3662
		hrtimer_cancel(&counter->hw.hrtimer);
3663
	cpu_clock_perf_counter_update(counter);
3664 3665 3666 3667
}

static void cpu_clock_perf_counter_read(struct perf_counter *counter)
{
3668
	cpu_clock_perf_counter_update(counter);
3669 3670
}

3671
static const struct pmu perf_ops_cpu_clock = {
Ingo Molnar's avatar
Ingo Molnar committed
3672 3673 3674
	.enable		= cpu_clock_perf_counter_enable,
	.disable	= cpu_clock_perf_counter_disable,
	.read		= cpu_clock_perf_counter_read,
3675 3676
};

3677 3678 3679 3680
/*
 * Software counter: task time clock
 */

3681
static void task_clock_perf_counter_update(struct perf_counter *counter, u64 now)
3682
{
3683
	u64 prev;
3684 3685
	s64 delta;

3686
	prev = atomic64_xchg(&counter->hw.prev_count, now);
3687 3688
	delta = now - prev;
	atomic64_add(delta, &counter->count);
3689 3690
}

3691
static int task_clock_perf_counter_enable(struct perf_counter *counter)
3692
{
3693
	struct hw_perf_counter *hwc = &counter->hw;
3694 3695 3696
	u64 now;

	now = counter->ctx->time;
3697

3698
	atomic64_set(&hwc->prev_count, now);
3699 3700
	hrtimer_init(&hwc->hrtimer, CLOCK_MONOTONIC, HRTIMER_MODE_REL);
	hwc->hrtimer.function = perf_swcounter_hrtimer;
3701 3702
	if (hwc->sample_period) {
		u64 period = max_t(u64, 10000, hwc->sample_period);
3703
		__hrtimer_start_range_ns(&hwc->hrtimer,
3704
				ns_to_ktime(period), 0,
3705 3706
				HRTIMER_MODE_REL, 0);
	}
3707 3708

	return 0;
3709 3710 3711
}

static void task_clock_perf_counter_disable(struct perf_counter *counter)
3712
{
3713
	if (counter->hw.sample_period)
3714
		hrtimer_cancel(&counter->hw.hrtimer);
3715 3716
	task_clock_perf_counter_update(counter, counter->ctx->time);

3717
}
3718

3719 3720
static void task_clock_perf_counter_read(struct perf_counter *counter)
{
3721 3722 3723 3724 3725 3726 3727 3728 3729 3730 3731 3732
	u64 time;

	if (!in_nmi()) {
		update_context_time(counter->ctx);
		time = counter->ctx->time;
	} else {
		u64 now = perf_clock();
		u64 delta = now - counter->ctx->timestamp;
		time = counter->ctx->time + delta;
	}

	task_clock_perf_counter_update(counter, time);
3733 3734
}

3735
static const struct pmu perf_ops_task_clock = {
Ingo Molnar's avatar
Ingo Molnar committed
3736 3737 3738
	.enable		= task_clock_perf_counter_enable,
	.disable	= task_clock_perf_counter_disable,
	.read		= task_clock_perf_counter_read,
3739 3740
};

3741
#ifdef CONFIG_EVENT_PROFILE
3742 3743
void perf_tpcounter_event(int event_id, u64 addr, u64 count, void *record,
			  int entry_size)
3744
{
3745
	struct perf_raw_record raw = {
3746
		.size = entry_size,
3747
		.data = record,
3748 3749
	};

3750
	struct perf_sample_data data = {
3751
		.regs = get_irq_regs(),
3752
		.addr = addr,
3753
		.raw = &raw,
3754
	};
3755

3756 3757
	if (!data.regs)
		data.regs = task_pt_regs(current);
3758

3759
	do_perf_swcounter_event(PERF_TYPE_TRACEPOINT, event_id, count, 1, &data);
3760
}
3761
EXPORT_SYMBOL_GPL(perf_tpcounter_event);
3762 3763 3764 3765 3766 3767

extern int ftrace_profile_enable(int);
extern void ftrace_profile_disable(int);

static void tp_perf_counter_destroy(struct perf_counter *counter)
{
3768
	ftrace_profile_disable(counter->attr.config);
3769 3770
}

3771
static const struct pmu *tp_perf_counter_init(struct perf_counter *counter)
3772
{
3773
	if (ftrace_profile_enable(counter->attr.config))
3774 3775 3776 3777 3778 3779 3780
		return NULL;

	counter->destroy = tp_perf_counter_destroy;

	return &perf_ops_generic;
}
#else
3781
static const struct pmu *tp_perf_counter_init(struct perf_counter *counter)
3782 3783 3784 3785 3786
{
	return NULL;
}
#endif

3787 3788 3789 3790 3791 3792
atomic_t perf_swcounter_enabled[PERF_COUNT_SW_MAX];

static void sw_perf_counter_destroy(struct perf_counter *counter)
{
	u64 event = counter->attr.config;

3793 3794
	WARN_ON(counter->parent);

3795 3796 3797
	atomic_dec(&perf_swcounter_enabled[event]);
}

3798
static const struct pmu *sw_perf_counter_init(struct perf_counter *counter)
3799
{
3800
	const struct pmu *pmu = NULL;
3801
	u64 event = counter->attr.config;
3802

3803 3804 3805 3806 3807 3808 3809
	/*
	 * Software counters (currently) can't in general distinguish
	 * between user, kernel and hypervisor events.
	 * However, context switches and cpu migrations are considered
	 * to be kernel events, and page faults are never hypervisor
	 * events.
	 */
3810
	switch (event) {
3811
	case PERF_COUNT_SW_CPU_CLOCK:
3812
		pmu = &perf_ops_cpu_clock;
3813

3814
		break;
3815
	case PERF_COUNT_SW_TASK_CLOCK:
3816 3817 3818 3819 3820
		/*
		 * If the user instantiates this as a per-cpu counter,
		 * use the cpu_clock counter instead.
		 */
		if (counter->ctx->task)
3821
			pmu = &perf_ops_task_clock;
3822
		else
3823
			pmu = &perf_ops_cpu_clock;
3824

3825
		break;
3826 3827 3828 3829 3830
	case PERF_COUNT_SW_PAGE_FAULTS:
	case PERF_COUNT_SW_PAGE_FAULTS_MIN:
	case PERF_COUNT_SW_PAGE_FAULTS_MAJ:
	case PERF_COUNT_SW_CONTEXT_SWITCHES:
	case PERF_COUNT_SW_CPU_MIGRATIONS:
3831 3832 3833 3834
		if (!counter->parent) {
			atomic_inc(&perf_swcounter_enabled[event]);
			counter->destroy = sw_perf_counter_destroy;
		}
3835
		pmu = &perf_ops_generic;
3836
		break;
3837
	}
3838

3839
	return pmu;
3840 3841
}

3842 3843 3844 3845
/*
 * Allocate and initialize a counter structure
 */
static struct perf_counter *
3846
perf_counter_alloc(struct perf_counter_attr *attr,
3847
		   int cpu,
3848
		   struct perf_counter_context *ctx,
3849
		   struct perf_counter *group_leader,
3850
		   struct perf_counter *parent_counter,
3851
		   gfp_t gfpflags)
3852
{
3853
	const struct pmu *pmu;
Ingo Molnar's avatar
Ingo Molnar committed
3854
	struct perf_counter *counter;
3855
	struct hw_perf_counter *hwc;
3856
	long err;
3857

3858
	counter = kzalloc(sizeof(*counter), gfpflags);
3859
	if (!counter)
3860
		return ERR_PTR(-ENOMEM);
3861

3862 3863 3864 3865 3866 3867 3868
	/*
	 * Single counters are their own group leaders, with an
	 * empty sibling list:
	 */
	if (!group_leader)
		group_leader = counter;

3869 3870 3871
	mutex_init(&counter->child_mutex);
	INIT_LIST_HEAD(&counter->child_list);

3872
	INIT_LIST_HEAD(&counter->list_entry);
3873
	INIT_LIST_HEAD(&counter->event_entry);
3874
	INIT_LIST_HEAD(&counter->sibling_list);
3875 3876
	init_waitqueue_head(&counter->waitq);

3877 3878
	mutex_init(&counter->mmap_mutex);

3879
	counter->cpu		= cpu;
3880
	counter->attr		= *attr;
3881 3882 3883 3884 3885
	counter->group_leader	= group_leader;
	counter->pmu		= NULL;
	counter->ctx		= ctx;
	counter->oncpu		= -1;

3886 3887
	counter->parent		= parent_counter;

3888 3889 3890 3891
	counter->ns		= get_pid_ns(current->nsproxy->pid_ns);
	counter->id		= atomic64_inc_return(&perf_counter_id);

	counter->state		= PERF_COUNTER_STATE_INACTIVE;
3892

3893
	if (attr->disabled)
3894 3895
		counter->state = PERF_COUNTER_STATE_OFF;

3896
	pmu = NULL;
3897

3898
	hwc = &counter->hw;
3899
	hwc->sample_period = attr->sample_period;
3900
	if (attr->freq && attr->sample_freq)
3901 3902 3903
		hwc->sample_period = 1;

	atomic64_set(&hwc->period_left, hwc->sample_period);
3904

3905
	/*
3906
	 * we currently do not support PERF_SAMPLE_GROUP on inherited counters
3907
	 */
3908
	if (attr->inherit && (attr->sample_type & PERF_SAMPLE_GROUP))
3909 3910
		goto done;

3911
	switch (attr->type) {
3912
	case PERF_TYPE_RAW:
3913
	case PERF_TYPE_HARDWARE:
3914
	case PERF_TYPE_HW_CACHE:
3915
		pmu = hw_perf_counter_init(counter);
3916 3917 3918
		break;

	case PERF_TYPE_SOFTWARE:
3919
		pmu = sw_perf_counter_init(counter);
3920 3921 3922
		break;

	case PERF_TYPE_TRACEPOINT:
3923
		pmu = tp_perf_counter_init(counter);
3924
		break;
3925 3926 3927

	default:
		break;
3928
	}
3929 3930
done:
	err = 0;
3931
	if (!pmu)
3932
		err = -EINVAL;
3933 3934
	else if (IS_ERR(pmu))
		err = PTR_ERR(pmu);
3935

3936
	if (err) {
3937 3938
		if (counter->ns)
			put_pid_ns(counter->ns);
Ingo Molnar's avatar
Ingo Molnar committed
3939
		kfree(counter);
3940
		return ERR_PTR(err);
Ingo Molnar's avatar
Ingo Molnar committed
3941
	}
3942

3943
	counter->pmu = pmu;
3944

3945 3946 3947 3948 3949 3950
	if (!counter->parent) {
		atomic_inc(&nr_counters);
		if (counter->attr.mmap)
			atomic_inc(&nr_mmap_counters);
		if (counter->attr.comm)
			atomic_inc(&nr_comm_counters);
3951 3952
		if (counter->attr.task)
			atomic_inc(&nr_task_counters);
3953
	}
3954

3955 3956 3957
	return counter;
}

3958 3959 3960 3961 3962 3963 3964 3965 3966 3967 3968 3969 3970 3971 3972 3973 3974 3975 3976 3977 3978 3979 3980 3981 3982 3983 3984 3985 3986 3987 3988 3989 3990 3991 3992 3993 3994 3995 3996 3997 3998 3999 4000 4001 4002 4003 4004 4005 4006 4007 4008 4009 4010 4011 4012 4013 4014 4015 4016 4017 4018 4019 4020 4021 4022 4023 4024 4025 4026 4027 4028 4029 4030 4031 4032 4033 4034 4035 4036
static int perf_copy_attr(struct perf_counter_attr __user *uattr,
			  struct perf_counter_attr *attr)
{
	int ret;
	u32 size;

	if (!access_ok(VERIFY_WRITE, uattr, PERF_ATTR_SIZE_VER0))
		return -EFAULT;

	/*
	 * zero the full structure, so that a short copy will be nice.
	 */
	memset(attr, 0, sizeof(*attr));

	ret = get_user(size, &uattr->size);
	if (ret)
		return ret;

	if (size > PAGE_SIZE)	/* silly large */
		goto err_size;

	if (!size)		/* abi compat */
		size = PERF_ATTR_SIZE_VER0;

	if (size < PERF_ATTR_SIZE_VER0)
		goto err_size;

	/*
	 * If we're handed a bigger struct than we know of,
	 * ensure all the unknown bits are 0.
	 */
	if (size > sizeof(*attr)) {
		unsigned long val;
		unsigned long __user *addr;
		unsigned long __user *end;

		addr = PTR_ALIGN((void __user *)uattr + sizeof(*attr),
				sizeof(unsigned long));
		end  = PTR_ALIGN((void __user *)uattr + size,
				sizeof(unsigned long));

		for (; addr < end; addr += sizeof(unsigned long)) {
			ret = get_user(val, addr);
			if (ret)
				return ret;
			if (val)
				goto err_size;
		}
	}

	ret = copy_from_user(attr, uattr, size);
	if (ret)
		return -EFAULT;

	/*
	 * If the type exists, the corresponding creation will verify
	 * the attr->config.
	 */
	if (attr->type >= PERF_TYPE_MAX)
		return -EINVAL;

	if (attr->__reserved_1 || attr->__reserved_2 || attr->__reserved_3)
		return -EINVAL;

	if (attr->sample_type & ~(PERF_SAMPLE_MAX-1))
		return -EINVAL;

	if (attr->read_format & ~(PERF_FORMAT_MAX-1))
		return -EINVAL;

out:
	return ret;

err_size:
	put_user(sizeof(*attr), &uattr->size);
	ret = -E2BIG;
	goto out;
}

4037
/**
4038
 * sys_perf_counter_open - open a performance counter, associate it to a task/cpu
4039
 *
4040
 * @attr_uptr:	event type attributes for monitoring/sampling
4041
 * @pid:		target pid
4042 4043
 * @cpu:		target cpu
 * @group_fd:		group leader counter fd
4044
 */
4045
SYSCALL_DEFINE5(perf_counter_open,
4046
		struct perf_counter_attr __user *, attr_uptr,
4047
		pid_t, pid, int, cpu, int, group_fd, unsigned long, flags)
4048
{
4049
	struct perf_counter *counter, *group_leader;
4050
	struct perf_counter_attr attr;
4051
	struct perf_counter_context *ctx;
4052
	struct file *counter_file = NULL;
4053 4054
	struct file *group_file = NULL;
	int fput_needed = 0;
4055
	int fput_needed2 = 0;
4056 4057
	int ret;

4058 4059 4060 4061
	/* for future expandability... */
	if (flags)
		return -EINVAL;

4062 4063 4064
	ret = perf_copy_attr(attr_uptr, &attr);
	if (ret)
		return ret;
4065

4066 4067 4068 4069 4070
	if (!attr.exclude_kernel) {
		if (perf_paranoid_kernel() && !capable(CAP_SYS_ADMIN))
			return -EACCES;
	}

4071 4072 4073 4074 4075
	if (attr.freq) {
		if (attr.sample_freq > sysctl_perf_counter_sample_rate)
			return -EINVAL;
	}

4076
	/*
4077 4078 4079 4080 4081 4082 4083 4084
	 * Get the target context (task or percpu):
	 */
	ctx = find_get_context(pid, cpu);
	if (IS_ERR(ctx))
		return PTR_ERR(ctx);

	/*
	 * Look up the group leader (we will attach this counter to it):
4085 4086 4087 4088 4089 4090
	 */
	group_leader = NULL;
	if (group_fd != -1) {
		ret = -EINVAL;
		group_file = fget_light(group_fd, &fput_needed);
		if (!group_file)
4091
			goto err_put_context;
4092
		if (group_file->f_op != &perf_fops)
4093
			goto err_put_context;
4094 4095 4096

		group_leader = group_file->private_data;
		/*
4097 4098 4099 4100 4101 4102 4103 4104
		 * Do not allow a recursive hierarchy (this new sibling
		 * becoming part of another group-sibling):
		 */
		if (group_leader->group_leader != group_leader)
			goto err_put_context;
		/*
		 * Do not allow to attach to a group in a different
		 * task or CPU context:
4105
		 */
4106 4107
		if (group_leader->ctx != ctx)
			goto err_put_context;
4108 4109 4110
		/*
		 * Only a group leader can be exclusive or pinned
		 */
4111
		if (attr.exclusive || attr.pinned)
4112
			goto err_put_context;
4113 4114
	}

4115
	counter = perf_counter_alloc(&attr, cpu, ctx, group_leader,
4116
				     NULL, GFP_KERNEL);
4117 4118
	ret = PTR_ERR(counter);
	if (IS_ERR(counter))
4119 4120 4121 4122
		goto err_put_context;

	ret = anon_inode_getfd("[perf_counter]", &perf_fops, counter, 0);
	if (ret < 0)
4123 4124 4125 4126 4127 4128 4129
		goto err_free_put_context;

	counter_file = fget_light(ret, &fput_needed2);
	if (!counter_file)
		goto err_free_put_context;

	counter->filp = counter_file;
4130
	WARN_ON_ONCE(ctx->parent_ctx);
4131
	mutex_lock(&ctx->mutex);
4132
	perf_install_in_context(ctx, counter, cpu);
4133
	++ctx->generation;
4134
	mutex_unlock(&ctx->mutex);
4135

4136 4137 4138 4139 4140 4141
	counter->owner = current;
	get_task_struct(current);
	mutex_lock(&current->perf_counter_mutex);
	list_add_tail(&counter->owner_entry, &current->perf_counter_list);
	mutex_unlock(&current->perf_counter_mutex);

4142
	fput_light(counter_file, fput_needed2);
4143

4144 4145 4146
out_fput:
	fput_light(group_file, fput_needed);

4147 4148
	return ret;

4149
err_free_put_context:
4150 4151 4152
	kfree(counter);

err_put_context:
4153
	put_ctx(ctx);
4154

4155
	goto out_fput;
4156 4157
}

4158 4159 4160
/*
 * inherit a counter from parent task to child task:
 */
4161
static struct perf_counter *
4162 4163 4164 4165
inherit_counter(struct perf_counter *parent_counter,
	      struct task_struct *parent,
	      struct perf_counter_context *parent_ctx,
	      struct task_struct *child,
4166
	      struct perf_counter *group_leader,
4167 4168 4169 4170
	      struct perf_counter_context *child_ctx)
{
	struct perf_counter *child_counter;

4171 4172 4173 4174 4175 4176 4177 4178 4179
	/*
	 * Instead of creating recursive hierarchies of counters,
	 * we link inherited counters back to the original parent,
	 * which has a filp for sure, which we use as the reference
	 * count:
	 */
	if (parent_counter->parent)
		parent_counter = parent_counter->parent;

4180
	child_counter = perf_counter_alloc(&parent_counter->attr,
4181
					   parent_counter->cpu, child_ctx,
4182 4183
					   group_leader, parent_counter,
					   GFP_KERNEL);
4184 4185
	if (IS_ERR(child_counter))
		return child_counter;
4186
	get_ctx(child_ctx);
4187

4188 4189
	/*
	 * Make the child state follow the state of the parent counter,
4190
	 * not its attr.disabled bit.  We hold the parent's mutex,
4191
	 * so we won't race with perf_counter_{en, dis}able_family.
4192 4193 4194 4195 4196 4197
	 */
	if (parent_counter->state >= PERF_COUNTER_STATE_INACTIVE)
		child_counter->state = PERF_COUNTER_STATE_INACTIVE;
	else
		child_counter->state = PERF_COUNTER_STATE_OFF;

4198 4199 4200
	if (parent_counter->attr.freq)
		child_counter->hw.sample_period = parent_counter->hw.sample_period;

4201 4202 4203
	/*
	 * Link it up in the child's context:
	 */
4204
	add_counter_to_ctx(child_counter, child_ctx);
4205 4206 4207 4208 4209 4210 4211 4212 4213

	/*
	 * Get a reference to the parent filp - we will fput it
	 * when the child counter exits. This is safe to do because
	 * we are in the parent and we know that the filp still
	 * exists and has a nonzero count:
	 */
	atomic_long_inc(&parent_counter->filp->f_count);

4214 4215 4216
	/*
	 * Link this into the parent counter's child list
	 */
4217
	WARN_ON_ONCE(parent_counter->ctx->parent_ctx);
4218
	mutex_lock(&parent_counter->child_mutex);
4219
	list_add_tail(&child_counter->child_list, &parent_counter->child_list);
4220
	mutex_unlock(&parent_counter->child_mutex);
4221 4222 4223 4224 4225 4226 4227 4228 4229 4230 4231 4232

	return child_counter;
}

static int inherit_group(struct perf_counter *parent_counter,
	      struct task_struct *parent,
	      struct perf_counter_context *parent_ctx,
	      struct task_struct *child,
	      struct perf_counter_context *child_ctx)
{
	struct perf_counter *leader;
	struct perf_counter *sub;
4233
	struct perf_counter *child_ctr;
4234 4235 4236

	leader = inherit_counter(parent_counter, parent, parent_ctx,
				 child, NULL, child_ctx);
4237 4238
	if (IS_ERR(leader))
		return PTR_ERR(leader);
4239
	list_for_each_entry(sub, &parent_counter->sibling_list, list_entry) {
4240 4241 4242 4243
		child_ctr = inherit_counter(sub, parent, parent_ctx,
					    child, leader, child_ctx);
		if (IS_ERR(child_ctr))
			return PTR_ERR(child_ctr);
4244
	}
4245 4246 4247
	return 0;
}

4248
static void sync_child_counter(struct perf_counter *child_counter,
4249
			       struct task_struct *child)
4250
{
4251
	struct perf_counter *parent_counter = child_counter->parent;
4252
	u64 child_val;
4253

4254 4255
	if (child_counter->attr.inherit_stat)
		perf_counter_read_event(child_counter, child);
4256

4257 4258 4259 4260 4261 4262
	child_val = atomic64_read(&child_counter->count);

	/*
	 * Add back the child's count to the parent's count:
	 */
	atomic64_add(child_val, &parent_counter->count);
4263 4264 4265 4266
	atomic64_add(child_counter->total_time_enabled,
		     &parent_counter->child_total_time_enabled);
	atomic64_add(child_counter->total_time_running,
		     &parent_counter->child_total_time_running);
4267 4268 4269 4270

	/*
	 * Remove this counter from the parent's list
	 */
4271
	WARN_ON_ONCE(parent_counter->ctx->parent_ctx);
4272
	mutex_lock(&parent_counter->child_mutex);
4273
	list_del_init(&child_counter->child_list);
4274
	mutex_unlock(&parent_counter->child_mutex);
4275 4276 4277 4278 4279 4280 4281 4282

	/*
	 * Release the parent counter, if this was the last
	 * reference to it.
	 */
	fput(parent_counter->filp);
}

4283
static void
4284
__perf_counter_exit_task(struct perf_counter *child_counter,
4285 4286
			 struct perf_counter_context *child_ctx,
			 struct task_struct *child)
4287 4288 4289
{
	struct perf_counter *parent_counter;

4290
	update_counter_times(child_counter);
4291
	perf_counter_remove_from_context(child_counter);
4292

4293 4294 4295 4296 4297 4298
	parent_counter = child_counter->parent;
	/*
	 * It can happen that parent exits first, and has counters
	 * that are still around due to the child reference. These
	 * counters need to be zapped - but otherwise linger.
	 */
4299
	if (parent_counter) {
4300
		sync_child_counter(child_counter, child);
4301
		free_counter(child_counter);
4302
	}
4303 4304 4305
}

/*
4306
 * When a child task exits, feed back counter values to parent counters.
4307 4308 4309 4310 4311
 */
void perf_counter_exit_task(struct task_struct *child)
{
	struct perf_counter *child_counter, *tmp;
	struct perf_counter_context *child_ctx;
4312
	unsigned long flags;
4313

4314
	if (likely(!child->perf_counter_ctxp)) {
4315
		perf_counter_task(child, NULL, 0);
4316
		return;
4317
	}
4318

4319
	local_irq_save(flags);
4320 4321 4322 4323 4324 4325 4326
	/*
	 * We can't reschedule here because interrupts are disabled,
	 * and either child is current or it is a task that can't be
	 * scheduled, so we are now safe from rescheduling changing
	 * our context.
	 */
	child_ctx = child->perf_counter_ctxp;
4327
	__perf_counter_task_sched_out(child_ctx);
4328 4329 4330 4331 4332 4333 4334

	/*
	 * Take the context lock here so that if find_get_context is
	 * reading child->perf_counter_ctxp, we wait until it has
	 * incremented the context's refcount before we do put_ctx below.
	 */
	spin_lock(&child_ctx->lock);
4335
	child->perf_counter_ctxp = NULL;
4336 4337 4338 4339 4340 4341
	/*
	 * If this context is a clone; unclone it so it can't get
	 * swapped to another process while we're removing all
	 * the counters from it.
	 */
	unclone_ctx(child_ctx);
4342 4343 4344 4345 4346 4347 4348
	spin_unlock_irqrestore(&child_ctx->lock, flags);

	/*
	 * Report the task dead after unscheduling the counters so that we
	 * won't get any samples after PERF_EVENT_EXIT. We can however still
	 * get a few PERF_EVENT_READ events.
	 */
4349
	perf_counter_task(child, child_ctx, 0);
4350

4351 4352 4353 4354 4355 4356 4357 4358 4359 4360 4361 4362
	/*
	 * We can recurse on the same lock type through:
	 *
	 *   __perf_counter_exit_task()
	 *     sync_child_counter()
	 *       fput(parent_counter->filp)
	 *         perf_release()
	 *           mutex_lock(&ctx->mutex)
	 *
	 * But since its the parent context it won't be the same instance.
	 */
	mutex_lock_nested(&child_ctx->mutex, SINGLE_DEPTH_NESTING);
4363

4364
again:
4365 4366
	list_for_each_entry_safe(child_counter, tmp, &child_ctx->counter_list,
				 list_entry)
4367
		__perf_counter_exit_task(child_counter, child_ctx, child);
4368 4369 4370 4371 4372 4373 4374 4375

	/*
	 * If the last counter was a group counter, it will have appended all
	 * its siblings to the list, but we obtained 'tmp' before that which
	 * will still point to the list head terminating the iteration.
	 */
	if (!list_empty(&child_ctx->counter_list))
		goto again;
4376 4377 4378 4379

	mutex_unlock(&child_ctx->mutex);

	put_ctx(child_ctx);
4380 4381
}

4382 4383 4384 4385 4386 4387 4388 4389 4390 4391 4392 4393 4394 4395 4396 4397 4398 4399 4400 4401 4402 4403 4404 4405 4406 4407 4408 4409 4410 4411 4412 4413 4414 4415 4416 4417 4418 4419
/*
 * free an unexposed, unused context as created by inheritance by
 * init_task below, used by fork() in case of fail.
 */
void perf_counter_free_task(struct task_struct *task)
{
	struct perf_counter_context *ctx = task->perf_counter_ctxp;
	struct perf_counter *counter, *tmp;

	if (!ctx)
		return;

	mutex_lock(&ctx->mutex);
again:
	list_for_each_entry_safe(counter, tmp, &ctx->counter_list, list_entry) {
		struct perf_counter *parent = counter->parent;

		if (WARN_ON_ONCE(!parent))
			continue;

		mutex_lock(&parent->child_mutex);
		list_del_init(&counter->child_list);
		mutex_unlock(&parent->child_mutex);

		fput(parent->filp);

		list_del_counter(counter, ctx);
		free_counter(counter);
	}

	if (!list_empty(&ctx->counter_list))
		goto again;

	mutex_unlock(&ctx->mutex);

	put_ctx(ctx);
}

4420 4421 4422
/*
 * Initialize the perf_counter context in task_struct
 */
4423
int perf_counter_init_task(struct task_struct *child)
4424 4425
{
	struct perf_counter_context *child_ctx, *parent_ctx;
4426
	struct perf_counter_context *cloned_ctx;
4427
	struct perf_counter *counter;
4428
	struct task_struct *parent = current;
4429
	int inherited_all = 1;
4430
	int ret = 0;
4431

4432
	child->perf_counter_ctxp = NULL;
4433

4434 4435 4436
	mutex_init(&child->perf_counter_mutex);
	INIT_LIST_HEAD(&child->perf_counter_list);

4437
	if (likely(!parent->perf_counter_ctxp))
4438 4439
		return 0;

4440 4441
	/*
	 * This is executed from the parent task context, so inherit
4442 4443
	 * counters that have been marked for cloning.
	 * First allocate and initialize a context for the child.
4444 4445
	 */

4446 4447
	child_ctx = kmalloc(sizeof(struct perf_counter_context), GFP_KERNEL);
	if (!child_ctx)
4448
		return -ENOMEM;
4449

4450 4451
	__perf_counter_init_context(child_ctx, child);
	child->perf_counter_ctxp = child_ctx;
4452
	get_task_struct(child);
4453

4454
	/*
4455 4456
	 * If the parent's context is a clone, pin it so it won't get
	 * swapped under us.
4457
	 */
4458 4459
	parent_ctx = perf_pin_task_context(parent);

4460 4461 4462 4463 4464 4465 4466
	/*
	 * No need to check if parent_ctx != NULL here; since we saw
	 * it non-NULL earlier, the only reason for it to become NULL
	 * is if we exit, and since we're currently in the middle of
	 * a fork we can't be exiting at the same time.
	 */

4467 4468 4469 4470
	/*
	 * Lock the parent list. No need to lock the child - not PID
	 * hashed yet and not running, so nobody can access it.
	 */
4471
	mutex_lock(&parent_ctx->mutex);
4472 4473 4474 4475 4476

	/*
	 * We dont have to disable NMIs - we are only looking at
	 * the list, not manipulating it:
	 */
4477 4478 4479 4480
	list_for_each_entry_rcu(counter, &parent_ctx->event_list, event_entry) {
		if (counter != counter->group_leader)
			continue;

4481
		if (!counter->attr.inherit) {
4482
			inherited_all = 0;
4483
			continue;
4484
		}
4485

4486 4487 4488
		ret = inherit_group(counter, parent, parent_ctx,
					     child, child_ctx);
		if (ret) {
4489
			inherited_all = 0;
4490
			break;
4491 4492 4493 4494 4495 4496 4497
		}
	}

	if (inherited_all) {
		/*
		 * Mark the child context as a clone of the parent
		 * context, or of whatever the parent is a clone of.
4498 4499 4500 4501
		 * Note that if the parent is a clone, it could get
		 * uncloned at any point, but that doesn't matter
		 * because the list of counters and the generation
		 * count can't have changed since we took the mutex.
4502
		 */
4503 4504 4505
		cloned_ctx = rcu_dereference(parent_ctx->parent_ctx);
		if (cloned_ctx) {
			child_ctx->parent_ctx = cloned_ctx;
4506
			child_ctx->parent_gen = parent_ctx->parent_gen;
4507 4508 4509 4510 4511
		} else {
			child_ctx->parent_ctx = parent_ctx;
			child_ctx->parent_gen = parent_ctx->generation;
		}
		get_ctx(child_ctx->parent_ctx);
4512 4513
	}

4514
	mutex_unlock(&parent_ctx->mutex);
4515

4516
	perf_unpin_context(parent_ctx);
4517

4518
	return ret;
4519 4520
}

4521
static void __cpuinit perf_counter_init_cpu(int cpu)
4522
{
4523
	struct perf_cpu_context *cpuctx;
4524

4525 4526
	cpuctx = &per_cpu(perf_cpu_context, cpu);
	__perf_counter_init_context(&cpuctx->ctx, NULL);
4527

4528
	spin_lock(&perf_resource_lock);
4529
	cpuctx->max_pertask = perf_max_counters - perf_reserved_percpu;
4530
	spin_unlock(&perf_resource_lock);
4531

4532
	hw_perf_counter_setup(cpu);
4533 4534 4535
}

#ifdef CONFIG_HOTPLUG_CPU
4536
static void __perf_counter_exit_cpu(void *info)
4537 4538 4539 4540 4541
{
	struct perf_cpu_context *cpuctx = &__get_cpu_var(perf_cpu_context);
	struct perf_counter_context *ctx = &cpuctx->ctx;
	struct perf_counter *counter, *tmp;

4542 4543
	list_for_each_entry_safe(counter, tmp, &ctx->counter_list, list_entry)
		__perf_counter_remove_from_context(counter);
4544
}
4545
static void perf_counter_exit_cpu(int cpu)
4546
{
4547 4548 4549 4550
	struct perf_cpu_context *cpuctx = &per_cpu(perf_cpu_context, cpu);
	struct perf_counter_context *ctx = &cpuctx->ctx;

	mutex_lock(&ctx->mutex);
4551
	smp_call_function_single(cpu, __perf_counter_exit_cpu, NULL, 1);
4552
	mutex_unlock(&ctx->mutex);
4553 4554
}
#else
4555
static inline void perf_counter_exit_cpu(int cpu) { }
4556 4557 4558 4559 4560 4561 4562 4563 4564 4565 4566
#endif

static int __cpuinit
perf_cpu_notify(struct notifier_block *self, unsigned long action, void *hcpu)
{
	unsigned int cpu = (long)hcpu;

	switch (action) {

	case CPU_UP_PREPARE:
	case CPU_UP_PREPARE_FROZEN:
4567
		perf_counter_init_cpu(cpu);
4568 4569
		break;

4570 4571 4572 4573 4574
	case CPU_ONLINE:
	case CPU_ONLINE_FROZEN:
		hw_perf_counter_setup_online(cpu);
		break;

4575 4576
	case CPU_DOWN_PREPARE:
	case CPU_DOWN_PREPARE_FROZEN:
4577
		perf_counter_exit_cpu(cpu);
4578 4579 4580 4581 4582 4583 4584 4585 4586
		break;

	default:
		break;
	}

	return NOTIFY_OK;
}

4587 4588 4589
/*
 * This has to have a higher priority than migration_notifier in sched.c.
 */
4590 4591
static struct notifier_block __cpuinitdata perf_cpu_nb = {
	.notifier_call		= perf_cpu_notify,
4592
	.priority		= 20,
4593 4594
};

4595
void __init perf_counter_init(void)
4596 4597 4598
{
	perf_cpu_notify(&perf_cpu_nb, (unsigned long)CPU_UP_PREPARE,
			(void *)(long)smp_processor_id());
4599 4600
	perf_cpu_notify(&perf_cpu_nb, (unsigned long)CPU_ONLINE,
			(void *)(long)smp_processor_id());
4601 4602 4603 4604 4605 4606 4607 4608 4609 4610 4611 4612 4613 4614 4615 4616 4617 4618 4619 4620 4621 4622 4623
	register_cpu_notifier(&perf_cpu_nb);
}

static ssize_t perf_show_reserve_percpu(struct sysdev_class *class, char *buf)
{
	return sprintf(buf, "%d\n", perf_reserved_percpu);
}

static ssize_t
perf_set_reserve_percpu(struct sysdev_class *class,
			const char *buf,
			size_t count)
{
	struct perf_cpu_context *cpuctx;
	unsigned long val;
	int err, cpu, mpt;

	err = strict_strtoul(buf, 10, &val);
	if (err)
		return err;
	if (val > perf_max_counters)
		return -EINVAL;

4624
	spin_lock(&perf_resource_lock);
4625 4626 4627 4628 4629 4630 4631 4632 4633
	perf_reserved_percpu = val;
	for_each_online_cpu(cpu) {
		cpuctx = &per_cpu(perf_cpu_context, cpu);
		spin_lock_irq(&cpuctx->ctx.lock);
		mpt = min(perf_max_counters - cpuctx->ctx.nr_counters,
			  perf_max_counters - perf_reserved_percpu);
		cpuctx->max_pertask = mpt;
		spin_unlock_irq(&cpuctx->ctx.lock);
	}
4634
	spin_unlock(&perf_resource_lock);
4635 4636 4637 4638 4639 4640 4641 4642 4643 4644 4645 4646 4647 4648 4649 4650 4651 4652 4653 4654 4655

	return count;
}

static ssize_t perf_show_overcommit(struct sysdev_class *class, char *buf)
{
	return sprintf(buf, "%d\n", perf_overcommit);
}

static ssize_t
perf_set_overcommit(struct sysdev_class *class, const char *buf, size_t count)
{
	unsigned long val;
	int err;

	err = strict_strtoul(buf, 10, &val);
	if (err)
		return err;
	if (val > 1)
		return -EINVAL;

4656
	spin_lock(&perf_resource_lock);
4657
	perf_overcommit = val;
4658
	spin_unlock(&perf_resource_lock);
4659 4660 4661 4662 4663 4664 4665 4666 4667 4668 4669 4670 4671 4672 4673 4674 4675 4676 4677 4678 4679 4680 4681 4682 4683 4684 4685 4686 4687 4688 4689 4690 4691 4692 4693

	return count;
}

static SYSDEV_CLASS_ATTR(
				reserve_percpu,
				0644,
				perf_show_reserve_percpu,
				perf_set_reserve_percpu
			);

static SYSDEV_CLASS_ATTR(
				overcommit,
				0644,
				perf_show_overcommit,
				perf_set_overcommit
			);

static struct attribute *perfclass_attrs[] = {
	&attr_reserve_percpu.attr,
	&attr_overcommit.attr,
	NULL
};

static struct attribute_group perfclass_attr_group = {
	.attrs			= perfclass_attrs,
	.name			= "perf_counters",
};

static int __init perf_counter_sysfs_init(void)
{
	return sysfs_create_group(&cpu_sysdev_class.kset.kobj,
				  &perfclass_attr_group);
}
device_initcall(perf_counter_sysfs_init);