Eric Lee / linux-smarc-t335x-v3.2

Browse Code »

Commit 9f8b6a6cf0ee78de87ebe1e87f54bec1c1741ef7

Authored by Ingo Molnar 2011-07-04 18:27:28 +0800

2 parents 729aa21ab8 a406ab6d77

Merge branch 'core' of git://git.kernel.org/pub/scm/linux/kernel/git/rric/oprofile into perf/core

Showing 8 changed files Inline Diff

arch/mips/include/asm/stacktrace.h
arch/mips/kernel/process.c
arch/mips/oprofile/Makefile
arch/mips/oprofile/backtrace.c
arch/mips/oprofile/common.c
arch/mips/oprofile/op_impl.h
arch/x86/oprofile/backtrace.c
arch/x86/oprofile/nmi_int.c

arch/mips/include/asm/stacktrace.h

Diff comments View file @ 9f8b6a6

 #ifndef _ASM_STACKTRACE_H
 #define _ASM_STACKTRACE_H
 #include <asm/ptrace.h>
 #ifdef CONFIG_KALLSYMS
 extern int raw_show_trace;
 extern unsigned long unwind_stack(struct task_struct *task, unsigned long *sp,
 				  unsigned long pc, unsigned long *ra);
+extern unsigned long unwind_stack_by_address(unsigned long stack_page,
+					     unsigned long *sp,
+					     unsigned long pc,
+					     unsigned long *ra);
 #else
 #define raw_show_trace 1
 static inline unsigned long unwind_stack(struct task_struct *task,
 	unsigned long *sp, unsigned long pc, unsigned long *ra)
 {
 	return 0;
 }
 #endif
 static __always_inline void prepare_frametrace(struct pt_regs *regs)
 {
 #ifndef CONFIG_KALLSYMS
 	/*
 	 * Remove any garbage that may be in regs (specially func
 	 * addresses) to avoid show_raw_backtrace() to report them
 	 */
 	memset(regs, 0, sizeof(*regs));
 #endif
 	__asm__ __volatile__(
 		".set push\n\t"
 		".set noat\n\t"
 #ifdef CONFIG_64BIT
 		"1: dla $1, 1b\n\t"
 		"sd $1, %0\n\t"
 		"sd $29, %1\n\t"
 		"sd $31, %2\n\t"
 #else
 		"1: la $1, 1b\n\t"
 		"sw $1, %0\n\t"
 		"sw $29, %1\n\t"
 		"sw $31, %2\n\t"
 #endif
 		".set pop\n\t"
 		: "=m" (regs->cp0_epc),
 		"=m" (regs->regs[29]), "=m" (regs->regs[31])
 		: : "memory");
 }
 #endif /* _ASM_STACKTRACE_H */

arch/mips/kernel/process.c

Diff comments View file @ 9f8b6a6

 /*
  * This file is subject to the terms and conditions of the GNU General Public
  * License.  See the file "COPYING" in the main directory of this archive
  * for more details.
  *
  * Copyright (C) 1994 - 1999, 2000 by Ralf Baechle and others.
  * Copyright (C) 2005, 2006 by Ralf Baechle (ralf@linux-mips.org)
  * Copyright (C) 1999, 2000 Silicon Graphics, Inc.
  * Copyright (C) 2004 Thiemo Seufer
  */
 #include <linux/errno.h>
 #include <linux/module.h>
 #include <linux/sched.h>
 #include <linux/tick.h>
 #include <linux/kernel.h>
 #include <linux/mm.h>
 #include <linux/stddef.h>
 #include <linux/unistd.h>
 #include <linux/ptrace.h>
 #include <linux/mman.h>
 #include <linux/personality.h>
 #include <linux/sys.h>
 #include <linux/user.h>
 #include <linux/init.h>
 #include <linux/completion.h>
 #include <linux/kallsyms.h>
 #include <linux/random.h>
 #include <asm/asm.h>
 #include <asm/bootinfo.h>
 #include <asm/cpu.h>
 #include <asm/dsp.h>
 #include <asm/fpu.h>
 #include <asm/pgtable.h>
 #include <asm/system.h>
 #include <asm/mipsregs.h>
 #include <asm/processor.h>
 #include <asm/uaccess.h>
 #include <asm/io.h>
 #include <asm/elf.h>
 #include <asm/isadep.h>
 #include <asm/inst.h>
 #include <asm/stacktrace.h>
 /*
  * The idle thread. There's no useful work to be done, so just try to conserve
  * power and have a low exit latency (ie sit in a loop waiting for somebody to
  * say that they'd like to reschedule)
  */
 void __noreturn cpu_idle(void)
 {
 	int cpu;
 	/* CPU is going idle. */
 	cpu = smp_processor_id();
 	/* endless idle loop with no priority at all */
 	while (1) {
 		tick_nohz_stop_sched_tick(1);
 		while (!need_resched() && cpu_online(cpu)) {
 #ifdef CONFIG_MIPS_MT_SMTC
 			extern void smtc_idle_loop_hook(void);
 			smtc_idle_loop_hook();
 #endif
 			if (cpu_wait) {
 				/* Don't trace irqs off for idle */
 				stop_critical_timings();
 				(*cpu_wait)();
 				start_critical_timings();
 			}
 		}
 #ifdef CONFIG_HOTPLUG_CPU
 		if (!cpu_online(cpu) && !cpu_isset(cpu, cpu_callin_map) &&
 		    (system_state == SYSTEM_RUNNING ||
 		     system_state == SYSTEM_BOOTING))
 			play_dead();
 #endif
 		tick_nohz_restart_sched_tick();
 		preempt_enable_no_resched();
 		schedule();
 		preempt_disable();
 	}
 }
 asmlinkage void ret_from_fork(void);
 void start_thread(struct pt_regs * regs, unsigned long pc, unsigned long sp)
 {
 	unsigned long status;
 	/* New thread loses kernel privileges. */
 	status = regs->cp0_status & ~(ST0_CU0|ST0_CU1|ST0_FR|KU_MASK);
 #ifdef CONFIG_64BIT
 	status |= test_thread_flag(TIF_32BIT_REGS) ? 0 : ST0_FR;
 #endif
 	status |= KU_USER;
 	regs->cp0_status = status;
 	clear_used_math();
 	clear_fpu_owner();
 	if (cpu_has_dsp)
 		__init_dsp();
 	regs->cp0_epc = pc;
 	regs->regs[29] = sp;
 	current_thread_info()->addr_limit = USER_DS;
 }
 void exit_thread(void)
 {
 }
 void flush_thread(void)
 {
 }
 int copy_thread(unsigned long clone_flags, unsigned long usp,
 	unsigned long unused, struct task_struct *p, struct pt_regs *regs)
 {
 	struct thread_info *ti = task_thread_info(p);
 	struct pt_regs *childregs;
 	unsigned long childksp;
 	p->set_child_tid = p->clear_child_tid = NULL;
 	childksp = (unsigned long)task_stack_page(p) + THREAD_SIZE - 32;
 	preempt_disable();
 	if (is_fpu_owner())
 		save_fp(p);
 	if (cpu_has_dsp)
 		save_dsp(p);
 	preempt_enable();
 	/* set up new TSS. */
 	childregs = (struct pt_regs *) childksp - 1;
 	/*  Put the stack after the struct pt_regs.  */
 	childksp = (unsigned long) childregs;
 	*childregs = *regs;
 	childregs->regs[7] = 0;	/* Clear error flag */
 	childregs->regs[2] = 0;	/* Child gets zero as return value */
 	if (childregs->cp0_status & ST0_CU0) {
 		childregs->regs[28] = (unsigned long) ti;
 		childregs->regs[29] = childksp;
 		ti->addr_limit = KERNEL_DS;
 	} else {
 		childregs->regs[29] = usp;
 		ti->addr_limit = USER_DS;
 	}
 	p->thread.reg29 = (unsigned long) childregs;
 	p->thread.reg31 = (unsigned long) ret_from_fork;
 	/*
 	 * New tasks lose permission to use the fpu. This accelerates context
 	 * switching for most programs since they don't use the fpu.
 	 */
 	p->thread.cp0_status = read_c0_status() & ~(ST0_CU2|ST0_CU1);
 	childregs->cp0_status &= ~(ST0_CU2|ST0_CU1);
 #ifdef CONFIG_MIPS_MT_SMTC
 	/*
 	 * SMTC restores TCStatus after Status, and the CU bits
 	 * are aliased there.
 	 */
 	childregs->cp0_tcstatus &= ~(ST0_CU2|ST0_CU1);
 #endif
 	clear_tsk_thread_flag(p, TIF_USEDFPU);
 #ifdef CONFIG_MIPS_MT_FPAFF
 	clear_tsk_thread_flag(p, TIF_FPUBOUND);
 #endif /* CONFIG_MIPS_MT_FPAFF */
 	if (clone_flags & CLONE_SETTLS)
 		ti->tp_value = regs->regs[7];
 	return 0;
 }
 /* Fill in the fpu structure for a core dump.. */
 int dump_fpu(struct pt_regs *regs, elf_fpregset_t *r)
 {
 	memcpy(r, &current->thread.fpu, sizeof(current->thread.fpu));
 	return 1;
 }
 void elf_dump_regs(elf_greg_t *gp, struct pt_regs *regs)
 {
 	int i;
 	for (i = 0; i < EF_R0; i++)
 		gp[i] = 0;
 	gp[EF_R0] = 0;
 	for (i = 1; i <= 31; i++)
 		gp[EF_R0 + i] = regs->regs[i];
 	gp[EF_R26] = 0;
 	gp[EF_R27] = 0;
 	gp[EF_LO] = regs->lo;
 	gp[EF_HI] = regs->hi;
 	gp[EF_CP0_EPC] = regs->cp0_epc;
 	gp[EF_CP0_BADVADDR] = regs->cp0_badvaddr;
 	gp[EF_CP0_STATUS] = regs->cp0_status;
 	gp[EF_CP0_CAUSE] = regs->cp0_cause;
 #ifdef EF_UNUSED0
 	gp[EF_UNUSED0] = 0;
 #endif
 }
 int dump_task_regs(struct task_struct *tsk, elf_gregset_t *regs)
 {
 	elf_dump_regs(*regs, task_pt_regs(tsk));
 	return 1;
 }
 int dump_task_fpu(struct task_struct *t, elf_fpregset_t *fpr)
 {
 	memcpy(fpr, &t->thread.fpu, sizeof(current->thread.fpu));
 	return 1;
 }
 /*
  * Create a kernel thread
  */
 static void __noreturn kernel_thread_helper(void *arg, int (*fn)(void *))
 {
 	do_exit(fn(arg));
 }
 long kernel_thread(int (*fn)(void *), void *arg, unsigned long flags)
 {
 	struct pt_regs regs;
 	memset(&regs, 0, sizeof(regs));
 	regs.regs[4] = (unsigned long) arg;
 	regs.regs[5] = (unsigned long) fn;
 	regs.cp0_epc = (unsigned long) kernel_thread_helper;
 	regs.cp0_status = read_c0_status();
 #if defined(CONFIG_CPU_R3000) || defined(CONFIG_CPU_TX39XX)
 	regs.cp0_status = (regs.cp0_status & ~(ST0_KUP | ST0_IEP | ST0_IEC)) |
 			  ((regs.cp0_status & (ST0_KUC | ST0_IEC)) << 2);
 #else
 	regs.cp0_status |= ST0_EXL;
 #endif
 	/* Ok, create the new process.. */
 	return do_fork(flags | CLONE_VM | CLONE_UNTRACED, 0, &regs, 0, NULL, NULL);
 }
 /*
  *
  */
 struct mips_frame_info {
 	void		*func;
 	unsigned long	func_size;
 	int		frame_size;
 	int		pc_offset;
 };
 static inline int is_ra_save_ins(union mips_instruction *ip)
 {
 	/* sw / sd $ra, offset($sp) */
 	return (ip->i_format.opcode == sw_op || ip->i_format.opcode == sd_op) &&
 		ip->i_format.rs == 29 &&
 		ip->i_format.rt == 31;
 }
 static inline int is_jal_jalr_jr_ins(union mips_instruction *ip)
 {
 	if (ip->j_format.opcode == jal_op)
 		return 1;
 	if (ip->r_format.opcode != spec_op)
 		return 0;
 	return ip->r_format.func == jalr_op || ip->r_format.func == jr_op;
 }
 static inline int is_sp_move_ins(union mips_instruction *ip)
 {
 	/* addiu/daddiu sp,sp,-imm */
 	if (ip->i_format.rs != 29 || ip->i_format.rt != 29)
 		return 0;
 	if (ip->i_format.opcode == addiu_op || ip->i_format.opcode == daddiu_op)
 		return 1;
 	return 0;
 }
 static int get_frame_info(struct mips_frame_info *info)
 {
 	union mips_instruction *ip = info->func;
 	unsigned max_insns = info->func_size / sizeof(union mips_instruction);
 	unsigned i;
 	info->pc_offset = -1;
 	info->frame_size = 0;
 	if (!ip)
 		goto err;
 	if (max_insns == 0)
 		max_insns = 128U;	/* unknown function size */
 	max_insns = min(128U, max_insns);
 	for (i = 0; i < max_insns; i++, ip++) {
 		if (is_jal_jalr_jr_ins(ip))
 			break;
 		if (!info->frame_size) {
 			if (is_sp_move_ins(ip))
 				info->frame_size = - ip->i_format.simmediate;
 			continue;
 		}
 		if (info->pc_offset == -1 && is_ra_save_ins(ip)) {
 			info->pc_offset =
 				ip->i_format.simmediate / sizeof(long);
 			break;
 		}
 	}
 	if (info->frame_size && info->pc_offset >= 0) /* nested */
 		return 0;
 	if (info->pc_offset < 0) /* leaf */
 		return 1;
 	/* prologue seems boggus... */
 err:
 	return -1;
 }
 static struct mips_frame_info schedule_mfi __read_mostly;
 static int __init frame_info_init(void)
 {
 	unsigned long size = 0;
 #ifdef CONFIG_KALLSYMS
 	unsigned long ofs;
 	kallsyms_lookup_size_offset((unsigned long)schedule, &size, &ofs);
 #endif
 	schedule_mfi.func = schedule;
 	schedule_mfi.func_size = size;
 	get_frame_info(&schedule_mfi);
 	/*
 	 * Without schedule() frame info, result given by
 	 * thread_saved_pc() and get_wchan() are not reliable.
 	 */
 	if (schedule_mfi.pc_offset < 0)
 		printk("Can't analyze schedule() prologue at %p\n", schedule);
 	return 0;
 }
 arch_initcall(frame_info_init);
 /*
  * Return saved PC of a blocked thread.
  */
 unsigned long thread_saved_pc(struct task_struct *tsk)
 {
 	struct thread_struct *t = &tsk->thread;
 	/* New born processes are a special case */
 	if (t->reg31 == (unsigned long) ret_from_fork)
 		return t->reg31;
 	if (schedule_mfi.pc_offset < 0)
 		return 0;
 	return ((unsigned long *)t->reg29)[schedule_mfi.pc_offset];
 }
 #ifdef CONFIG_KALLSYMS
-/* used by show_backtrace() */
+/* generic stack unwinding function */
-unsigned long unwind_stack(struct task_struct *task, unsigned long *sp,
+unsigned long notrace unwind_stack_by_address(unsigned long stack_page,
-			   unsigned long pc, unsigned long *ra)
+					      unsigned long *sp,
+					      unsigned long pc,
+					      unsigned long *ra)
 {
-	unsigned long stack_page;
 	struct mips_frame_info info;
 	unsigned long size, ofs;
 	int leaf;
 	extern void ret_from_irq(void);
 	extern void ret_from_exception(void);
-	stack_page = (unsigned long)task_stack_page(task);
 	if (!stack_page)
 		return 0;
 	/*
 	 * If we reached the bottom of interrupt context,
 	 * return saved pc in pt_regs.
 	 */
 	if (pc == (unsigned long)ret_from_irq ||
 	    pc == (unsigned long)ret_from_exception) {
 		struct pt_regs *regs;
 		if (*sp >= stack_page &&
 		    *sp + sizeof(*regs) <= stack_page + THREAD_SIZE - 32) {
 			regs = (struct pt_regs *)*sp;
 			pc = regs->cp0_epc;
 			if (__kernel_text_address(pc)) {
 				*sp = regs->regs[29];
 				*ra = regs->regs[31];
 				return pc;
 			}
 		}
 		return 0;
 	}
 	if (!kallsyms_lookup_size_offset(pc, &size, &ofs))
 		return 0;
 	/*
 	 * Return ra if an exception occurred at the first instruction
 	 */
 	if (unlikely(ofs == 0)) {
 		pc = *ra;
 		*ra = 0;
 		return pc;
 	}
 	info.func = (void *)(pc - ofs);
 	info.func_size = ofs;	/* analyze from start to ofs */
 	leaf = get_frame_info(&info);
 	if (leaf < 0)
 		return 0;
 	if (*sp < stack_page ||
 	    *sp + info.frame_size > stack_page + THREAD_SIZE - 32)
 		return 0;
 	if (leaf)
 		/*
 		 * For some extreme cases, get_frame_info() can
 		 * consider wrongly a nested function as a leaf
 		 * one. In that cases avoid to return always the
 		 * same value.
 		 */
 		pc = pc != *ra ? *ra : 0;
 	else
 		pc = ((unsigned long *)(*sp))[info.pc_offset];
 	*sp += info.frame_size;
 	*ra = 0;
 	return __kernel_text_address(pc) ? pc : 0;
+}
+EXPORT_SYMBOL(unwind_stack_by_address);
+/* used by show_backtrace() */
+unsigned long unwind_stack(struct task_struct *task, unsigned long *sp,
+			   unsigned long pc, unsigned long *ra)
+{
+	unsigned long stack_page = (unsigned long)task_stack_page(task);
+	return unwind_stack_by_address(stack_page, sp, pc, ra);
 }
 #endif
 /*
  * get_wchan - a maintenance nightmare^W^Wpain in the ass ...
  */
 unsigned long get_wchan(struct task_struct *task)
 {
 	unsigned long pc = 0;
 #ifdef CONFIG_KALLSYMS
 	unsigned long sp;
 	unsigned long ra = 0;
 #endif
 	if (!task || task == current || task->state == TASK_RUNNING)
 		goto out;
 	if (!task_stack_page(task))
 		goto out;
 	pc = thread_saved_pc(task);
 #ifdef CONFIG_KALLSYMS
 	sp = task->thread.reg29 + schedule_mfi.frame_size;
 	while (in_sched_functions(pc))
 		pc = unwind_stack(task, &sp, pc, &ra);
 #endif
 out:
 	return pc;
 }
 /*
  * Don't forget that the stack pointer must be aligned on a 8 bytes
  * boundary for 32-bits ABI and 16 bytes for 64-bits ABI.
  */
 unsigned long arch_align_stack(unsigned long sp)
 {
 	if (!(current->personality & ADDR_NO_RANDOMIZE) && randomize_va_space)
 		sp -= get_random_int() & ~PAGE_MASK;
 	return sp & ALMASK;

arch/mips/oprofile/Makefile

Diff comments View file @ 9f8b6a6

1	ccflags-y := -Werror	1	ccflags-y := -Werror
2		2
3	obj-$(CONFIG_OPROFILE) += oprofile.o	3	obj-$(CONFIG_OPROFILE) += oprofile.o
4		4
5	DRIVER_OBJS = $(addprefix ../../../drivers/oprofile/, \	5	DRIVER_OBJS = $(addprefix ../../../drivers/oprofile/, \
6	oprof.o cpu_buffer.o buffer_sync.o \	6	oprof.o cpu_buffer.o buffer_sync.o \
7	event_buffer.o oprofile_files.o \	7	event_buffer.o oprofile_files.o \
8	oprofilefs.o oprofile_stats.o \	8	oprofilefs.o oprofile_stats.o \
9	timer_int.o )	9	timer_int.o )
10		10
11	oprofile-y := $(DRIVER_OBJS) common.o	11	oprofile-y := $(DRIVER_OBJS) common.o backtrace.o
12		12
13	oprofile-$(CONFIG_CPU_MIPS32) += op_model_mipsxx.o	13	oprofile-$(CONFIG_CPU_MIPS32) += op_model_mipsxx.o
14	oprofile-$(CONFIG_CPU_MIPS64) += op_model_mipsxx.o	14	oprofile-$(CONFIG_CPU_MIPS64) += op_model_mipsxx.o
15	oprofile-$(CONFIG_CPU_R10000) += op_model_mipsxx.o	15	oprofile-$(CONFIG_CPU_R10000) += op_model_mipsxx.o
16	oprofile-$(CONFIG_CPU_SB1) += op_model_mipsxx.o	16	oprofile-$(CONFIG_CPU_SB1) += op_model_mipsxx.o
17	oprofile-$(CONFIG_CPU_RM9000) += op_model_rm9000.o	17	oprofile-$(CONFIG_CPU_RM9000) += op_model_rm9000.o
18	oprofile-$(CONFIG_CPU_LOONGSON2) += op_model_loongson2.o	18	oprofile-$(CONFIG_CPU_LOONGSON2) += op_model_loongson2.o
19		19

arch/mips/oprofile/backtrace.c

Diff comments View file @ 9f8b6a6

File was created	1	#include <linux/oprofile.h>
	2	#include <linux/sched.h>
	3	#include <linux/mm.h>
	4	#include <linux/uaccess.h>
	5	#include <asm/ptrace.h>
	6	#include <asm/stacktrace.h>
	7	#include <linux/stacktrace.h>
	8	#include <linux/kernel.h>
	9	#include <asm/sections.h>
	10	#include <asm/inst.h>
	11
	12	struct stackframe {
	13	unsigned long sp;
	14	unsigned long pc;
	15	unsigned long ra;
	16	};
	17
	18	static inline int get_mem(unsigned long addr, unsigned long *result)
	19	{
	20	unsigned long address = (unsigned long ) addr;
	21	if (!access_ok(VERIFY_READ, addr, sizeof(unsigned long)))
	22	return -1;
	23	if (__copy_from_user_inatomic(result, address, sizeof(unsigned long)))
	24	return -3;
	25	return 0;
	26	}
	27
	28	/*
	29	* These two instruction helpers were taken from process.c
	30	*/
	31	static inline int is_ra_save_ins(union mips_instruction *ip)
	32	{
	33	/* sw / sd $ra, offset($sp) */
	34	return (ip->i_format.opcode == sw_op \|\| ip->i_format.opcode == sd_op)
	35	&& ip->i_format.rs == 29 && ip->i_format.rt == 31;
	36	}
	37
	38	static inline int is_sp_move_ins(union mips_instruction *ip)
	39	{
	40	/* addiu/daddiu sp,sp,-imm */
	41	if (ip->i_format.rs != 29 \|\| ip->i_format.rt != 29)
	42	return 0;
	43	if (ip->i_format.opcode == addiu_op \|\| ip->i_format.opcode == daddiu_op)
	44	return 1;
	45	return 0;
	46	}
	47
	48	/*
	49	* Looks for specific instructions that mark the end of a function.
	50	* This usually means we ran into the code area of the previous function.
	51	*/
	52	static inline int is_end_of_function_marker(union mips_instruction *ip)
	53	{
	54	/* jr ra */
	55	if (ip->r_format.func == jr_op && ip->r_format.rs == 31)
	56	return 1;
	57	/* lui gp */
	58	if (ip->i_format.opcode == lui_op && ip->i_format.rt == 28)
	59	return 1;
	60	return 0;
	61	}
	62
	63	/*
	64	* TODO for userspace stack unwinding:
	65	* - handle cases where the stack is adjusted inside a function
	66	* (generally doesn't happen)
	67	* - find optimal value for max_instr_check
	68	* - try to find a way to handle leaf functions
	69	*/
	70
	71	static inline int unwind_user_frame(struct stackframe *old_frame,
	72	const unsigned int max_instr_check)
	73	{
	74	struct stackframe new_frame = *old_frame;
	75	off_t ra_offset = 0;
	76	size_t stack_size = 0;
	77	unsigned long addr;
	78
	79	if (old_frame->pc == 0 \|\| old_frame->sp == 0 \|\| old_frame->ra == 0)
	80	return -9;
	81
	82	for (addr = new_frame.pc; (addr + max_instr_check > new_frame.pc)
	83	&& (!ra_offset \|\| !stack_size); --addr) {
	84	union mips_instruction ip;
	85
	86	if (get_mem(addr, (unsigned long *) &ip))
	87	return -11;
	88
	89	if (is_sp_move_ins(&ip)) {
	90	int stack_adjustment = ip.i_format.simmediate;
	91	if (stack_adjustment > 0)
	92	/* This marks the end of the previous function,
	93	which means we overran. */
	94	break;
	95	stack_size = (unsigned) stack_adjustment;
	96	} else if (is_ra_save_ins(&ip)) {
	97	int ra_slot = ip.i_format.simmediate;
	98	if (ra_slot < 0)
	99	/* This shouldn't happen. */
	100	break;
	101	ra_offset = ra_slot;
	102	} else if (is_end_of_function_marker(&ip))
	103	break;
	104	}
	105
	106	if (!ra_offset \|\| !stack_size)
	107	return -1;
	108
	109	if (ra_offset) {
	110	new_frame.ra = old_frame->sp + ra_offset;
	111	if (get_mem(new_frame.ra, &(new_frame.ra)))
	112	return -13;
	113	}
	114
	115	if (stack_size) {
	116	new_frame.sp = old_frame->sp + stack_size;
	117	if (get_mem(new_frame.sp, &(new_frame.sp)))
	118	return -14;
	119	}
	120
	121	if (new_frame.sp > old_frame->sp)
	122	return -2;
	123
	124	new_frame.pc = old_frame->ra;
	125	*old_frame = new_frame;
	126
	127	return 0;
	128	}
	129
	130	static inline void do_user_backtrace(unsigned long low_addr,
	131	struct stackframe *frame,
	132	unsigned int depth)
	133	{
	134	const unsigned int max_instr_check = 512;
	135	const unsigned long high_addr = low_addr + THREAD_SIZE;
	136
	137	while (depth-- && !unwind_user_frame(frame, max_instr_check)) {
	138	oprofile_add_trace(frame->ra);
	139	if (frame->sp < low_addr \|\| frame->sp > high_addr)
	140	break;
	141	}
	142	}
	143
	144	#ifndef CONFIG_KALLSYMS
	145	static inline void do_kernel_backtrace(unsigned long low_addr,
	146	struct stackframe *frame,
	147	unsigned int depth) { }
	148	#else
	149	static inline void do_kernel_backtrace(unsigned long low_addr,
	150	struct stackframe *frame,
	151	unsigned int depth)
	152	{
	153	while (depth-- && frame->pc) {
	154	frame->pc = unwind_stack_by_address(low_addr,
	155	&(frame->sp),
	156	frame->pc,
	157	&(frame->ra));
	158	oprofile_add_trace(frame->ra);
	159	}
	160	}
	161	#endif
	162
	163	void notrace op_mips_backtrace(struct pt_regs *const regs, unsigned int depth)
	164	{
	165	struct stackframe frame = { .sp = regs->regs[29],
	166	.pc = regs->cp0_epc,
	167	.ra = regs->regs[31] };
	168	const int userspace = user_mode(regs);
	169	const unsigned long low_addr = ALIGN(frame.sp, THREAD_SIZE);
	170
	171	if (userspace)
	172	do_user_backtrace(low_addr, &frame, depth);
	173	else
	174	do_kernel_backtrace(low_addr, &frame, depth);
	175	}
	176

arch/mips/oprofile/common.c

Diff comments View file @ 9f8b6a6

 /*
  * This file is subject to the terms and conditions of the GNU General Public
  * License.  See the file "COPYING" in the main directory of this archive
  * for more details.
  *
  * Copyright (C) 2004, 2005 Ralf Baechle
  * Copyright (C) 2005 MIPS Technologies, Inc.
  */
 #include <linux/compiler.h>
 #include <linux/errno.h>
 #include <linux/init.h>
 #include <linux/oprofile.h>
 #include <linux/smp.h>
 #include <asm/cpu-info.h>
 #include "op_impl.h"
 extern struct op_mips_model op_model_mipsxx_ops __weak;
 extern struct op_mips_model op_model_rm9000_ops __weak;
 extern struct op_mips_model op_model_loongson2_ops __weak;
 static struct op_mips_model *model;
 static struct op_counter_config ctr[20];
 static int op_mips_setup(void)
 {
 	/* Pre-compute the values to stuff in the hardware registers.  */
 	model->reg_setup(ctr);
 	/* Configure the registers on all cpus.  */
 	on_each_cpu(model->cpu_setup, NULL, 1);
         return 0;
 }
 static int op_mips_create_files(struct super_block *sb, struct dentry *root)
 {
 	int i;
 	for (i = 0; i < model->num_counters; ++i) {
 		struct dentry *dir;
 		char buf[4];
 		snprintf(buf, sizeof buf, "%d", i);
 		dir = oprofilefs_mkdir(sb, root, buf);
 		oprofilefs_create_ulong(sb, dir, "enabled", &ctr[i].enabled);
 		oprofilefs_create_ulong(sb, dir, "event", &ctr[i].event);
 		oprofilefs_create_ulong(sb, dir, "count", &ctr[i].count);
 		oprofilefs_create_ulong(sb, dir, "kernel", &ctr[i].kernel);
 		oprofilefs_create_ulong(sb, dir, "user", &ctr[i].user);
 		oprofilefs_create_ulong(sb, dir, "exl", &ctr[i].exl);
 		/* Dummy.  */
 		oprofilefs_create_ulong(sb, dir, "unit_mask", &ctr[i].unit_mask);
 	}
 	return 0;
 }
 static int op_mips_start(void)
 {
 	on_each_cpu(model->cpu_start, NULL, 1);
 	return 0;
 }
 static void op_mips_stop(void)
 {
 	/* Disable performance monitoring for all counters.  */
 	on_each_cpu(model->cpu_stop, NULL, 1);
 }
 int __init oprofile_arch_init(struct oprofile_operations *ops)
 {
 	struct op_mips_model *lmodel = NULL;
 	int res;
 	switch (current_cpu_type()) {
 	case CPU_5KC:
 	case CPU_20KC:
 	case CPU_24K:
 	case CPU_25KF:
 	case CPU_34K:
 	case CPU_1004K:
 	case CPU_74K:
 	case CPU_SB1:
 	case CPU_SB1A:
 	case CPU_R10000:
 	case CPU_R12000:
 	case CPU_R14000:
 		lmodel = &op_model_mipsxx_ops;
 		break;
 	case CPU_RM9000:
 		lmodel = &op_model_rm9000_ops;
 		break;
 	case CPU_LOONGSON2:
 		lmodel = &op_model_loongson2_ops;
 		break;
 	};
 	if (!lmodel)
 		return -ENODEV;
 	res = lmodel->init();
 	if (res)
 		return res;
 	model = lmodel;
 	ops->create_files	= op_mips_create_files;
 	ops->setup		= op_mips_setup;
 	//ops->shutdown         = op_mips_shutdown;
 	ops->start		= op_mips_start;
 	ops->stop		= op_mips_stop;
 	ops->cpu_type		= lmodel->cpu_type;
+	ops->backtrace		= op_mips_backtrace;
 	printk(KERN_INFO "oprofile: using %s performance monitoring.\n",
 	       lmodel->cpu_type);
 	return 0;
 }
 void oprofile_arch_exit(void)
 {
 	if (model)
 		model->exit();
 }

arch/mips/oprofile/op_impl.h

Diff comments View file @ 9f8b6a6

 /**
  * @file arch/alpha/oprofile/op_impl.h
  *
  * @remark Copyright 2002 OProfile authors
  * @remark Read the file COPYING
  *
  * @author Richard Henderson <rth@twiddle.net>
  */
 #ifndef OP_IMPL_H
 #define OP_IMPL_H 1
 extern int (*perf_irq)(void);
 /* Per-counter configuration as set via oprofilefs.  */
 struct op_counter_config {
 	unsigned long enabled;
 	unsigned long event;
 	unsigned long count;
 	/* Dummies because I am too lazy to hack the userspace tools.  */
 	unsigned long kernel;
 	unsigned long user;
 	unsigned long exl;
 	unsigned long unit_mask;
 };
 /* Per-architecture configury and hooks.  */
 struct op_mips_model {
 	void (*reg_setup) (struct op_counter_config *);
 	void (*cpu_setup) (void *dummy);
 	int (*init)(void);
 	void (*exit)(void);
 	void (*cpu_start)(void *args);
 	void (*cpu_stop)(void *args);
 	char *cpu_type;
 	unsigned char num_counters;
 };
+void op_mips_backtrace(struct pt_regs * const regs, unsigned int depth);
 #endif

arch/x86/oprofile/backtrace.c

Diff comments View file @ 9f8b6a6

 /**
  * @file backtrace.c
  *
  * @remark Copyright 2002 OProfile authors
  * @remark Read the file COPYING
  *
  * @author John Levon
  * @author David Smith
  */
 #include <linux/oprofile.h>
 #include <linux/sched.h>
 #include <linux/mm.h>
+#include <linux/compat.h>
+#include <linux/highmem.h>
 #include <asm/ptrace.h>
 #include <asm/uaccess.h>
 #include <asm/stacktrace.h>
-#include <linux/compat.h>
 static int backtrace_stack(void *data, char *name)
 {
 	/* Yes, we want all stacks */
 	return 0;
 }
 static void backtrace_address(void *data, unsigned long addr, int reliable)
 {
 	unsigned int *depth = data;
 	if ((*depth)--)
 		oprofile_add_trace(addr);
 }
 static struct stacktrace_ops backtrace_ops = {
 	.stack		= backtrace_stack,
 	.address	= backtrace_address,
 	.walk_stack	= print_context_stack,
 };
+/* from arch/x86/kernel/cpu/perf_event.c: */
+/*
+ * best effort, GUP based copy_from_user() that assumes IRQ or NMI context
+ */
+static unsigned long
+copy_from_user_nmi(void *to, const void __user *from, unsigned long n)
+{
+	unsigned long offset, addr = (unsigned long)from;
+	unsigned long size, len = 0;
+	struct page *page;
+	void *map;
+	int ret;
+	do {
+		ret = __get_user_pages_fast(addr, 1, 0, &page);
+		if (!ret)
+			break;
+		offset = addr & (PAGE_SIZE - 1);
+		size = min(PAGE_SIZE - offset, n - len);
+		map = kmap_atomic(page);
+		memcpy(to, map+offset, size);
+		kunmap_atomic(map);
+		put_page(page);
+		len  += size;
+		to   += size;
+		addr += size;
+	} while (len < n);
+	return len;
+}
 #ifdef CONFIG_COMPAT
 static struct stack_frame_ia32 *
 dump_user_backtrace_32(struct stack_frame_ia32 *head)
 {
+	/* Also check accessibility of one struct frame_head beyond: */
 	struct stack_frame_ia32 bufhead[2];
 	struct stack_frame_ia32 *fp;
+	unsigned long bytes;
-	/* Also check accessibility of one struct frame_head beyond */
+	bytes = copy_from_user_nmi(bufhead, head, sizeof(bufhead));
-	if (!access_ok(VERIFY_READ, head, sizeof(bufhead)))
+	if (bytes != sizeof(bufhead))
 		return NULL;
-	if (__copy_from_user_inatomic(bufhead, head, sizeof(bufhead)))
-		return NULL;
 	fp = (struct stack_frame_ia32 *) compat_ptr(bufhead[0].next_frame);
 	oprofile_add_trace(bufhead[0].return_address);
 	/* frame pointers should strictly progress back up the stack
 	* (towards higher addresses) */
 	if (head >= fp)
 		return NULL;
 	return fp;
 }
 static inline int
 x86_backtrace_32(struct pt_regs * const regs, unsigned int depth)
 {
 	struct stack_frame_ia32 *head;
 	/* User process is 32-bit */
 	if (!current || !test_thread_flag(TIF_IA32))
 		return 0;
 	head = (struct stack_frame_ia32 *) regs->bp;
 	while (depth-- && head)
 		head = dump_user_backtrace_32(head);
 	return 1;
 }
 #else
 static inline int
 x86_backtrace_32(struct pt_regs * const regs, unsigned int depth)
 {
 	return 0;
 }
 #endif /* CONFIG_COMPAT */
 static struct stack_frame *dump_user_backtrace(struct stack_frame *head)
 {
+	/* Also check accessibility of one struct frame_head beyond: */
 	struct stack_frame bufhead[2];
+	unsigned long bytes;
-	/* Also check accessibility of one struct stack_frame beyond */
+	bytes = copy_from_user_nmi(bufhead, head, sizeof(bufhead));
-	if (!access_ok(VERIFY_READ, head, sizeof(bufhead)))
+	if (bytes != sizeof(bufhead))
-		return NULL;
-	if (__copy_from_user_inatomic(bufhead, head, sizeof(bufhead)))
 		return NULL;
 	oprofile_add_trace(bufhead[0].return_address);
 	/* frame pointers should strictly progress back up the stack
 	 * (towards higher addresses) */
 	if (head >= bufhead[0].next_frame)
 		return NULL;
 	return bufhead[0].next_frame;
 }
 void
 x86_backtrace(struct pt_regs * const regs, unsigned int depth)
 {
 	struct stack_frame *head = (struct stack_frame *)frame_pointer(regs);
 	if (!user_mode_vm(regs)) {
 		unsigned long stack = kernel_stack_pointer(regs);
 		if (depth)
 			dump_trace(NULL, regs, (unsigned long *)stack, 0,
 				   &backtrace_ops, &depth);
 		return;
 	}
 	if (x86_backtrace_32(regs, depth))
 		return;

arch/x86/oprofile/nmi_int.c

Diff comments View file @ 9f8b6a6

 /**
  * @file nmi_int.c
  *
  * @remark Copyright 2002-2009 OProfile authors
  * @remark Read the file COPYING
  *
  * @author John Levon <levon@movementarian.org>
  * @author Robert Richter <robert.richter@amd.com>
  * @author Barry Kasindorf <barry.kasindorf@amd.com>
  * @author Jason Yeh <jason.yeh@amd.com>
  * @author Suravee Suthikulpanit <suravee.suthikulpanit@amd.com>
  */
 #include <linux/init.h>
 #include <linux/notifier.h>
 #include <linux/smp.h>
 #include <linux/oprofile.h>
 #include <linux/syscore_ops.h>
 #include <linux/slab.h>
 #include <linux/moduleparam.h>
 #include <linux/kdebug.h>
 #include <linux/cpu.h>
 #include <asm/nmi.h>
 #include <asm/msr.h>
 #include <asm/apic.h>
 #include "op_counter.h"
 #include "op_x86_model.h"
 static struct op_x86_model_spec *model;
 static DEFINE_PER_CPU(struct op_msrs, cpu_msrs);
 static DEFINE_PER_CPU(unsigned long, saved_lvtpc);
 /* must be protected with get_online_cpus()/put_online_cpus(): */
 static int nmi_enabled;
 static int ctr_running;
 struct op_counter_config counter_config[OP_MAX_COUNTER];
 /* 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;
 	counter_config->extra &= (ARCH_PERFMON_EVENTSEL_INV |
 				  ARCH_PERFMON_EVENTSEL_EDGE |
 				  ARCH_PERFMON_EVENTSEL_CMASK);
 	val |= counter_config->extra;
 	event &= model->event_mask ? model->event_mask : 0xFF;
 	val |= event & 0xFF;
 	val |= (event & 0x0F00) << 24;
 	return val;
 }
 static int profile_exceptions_notify(struct notifier_block *self,
 				     unsigned long val, void *data)
 {
 	struct die_args *args = (struct die_args *)data;
 	int ret = NOTIFY_DONE;
 	switch (val) {
 	case DIE_NMI:
 		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));
 		ret = NOTIFY_STOP;
 		break;
 	default:
 		break;
 	}
 	return ret;
 }
 static void nmi_cpu_save_registers(struct op_msrs *msrs)
 {
 	struct op_msr *counters = msrs->counters;
 	struct op_msr *controls = msrs->controls;
 	unsigned int i;
 	for (i = 0; i < model->num_counters; ++i) {
 		if (counters[i].addr)
 			rdmsrl(counters[i].addr, counters[i].saved);
 	}
 	for (i = 0; i < model->num_controls; ++i) {
 		if (controls[i].addr)
 			rdmsrl(controls[i].addr, controls[i].saved);
 	}
 }
 static void nmi_cpu_start(void *dummy)
 {
 	struct op_msrs const *msrs = &__get_cpu_var(cpu_msrs);
 	if (!msrs->controls)
 		WARN_ON_ONCE(1);
 	else
 		model->start(msrs);
 }
 static int nmi_start(void)
 {
 	get_online_cpus();
-	on_each_cpu(nmi_cpu_start, NULL, 1);
 	ctr_running = 1;
+	/* make ctr_running visible to the nmi handler: */
+	smp_mb();
+	on_each_cpu(nmi_cpu_start, NULL, 1);
 	put_online_cpus();
 	return 0;
 }
 static void nmi_cpu_stop(void *dummy)
 {
 	struct op_msrs const *msrs = &__get_cpu_var(cpu_msrs);
 	if (!msrs->controls)
 		WARN_ON_ONCE(1);
 	else
 		model->stop(msrs);
 }
 static void nmi_stop(void)
 {
 	get_online_cpus();
 	on_each_cpu(nmi_cpu_stop, NULL, 1);
 	ctr_running = 0;
 	put_online_cpus();
 }
 #ifdef CONFIG_OPROFILE_EVENT_MULTIPLEX
 static DEFINE_PER_CPU(int, switch_index);
 static inline int has_mux(void)
 {
 	return !!model->switch_ctrl;
 }
 inline int op_x86_phys_to_virt(int phys)
 {
 	return __this_cpu_read(switch_index) + phys;
 }
 inline int op_x86_virt_to_phys(int virt)
 {
 	return virt % model->num_counters;
 }
 static void nmi_shutdown_mux(void)
 {
 	int i;
 	if (!has_mux())
 		return;
 	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;
 	if (!has_mux())
 		return 1;
 	for_each_possible_cpu(i) {
 		per_cpu(cpu_msrs, i).multiplex =
 			kzalloc(multiplex_size, GFP_KERNEL);
 		if (!per_cpu(cpu_msrs, i).multiplex)
 			return 0;
 	}
 	return 1;
 }
 static void nmi_cpu_setup_mux(int cpu, struct op_msrs const * const msrs)
 {
 	int i;
 	struct op_msr *multiplex = msrs->multiplex;
 	if (!has_mux())
 		return;
 	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;
 }
 static void nmi_cpu_save_mpx_registers(struct op_msrs *msrs)
 {
 	struct op_msr *counters = msrs->counters;
 	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 (counters[i].addr)
 			rdmsrl(counters[i].addr, multiplex[virt].saved);
 	}
 }
 static void nmi_cpu_restore_mpx_registers(struct op_msrs *msrs)
 {
 	struct op_msr *counters = msrs->counters;
 	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 (counters[i].addr)
 			wrmsrl(counters[i].addr, multiplex[virt].saved);
 	}
 }
 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)
 {
 	if (!has_mux())
 		return -ENOSYS;		/* not implemented */
 	if (nmi_multiplex_on() < 0)
 		return -EINVAL;		/* not necessary */
 	get_online_cpus();
 	if (ctr_running)
 		on_each_cpu(nmi_cpu_switch, NULL, 1);
 	put_online_cpus();
 	return 0;
 }
 static inline void mux_init(struct oprofile_operations *ops)
 {
 	if (has_mux())
 		ops->switch_events = nmi_switch_event;
 }
 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);
 }
 #else
 inline int op_x86_phys_to_virt(int phys) { return phys; }
 inline int op_x86_virt_to_phys(int virt) { return virt; }
 static inline void nmi_shutdown_mux(void) { }
 static inline int nmi_setup_mux(void) { return 1; }
 static inline void
 nmi_cpu_setup_mux(int cpu, struct op_msrs const * const msrs) { }
 static inline void mux_init(struct oprofile_operations *ops) { }
 static void mux_clone(int cpu) { }
 #endif
 static void free_msrs(void)
 {
 	int i;
 	for_each_possible_cpu(i) {
 		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;
 	}
 	nmi_shutdown_mux();
 }
 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;
 	int i;
 	for_each_possible_cpu(i) {
 		per_cpu(cpu_msrs, i).counters = kzalloc(counters_size,
 							GFP_KERNEL);
 		if (!per_cpu(cpu_msrs, i).counters)
 			goto fail;
 		per_cpu(cpu_msrs, i).controls = kzalloc(controls_size,
 							GFP_KERNEL);
 		if (!per_cpu(cpu_msrs, i).controls)
 			goto fail;
 	}
 	if (!nmi_setup_mux())
 		goto fail;
 	return 1;
 fail:
 	free_msrs();
 	return 0;
 }
 static void nmi_cpu_setup(void *dummy)
 {
 	int cpu = smp_processor_id();
 	struct op_msrs *msrs = &per_cpu(cpu_msrs, cpu);
 	nmi_cpu_save_registers(msrs);
 	spin_lock(&oprofilefs_lock);
 	model->setup_ctrs(model, msrs);
 	nmi_cpu_setup_mux(cpu, msrs);
 	spin_unlock(&oprofilefs_lock);
 	per_cpu(saved_lvtpc, cpu) = apic_read(APIC_LVTPC);
 	apic_write(APIC_LVTPC, APIC_DM_NMI);
 }
 static struct notifier_block profile_exceptions_nb = {
 	.notifier_call = profile_exceptions_notify,
 	.next = NULL,
 	.priority = NMI_LOCAL_LOW_PRIOR,
 };
 static void nmi_cpu_restore_registers(struct op_msrs *msrs)
 {
 	struct op_msr *counters = msrs->counters;
 	struct op_msr *controls = msrs->controls;
 	unsigned int i;
 	for (i = 0; i < model->num_controls; ++i) {
 		if (controls[i].addr)
 			wrmsrl(controls[i].addr, controls[i].saved);
 	}
 	for (i = 0; i < model->num_counters; ++i) {
 		if (counters[i].addr)
 			wrmsrl(counters[i].addr, counters[i].saved);
 	}
 }
 static void nmi_cpu_shutdown(void *dummy)
 {
 	unsigned int v;
 	int cpu = smp_processor_id();
 	struct op_msrs *msrs = &per_cpu(cpu_msrs, cpu);
 	/* 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);
 	apic_write(APIC_LVTPC, per_cpu(saved_lvtpc, cpu));
 	apic_write(APIC_LVTERR, v);
 	nmi_cpu_restore_registers(msrs);
 	if (model->cpu_down)
 		model->cpu_down();
 }
 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);
 }
 static int nmi_create_files(struct super_block *sb, struct dentry *root)
 {
 	unsigned int i;
 	for (i = 0; i < model->num_virt_counters; ++i) {
 		struct dentry *dir;
 		char buf[4];
 		/* quick little hack to _not_ expose a counter if it is not
 		 * available for use.  This should protect userspace app.
 		 * NOTE:  assumes 1:1 mapping here (that counters are organized
 		 *        sequentially in their struct assignment).
 		 */
 		if (!avail_to_resrv_perfctr_nmi_bit(op_x86_virt_to_phys(i)))
 			continue;
 		snprintf(buf,  sizeof(buf), "%d", i);
 		dir = oprofilefs_mkdir(sb, root, buf);
 		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);
 		oprofilefs_create_ulong(sb, dir, "extra", &counter_config[i].extra);
 	}
 	return 0;
 }
 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_up, NULL, 0);
 		break;
 	case CPU_DOWN_PREPARE:
 		smp_call_function_single(cpu, nmi_cpu_down, NULL, 1);
 		break;
 	}
 	return NOTIFY_DONE;
 }
 static struct notifier_block oprofile_cpu_nb = {
 	.notifier_call = oprofile_cpu_notifier
 };
 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();
+	/* make variables visible to the nmi handler: */
+	smp_mb();
 	err = register_die_notifier(&profile_exceptions_nb);
 	if (err)
 		goto fail;
 	get_online_cpus();
 	register_cpu_notifier(&oprofile_cpu_nb);
-	on_each_cpu(nmi_cpu_setup, NULL, 1);
 	nmi_enabled = 1;
+	/* make nmi_enabled visible to the nmi handler: */
+	smp_mb();
+	on_each_cpu(nmi_cpu_setup, NULL, 1);
 	put_online_cpus();
 	return 0;
 fail:
 	free_msrs();
 	return err;
 }
 static void nmi_shutdown(void)
 {
 	struct op_msrs *msrs;
 	get_online_cpus();
 	unregister_cpu_notifier(&oprofile_cpu_nb);
 	on_each_cpu(nmi_cpu_shutdown, NULL, 1);
 	nmi_enabled = 0;
 	ctr_running = 0;
 	put_online_cpus();
-	barrier();
+	/* make variables visible to the nmi handler: */
+	smp_mb();
 	unregister_die_notifier(&profile_exceptions_nb);
 	msrs = &get_cpu_var(cpu_msrs);
 	model->shutdown(msrs);
 	free_msrs();
 	put_cpu_var(cpu_msrs);
 }
 #ifdef CONFIG_PM
 static int nmi_suspend(void)
 {
 	/* Only one CPU left, just stop that one */
 	if (nmi_enabled == 1)
 		nmi_cpu_stop(NULL);
 	return 0;
 }
 static void nmi_resume(void)
 {
 	if (nmi_enabled == 1)
 		nmi_cpu_start(NULL);
 }
 static struct syscore_ops oprofile_syscore_ops = {
 	.resume		= nmi_resume,
 	.suspend	= nmi_suspend,
 };
 static void __init init_suspend_resume(void)
 {
 	register_syscore_ops(&oprofile_syscore_ops);
 }
 static void exit_suspend_resume(void)
 {
 	unregister_syscore_ops(&oprofile_syscore_ops);
 }
 #else
 static inline void init_suspend_resume(void) { }
 static inline void exit_suspend_resume(void) { }
 #endif /* CONFIG_PM */
 static int __init p4_init(char **cpu_type)
 {
 	__u8 cpu_model = boot_cpu_data.x86_model;
 	if (cpu_model > 6 || cpu_model == 5)
 		return 0;
 #ifndef CONFIG_SMP
 	*cpu_type = "i386/p4";
 	model = &op_p4_spec;
 	return 1;
 #else
 	switch (smp_num_siblings) {
 	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;
 	}
 #endif
 	printk(KERN_INFO "oprofile: P4 HyperThreading detected with > 2 threads\n");
 	printk(KERN_INFO "oprofile: Reverting to timer mode.\n");
 	return 0;
 }
 static int force_arch_perfmon;
 static int force_cpu_type(const char *str, struct kernel_param *kp)
 {
 	if (!strcmp(str, "arch_perfmon")) {
 		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);
 static int __init ppro_init(char **cpu_type)
 {
 	__u8 cpu_model = boot_cpu_data.x86_model;
 	struct op_x86_model_spec *spec = &op_ppro_spec;	/* default */
 	if (force_arch_perfmon && cpu_has_arch_perfmon)
 		return 0;
 	/*
 	 * 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".
 	 */
 	switch (cpu_model) {
 	case 0 ... 2:
 		*cpu_type = "i386/ppro";
 		break;
 	case 3 ... 5:
 		*cpu_type = "i386/pii";
 		break;
 	case 6 ... 8:
 	case 10 ... 11:
 		*cpu_type = "i386/piii";
 		break;
 	case 9:
 	case 13:
 		*cpu_type = "i386/p6_mobile";
 		break;
 	case 14:
 		*cpu_type = "i386/core";
 		break;
 	case 0x0f:
 	case 0x16:
 	case 0x17:
 	case 0x1d:
 		*cpu_type = "i386/core_2";
 		break;
 	case 0x1a:
 	case 0x1e:
 	case 0x2e:
 		spec = &op_arch_perfmon_spec;
 		*cpu_type = "i386/core_i7";
 		break;
 	case 0x1c:
 		*cpu_type = "i386/atom";
 		break;
 	default:
 		/* Unknown */
 		return 0;
 	}
 	model = spec;
 	return 1;
 }
 int __init op_nmi_init(struct oprofile_operations *ops)
 {
 	__u8 vendor = boot_cpu_data.x86_vendor;
 	__u8 family = boot_cpu_data.x86;
 	char *cpu_type = NULL;
 	int ret = 0;
 	if (!cpu_has_apic)
 		return -ENODEV;
 	switch (vendor) {
 	case X86_VENDOR_AMD:
 		/* Needs to be at least an Athlon (or hammer in 32bit mode) */
 		switch (family) {
 		case 6:
 			cpu_type = "i386/athlon";
 			break;
 		case 0xf:
 			/*
 			 * Actually it could be i386/hammer too, but
 			 * give user space an consistent name.
 			 */
 			cpu_type = "x86-64/hammer";
 			break;
 		case 0x10:
 			cpu_type = "x86-64/family10";
 			break;
 		case 0x11:
 			cpu_type = "x86-64/family11h";
 			break;
 		case 0x12:
 			cpu_type = "x86-64/family12h";
 			break;
 		case 0x14:
 			cpu_type = "x86-64/family14h";
 			break;
 		case 0x15:
 			cpu_type = "x86-64/family15h";
 			break;
 		default:
 			return -ENODEV;
 		}
 		model = &op_amd_spec;
 		break;
 	case X86_VENDOR_INTEL:
 		switch (family) {
 			/* Pentium IV */
 		case 0xf:
 			p4_init(&cpu_type);
 			break;
 			/* A P6-class processor */
 		case 6:
 			ppro_init(&cpu_type);
 			break;
 		default:
 			break;
 		}
 		if (cpu_type)
 			break;
 		if (!cpu_has_arch_perfmon)
 			return -ENODEV;
 		/* use arch perfmon as fallback */
 		cpu_type = "i386/arch_perfmon";
 		model = &op_arch_perfmon_spec;
 		break;
 	default:
 		return -ENODEV;
 	}
 	/* default values, can be overwritten by model */
 	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;
 	if (model->init)
 		ret = model->init(ops);
 	if (ret)
 		return ret;
 	if (!model->num_virt_counters)
 		model->num_virt_counters = model->num_counters;
 	mux_init(ops);
 	init_suspend_resume();
 	printk(KERN_INFO "oprofile: using NMI interrupt.\n");
 	return 0;
 }
 void op_nmi_exit(void)
 {
 	exit_suspend_resume();