nmi_int.c 15.2 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

L
Linus Torvalds 已提交
34 35 36
/* 0 == registered but off, 1 == registered and on */
static int nmi_enabled = 0;

37 38 39 40 41 42 43

#ifdef CONFIG_OPROFILE_EVENT_MULTIPLEX
extern atomic_t multiplex_counter;
#endif

struct op_counter_config counter_config[OP_MAX_COUNTER];

44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63
/* 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;
}


64 65
static int profile_exceptions_notify(struct notifier_block *self,
				     unsigned long val, void *data)
L
Linus Torvalds 已提交
66
{
67 68 69 70
	struct die_args *args = (struct die_args *)data;
	int ret = NOTIFY_DONE;
	int cpu = smp_processor_id();

71
	switch (val) {
72
	case DIE_NMI:
73 74 75
	case DIE_NMI_IPI:
		model->check_ctrs(args->regs, &per_cpu(cpu_msrs, cpu));
		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 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122
static void nmi_cpu_start(void *dummy)
{
	struct op_msrs const *msrs = &__get_cpu_var(cpu_msrs);
	model->start(msrs);
}

static int nmi_start(void)
{
	on_each_cpu(nmi_cpu_start, NULL, 1);
	return 0;
}

static void nmi_cpu_stop(void *dummy)
{
	struct op_msrs const *msrs = &__get_cpu_var(cpu_msrs);
	model->stop(msrs);
}

static void nmi_stop(void)
{
	on_each_cpu(nmi_cpu_stop, NULL, 1);
}

123 124 125 126
#ifdef CONFIG_OPROFILE_EVENT_MULTIPLEX

static DEFINE_PER_CPU(int, switch_index);

127 128 129 130 131
static inline int has_mux(void)
{
	return !!model->switch_ctrl;
}

132 133 134 135 136
inline int op_x86_phys_to_virt(int phys)
{
	return __get_cpu_var(switch_index) + phys;
}

137 138 139
static void nmi_shutdown_mux(void)
{
	int i;
140 141 142 143

	if (!has_mux())
		return;

144 145 146 147 148 149 150 151 152 153 154 155
	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;
156 157 158 159

	if (!has_mux())
		return 1;

160 161 162 163 164 165
	for_each_possible_cpu(i) {
		per_cpu(cpu_msrs, i).multiplex =
			kmalloc(multiplex_size, GFP_KERNEL);
		if (!per_cpu(cpu_msrs, i).multiplex)
			return 0;
	}
166

167 168 169
	return 1;
}

170 171 172 173 174
static void nmi_cpu_setup_mux(int cpu, struct op_msrs const * const msrs)
{
	int i;
	struct op_msr *multiplex = msrs->multiplex;

175 176 177
	if (!has_mux())
		return;

178 179 180 181 182 183 184 185 186 187 188 189
	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].addr  = 0;
			multiplex[i].saved = 0;
		}
	}

	per_cpu(switch_index, cpu) = 0;
}

190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213
static void nmi_cpu_save_mpx_registers(struct op_msrs *msrs)
{
	struct op_msr *multiplex = msrs->multiplex;
	int i;

	for (i = 0; i < model->num_counters; ++i) {
		int virt = op_x86_phys_to_virt(i);
		if (multiplex[virt].addr)
			rdmsrl(multiplex[virt].addr, multiplex[virt].saved);
	}
}

static void nmi_cpu_restore_mpx_registers(struct op_msrs *msrs)
{
	struct op_msr *multiplex = msrs->multiplex;
	int i;

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

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 240 241 242 243 244 245 246 247 248
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;
	if ((si > model->num_virt_counters) || (counter_config[si].count == 0))
		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)
{
249
	if (!has_mux())
250 251 252 253 254 255 256 257 258 259 260
		return -ENOSYS;		/* not implemented */
	if (nmi_multiplex_on() < 0)
		return -EINVAL;		/* not necessary */

	on_each_cpu(nmi_cpu_switch, NULL, 1);

	atomic_inc(&multiplex_counter);

	return 0;
}

261 262 263
#else

inline int op_x86_phys_to_virt(int phys) { return phys; }
264 265
static inline void nmi_shutdown_mux(void) { }
static inline int nmi_setup_mux(void) { return 1; }
266 267
static inline void
nmi_cpu_setup_mux(int cpu, struct op_msrs const * const msrs) { }
268 269 270

#endif

L
Linus Torvalds 已提交
271 272 273
static void free_msrs(void)
{
	int i;
274
	for_each_possible_cpu(i) {
275 276 277 278
		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 已提交
279 280 281 282 283 284 285 286
	}
}

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;

287
	int i;
C
Chris Wright 已提交
288
	for_each_possible_cpu(i) {
289
		per_cpu(cpu_msrs, i).counters = kmalloc(counters_size,
290 291 292
							GFP_KERNEL);
		if (!per_cpu(cpu_msrs, i).counters)
			return 0;
293
		per_cpu(cpu_msrs, i).controls = kmalloc(controls_size,
294 295 296
							GFP_KERNEL);
		if (!per_cpu(cpu_msrs, i).controls)
			return 0;
L
Linus Torvalds 已提交
297 298
	}

299
	return 1;
L
Linus Torvalds 已提交
300 301
}

302
static void nmi_cpu_setup(void *dummy)
L
Linus Torvalds 已提交
303 304
{
	int cpu = smp_processor_id();
305
	struct op_msrs *msrs = &per_cpu(cpu_msrs, cpu);
306
	nmi_cpu_save_registers(msrs);
L
Linus Torvalds 已提交
307
	spin_lock(&oprofilefs_lock);
308
	model->setup_ctrs(model, msrs);
309
	nmi_cpu_setup_mux(cpu, msrs);
L
Linus Torvalds 已提交
310
	spin_unlock(&oprofilefs_lock);
311
	per_cpu(saved_lvtpc, cpu) = apic_read(APIC_LVTPC);
L
Linus Torvalds 已提交
312 313 314
	apic_write(APIC_LVTPC, APIC_DM_NMI);
}

315 316 317
static struct notifier_block profile_exceptions_nb = {
	.notifier_call = profile_exceptions_notify,
	.next = NULL,
318
	.priority = 2
319
};
L
Linus Torvalds 已提交
320 321 322

static int nmi_setup(void)
{
323
	int err = 0;
324
	int cpu;
325

L
Linus Torvalds 已提交
326
	if (!allocate_msrs())
327 328 329 330 331
		err = -ENOMEM;
	else if (!nmi_setup_mux())
		err = -ENOMEM;
	else
		err = register_die_notifier(&profile_exceptions_nb);
L
Linus Torvalds 已提交
332

333
	if (err) {
L
Linus Torvalds 已提交
334
		free_msrs();
335
		nmi_shutdown_mux();
336
		return err;
L
Linus Torvalds 已提交
337
	}
338

339
	/* We need to serialize save and setup for HT because the subset
L
Linus Torvalds 已提交
340 341
	 * of msrs are distinct for save and setup operations
	 */
342 343

	/* Assume saved/restored counters are the same on all CPUs */
344
	model->fill_in_addresses(&per_cpu(cpu_msrs, 0));
345
	for_each_possible_cpu(cpu) {
C
Chris Wright 已提交
346
		if (cpu != 0) {
347 348
			memcpy(per_cpu(cpu_msrs, cpu).counters,
				per_cpu(cpu_msrs, 0).counters,
C
Chris Wright 已提交
349 350
				sizeof(struct op_msr) * model->num_counters);

351 352
			memcpy(per_cpu(cpu_msrs, cpu).controls,
				per_cpu(cpu_msrs, 0).controls,
C
Chris Wright 已提交
353
				sizeof(struct op_msr) * model->num_controls);
354 355 356 357 358
#ifdef CONFIG_OPROFILE_EVENT_MULTIPLEX
			memcpy(per_cpu(cpu_msrs, cpu).multiplex,
				per_cpu(cpu_msrs, 0).multiplex,
				sizeof(struct op_msr) * model->num_virt_counters);
#endif
C
Chris Wright 已提交
359
		}
360
	}
361
	on_each_cpu(nmi_cpu_setup, NULL, 1);
L
Linus Torvalds 已提交
362 363 364 365
	nmi_enabled = 1;
	return 0;
}

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

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

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

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

L
Linus Torvalds 已提交
389 390 391 392 393 394 395
	/* 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);
396
	apic_write(APIC_LVTPC, per_cpu(saved_lvtpc, cpu));
L
Linus Torvalds 已提交
397
	apic_write(APIC_LVTERR, v);
398
	nmi_cpu_restore_registers(msrs);
L
Linus Torvalds 已提交
399 400 401 402
}

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

L
Linus Torvalds 已提交
405
	nmi_enabled = 0;
406
	on_each_cpu(nmi_cpu_shutdown, NULL, 1);
407
	unregister_die_notifier(&profile_exceptions_nb);
408
	nmi_shutdown_mux();
409
	msrs = &get_cpu_var(cpu_msrs);
410
	model->shutdown(msrs);
L
Linus Torvalds 已提交
411
	free_msrs();
412
	put_cpu_var(cpu_msrs);
L
Linus Torvalds 已提交
413 414
}

415
static int nmi_create_files(struct super_block *sb, struct dentry *root)
L
Linus Torvalds 已提交
416 417 418
{
	unsigned int i;

419
	for (i = 0; i < model->num_virt_counters; ++i) {
420
		struct dentry *dir;
421
		char buf[4];
422

423
#ifndef CONFIG_OPROFILE_EVENT_MULTIPLEX
424
		/* quick little hack to _not_ expose a counter if it is not
425 426 427 428 429 430
		 * available for use.  This should protect userspace app.
		 * NOTE:  assumes 1:1 mapping here (that counters are organized
		 *        sequentially in their struct assignment).
		 */
		if (unlikely(!avail_to_resrv_perfctr_nmi_bit(i)))
			continue;
431
#endif /* CONFIG_OPROFILE_EVENT_MULTIPLEX */
432

433
		snprintf(buf,  sizeof(buf), "%d", i);
L
Linus Torvalds 已提交
434
		dir = oprofilefs_mkdir(sb, root, buf);
435 436 437 438 439 440
		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 已提交
441 442 443 444
	}

	return 0;
}
445

446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 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 509 510 511 512 513 514 515 516
#ifdef CONFIG_SMP
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:
		smp_call_function_single(cpu, nmi_cpu_start, NULL, 0);
		break;
	case CPU_DOWN_PREPARE:
		smp_call_function_single(cpu, nmi_cpu_stop, NULL, 1);
		break;
	}
	return NOTIFY_DONE;
}

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

#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);
	if (!error)
		error = sysdev_register(&device_oprofile);
	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 */

517
static int __init p4_init(char **cpu_type)
L
Linus Torvalds 已提交
518 519 520
{
	__u8 cpu_model = boot_cpu_data.x86_model;

521
	if (cpu_model > 6 || cpu_model == 5)
L
Linus Torvalds 已提交
522 523 524 525 526 527 528 529
		return 0;

#ifndef CONFIG_SMP
	*cpu_type = "i386/p4";
	model = &op_p4_spec;
	return 1;
#else
	switch (smp_num_siblings) {
530 531 532 533 534 535 536 537 538
	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 已提交
539 540 541 542 543 544 545 546
	}
#endif

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

547 548 549
static int force_arch_perfmon;
static int force_cpu_type(const char *str, struct kernel_param *kp)
{
550
	if (!strcmp(str, "arch_perfmon")) {
551 552 553 554 555 556 557
		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);
558

559
static int __init ppro_init(char **cpu_type)
L
Linus Torvalds 已提交
560 561
{
	__u8 cpu_model = boot_cpu_data.x86_model;
562
	struct op_x86_model_spec *spec = &op_ppro_spec;	/* default */
L
Linus Torvalds 已提交
563

564 565 566
	if (force_arch_perfmon && cpu_has_arch_perfmon)
		return 0;

567 568 569 570 571 572 573 574
	switch (cpu_model) {
	case 0 ... 2:
		*cpu_type = "i386/ppro";
		break;
	case 3 ... 5:
		*cpu_type = "i386/pii";
		break;
	case 6 ... 8:
575
	case 10 ... 11:
576 577 578
		*cpu_type = "i386/piii";
		break;
	case 9:
579
	case 13:
580 581 582
		*cpu_type = "i386/p6_mobile";
		break;
	case 14:
583
		*cpu_type = "i386/core";
584 585 586 587
		break;
	case 15: case 23:
		*cpu_type = "i386/core_2";
		break;
588
	case 26:
589
		spec = &op_arch_perfmon_spec;
590 591 592 593 594
		*cpu_type = "i386/core_i7";
		break;
	case 28:
		*cpu_type = "i386/atom";
		break;
595 596
	default:
		/* Unknown */
L
Linus Torvalds 已提交
597 598 599
		return 0;
	}

600
	model = spec;
L
Linus Torvalds 已提交
601 602 603
	return 1;
}

604
/* in order to get sysfs right */
L
Linus Torvalds 已提交
605 606
static int using_nmi;

607
int __init op_nmi_init(struct oprofile_operations *ops)
L
Linus Torvalds 已提交
608 609 610
{
	__u8 vendor = boot_cpu_data.x86_vendor;
	__u8 family = boot_cpu_data.x86;
611
	char *cpu_type = NULL;
612
	int ret = 0;
L
Linus Torvalds 已提交
613 614 615

	if (!cpu_has_apic)
		return -ENODEV;
616

L
Linus Torvalds 已提交
617
	switch (vendor) {
618 619
	case X86_VENDOR_AMD:
		/* Needs to be at least an Athlon (or hammer in 32bit mode) */
L
Linus Torvalds 已提交
620

621 622 623 624 625
		switch (family) {
		case 6:
			cpu_type = "i386/athlon";
			break;
		case 0xf:
626 627 628 629
			/*
			 * Actually it could be i386/hammer too, but
			 * give user space an consistent name.
			 */
630 631 632 633 634
			cpu_type = "x86-64/hammer";
			break;
		case 0x10:
			cpu_type = "x86-64/family10";
			break;
635 636 637
		case 0x11:
			cpu_type = "x86-64/family11h";
			break;
638 639
		default:
			return -ENODEV;
640
		}
641
		model = &op_amd_spec;
642 643 644 645 646 647
		break;

	case X86_VENDOR_INTEL:
		switch (family) {
			/* Pentium IV */
		case 0xf:
648
			p4_init(&cpu_type);
L
Linus Torvalds 已提交
649
			break;
650 651 652

			/* A P6-class processor */
		case 6:
653
			ppro_init(&cpu_type);
L
Linus Torvalds 已提交
654 655 656
			break;

		default:
657
			break;
658
		}
659

660 661 662 663
		if (cpu_type)
			break;

		if (!cpu_has_arch_perfmon)
664
			return -ENODEV;
665 666 667 668

		/* use arch perfmon as fallback */
		cpu_type = "i386/arch_perfmon";
		model = &op_arch_perfmon_spec;
669 670 671 672
		break;

	default:
		return -ENODEV;
L
Linus Torvalds 已提交
673 674
	}

675 676 677
#ifdef CONFIG_SMP
	register_cpu_notifier(&oprofile_cpu_nb);
#endif
678
	/* default values, can be overwritten by model */
679 680 681 682 683 684
	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;
685 686 687
#ifdef CONFIG_OPROFILE_EVENT_MULTIPLEX
	ops->switch_events	= nmi_switch_event;
#endif
688

689 690 691 692 693
	if (model->init)
		ret = model->init(ops);
	if (ret)
		return ret;

694 695 696
	if (!model->num_virt_counters)
		model->num_virt_counters = model->num_counters;

697
	init_sysfs();
L
Linus Torvalds 已提交
698 699 700 701 702
	using_nmi = 1;
	printk(KERN_INFO "oprofile: using NMI interrupt.\n");
	return 0;
}

703
void op_nmi_exit(void)
L
Linus Torvalds 已提交
704
{
705
	if (using_nmi) {
706
		exit_sysfs();
707 708 709 710
#ifdef CONFIG_SMP
		unregister_cpu_notifier(&oprofile_cpu_nb);
#endif
	}
711 712
	if (model->exit)
		model->exit();
L
Linus Torvalds 已提交
713
}