Commit 13b54a50 authored by Haavard Skinnemoen's avatar Haavard Skinnemoen
Browse files

[AVR32] Enable debugging only when needed 



Keep track of processes being debugged (including the kernel itself)
and turn the OCD system on and off as appropriate. Since enabling
debugging turns off some optimizations in the CPU core, this fixes the
issue that enabling KProbes support or simply running a program under
gdbserver will reduce system performance significantly until the next
reboot.

The CPU performance will still be reduced for all processes while a
process is being debugged, but this is a lot better than reducing the
performance forever.

Signed-off-by: default avatarHaavard Skinnemoen <hskinnemoen@atmel.com>
parent 6ea6dd93

arch/avr32/kernel/Makefile

+1 −1
Original line number Diff line number Diff line
@@ -6,7 +6,7 @@ extra-y := head.o vmlinux.lds 


obj-$(CONFIG_SUBARCH_AVR32B)	+= entry-avr32b.o

obj-y				+= syscall_table.o syscall-stubs.o irq.o

obj-y				+= setup.o traps.o semaphore.o ptrace.o

obj-y				+= setup.o traps.o semaphore.o ocd.o ptrace.o

obj-y				+= signal.o sys_avr32.o process.o time.o

obj-y				+= init_task.o switch_to.o cpu.o

obj-$(CONFIG_MODULES)		+= module.o avr32_ksyms.o

arch/avr32/kernel/kprobes.c

+2 −3
Original line number Diff line number Diff line
@@ -48,6 +48,7 @@ int __kprobes arch_prepare_kprobe(struct kprobe *p) 
void __kprobes arch_arm_kprobe(struct kprobe *p)

{

	pr_debug("arming kprobe at %p\n", p->addr);

	ocd_enable(NULL);

	*p->addr = BREAKPOINT_INSTRUCTION;

	flush_icache_range((unsigned long)p->addr,

			   (unsigned long)p->addr + sizeof(kprobe_opcode_t));
@@ -56,6 +57,7 @@ void __kprobes arch_arm_kprobe(struct kprobe *p) 
void __kprobes arch_disarm_kprobe(struct kprobe *p)

{

	pr_debug("disarming kprobe at %p\n", p->addr);

	ocd_disable(NULL);

	*p->addr = p->opcode;

	flush_icache_range((unsigned long)p->addr,

			   (unsigned long)p->addr + sizeof(kprobe_opcode_t));
@@ -260,9 +262,6 @@ int __kprobes longjmp_break_handler(struct kprobe *p, struct pt_regs *regs) 


int __init arch_init_kprobes(void)

{

	printk("KPROBES: Enabling monitor mode (MM|DBE)...\n");

	ocd_write(DC, (1 << OCD_DC_MM_BIT) | (1 << OCD_DC_DBE_BIT));



	/* TODO: Register kretprobe trampoline */

	return 0;

}

arch/avr32/kernel/ocd.c

0 → 100644
+163 −0
Original line number Diff line number Diff line 
/*

 * Copyright (C) 2007 Atmel Corporation

 *

 * This program is free software; you can redistribute it and/or modify

 * it under the terms of the GNU General Public License version 2 as

 * published by the Free Software Foundation.

 */

#include <linux/init.h>

#include <linux/sched.h>

#include <linux/spinlock.h>



#include <asm/ocd.h>



static long ocd_count;

static spinlock_t ocd_lock;



/**

 * ocd_enable - enable on-chip debugging

 * @child: task to be debugged

 *

 * If @child is non-NULL, ocd_enable() first checks if debugging has

 * already been enabled for @child, and if it has, does nothing.

 *

 * If @child is NULL (e.g. when debugging the kernel), or debugging

 * has not already been enabled for it, ocd_enable() increments the

 * reference count and enables the debugging hardware.

 */

void ocd_enable(struct task_struct *child)

{

	u32 dc;



	if (child)

		pr_debug("ocd_enable: child=%s [%u]\n",

				child->comm, child->pid);

	else

		pr_debug("ocd_enable (no child)\n");



	if (!child || !test_and_set_tsk_thread_flag(child, TIF_DEBUG)) {

		spin_lock(&ocd_lock);

		ocd_count++;

		dc = ocd_read(DC);

		dc |= (1 << OCD_DC_MM_BIT) | (1 << OCD_DC_DBE_BIT);

		ocd_write(DC, dc);

		spin_unlock(&ocd_lock);

	}

}



/**

 * ocd_disable - disable on-chip debugging

 * @child: task that was being debugged, but isn't anymore

 *

 * If @child is non-NULL, ocd_disable() checks if debugging is enabled

 * for @child, and if it isn't, does nothing.

 *

 * If @child is NULL (e.g. when debugging the kernel), or debugging is

 * enabled, ocd_disable() decrements the reference count, and if it

 * reaches zero, disables the debugging hardware.

 */

void ocd_disable(struct task_struct *child)

{

	u32 dc;



	if (!child)

		pr_debug("ocd_disable (no child)\n");

	else if (test_tsk_thread_flag(child, TIF_DEBUG))

		pr_debug("ocd_disable: child=%s [%u]\n",

				child->comm, child->pid);



	if (!child || test_and_clear_tsk_thread_flag(child, TIF_DEBUG)) {

		spin_lock(&ocd_lock);

		ocd_count--;



		WARN_ON(ocd_count < 0);



		if (ocd_count <= 0) {

			dc = ocd_read(DC);

			dc &= ~((1 << OCD_DC_MM_BIT) | (1 << OCD_DC_DBE_BIT));

			ocd_write(DC, dc);

		}

		spin_unlock(&ocd_lock);

	}

}



#ifdef CONFIG_DEBUG_FS

#include <linux/debugfs.h>

#include <linux/module.h>



static struct dentry *ocd_debugfs_root;

static struct dentry *ocd_debugfs_DC;

static struct dentry *ocd_debugfs_DS;

static struct dentry *ocd_debugfs_count;



static u64 ocd_DC_get(void *data)

{

	return ocd_read(DC);

}

static void ocd_DC_set(void *data, u64 val)

{

	ocd_write(DC, val);

}

DEFINE_SIMPLE_ATTRIBUTE(fops_DC, ocd_DC_get, ocd_DC_set, "0x%08llx\n");



static u64 ocd_DS_get(void *data)

{

	return ocd_read(DS);

}

DEFINE_SIMPLE_ATTRIBUTE(fops_DS, ocd_DS_get, NULL, "0x%08llx\n");



static u64 ocd_count_get(void *data)

{

	return ocd_count;

}

DEFINE_SIMPLE_ATTRIBUTE(fops_count, ocd_count_get, NULL, "%lld\n");



static void ocd_debugfs_init(void)

{

	struct dentry *root;



	root = debugfs_create_dir("ocd", NULL);

	if (IS_ERR(root) || !root)

		goto err_root;

	ocd_debugfs_root = root;



	ocd_debugfs_DC = debugfs_create_file("DC", S_IRUSR | S_IWUSR,

				root, NULL, &fops_DC);

	if (!ocd_debugfs_DC)

		goto err_DC;



	ocd_debugfs_DS = debugfs_create_file("DS", S_IRUSR, root,

				NULL, &fops_DS);

	if (!ocd_debugfs_DS)

		goto err_DS;



	ocd_debugfs_count = debugfs_create_file("count", S_IRUSR, root,

				NULL, &fops_count);

	if (!ocd_debugfs_count)

		goto err_count;



	return;



err_count:

	debugfs_remove(ocd_debugfs_DS);

err_DS:

	debugfs_remove(ocd_debugfs_DC);

err_DC:

	debugfs_remove(ocd_debugfs_root);

err_root:

	printk(KERN_WARNING "OCD: Failed to create debugfs entries\n");

}

#else

static inline void ocd_debugfs_init(void)

{



}

#endif



static int __init ocd_init(void)

{

	spin_lock_init(&ocd_lock);

	ocd_debugfs_init();

	return 0;

}

arch_initcall(ocd_init);

arch/avr32/kernel/process.c

+4 −1
Original line number Diff line number Diff line
@@ -103,7 +103,7 @@ EXPORT_SYMBOL(kernel_thread); 
 */

void exit_thread(void)

{

	/* nothing to do */

	ocd_disable(current);

}



void flush_thread(void)
@@ -345,6 +345,9 @@ int copy_thread(int nr, unsigned long clone_flags, unsigned long usp, 
	p->thread.cpu_context.ksp = (unsigned long)childregs;

	p->thread.cpu_context.pc = (unsigned long)ret_from_fork;



	if ((clone_flags & CLONE_PTRACE) && test_thread_flag(TIF_DEBUG))

		ocd_enable(p);



	return 0;

}

arch/avr32/kernel/ptrace.c

+1 −4
Original line number Diff line number Diff line
@@ -58,6 +58,7 @@ void ptrace_disable(struct task_struct *child) 
{

	clear_tsk_thread_flag(child, TIF_SINGLE_STEP);

	clear_tsk_thread_flag(child, TIF_BREAKPOINT);

	ocd_disable(child);

}



/*
@@ -144,10 +145,6 @@ long arch_ptrace(struct task_struct *child, long request, long addr, long data) 
{

	int ret;



	pr_debug("ptrace: Enabling monitor mode...\n");

	ocd_write(DC, ocd_read(DC) | (1 << OCD_DC_MM_BIT)

			| (1 << OCD_DC_DBE_BIT));



	switch (request) {

	/* Read the word at location addr in the child process */

	case PTRACE_PEEKTEXT:

CRA Git | Maintained and supported by SUSTech CRA and CCSE