nmi_int.c 16.8 KB
Newer Older
L
Linus Torvalds 已提交
1 2 3
/**
 * @file nmi_int.c
 *
4
 * @remark Copyright 2002-2009 OProfile authors
L
Linus Torvalds 已提交
5 6 7
 * @remark Read the file COPYING
 *
 * @author John Levon <levon@movementarian.org>
8
 * @author Robert Richter <robert.richter@amd.com>
9 10 11
 * @author Barry Kasindorf <barry.kasindorf@amd.com>
 * @author Jason Yeh <jason.yeh@amd.com>
 * @author Suravee Suthikulpanit <suravee.suthikulpanit@amd.com>
L
Linus Torvalds 已提交
12 13 14 15 16 17 18 19
 */

#include <linux/init.h>
#include <linux/notifier.h>
#include <linux/smp.h>
#include <linux/oprofile.h>
#include <linux/sysdev.h>
#include <linux/slab.h>
20
#include <linux/moduleparam.h>
21
#include <linux/kdebug.h>
22
#include <linux/cpu.h>
L
Linus Torvalds 已提交
23 24 25
#include <asm/nmi.h>
#include <asm/msr.h>
#include <asm/apic.h>
26

L
Linus Torvalds 已提交
27 28
#include "op_counter.h"
#include "op_x86_model.h"
29

30
static struct op_x86_model_spec *model;
31 32
static DEFINE_PER_CPU(struct op_msrs, cpu_msrs);
static DEFINE_PER_CPU(unsigned long, saved_lvtpc);
33

34 35 36
/* must be protected with get_online_cpus()/put_online_cpus(): */
static int nmi_enabled;
static int ctr_running;
L
Linus Torvalds 已提交
37

38 39
struct op_counter_config counter_config[OP_MAX_COUNTER];

40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59
/* common functions */

u64 op_x86_get_ctrl(struct op_x86_model_spec const *model,
		    struct op_counter_config *counter_config)
{
	u64 val = 0;
	u16 event = (u16)counter_config->event;

	val |= ARCH_PERFMON_EVENTSEL_INT;
	val |= counter_config->user ? ARCH_PERFMON_EVENTSEL_USR : 0;
	val |= counter_config->kernel ? ARCH_PERFMON_EVENTSEL_OS : 0;
	val |= (counter_config->unit_mask & 0xFF) << 8;
	event &= model->event_mask ? model->event_mask : 0xFF;
	val |= event & 0xFF;
	val |= (event & 0x0F00) << 24;

	return val;
}


60 61
static int profile_exceptions_notify(struct notifier_block *self,
				     unsigned long val, void *data)
L
Linus Torvalds 已提交
62
{
63 64 65
	struct die_args *args = (struct die_args *)data;
	int ret = NOTIFY_DONE;

66
	switch (val) {
67
	case DIE_NMI:
68
	case DIE_NMI_IPI:
69 70 71 72 73 74
		if (ctr_running)
			model->check_ctrs(args->regs, &__get_cpu_var(cpu_msrs));
		else if (!nmi_enabled)
			break;
		else
			model->stop(&__get_cpu_var(cpu_msrs));
75
		ret = NOTIFY_STOP;
76 77 78 79 80
		break;
	default:
		break;
	}
	return ret;
L
Linus Torvalds 已提交
81
}
82

83
static void nmi_cpu_save_registers(struct op_msrs *msrs)
L
Linus Torvalds 已提交
84
{
85 86
	struct op_msr *counters = msrs->counters;
	struct op_msr *controls = msrs->controls;
L
Linus Torvalds 已提交
87 88
	unsigned int i;

89
	for (i = 0; i < model->num_counters; ++i) {
90 91
		if (counters[i].addr)
			rdmsrl(counters[i].addr, counters[i].saved);
L
Linus Torvalds 已提交
92
	}
93

94
	for (i = 0; i < model->num_controls; ++i) {
95 96
		if (controls[i].addr)
			rdmsrl(controls[i].addr, controls[i].saved);
L
Linus Torvalds 已提交
97 98 99
	}
}

100 101 102
static void nmi_cpu_start(void *dummy)
{
	struct op_msrs const *msrs = &__get_cpu_var(cpu_msrs);
103 104 105 106
	if (!msrs->controls)
		WARN_ON_ONCE(1);
	else
		model->start(msrs);
107 108 109 110
}

static int nmi_start(void)
{
111
	get_online_cpus();
112
	on_each_cpu(nmi_cpu_start, NULL, 1);
113 114
	ctr_running = 1;
	put_online_cpus();
115 116 117 118 119 120
	return 0;
}

static void nmi_cpu_stop(void *dummy)
{
	struct op_msrs const *msrs = &__get_cpu_var(cpu_msrs);
121 122 123 124
	if (!msrs->controls)
		WARN_ON_ONCE(1);
	else
		model->stop(msrs);
125 126 127 128
}

static void nmi_stop(void)
{
129
	get_online_cpus();
130
	on_each_cpu(nmi_cpu_stop, NULL, 1);
131 132
	ctr_running = 0;
	put_online_cpus();
133 134
}

135 136 137 138
#ifdef CONFIG_OPROFILE_EVENT_MULTIPLEX

static DEFINE_PER_CPU(int, switch_index);

139 140 141 142 143
static inline int has_mux(void)
{
	return !!model->switch_ctrl;
}

144 145 146 147 148
inline int op_x86_phys_to_virt(int phys)
{
	return __get_cpu_var(switch_index) + phys;
}

149 150 151 152 153
inline int op_x86_virt_to_phys(int virt)
{
	return virt % model->num_counters;
}

154 155 156
static void nmi_shutdown_mux(void)
{
	int i;
157 158 159 160

	if (!has_mux())
		return;

161 162 163 164 165 166 167 168 169 170 171 172
	for_each_possible_cpu(i) {
		kfree(per_cpu(cpu_msrs, i).multiplex);
		per_cpu(cpu_msrs, i).multiplex = NULL;
		per_cpu(switch_index, i) = 0;
	}
}

static int nmi_setup_mux(void)
{
	size_t multiplex_size =
		sizeof(struct op_msr) * model->num_virt_counters;
	int i;
173 174 175 176

	if (!has_mux())
		return 1;

177 178
	for_each_possible_cpu(i) {
		per_cpu(cpu_msrs, i).multiplex =
179
			kzalloc(multiplex_size, GFP_KERNEL);
180 181 182
		if (!per_cpu(cpu_msrs, i).multiplex)
			return 0;
	}
183

184 185 186
	return 1;
}

187 188 189 190 191
static void nmi_cpu_setup_mux(int cpu, struct op_msrs const * const msrs)
{
	int i;
	struct op_msr *multiplex = msrs->multiplex;

192 193 194
	if (!has_mux())
		return;

195 196 197 198 199 200 201 202 203 204 205
	for (i = 0; i < model->num_virt_counters; ++i) {
		if (counter_config[i].enabled) {
			multiplex[i].saved = -(u64)counter_config[i].count;
		} else {
			multiplex[i].saved = 0;
		}
	}

	per_cpu(switch_index, cpu) = 0;
}

206 207
static void nmi_cpu_save_mpx_registers(struct op_msrs *msrs)
{
208
	struct op_msr *counters = msrs->counters;
209 210 211 212 213
	struct op_msr *multiplex = msrs->multiplex;
	int i;

	for (i = 0; i < model->num_counters; ++i) {
		int virt = op_x86_phys_to_virt(i);
214 215
		if (counters[i].addr)
			rdmsrl(counters[i].addr, multiplex[virt].saved);
216 217 218 219 220
	}
}

static void nmi_cpu_restore_mpx_registers(struct op_msrs *msrs)
{
221
	struct op_msr *counters = msrs->counters;
222 223 224 225 226
	struct op_msr *multiplex = msrs->multiplex;
	int i;

	for (i = 0; i < model->num_counters; ++i) {
		int virt = op_x86_phys_to_virt(i);
227 228
		if (counters[i].addr)
			wrmsrl(counters[i].addr, multiplex[virt].saved);
229 230 231
	}
}

232 233 234 235 236 237 238 239 240 241 242
static void nmi_cpu_switch(void *dummy)
{
	int cpu = smp_processor_id();
	int si = per_cpu(switch_index, cpu);
	struct op_msrs *msrs = &per_cpu(cpu_msrs, cpu);

	nmi_cpu_stop(NULL);
	nmi_cpu_save_mpx_registers(msrs);

	/* move to next set */
	si += model->num_counters;
243
	if ((si >= model->num_virt_counters) || (counter_config[si].count == 0))
244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266
		per_cpu(switch_index, cpu) = 0;
	else
		per_cpu(switch_index, cpu) = si;

	model->switch_ctrl(model, msrs);
	nmi_cpu_restore_mpx_registers(msrs);

	nmi_cpu_start(NULL);
}


/*
 * Quick check to see if multiplexing is necessary.
 * The check should be sufficient since counters are used
 * in ordre.
 */
static int nmi_multiplex_on(void)
{
	return counter_config[model->num_counters].count ? 0 : -EINVAL;
}

static int nmi_switch_event(void)
{
267
	if (!has_mux())
268 269 270 271
		return -ENOSYS;		/* not implemented */
	if (nmi_multiplex_on() < 0)
		return -EINVAL;		/* not necessary */

272 273 274 275
	get_online_cpus();
	if (ctr_running)
		on_each_cpu(nmi_cpu_switch, NULL, 1);
	put_online_cpus();
276 277 278 279

	return 0;
}

280 281 282 283 284 285
static inline void mux_init(struct oprofile_operations *ops)
{
	if (has_mux())
		ops->switch_events = nmi_switch_event;
}

286 287 288 289 290 291 292 293 294 295
static void mux_clone(int cpu)
{
	if (!has_mux())
		return;

	memcpy(per_cpu(cpu_msrs, cpu).multiplex,
	       per_cpu(cpu_msrs, 0).multiplex,
	       sizeof(struct op_msr) * model->num_virt_counters);
}

296 297 298
#else

inline int op_x86_phys_to_virt(int phys) { return phys; }
299
inline int op_x86_virt_to_phys(int virt) { return virt; }
300 301
static inline void nmi_shutdown_mux(void) { }
static inline int nmi_setup_mux(void) { return 1; }
302 303
static inline void
nmi_cpu_setup_mux(int cpu, struct op_msrs const * const msrs) { }
304
static inline void mux_init(struct oprofile_operations *ops) { }
305
static void mux_clone(int cpu) { }
306 307 308

#endif

L
Linus Torvalds 已提交
309 310 311
static void free_msrs(void)
{
	int i;
312
	for_each_possible_cpu(i) {
313 314 315 316
		kfree(per_cpu(cpu_msrs, i).counters);
		per_cpu(cpu_msrs, i).counters = NULL;
		kfree(per_cpu(cpu_msrs, i).controls);
		per_cpu(cpu_msrs, i).controls = NULL;
L
Linus Torvalds 已提交
317
	}
318
	nmi_shutdown_mux();
L
Linus Torvalds 已提交
319 320 321 322 323 324 325
}

static int allocate_msrs(void)
{
	size_t controls_size = sizeof(struct op_msr) * model->num_controls;
	size_t counters_size = sizeof(struct op_msr) * model->num_counters;

326
	int i;
C
Chris Wright 已提交
327
	for_each_possible_cpu(i) {
328
		per_cpu(cpu_msrs, i).counters = kzalloc(counters_size,
329 330
							GFP_KERNEL);
		if (!per_cpu(cpu_msrs, i).counters)
331
			goto fail;
332
		per_cpu(cpu_msrs, i).controls = kzalloc(controls_size,
333 334
							GFP_KERNEL);
		if (!per_cpu(cpu_msrs, i).controls)
335
			goto fail;
L
Linus Torvalds 已提交
336 337
	}

338 339 340
	if (!nmi_setup_mux())
		goto fail;

341
	return 1;
342 343 344 345

fail:
	free_msrs();
	return 0;
L
Linus Torvalds 已提交
346 347
}

348
static void nmi_cpu_setup(void *dummy)
L
Linus Torvalds 已提交
349 350
{
	int cpu = smp_processor_id();
351
	struct op_msrs *msrs = &per_cpu(cpu_msrs, cpu);
352
	nmi_cpu_save_registers(msrs);
L
Linus Torvalds 已提交
353
	spin_lock(&oprofilefs_lock);
354
	model->setup_ctrs(model, msrs);
355
	nmi_cpu_setup_mux(cpu, msrs);
L
Linus Torvalds 已提交
356
	spin_unlock(&oprofilefs_lock);
357
	per_cpu(saved_lvtpc, cpu) = apic_read(APIC_LVTPC);
L
Linus Torvalds 已提交
358 359 360
	apic_write(APIC_LVTPC, APIC_DM_NMI);
}

361 362 363
static struct notifier_block profile_exceptions_nb = {
	.notifier_call = profile_exceptions_notify,
	.next = NULL,
364
	.priority = 2
365
};
L
Linus Torvalds 已提交
366

367
static void nmi_cpu_restore_registers(struct op_msrs *msrs)
L
Linus Torvalds 已提交
368
{
369 370
	struct op_msr *counters = msrs->counters;
	struct op_msr *controls = msrs->controls;
L
Linus Torvalds 已提交
371 372
	unsigned int i;

373
	for (i = 0; i < model->num_controls; ++i) {
374 375
		if (controls[i].addr)
			wrmsrl(controls[i].addr, controls[i].saved);
L
Linus Torvalds 已提交
376
	}
377

378
	for (i = 0; i < model->num_counters; ++i) {
379 380
		if (counters[i].addr)
			wrmsrl(counters[i].addr, counters[i].saved);
L
Linus Torvalds 已提交
381 382 383
	}
}

384
static void nmi_cpu_shutdown(void *dummy)
L
Linus Torvalds 已提交
385 386 387
{
	unsigned int v;
	int cpu = smp_processor_id();
388
	struct op_msrs *msrs = &per_cpu(cpu_msrs, cpu);
389

L
Linus Torvalds 已提交
390 391 392 393 394 395 396
	/* restoring APIC_LVTPC can trigger an apic error because the delivery
	 * mode and vector nr combination can be illegal. That's by design: on
	 * power on apic lvt contain a zero vector nr which are legal only for
	 * NMI delivery mode. So inhibit apic err before restoring lvtpc
	 */
	v = apic_read(APIC_LVTERR);
	apic_write(APIC_LVTERR, v | APIC_LVT_MASKED);
397
	apic_write(APIC_LVTPC, per_cpu(saved_lvtpc, cpu));
L
Linus Torvalds 已提交
398
	apic_write(APIC_LVTERR, v);
399
	nmi_cpu_restore_registers(msrs);
400 401
	if (model->cpu_down)
		model->cpu_down();
L
Linus Torvalds 已提交
402 403
}

404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419
static void nmi_cpu_up(void *dummy)
{
	if (nmi_enabled)
		nmi_cpu_setup(dummy);
	if (ctr_running)
		nmi_cpu_start(dummy);
}

static void nmi_cpu_down(void *dummy)
{
	if (ctr_running)
		nmi_cpu_stop(dummy);
	if (nmi_enabled)
		nmi_cpu_shutdown(dummy);
}

420
static int nmi_create_files(struct super_block *sb, struct dentry *root)
L
Linus Torvalds 已提交
421 422 423
{
	unsigned int i;

424
	for (i = 0; i < model->num_virt_counters; ++i) {
425
		struct dentry *dir;
426
		char buf[4];
427 428

		/* quick little hack to _not_ expose a counter if it is not
429 430 431 432
		 * available for use.  This should protect userspace app.
		 * NOTE:  assumes 1:1 mapping here (that counters are organized
		 *        sequentially in their struct assignment).
		 */
433
		if (!avail_to_resrv_perfctr_nmi_bit(op_x86_virt_to_phys(i)))
434 435
			continue;

436
		snprintf(buf,  sizeof(buf), "%d", i);
L
Linus Torvalds 已提交
437
		dir = oprofilefs_mkdir(sb, root, buf);
438 439 440 441 442 443
		oprofilefs_create_ulong(sb, dir, "enabled", &counter_config[i].enabled);
		oprofilefs_create_ulong(sb, dir, "event", &counter_config[i].event);
		oprofilefs_create_ulong(sb, dir, "count", &counter_config[i].count);
		oprofilefs_create_ulong(sb, dir, "unit_mask", &counter_config[i].unit_mask);
		oprofilefs_create_ulong(sb, dir, "kernel", &counter_config[i].kernel);
		oprofilefs_create_ulong(sb, dir, "user", &counter_config[i].user);
L
Linus Torvalds 已提交
444 445 446 447
	}

	return 0;
}
448

449 450 451 452 453 454 455
static int oprofile_cpu_notifier(struct notifier_block *b, unsigned long action,
				 void *data)
{
	int cpu = (unsigned long)data;
	switch (action) {
	case CPU_DOWN_FAILED:
	case CPU_ONLINE:
456
		smp_call_function_single(cpu, nmi_cpu_up, NULL, 0);
457 458
		break;
	case CPU_DOWN_PREPARE:
459
		smp_call_function_single(cpu, nmi_cpu_down, NULL, 1);
460 461 462 463 464 465 466 467 468
		break;
	}
	return NOTIFY_DONE;
}

static struct notifier_block oprofile_cpu_nb = {
	.notifier_call = oprofile_cpu_notifier
};

469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508
static int nmi_setup(void)
{
	int err = 0;
	int cpu;

	if (!allocate_msrs())
		return -ENOMEM;

	/* We need to serialize save and setup for HT because the subset
	 * of msrs are distinct for save and setup operations
	 */

	/* Assume saved/restored counters are the same on all CPUs */
	err = model->fill_in_addresses(&per_cpu(cpu_msrs, 0));
	if (err)
		goto fail;

	for_each_possible_cpu(cpu) {
		if (!cpu)
			continue;

		memcpy(per_cpu(cpu_msrs, cpu).counters,
		       per_cpu(cpu_msrs, 0).counters,
		       sizeof(struct op_msr) * model->num_counters);

		memcpy(per_cpu(cpu_msrs, cpu).controls,
		       per_cpu(cpu_msrs, 0).controls,
		       sizeof(struct op_msr) * model->num_controls);

		mux_clone(cpu);
	}

	nmi_enabled = 0;
	ctr_running = 0;
	barrier();
	err = register_die_notifier(&profile_exceptions_nb);
	if (err)
		goto fail;

	get_online_cpus();
509
	register_cpu_notifier(&oprofile_cpu_nb);
510 511 512 513 514 515 516 517 518 519 520 521 522 523 524
	on_each_cpu(nmi_cpu_setup, NULL, 1);
	nmi_enabled = 1;
	put_online_cpus();

	return 0;
fail:
	free_msrs();
	return err;
}

static void nmi_shutdown(void)
{
	struct op_msrs *msrs;

	get_online_cpus();
525
	unregister_cpu_notifier(&oprofile_cpu_nb);
526 527 528 529 530 531 532 533 534 535 536 537
	on_each_cpu(nmi_cpu_shutdown, NULL, 1);
	nmi_enabled = 0;
	ctr_running = 0;
	put_online_cpus();
	barrier();
	unregister_die_notifier(&profile_exceptions_nb);
	msrs = &get_cpu_var(cpu_msrs);
	model->shutdown(msrs);
	free_msrs();
	put_cpu_var(cpu_msrs);
}

538 539 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
#ifdef CONFIG_PM

static int nmi_suspend(struct sys_device *dev, pm_message_t state)
{
	/* Only one CPU left, just stop that one */
	if (nmi_enabled == 1)
		nmi_cpu_stop(NULL);
	return 0;
}

static int nmi_resume(struct sys_device *dev)
{
	if (nmi_enabled == 1)
		nmi_cpu_start(NULL);
	return 0;
}

static struct sysdev_class oprofile_sysclass = {
	.name		= "oprofile",
	.resume		= nmi_resume,
	.suspend	= nmi_suspend,
};

static struct sys_device device_oprofile = {
	.id	= 0,
	.cls	= &oprofile_sysclass,
};

static int __init init_sysfs(void)
{
	int error;

	error = sysdev_class_register(&oprofile_sysclass);
571 572 573 574 575 576 577
	if (error)
		return error;

	error = sysdev_register(&device_oprofile);
	if (error)
		sysdev_class_unregister(&oprofile_sysclass);

578 579 580 581 582 583 584 585 586 587 588 589 590 591
	return error;
}

static void exit_sysfs(void)
{
	sysdev_unregister(&device_oprofile);
	sysdev_class_unregister(&oprofile_sysclass);
}

#else
#define init_sysfs() do { } while (0)
#define exit_sysfs() do { } while (0)
#endif /* CONFIG_PM */

592
static int __init p4_init(char **cpu_type)
L
Linus Torvalds 已提交
593 594 595
{
	__u8 cpu_model = boot_cpu_data.x86_model;

596
	if (cpu_model > 6 || cpu_model == 5)
L
Linus Torvalds 已提交
597 598 599 600 601 602 603 604
		return 0;

#ifndef CONFIG_SMP
	*cpu_type = "i386/p4";
	model = &op_p4_spec;
	return 1;
#else
	switch (smp_num_siblings) {
605 606 607 608 609 610 611 612 613
	case 1:
		*cpu_type = "i386/p4";
		model = &op_p4_spec;
		return 1;

	case 2:
		*cpu_type = "i386/p4-ht";
		model = &op_p4_ht2_spec;
		return 1;
L
Linus Torvalds 已提交
614 615 616 617 618 619 620 621
	}
#endif

	printk(KERN_INFO "oprofile: P4 HyperThreading detected with > 2 threads\n");
	printk(KERN_INFO "oprofile: Reverting to timer mode.\n");
	return 0;
}

622 623 624
static int force_arch_perfmon;
static int force_cpu_type(const char *str, struct kernel_param *kp)
{
625
	if (!strcmp(str, "arch_perfmon")) {
626 627 628 629 630 631 632
		force_arch_perfmon = 1;
		printk(KERN_INFO "oprofile: forcing architectural perfmon\n");
	}

	return 0;
}
module_param_call(cpu_type, force_cpu_type, NULL, NULL, 0);
633

634
static int __init ppro_init(char **cpu_type)
L
Linus Torvalds 已提交
635 636
{
	__u8 cpu_model = boot_cpu_data.x86_model;
637
	struct op_x86_model_spec *spec = &op_ppro_spec;	/* default */
L
Linus Torvalds 已提交
638

639 640 641
	if (force_arch_perfmon && cpu_has_arch_perfmon)
		return 0;

642 643 644 645 646 647 648 649 650 651 652 653
	/*
	 * Documentation on identifying Intel processors by CPU family
	 * and model can be found in the Intel Software Developer's
	 * Manuals (SDM):
	 *
	 *  http://www.intel.com/products/processor/manuals/
	 *
	 * As of May 2010 the documentation for this was in the:
	 * "Intel 64 and IA-32 Architectures Software Developer's
	 * Manual Volume 3B: System Programming Guide", "Table B-1
	 * CPUID Signature Values of DisplayFamily_DisplayModel".
	 */
654 655 656 657 658 659 660 661
	switch (cpu_model) {
	case 0 ... 2:
		*cpu_type = "i386/ppro";
		break;
	case 3 ... 5:
		*cpu_type = "i386/pii";
		break;
	case 6 ... 8:
662
	case 10 ... 11:
663 664 665
		*cpu_type = "i386/piii";
		break;
	case 9:
666
	case 13:
667 668 669
		*cpu_type = "i386/p6_mobile";
		break;
	case 14:
670
		*cpu_type = "i386/core";
671 672 673 674
		break;
	case 15: case 23:
		*cpu_type = "i386/core_2";
		break;
675
	case 0x1a:
676
	case 0x1e:
677
	case 0x2e:
678
		spec = &op_arch_perfmon_spec;
679 680
		*cpu_type = "i386/core_i7";
		break;
681
	case 0x1c:
682 683
		*cpu_type = "i386/atom";
		break;
684 685
	default:
		/* Unknown */
L
Linus Torvalds 已提交
686 687 688
		return 0;
	}

689
	model = spec;
L
Linus Torvalds 已提交
690 691 692
	return 1;
}

693
/* in order to get sysfs right */
L
Linus Torvalds 已提交
694 695
static int using_nmi;

696
int __init op_nmi_init(struct oprofile_operations *ops)
L
Linus Torvalds 已提交
697 698 699
{
	__u8 vendor = boot_cpu_data.x86_vendor;
	__u8 family = boot_cpu_data.x86;
700
	char *cpu_type = NULL;
701
	int ret = 0;
L
Linus Torvalds 已提交
702

703 704
	using_nmi = 0;

L
Linus Torvalds 已提交
705 706
	if (!cpu_has_apic)
		return -ENODEV;
707

L
Linus Torvalds 已提交
708
	switch (vendor) {
709 710
	case X86_VENDOR_AMD:
		/* Needs to be at least an Athlon (or hammer in 32bit mode) */
L
Linus Torvalds 已提交
711

712 713 714 715 716
		switch (family) {
		case 6:
			cpu_type = "i386/athlon";
			break;
		case 0xf:
717 718 719 720
			/*
			 * Actually it could be i386/hammer too, but
			 * give user space an consistent name.
			 */
721 722 723 724 725
			cpu_type = "x86-64/hammer";
			break;
		case 0x10:
			cpu_type = "x86-64/family10";
			break;
726 727 728
		case 0x11:
			cpu_type = "x86-64/family11h";
			break;
729 730
		default:
			return -ENODEV;
731
		}
732
		model = &op_amd_spec;
733 734 735 736 737 738
		break;

	case X86_VENDOR_INTEL:
		switch (family) {
			/* Pentium IV */
		case 0xf:
739
			p4_init(&cpu_type);
L
Linus Torvalds 已提交
740
			break;
741 742 743

			/* A P6-class processor */
		case 6:
744
			ppro_init(&cpu_type);
L
Linus Torvalds 已提交
745 746 747
			break;

		default:
748
			break;
749
		}
750

751 752 753 754
		if (cpu_type)
			break;

		if (!cpu_has_arch_perfmon)
755
			return -ENODEV;
756 757 758 759

		/* use arch perfmon as fallback */
		cpu_type = "i386/arch_perfmon";
		model = &op_arch_perfmon_spec;
760 761 762 763
		break;

	default:
		return -ENODEV;
L
Linus Torvalds 已提交
764 765
	}

766
	/* default values, can be overwritten by model */
767 768 769 770 771 772
	ops->create_files	= nmi_create_files;
	ops->setup		= nmi_setup;
	ops->shutdown		= nmi_shutdown;
	ops->start		= nmi_start;
	ops->stop		= nmi_stop;
	ops->cpu_type		= cpu_type;
773

774 775 776 777 778
	if (model->init)
		ret = model->init(ops);
	if (ret)
		return ret;

779 780 781
	if (!model->num_virt_counters)
		model->num_virt_counters = model->num_counters;

782 783
	mux_init(ops);

784 785 786 787
	ret = init_sysfs();
	if (ret)
		return ret;

L
Linus Torvalds 已提交
788 789 790 791 792
	using_nmi = 1;
	printk(KERN_INFO "oprofile: using NMI interrupt.\n");
	return 0;
}

793
void op_nmi_exit(void)
L
Linus Torvalds 已提交
794
{
795
	if (using_nmi)
796
		exit_sysfs();
L
Linus Torvalds 已提交
797
}