Release 4.7 kernel/debug/kdb/kdb_bp.c

/*
 * Kernel Debugger Architecture Independent Breakpoint Handler
 *
 * 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) 1999-2004 Silicon Graphics, Inc.  All Rights Reserved.
 * Copyright (c) 2009 Wind River Systems, Inc.  All Rights Reserved.
 */

#include <linux/string.h>
#include <linux/kernel.h>
#include <linux/init.h>
#include <linux/kdb.h>
#include <linux/kgdb.h>
#include <linux/smp.h>
#include <linux/sched.h>
#include <linux/interrupt.h>
#include "kdb_private.h"

/*
 * Table of kdb_breakpoints
 */

kdb_bp_t kdb_breakpoints[KDB_MAXBPT];



static void kdb_setsinglestep(struct pt_regs *regs)
{
	KDB_STATE_SET(DOING_SS);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
jason wessel
jason wessel
16
100.00%
1
100.00%
Total
16
100.00%
1
100.00%


static char *kdb_rwtypes[] = {
	"Instruction(i)",
	"Instruction(Register)",
	"Data Write",
	"I/O",
	"Data Access"
};



static char *kdb_bptype(kdb_bp_t *bp)
{
	if (bp->bp_type < 0 || bp->bp_type > 4)
		return "";

	return kdb_rwtypes[bp->bp_type];
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
jason wessel
jason wessel
36
100.00%
1
100.00%
Total
36
100.00%
1
100.00%



static int kdb_parsebp(int argc, const char **argv, int *nextargp, kdb_bp_t *bp)
{
	int nextarg = *nextargp;
	int diag;

	bp->bph_length = 1;
	if ((argc + 1) != nextarg) {
		if (strncasecmp(argv[nextarg], "datar", sizeof("datar")) == 0)
			bp->bp_type = BP_ACCESS_WATCHPOINT;
		else if (strncasecmp(argv[nextarg], "dataw", sizeof("dataw")) == 0)
			bp->bp_type = BP_WRITE_WATCHPOINT;
		else if (strncasecmp(argv[nextarg], "inst", sizeof("inst")) == 0)
			bp->bp_type = BP_HARDWARE_BREAKPOINT;
		else
			return KDB_ARGCOUNT;

		bp->bph_length = 1;

		nextarg++;

		if ((argc + 1) != nextarg) {
			unsigned long len;

			diag = kdbgetularg((char *)argv[nextarg],
					   &len);
			if (diag)
				return diag;


			if (len > 8)
				return KDB_BADLENGTH;

			bp->bph_length = len;
			nextarg++;
		}

		if ((argc + 1) != nextarg)
			return KDB_ARGCOUNT;
	}

	*nextargp = nextarg;
	return 0;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
jason wessel
jason wessel
216
98.63%
1
50.00%
rasmus villemoes
rasmus villemoes
3
1.37%
1
50.00%
Total
219
100.00%
2
100.00%



static int _kdb_bp_remove(kdb_bp_t *bp)
{
	int ret = 1;
	if (!bp->bp_installed)
		return ret;
	if (!bp->bp_type)
		ret = dbg_remove_sw_break(bp->bp_addr);
	else
		ret = arch_kgdb_ops.remove_hw_breakpoint(bp->bp_addr,
			 bp->bph_length,
			 bp->bp_type);
	if (ret == 0)
		bp->bp_installed = 0;
	return ret;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
jason wessel
jason wessel
76
100.00%
1
100.00%
Total
76
100.00%
1
100.00%



static void kdb_handle_bp(struct pt_regs *regs, kdb_bp_t *bp)
{
	if (KDB_DEBUG(BP))
		kdb_printf("regs->ip = 0x%lx\n", instruction_pointer(regs));

	/*
         * Setup single step
         */
	kdb_setsinglestep(regs);

	/*
         * Reset delay attribute
         */
	bp->bp_delay = 0;
	bp->bp_delayed = 1;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
jason wessel
jason wessel
51
100.00%
1
100.00%
Total
51
100.00%
1
100.00%



static int _kdb_bp_install(struct pt_regs *regs, kdb_bp_t *bp)
{
	int ret;
	/*
         * Install the breakpoint, if it is not already installed.
         */

	if (KDB_DEBUG(BP))
		kdb_printf("%s: bp_installed %d\n",
			   __func__, bp->bp_installed);
	if (!KDB_STATE(SSBPT))
		bp->bp_delay = 0;
	if (bp->bp_installed)
		return 1;
	if (bp->bp_delay || (bp->bp_delayed && KDB_STATE(DOING_SS))) {
		if (KDB_DEBUG(BP))
			kdb_printf("%s: delayed bp\n", __func__);
		kdb_handle_bp(regs, bp);
		return 0;
	}
	if (!bp->bp_type)
		ret = dbg_set_sw_break(bp->bp_addr);
	else
		ret = arch_kgdb_ops.set_hw_breakpoint(bp->bp_addr,
			 bp->bph_length,
			 bp->bp_type);
	if (ret == 0) {
		bp->bp_installed = 1;
	} else {
		kdb_printf("%s: failed to set breakpoint at 0x%lx\n",
			   __func__, bp->bp_addr);
		if (!bp->bp_type) {
			kdb_printf("Software breakpoints are unavailable.\n"
				   "  Boot the kernel with rodata=off\n"
				   "  OR use hw breaks: help bph\n");
		}
		return 1;
	}
	return 0;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
jason wessel
jason wessel
188
99.47%
2
66.67%
kees cook
kees cook
1
0.53%
1
33.33%
Total
189
100.00%
3
100.00%

/*
 * kdb_bp_install
 *
 *      Install kdb_breakpoints prior to returning from the
 *      kernel debugger.  This allows the kdb_breakpoints to be set
 *      upon functions that are used internally by kdb, such as
 *      printk().  This function is only called once per kdb session.
 */


void kdb_bp_install(struct pt_regs *regs)
{
	int i;

	for (i = 0; i < KDB_MAXBPT; i++) {
		kdb_bp_t *bp = &kdb_breakpoints[i];

		if (KDB_DEBUG(BP)) {
			kdb_printf("%s: bp %d bp_enabled %d\n",
				   __func__, i, bp->bp_enabled);
		}
		if (bp->bp_enabled)
			_kdb_bp_install(regs, bp);
	}
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
jason wessel
jason wessel
73
100.00%
1
100.00%
Total
73
100.00%
1
100.00%

/*
 * kdb_bp_remove
 *
 *      Remove kdb_breakpoints upon entry to the kernel debugger.
 *
 * Parameters:
 *      None.
 * Outputs:
 *      None.
 * Returns:
 *      None.
 * Locking:
 *      None.
 * Remarks:
 */


void kdb_bp_remove(void)
{
	int i;

	for (i = KDB_MAXBPT - 1; i >= 0; i--) {
		kdb_bp_t *bp = &kdb_breakpoints[i];

		if (KDB_DEBUG(BP)) {
			kdb_printf("%s: bp %d bp_enabled %d\n",
				   __func__, i, bp->bp_enabled);
		}
		if (bp->bp_enabled)
			_kdb_bp_remove(bp);
	}
}


Contributors
Person
Tokens
Prop
Commits
CommitProp
jason wessel
jason wessel
70
100.00%
1
100.00%
Total
70
100.00%
1
100.00%

/*
 * kdb_printbp
 *
 *      Internal function to format and print a breakpoint entry.
 *
 * Parameters:
 *      None.
 * Outputs:
 *      None.
 * Returns:
 *      None.
 * Locking:
 *      None.
 * Remarks:
 */



static void kdb_printbp(kdb_bp_t *bp, int i)
{
	kdb_printf("%s ", kdb_bptype(bp));
	kdb_printf("BP #%d at ", i);
	kdb_symbol_print(bp->bp_addr, NULL, KDB_SP_DEFAULT);

	if (bp->bp_enabled)
		kdb_printf("\n    is enabled");
	else
		kdb_printf("\n    is disabled");

	kdb_printf("\taddr at %016lx, hardtype=%d installed=%d\n",
		   bp->bp_addr, bp->bp_type, bp->bp_installed);

	kdb_printf("\n");
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
jason wessel
jason wessel
80
100.00%
1
100.00%
Total
80
100.00%
1
100.00%

/*
 * kdb_bp
 *
 *      Handle the bp commands.
 *
 *      [bp|bph] <addr-expression> [DATAR|DATAW]
 *
 * Parameters:
 *      argc    Count of arguments in argv
 *      argv    Space delimited command line arguments
 * Outputs:
 *      None.
 * Returns:
 *      Zero for success, a kdb diagnostic if failure.
 * Locking:
 *      None.
 * Remarks:
 *
 *      bp      Set breakpoint on all cpus.  Only use hardware assist if need.
 *      bph     Set breakpoint on all cpus.  Force hardware register
 */



static int kdb_bp(int argc, const char **argv)
{
	int i, bpno;
	kdb_bp_t *bp, *bp_check;
	int diag;
	char *symname = NULL;
	long offset = 0ul;
	int nextarg;
	kdb_bp_t template = {0};

	if (argc == 0) {
		/*
                 * Display breakpoint table
                 */
		for (bpno = 0, bp = kdb_breakpoints; bpno < KDB_MAXBPT;
		     bpno++, bp++) {
			if (bp->bp_free)
				continue;
			kdb_printbp(bp, bpno);
		}

		return 0;
	}

	nextarg = 1;
	diag = kdbgetaddrarg(argc, argv, &nextarg, &template.bp_addr,
			     &offset, &symname);
	if (diag)
		return diag;
	if (!template.bp_addr)
		return KDB_BADINT;

	/*
         * Find an empty bp structure to allocate
         */
	for (bpno = 0, bp = kdb_breakpoints; bpno < KDB_MAXBPT; bpno++, bp++) {
		if (bp->bp_free)
			break;
	}

	if (bpno == KDB_MAXBPT)
		return KDB_TOOMANYBPT;

	if (strcmp(argv[0], "bph") == 0) {
		template.bp_type = BP_HARDWARE_BREAKPOINT;
		diag = kdb_parsebp(argc, argv, &nextarg, &template);
		if (diag)
			return diag;
	} else {
		template.bp_type = BP_BREAKPOINT;
	}

	/*
         * Check for clashing breakpoints.
         *
         * Note, in this design we can't have hardware breakpoints
         * enabled for both read and write on the same address.
         */
	for (i = 0, bp_check = kdb_breakpoints; i < KDB_MAXBPT;
	     i++, bp_check++) {
		if (!bp_check->bp_free &&
		    bp_check->bp_addr == template.bp_addr) {
			kdb_printf("You already have a breakpoint at "
				   kdb_bfd_vma_fmt0 "\n", template.bp_addr);
			return KDB_DUPBPT;
		}
	}

	template.bp_enabled = 1;

	/*
         * Actually allocate the breakpoint found earlier
         */
	*bp = template;
	bp->bp_free = 0;

	kdb_printbp(bp, bpno);

	return 0;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
jason wessel
jason wessel
317
100.00%
1
100.00%
Total
317
100.00%
1
100.00%

/*
 * kdb_bc
 *
 *      Handles the 'bc', 'be', and 'bd' commands
 *
 *      [bd|bc|be] <breakpoint-number>
 *      [bd|bc|be] *
 *
 * Parameters:
 *      argc    Count of arguments in argv
 *      argv    Space delimited command line arguments
 * Outputs:
 *      None.
 * Returns:
 *      Zero for success, a kdb diagnostic for failure
 * Locking:
 *      None.
 * Remarks:
 */


static int kdb_bc(int argc, const char **argv)
{
	unsigned long addr;
	kdb_bp_t *bp = NULL;
	int lowbp = KDB_MAXBPT;
	int highbp = 0;
	int done = 0;
	int i;
	int diag = 0;

	int cmd;			/* KDBCMD_B? */

#define KDBCMD_BC	0

#define KDBCMD_BE	1

#define KDBCMD_BD	2

	if (strcmp(argv[0], "be") == 0)
		cmd = KDBCMD_BE;
	else if (strcmp(argv[0], "bd") == 0)
		cmd = KDBCMD_BD;
	else
		cmd = KDBCMD_BC;

	if (argc != 1)
		return KDB_ARGCOUNT;

	if (strcmp(argv[1], "*") == 0) {
		lowbp = 0;
		highbp = KDB_MAXBPT;
	} else {
		diag = kdbgetularg(argv[1], &addr);
		if (diag)
			return diag;

		/*
                 * For addresses less than the maximum breakpoint number,
                 * assume that the breakpoint number is desired.
                 */
		if (addr < KDB_MAXBPT) {
			bp = &kdb_breakpoints[addr];
			lowbp = highbp = addr;
			highbp++;
		} else {
			for (i = 0, bp = kdb_breakpoints; i < KDB_MAXBPT;
			    i++, bp++) {
				if (bp->bp_addr == addr) {
					lowbp = highbp = i;
					highbp++;
					break;
				}
			}
		}
	}

	/*
         * Now operate on the set of breakpoints matching the input
         * criteria (either '*' for all, or an individual breakpoint).
         */
	for (bp = &kdb_breakpoints[lowbp], i = lowbp;
	    i < highbp;
	    i++, bp++) {
		if (bp->bp_free)
			continue;

		done++;

		switch (cmd) {
		case KDBCMD_BC:
			bp->bp_enabled = 0;

			kdb_printf("Breakpoint %d at "
				   kdb_bfd_vma_fmt " cleared\n",
				   i, bp->bp_addr);

			bp->bp_addr = 0;
			bp->bp_free = 1;

			break;
		case KDBCMD_BE:
			bp->bp_enabled = 1;

			kdb_printf("Breakpoint %d at "
				   kdb_bfd_vma_fmt " enabled",
				   i, bp->bp_addr);

			kdb_printf("\n");
			break;
		case KDBCMD_BD:
			if (!bp->bp_enabled)
				break;

			bp->bp_enabled = 0;

			kdb_printf("Breakpoint %d at "
				   kdb_bfd_vma_fmt " disabled\n",
				   i, bp->bp_addr);

			break;
		}
		if (bp->bp_delay && (cmd == KDBCMD_BC || cmd == KDBCMD_BD)) {
			bp->bp_delay = 0;
			KDB_STATE_CLEAR(SSBPT);
		}
	}

	return (!done) ? KDB_BPTNOTFOUND : 0;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
jason wessel
jason wessel
409
100.00%
1
100.00%
Total
409
100.00%
1
100.00%

/*
 * kdb_ss
 *
 *      Process the 'ss' (Single Step) command.
 *
 *      ss
 *
 * Parameters:
 *      argc    Argument count
 *      argv    Argument vector
 * Outputs:
 *      None.
 * Returns:
 *      KDB_CMD_SS for success, a kdb error if failure.
 * Locking:
 *      None.
 * Remarks:
 *
 *      Set the arch specific option to trigger a debug trap after the next
 *      instruction.
 */



static int kdb_ss(int argc, const char **argv)
{
	if (argc != 0)
		return KDB_ARGCOUNT;
	/*
         * Set trace flag and go.
         */
	KDB_STATE_SET(DOING_SS);
	return KDB_CMD_SS;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
jason wessel
jason wessel
33
100.00%
1
100.00%
Total
33
100.00%
1
100.00%

/* Initialize the breakpoint table and register breakpoint commands. */



void __init kdb_initbptab(void)
{
	int i;
	kdb_bp_t *bp;

	/*
         * First time initialization.
         */
	memset(&kdb_breakpoints, '\0', sizeof(kdb_breakpoints));

	for (i = 0, bp = kdb_breakpoints; i < KDB_MAXBPT; i++, bp++)
		bp->bp_free = 1;

	kdb_register_flags("bp", kdb_bp, "[<vaddr>]",
		"Set/Display breakpoints", 0,
		KDB_ENABLE_FLOW_CTRL | KDB_REPEAT_NO_ARGS);
	kdb_register_flags("bl", kdb_bp, "[<vaddr>]",
		"Display breakpoints", 0,
		KDB_ENABLE_FLOW_CTRL | KDB_REPEAT_NO_ARGS);
	if (arch_kgdb_ops.flags & KGDB_HW_BREAKPOINT)
		kdb_register_flags("bph", kdb_bp, "[<vaddr>]",
		"[datar [length]|dataw [length]]   Set hw brk", 0,
		KDB_ENABLE_FLOW_CTRL | KDB_REPEAT_NO_ARGS);
	kdb_register_flags("bc", kdb_bc, "<bpnum>",
		"Clear Breakpoint", 0,
		KDB_ENABLE_FLOW_CTRL);
	kdb_register_flags("be", kdb_bc, "<bpnum>",
		"Enable Breakpoint", 0,
		KDB_ENABLE_FLOW_CTRL);
	kdb_register_flags("bd", kdb_bc, "<bpnum>",
		"Disable Breakpoint", 0,
		KDB_ENABLE_FLOW_CTRL);

	kdb_register_flags("ss", kdb_ss, "",
		"Single Step", 1,
		KDB_ENABLE_FLOW_CTRL | KDB_REPEAT_NO_ARGS);
	/*
         * Architecture dependent initialization.
         */
}
Contributors
Person
Tokens
Prop
Commits
CommitProp
jason wessel
jason wessel
159
89.83%
1
33.33%
daniel thompson
daniel thompson
11
6.21%
1
33.33%
anton vorontsov
anton vorontsov
7
3.95%
1
33.33%
Total
177
100.00%
3
100.00%

Overall Contributors
Person
Tokens
Prop
Commits
CommitProp
jason wessel
jason wessel
1783
98.73%
2
28.57%
daniel thompson
daniel thompson
11
0.61%
1
14.29%
anton vorontsov
anton vorontsov
7
0.39%
1
14.29%
rasmus villemoes
rasmus villemoes
3
0.17%
1
14.29%
vincent stehle
vincent stehle
1
0.06%
1
14.29%
kees cook
kees cook
1
0.06%
1
14.29%
Total
1806
100.00%
7
100.00%
  
Directory: kernel/debug/kdb

Information contained on this website is for historical information purposes only and does not indicate or represent copyright ownership.