Linux Audio

Check our new training course

Loading...
v3.1
   1/*
   2 * Kernel Debugger Architecture Independent Main Code
   3 *
   4 * This file is subject to the terms and conditions of the GNU General Public
   5 * License.  See the file "COPYING" in the main directory of this archive
   6 * for more details.
   7 *
   8 * Copyright (C) 1999-2004 Silicon Graphics, Inc.  All Rights Reserved.
   9 * Copyright (C) 2000 Stephane Eranian <eranian@hpl.hp.com>
  10 * Xscale (R) modifications copyright (C) 2003 Intel Corporation.
  11 * Copyright (c) 2009 Wind River Systems, Inc.  All Rights Reserved.
  12 */
  13
  14#include <linux/ctype.h>
 
  15#include <linux/string.h>
  16#include <linux/kernel.h>
 
  17#include <linux/reboot.h>
  18#include <linux/sched.h>
 
 
 
  19#include <linux/sysrq.h>
  20#include <linux/smp.h>
  21#include <linux/utsname.h>
  22#include <linux/vmalloc.h>
 
  23#include <linux/module.h>
 
  24#include <linux/mm.h>
  25#include <linux/init.h>
  26#include <linux/kallsyms.h>
  27#include <linux/kgdb.h>
  28#include <linux/kdb.h>
  29#include <linux/notifier.h>
  30#include <linux/interrupt.h>
  31#include <linux/delay.h>
  32#include <linux/nmi.h>
  33#include <linux/time.h>
  34#include <linux/ptrace.h>
  35#include <linux/sysctl.h>
  36#include <linux/cpu.h>
  37#include <linux/kdebug.h>
  38#include <linux/proc_fs.h>
  39#include <linux/uaccess.h>
  40#include <linux/slab.h>
  41#include "kdb_private.h"
  42
  43#define GREP_LEN 256
  44char kdb_grep_string[GREP_LEN];
 
 
 
 
 
  45int kdb_grepping_flag;
  46EXPORT_SYMBOL(kdb_grepping_flag);
  47int kdb_grep_leading;
  48int kdb_grep_trailing;
  49
  50/*
  51 * Kernel debugger state flags
  52 */
  53int kdb_flags;
  54atomic_t kdb_event;
  55
  56/*
  57 * kdb_lock protects updates to kdb_initial_cpu.  Used to
  58 * single thread processors through the kernel debugger.
  59 */
  60int kdb_initial_cpu = -1;	/* cpu number that owns kdb */
  61int kdb_nextline = 1;
  62int kdb_state;			/* General KDB state */
  63
  64struct task_struct *kdb_current_task;
  65EXPORT_SYMBOL(kdb_current_task);
  66struct pt_regs *kdb_current_regs;
  67
  68const char *kdb_diemsg;
  69static int kdb_go_count;
  70#ifdef CONFIG_KDB_CONTINUE_CATASTROPHIC
  71static unsigned int kdb_continue_catastrophic =
  72	CONFIG_KDB_CONTINUE_CATASTROPHIC;
  73#else
  74static unsigned int kdb_continue_catastrophic;
  75#endif
  76
  77/* kdb_commands describes the available commands. */
  78static kdbtab_t *kdb_commands;
  79#define KDB_BASE_CMD_MAX 50
  80static int kdb_max_commands = KDB_BASE_CMD_MAX;
  81static kdbtab_t kdb_base_commands[KDB_BASE_CMD_MAX];
  82#define for_each_kdbcmd(cmd, num)					\
  83	for ((cmd) = kdb_base_commands, (num) = 0;			\
  84	     num < kdb_max_commands;					\
  85	     num++, num == KDB_BASE_CMD_MAX ? cmd = kdb_commands : cmd++)
  86
  87typedef struct _kdbmsg {
  88	int	km_diag;	/* kdb diagnostic */
  89	char	*km_msg;	/* Corresponding message text */
  90} kdbmsg_t;
  91
  92#define KDBMSG(msgnum, text) \
  93	{ KDB_##msgnum, text }
  94
  95static kdbmsg_t kdbmsgs[] = {
  96	KDBMSG(NOTFOUND, "Command Not Found"),
  97	KDBMSG(ARGCOUNT, "Improper argument count, see usage."),
  98	KDBMSG(BADWIDTH, "Illegal value for BYTESPERWORD use 1, 2, 4 or 8, "
  99	       "8 is only allowed on 64 bit systems"),
 100	KDBMSG(BADRADIX, "Illegal value for RADIX use 8, 10 or 16"),
 101	KDBMSG(NOTENV, "Cannot find environment variable"),
 102	KDBMSG(NOENVVALUE, "Environment variable should have value"),
 103	KDBMSG(NOTIMP, "Command not implemented"),
 104	KDBMSG(ENVFULL, "Environment full"),
 105	KDBMSG(ENVBUFFULL, "Environment buffer full"),
 106	KDBMSG(TOOMANYBPT, "Too many breakpoints defined"),
 107#ifdef CONFIG_CPU_XSCALE
 108	KDBMSG(TOOMANYDBREGS, "More breakpoints than ibcr registers defined"),
 109#else
 110	KDBMSG(TOOMANYDBREGS, "More breakpoints than db registers defined"),
 111#endif
 112	KDBMSG(DUPBPT, "Duplicate breakpoint address"),
 113	KDBMSG(BPTNOTFOUND, "Breakpoint not found"),
 114	KDBMSG(BADMODE, "Invalid IDMODE"),
 115	KDBMSG(BADINT, "Illegal numeric value"),
 116	KDBMSG(INVADDRFMT, "Invalid symbolic address format"),
 117	KDBMSG(BADREG, "Invalid register name"),
 118	KDBMSG(BADCPUNUM, "Invalid cpu number"),
 119	KDBMSG(BADLENGTH, "Invalid length field"),
 120	KDBMSG(NOBP, "No Breakpoint exists"),
 121	KDBMSG(BADADDR, "Invalid address"),
 
 122};
 123#undef KDBMSG
 124
 125static const int __nkdb_err = sizeof(kdbmsgs) / sizeof(kdbmsg_t);
 126
 127
 128/*
 129 * Initial environment.   This is all kept static and local to
 130 * this file.   We don't want to rely on the memory allocation
 131 * mechanisms in the kernel, so we use a very limited allocate-only
 132 * heap for new and altered environment variables.  The entire
 133 * environment is limited to a fixed number of entries (add more
 134 * to __env[] if required) and a fixed amount of heap (add more to
 135 * KDB_ENVBUFSIZE if required).
 136 */
 137
 138static char *__env[] = {
 139#if defined(CONFIG_SMP)
 140 "PROMPT=[%d]kdb> ",
 141 "MOREPROMPT=[%d]more> ",
 142#else
 143 "PROMPT=kdb> ",
 144 "MOREPROMPT=more> ",
 145#endif
 
 146 "RADIX=16",
 147 "MDCOUNT=8",			/* lines of md output */
 148 KDB_PLATFORM_ENV,
 149 "DTABCOUNT=30",
 150 "NOSECT=1",
 151 (char *)0,
 152 (char *)0,
 153 (char *)0,
 154 (char *)0,
 155 (char *)0,
 156 (char *)0,
 157 (char *)0,
 158 (char *)0,
 159 (char *)0,
 160 (char *)0,
 161 (char *)0,
 162 (char *)0,
 163 (char *)0,
 164 (char *)0,
 165 (char *)0,
 166 (char *)0,
 167 (char *)0,
 168 (char *)0,
 169 (char *)0,
 170 (char *)0,
 171 (char *)0,
 172 (char *)0,
 173 (char *)0,
 174 (char *)0,
 175};
 176
 177static const int __nenv = (sizeof(__env) / sizeof(char *));
 178
 179struct task_struct *kdb_curr_task(int cpu)
 180{
 181	struct task_struct *p = curr_task(cpu);
 182#ifdef	_TIF_MCA_INIT
 183	if ((task_thread_info(p)->flags & _TIF_MCA_INIT) && KDB_TSK(cpu))
 184		p = krp->p;
 185#endif
 186	return p;
 187}
 188
 189/*
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 190 * kdbgetenv - This function will return the character string value of
 191 *	an environment variable.
 192 * Parameters:
 193 *	match	A character string representing an environment variable.
 194 * Returns:
 195 *	NULL	No environment variable matches 'match'
 196 *	char*	Pointer to string value of environment variable.
 197 */
 198char *kdbgetenv(const char *match)
 199{
 200	char **ep = __env;
 201	int matchlen = strlen(match);
 202	int i;
 203
 204	for (i = 0; i < __nenv; i++) {
 205		char *e = *ep++;
 206
 207		if (!e)
 208			continue;
 209
 210		if ((strncmp(match, e, matchlen) == 0)
 211		 && ((e[matchlen] == '\0')
 212		   || (e[matchlen] == '='))) {
 213			char *cp = strchr(e, '=');
 214			return cp ? ++cp : "";
 215		}
 216	}
 217	return NULL;
 218}
 219
 220/*
 221 * kdballocenv - This function is used to allocate bytes for
 222 *	environment entries.
 223 * Parameters:
 224 *	match	A character string representing a numeric value
 225 * Outputs:
 226 *	*value  the unsigned long representation of the env variable 'match'
 227 * Returns:
 228 *	Zero on success, a kdb diagnostic on failure.
 229 * Remarks:
 230 *	We use a static environment buffer (envbuffer) to hold the values
 231 *	of dynamically generated environment variables (see kdb_set).  Buffer
 232 *	space once allocated is never free'd, so over time, the amount of space
 233 *	(currently 512 bytes) will be exhausted if env variables are changed
 234 *	frequently.
 235 */
 236static char *kdballocenv(size_t bytes)
 237{
 238#define	KDB_ENVBUFSIZE	512
 239	static char envbuffer[KDB_ENVBUFSIZE];
 240	static int envbufsize;
 241	char *ep = NULL;
 242
 243	if ((KDB_ENVBUFSIZE - envbufsize) >= bytes) {
 244		ep = &envbuffer[envbufsize];
 245		envbufsize += bytes;
 246	}
 247	return ep;
 248}
 249
 250/*
 251 * kdbgetulenv - This function will return the value of an unsigned
 252 *	long-valued environment variable.
 253 * Parameters:
 254 *	match	A character string representing a numeric value
 255 * Outputs:
 256 *	*value  the unsigned long represntation of the env variable 'match'
 257 * Returns:
 258 *	Zero on success, a kdb diagnostic on failure.
 259 */
 260static int kdbgetulenv(const char *match, unsigned long *value)
 261{
 262	char *ep;
 263
 264	ep = kdbgetenv(match);
 265	if (!ep)
 266		return KDB_NOTENV;
 267	if (strlen(ep) == 0)
 268		return KDB_NOENVVALUE;
 269
 270	*value = simple_strtoul(ep, NULL, 0);
 271
 272	return 0;
 273}
 274
 275/*
 276 * kdbgetintenv - This function will return the value of an
 277 *	integer-valued environment variable.
 278 * Parameters:
 279 *	match	A character string representing an integer-valued env variable
 280 * Outputs:
 281 *	*value  the integer representation of the environment variable 'match'
 282 * Returns:
 283 *	Zero on success, a kdb diagnostic on failure.
 284 */
 285int kdbgetintenv(const char *match, int *value)
 286{
 287	unsigned long val;
 288	int diag;
 289
 290	diag = kdbgetulenv(match, &val);
 291	if (!diag)
 292		*value = (int) val;
 293	return diag;
 294}
 295
 296/*
 297 * kdbgetularg - This function will convert a numeric string into an
 298 *	unsigned long value.
 299 * Parameters:
 300 *	arg	A character string representing a numeric value
 301 * Outputs:
 302 *	*value  the unsigned long represntation of arg.
 303 * Returns:
 304 *	Zero on success, a kdb diagnostic on failure.
 305 */
 306int kdbgetularg(const char *arg, unsigned long *value)
 307{
 308	char *endp;
 309	unsigned long val;
 310
 311	val = simple_strtoul(arg, &endp, 0);
 312
 313	if (endp == arg) {
 314		/*
 315		 * Also try base 16, for us folks too lazy to type the
 316		 * leading 0x...
 317		 */
 318		val = simple_strtoul(arg, &endp, 16);
 319		if (endp == arg)
 320			return KDB_BADINT;
 321	}
 322
 323	*value = val;
 324
 325	return 0;
 326}
 327
 328int kdbgetu64arg(const char *arg, u64 *value)
 329{
 330	char *endp;
 331	u64 val;
 332
 333	val = simple_strtoull(arg, &endp, 0);
 334
 335	if (endp == arg) {
 336
 337		val = simple_strtoull(arg, &endp, 16);
 338		if (endp == arg)
 339			return KDB_BADINT;
 340	}
 341
 342	*value = val;
 343
 344	return 0;
 345}
 346
 347/*
 348 * kdb_set - This function implements the 'set' command.  Alter an
 349 *	existing environment variable or create a new one.
 350 */
 351int kdb_set(int argc, const char **argv)
 352{
 353	int i;
 354	char *ep;
 355	size_t varlen, vallen;
 356
 357	/*
 358	 * we can be invoked two ways:
 359	 *   set var=value    argv[1]="var", argv[2]="value"
 360	 *   set var = value  argv[1]="var", argv[2]="=", argv[3]="value"
 361	 * - if the latter, shift 'em down.
 362	 */
 363	if (argc == 3) {
 364		argv[2] = argv[3];
 365		argc--;
 366	}
 367
 368	if (argc != 2)
 369		return KDB_ARGCOUNT;
 370
 371	/*
 372	 * Check for internal variables
 373	 */
 374	if (strcmp(argv[1], "KDBDEBUG") == 0) {
 375		unsigned int debugflags;
 376		char *cp;
 377
 378		debugflags = simple_strtoul(argv[2], &cp, 0);
 379		if (cp == argv[2] || debugflags & ~KDB_DEBUG_FLAG_MASK) {
 380			kdb_printf("kdb: illegal debug flags '%s'\n",
 381				    argv[2]);
 382			return 0;
 383		}
 384		kdb_flags = (kdb_flags &
 385			     ~(KDB_DEBUG_FLAG_MASK << KDB_DEBUG_FLAG_SHIFT))
 386			| (debugflags << KDB_DEBUG_FLAG_SHIFT);
 387
 388		return 0;
 389	}
 390
 391	/*
 392	 * Tokenizer squashed the '=' sign.  argv[1] is variable
 393	 * name, argv[2] = value.
 394	 */
 395	varlen = strlen(argv[1]);
 396	vallen = strlen(argv[2]);
 397	ep = kdballocenv(varlen + vallen + 2);
 398	if (ep == (char *)0)
 399		return KDB_ENVBUFFULL;
 400
 401	sprintf(ep, "%s=%s", argv[1], argv[2]);
 402
 403	ep[varlen+vallen+1] = '\0';
 404
 405	for (i = 0; i < __nenv; i++) {
 406		if (__env[i]
 407		 && ((strncmp(__env[i], argv[1], varlen) == 0)
 408		   && ((__env[i][varlen] == '\0')
 409		    || (__env[i][varlen] == '=')))) {
 410			__env[i] = ep;
 411			return 0;
 412		}
 413	}
 414
 415	/*
 416	 * Wasn't existing variable.  Fit into slot.
 417	 */
 418	for (i = 0; i < __nenv-1; i++) {
 419		if (__env[i] == (char *)0) {
 420			__env[i] = ep;
 421			return 0;
 422		}
 423	}
 424
 425	return KDB_ENVFULL;
 426}
 427
 428static int kdb_check_regs(void)
 429{
 430	if (!kdb_current_regs) {
 431		kdb_printf("No current kdb registers."
 432			   "  You may need to select another task\n");
 433		return KDB_BADREG;
 434	}
 435	return 0;
 436}
 437
 438/*
 439 * kdbgetaddrarg - This function is responsible for parsing an
 440 *	address-expression and returning the value of the expression,
 441 *	symbol name, and offset to the caller.
 442 *
 443 *	The argument may consist of a numeric value (decimal or
 444 *	hexidecimal), a symbol name, a register name (preceded by the
 445 *	percent sign), an environment variable with a numeric value
 446 *	(preceded by a dollar sign) or a simple arithmetic expression
 447 *	consisting of a symbol name, +/-, and a numeric constant value
 448 *	(offset).
 449 * Parameters:
 450 *	argc	- count of arguments in argv
 451 *	argv	- argument vector
 452 *	*nextarg - index to next unparsed argument in argv[]
 453 *	regs	- Register state at time of KDB entry
 454 * Outputs:
 455 *	*value	- receives the value of the address-expression
 456 *	*offset - receives the offset specified, if any
 457 *	*name   - receives the symbol name, if any
 458 *	*nextarg - index to next unparsed argument in argv[]
 459 * Returns:
 460 *	zero is returned on success, a kdb diagnostic code is
 461 *      returned on error.
 462 */
 463int kdbgetaddrarg(int argc, const char **argv, int *nextarg,
 464		  unsigned long *value,  long *offset,
 465		  char **name)
 466{
 467	unsigned long addr;
 468	unsigned long off = 0;
 469	int positive;
 470	int diag;
 471	int found = 0;
 472	char *symname;
 473	char symbol = '\0';
 474	char *cp;
 475	kdb_symtab_t symtab;
 476
 477	/*
 
 
 
 
 
 
 
 
 
 478	 * Process arguments which follow the following syntax:
 479	 *
 480	 *  symbol | numeric-address [+/- numeric-offset]
 481	 *  %register
 482	 *  $environment-variable
 483	 */
 484
 485	if (*nextarg > argc)
 486		return KDB_ARGCOUNT;
 487
 488	symname = (char *)argv[*nextarg];
 489
 490	/*
 491	 * If there is no whitespace between the symbol
 492	 * or address and the '+' or '-' symbols, we
 493	 * remember the character and replace it with a
 494	 * null so the symbol/value can be properly parsed
 495	 */
 496	cp = strpbrk(symname, "+-");
 497	if (cp != NULL) {
 498		symbol = *cp;
 499		*cp++ = '\0';
 500	}
 501
 502	if (symname[0] == '$') {
 503		diag = kdbgetulenv(&symname[1], &addr);
 504		if (diag)
 505			return diag;
 506	} else if (symname[0] == '%') {
 507		diag = kdb_check_regs();
 508		if (diag)
 509			return diag;
 510		/* Implement register values with % at a later time as it is
 511		 * arch optional.
 512		 */
 513		return KDB_NOTIMP;
 514	} else {
 515		found = kdbgetsymval(symname, &symtab);
 516		if (found) {
 517			addr = symtab.sym_start;
 518		} else {
 519			diag = kdbgetularg(argv[*nextarg], &addr);
 520			if (diag)
 521				return diag;
 522		}
 523	}
 524
 525	if (!found)
 526		found = kdbnearsym(addr, &symtab);
 527
 528	(*nextarg)++;
 529
 530	if (name)
 531		*name = symname;
 532	if (value)
 533		*value = addr;
 534	if (offset && name && *name)
 535		*offset = addr - symtab.sym_start;
 536
 537	if ((*nextarg > argc)
 538	 && (symbol == '\0'))
 539		return 0;
 540
 541	/*
 542	 * check for +/- and offset
 543	 */
 544
 545	if (symbol == '\0') {
 546		if ((argv[*nextarg][0] != '+')
 547		 && (argv[*nextarg][0] != '-')) {
 548			/*
 549			 * Not our argument.  Return.
 550			 */
 551			return 0;
 552		} else {
 553			positive = (argv[*nextarg][0] == '+');
 554			(*nextarg)++;
 555		}
 556	} else
 557		positive = (symbol == '+');
 558
 559	/*
 560	 * Now there must be an offset!
 561	 */
 562	if ((*nextarg > argc)
 563	 && (symbol == '\0')) {
 564		return KDB_INVADDRFMT;
 565	}
 566
 567	if (!symbol) {
 568		cp = (char *)argv[*nextarg];
 569		(*nextarg)++;
 570	}
 571
 572	diag = kdbgetularg(cp, &off);
 573	if (diag)
 574		return diag;
 575
 576	if (!positive)
 577		off = -off;
 578
 579	if (offset)
 580		*offset += off;
 581
 582	if (value)
 583		*value += off;
 584
 585	return 0;
 586}
 587
 588static void kdb_cmderror(int diag)
 589{
 590	int i;
 591
 592	if (diag >= 0) {
 593		kdb_printf("no error detected (diagnostic is %d)\n", diag);
 594		return;
 595	}
 596
 597	for (i = 0; i < __nkdb_err; i++) {
 598		if (kdbmsgs[i].km_diag == diag) {
 599			kdb_printf("diag: %d: %s\n", diag, kdbmsgs[i].km_msg);
 600			return;
 601		}
 602	}
 603
 604	kdb_printf("Unknown diag %d\n", -diag);
 605}
 606
 607/*
 608 * kdb_defcmd, kdb_defcmd2 - This function implements the 'defcmd'
 609 *	command which defines one command as a set of other commands,
 610 *	terminated by endefcmd.  kdb_defcmd processes the initial
 611 *	'defcmd' command, kdb_defcmd2 is invoked from kdb_parse for
 612 *	the following commands until 'endefcmd'.
 613 * Inputs:
 614 *	argc	argument count
 615 *	argv	argument vector
 616 * Returns:
 617 *	zero for success, a kdb diagnostic if error
 618 */
 619struct defcmd_set {
 620	int count;
 621	int usable;
 622	char *name;
 623	char *usage;
 624	char *help;
 625	char **command;
 626};
 627static struct defcmd_set *defcmd_set;
 628static int defcmd_set_count;
 629static int defcmd_in_progress;
 630
 631/* Forward references */
 632static int kdb_exec_defcmd(int argc, const char **argv);
 633
 634static int kdb_defcmd2(const char *cmdstr, const char *argv0)
 635{
 636	struct defcmd_set *s = defcmd_set + defcmd_set_count - 1;
 637	char **save_command = s->command;
 638	if (strcmp(argv0, "endefcmd") == 0) {
 639		defcmd_in_progress = 0;
 640		if (!s->count)
 641			s->usable = 0;
 642		if (s->usable)
 643			kdb_register(s->name, kdb_exec_defcmd,
 644				     s->usage, s->help, 0);
 
 
 
 
 
 645		return 0;
 646	}
 647	if (!s->usable)
 648		return KDB_NOTIMP;
 649	s->command = kzalloc((s->count + 1) * sizeof(*(s->command)), GFP_KDB);
 650	if (!s->command) {
 651		kdb_printf("Could not allocate new kdb_defcmd table for %s\n",
 652			   cmdstr);
 653		s->usable = 0;
 654		return KDB_NOTIMP;
 655	}
 656	memcpy(s->command, save_command, s->count * sizeof(*(s->command)));
 657	s->command[s->count++] = kdb_strdup(cmdstr, GFP_KDB);
 658	kfree(save_command);
 659	return 0;
 660}
 661
 662static int kdb_defcmd(int argc, const char **argv)
 663{
 664	struct defcmd_set *save_defcmd_set = defcmd_set, *s;
 665	if (defcmd_in_progress) {
 666		kdb_printf("kdb: nested defcmd detected, assuming missing "
 667			   "endefcmd\n");
 668		kdb_defcmd2("endefcmd", "endefcmd");
 669	}
 670	if (argc == 0) {
 671		int i;
 672		for (s = defcmd_set; s < defcmd_set + defcmd_set_count; ++s) {
 673			kdb_printf("defcmd %s \"%s\" \"%s\"\n", s->name,
 674				   s->usage, s->help);
 675			for (i = 0; i < s->count; ++i)
 676				kdb_printf("%s", s->command[i]);
 677			kdb_printf("endefcmd\n");
 678		}
 679		return 0;
 680	}
 681	if (argc != 3)
 682		return KDB_ARGCOUNT;
 683	defcmd_set = kmalloc((defcmd_set_count + 1) * sizeof(*defcmd_set),
 684			     GFP_KDB);
 685	if (!defcmd_set) {
 686		kdb_printf("Could not allocate new defcmd_set entry for %s\n",
 687			   argv[1]);
 688		defcmd_set = save_defcmd_set;
 689		return KDB_NOTIMP;
 690	}
 
 
 
 
 691	memcpy(defcmd_set, save_defcmd_set,
 692	       defcmd_set_count * sizeof(*defcmd_set));
 693	kfree(save_defcmd_set);
 694	s = defcmd_set + defcmd_set_count;
 695	memset(s, 0, sizeof(*s));
 696	s->usable = 1;
 697	s->name = kdb_strdup(argv[1], GFP_KDB);
 
 
 698	s->usage = kdb_strdup(argv[2], GFP_KDB);
 
 
 699	s->help = kdb_strdup(argv[3], GFP_KDB);
 
 
 700	if (s->usage[0] == '"') {
 701		strcpy(s->usage, s->usage+1);
 702		s->usage[strlen(s->usage)-1] = '\0';
 703	}
 704	if (s->help[0] == '"') {
 705		strcpy(s->help, s->help+1);
 706		s->help[strlen(s->help)-1] = '\0';
 707	}
 708	++defcmd_set_count;
 709	defcmd_in_progress = 1;
 
 710	return 0;
 
 
 
 
 
 
 
 
 
 
 711}
 712
 713/*
 714 * kdb_exec_defcmd - Execute the set of commands associated with this
 715 *	defcmd name.
 716 * Inputs:
 717 *	argc	argument count
 718 *	argv	argument vector
 719 * Returns:
 720 *	zero for success, a kdb diagnostic if error
 721 */
 722static int kdb_exec_defcmd(int argc, const char **argv)
 723{
 724	int i, ret;
 725	struct defcmd_set *s;
 726	if (argc != 0)
 727		return KDB_ARGCOUNT;
 728	for (s = defcmd_set, i = 0; i < defcmd_set_count; ++i, ++s) {
 729		if (strcmp(s->name, argv[0]) == 0)
 730			break;
 731	}
 732	if (i == defcmd_set_count) {
 733		kdb_printf("kdb_exec_defcmd: could not find commands for %s\n",
 734			   argv[0]);
 735		return KDB_NOTIMP;
 736	}
 737	for (i = 0; i < s->count; ++i) {
 738		/* Recursive use of kdb_parse, do not use argv after
 739		 * this point */
 740		argv = NULL;
 741		kdb_printf("[%s]kdb> %s\n", s->name, s->command[i]);
 742		ret = kdb_parse(s->command[i]);
 743		if (ret)
 744			return ret;
 745	}
 746	return 0;
 747}
 748
 749/* Command history */
 750#define KDB_CMD_HISTORY_COUNT	32
 751#define CMD_BUFLEN		200	/* kdb_printf: max printline
 752					 * size == 256 */
 753static unsigned int cmd_head, cmd_tail;
 754static unsigned int cmdptr;
 755static char cmd_hist[KDB_CMD_HISTORY_COUNT][CMD_BUFLEN];
 756static char cmd_cur[CMD_BUFLEN];
 757
 758/*
 759 * The "str" argument may point to something like  | grep xyz
 760 */
 761static void parse_grep(const char *str)
 762{
 763	int	len;
 764	char	*cp = (char *)str, *cp2;
 765
 766	/* sanity check: we should have been called with the \ first */
 767	if (*cp != '|')
 768		return;
 769	cp++;
 770	while (isspace(*cp))
 771		cp++;
 772	if (strncmp(cp, "grep ", 5)) {
 773		kdb_printf("invalid 'pipe', see grephelp\n");
 774		return;
 775	}
 776	cp += 5;
 777	while (isspace(*cp))
 778		cp++;
 779	cp2 = strchr(cp, '\n');
 780	if (cp2)
 781		*cp2 = '\0'; /* remove the trailing newline */
 782	len = strlen(cp);
 783	if (len == 0) {
 784		kdb_printf("invalid 'pipe', see grephelp\n");
 785		return;
 786	}
 787	/* now cp points to a nonzero length search string */
 788	if (*cp == '"') {
 789		/* allow it be "x y z" by removing the "'s - there must
 790		   be two of them */
 791		cp++;
 792		cp2 = strchr(cp, '"');
 793		if (!cp2) {
 794			kdb_printf("invalid quoted string, see grephelp\n");
 795			return;
 796		}
 797		*cp2 = '\0'; /* end the string where the 2nd " was */
 798	}
 799	kdb_grep_leading = 0;
 800	if (*cp == '^') {
 801		kdb_grep_leading = 1;
 802		cp++;
 803	}
 804	len = strlen(cp);
 805	kdb_grep_trailing = 0;
 806	if (*(cp+len-1) == '$') {
 807		kdb_grep_trailing = 1;
 808		*(cp+len-1) = '\0';
 809	}
 810	len = strlen(cp);
 811	if (!len)
 812		return;
 813	if (len >= GREP_LEN) {
 814		kdb_printf("search string too long\n");
 815		return;
 816	}
 817	strcpy(kdb_grep_string, cp);
 818	kdb_grepping_flag++;
 819	return;
 820}
 821
 822/*
 823 * kdb_parse - Parse the command line, search the command table for a
 824 *	matching command and invoke the command function.  This
 825 *	function may be called recursively, if it is, the second call
 826 *	will overwrite argv and cbuf.  It is the caller's
 827 *	responsibility to save their argv if they recursively call
 828 *	kdb_parse().
 829 * Parameters:
 830 *      cmdstr	The input command line to be parsed.
 831 *	regs	The registers at the time kdb was entered.
 832 * Returns:
 833 *	Zero for success, a kdb diagnostic if failure.
 834 * Remarks:
 835 *	Limited to 20 tokens.
 836 *
 837 *	Real rudimentary tokenization. Basically only whitespace
 838 *	is considered a token delimeter (but special consideration
 839 *	is taken of the '=' sign as used by the 'set' command).
 840 *
 841 *	The algorithm used to tokenize the input string relies on
 842 *	there being at least one whitespace (or otherwise useless)
 843 *	character between tokens as the character immediately following
 844 *	the token is altered in-place to a null-byte to terminate the
 845 *	token string.
 846 */
 847
 848#define MAXARGC	20
 849
 850int kdb_parse(const char *cmdstr)
 851{
 852	static char *argv[MAXARGC];
 853	static int argc;
 854	static char cbuf[CMD_BUFLEN+2];
 855	char *cp;
 856	char *cpp, quoted;
 857	kdbtab_t *tp;
 858	int i, escaped, ignore_errors = 0, check_grep;
 859
 860	/*
 861	 * First tokenize the command string.
 862	 */
 863	cp = (char *)cmdstr;
 864	kdb_grepping_flag = check_grep = 0;
 865
 866	if (KDB_FLAG(CMD_INTERRUPT)) {
 867		/* Previous command was interrupted, newline must not
 868		 * repeat the command */
 869		KDB_FLAG_CLEAR(CMD_INTERRUPT);
 870		KDB_STATE_SET(PAGER);
 871		argc = 0;	/* no repeat */
 872	}
 873
 874	if (*cp != '\n' && *cp != '\0') {
 875		argc = 0;
 876		cpp = cbuf;
 877		while (*cp) {
 878			/* skip whitespace */
 879			while (isspace(*cp))
 880				cp++;
 881			if ((*cp == '\0') || (*cp == '\n') ||
 882			    (*cp == '#' && !defcmd_in_progress))
 883				break;
 884			/* special case: check for | grep pattern */
 885			if (*cp == '|') {
 886				check_grep++;
 887				break;
 888			}
 889			if (cpp >= cbuf + CMD_BUFLEN) {
 890				kdb_printf("kdb_parse: command buffer "
 891					   "overflow, command ignored\n%s\n",
 892					   cmdstr);
 893				return KDB_NOTFOUND;
 894			}
 895			if (argc >= MAXARGC - 1) {
 896				kdb_printf("kdb_parse: too many arguments, "
 897					   "command ignored\n%s\n", cmdstr);
 898				return KDB_NOTFOUND;
 899			}
 900			argv[argc++] = cpp;
 901			escaped = 0;
 902			quoted = '\0';
 903			/* Copy to next unquoted and unescaped
 904			 * whitespace or '=' */
 905			while (*cp && *cp != '\n' &&
 906			       (escaped || quoted || !isspace(*cp))) {
 907				if (cpp >= cbuf + CMD_BUFLEN)
 908					break;
 909				if (escaped) {
 910					escaped = 0;
 911					*cpp++ = *cp++;
 912					continue;
 913				}
 914				if (*cp == '\\') {
 915					escaped = 1;
 916					++cp;
 917					continue;
 918				}
 919				if (*cp == quoted)
 920					quoted = '\0';
 921				else if (*cp == '\'' || *cp == '"')
 922					quoted = *cp;
 923				*cpp = *cp++;
 924				if (*cpp == '=' && !quoted)
 925					break;
 926				++cpp;
 927			}
 928			*cpp++ = '\0';	/* Squash a ws or '=' character */
 929		}
 930	}
 931	if (!argc)
 932		return 0;
 933	if (check_grep)
 934		parse_grep(cp);
 935	if (defcmd_in_progress) {
 936		int result = kdb_defcmd2(cmdstr, argv[0]);
 937		if (!defcmd_in_progress) {
 938			argc = 0;	/* avoid repeat on endefcmd */
 939			*(argv[0]) = '\0';
 940		}
 941		return result;
 942	}
 943	if (argv[0][0] == '-' && argv[0][1] &&
 944	    (argv[0][1] < '0' || argv[0][1] > '9')) {
 945		ignore_errors = 1;
 946		++argv[0];
 947	}
 948
 949	for_each_kdbcmd(tp, i) {
 950		if (tp->cmd_name) {
 951			/*
 952			 * If this command is allowed to be abbreviated,
 953			 * check to see if this is it.
 954			 */
 955
 956			if (tp->cmd_minlen
 957			 && (strlen(argv[0]) <= tp->cmd_minlen)) {
 958				if (strncmp(argv[0],
 959					    tp->cmd_name,
 960					    tp->cmd_minlen) == 0) {
 961					break;
 962				}
 963			}
 964
 965			if (strcmp(argv[0], tp->cmd_name) == 0)
 966				break;
 967		}
 968	}
 969
 970	/*
 971	 * If we don't find a command by this name, see if the first
 972	 * few characters of this match any of the known commands.
 973	 * e.g., md1c20 should match md.
 974	 */
 975	if (i == kdb_max_commands) {
 976		for_each_kdbcmd(tp, i) {
 977			if (tp->cmd_name) {
 978				if (strncmp(argv[0],
 979					    tp->cmd_name,
 980					    strlen(tp->cmd_name)) == 0) {
 981					break;
 982				}
 983			}
 984		}
 985	}
 986
 987	if (i < kdb_max_commands) {
 988		int result;
 
 
 
 
 989		KDB_STATE_SET(CMD);
 990		result = (*tp->cmd_func)(argc-1, (const char **)argv);
 991		if (result && ignore_errors && result > KDB_CMD_GO)
 992			result = 0;
 993		KDB_STATE_CLEAR(CMD);
 994		switch (tp->cmd_repeat) {
 995		case KDB_REPEAT_NONE:
 996			argc = 0;
 997			if (argv[0])
 998				*(argv[0]) = '\0';
 999			break;
1000		case KDB_REPEAT_NO_ARGS:
1001			argc = 1;
1002			if (argv[1])
1003				*(argv[1]) = '\0';
1004			break;
1005		case KDB_REPEAT_WITH_ARGS:
1006			break;
1007		}
1008		return result;
1009	}
1010
1011	/*
1012	 * If the input with which we were presented does not
1013	 * map to an existing command, attempt to parse it as an
1014	 * address argument and display the result.   Useful for
1015	 * obtaining the address of a variable, or the nearest symbol
1016	 * to an address contained in a register.
1017	 */
1018	{
1019		unsigned long value;
1020		char *name = NULL;
1021		long offset;
1022		int nextarg = 0;
1023
1024		if (kdbgetaddrarg(0, (const char **)argv, &nextarg,
1025				  &value, &offset, &name)) {
1026			return KDB_NOTFOUND;
1027		}
1028
1029		kdb_printf("%s = ", argv[0]);
1030		kdb_symbol_print(value, NULL, KDB_SP_DEFAULT);
1031		kdb_printf("\n");
1032		return 0;
1033	}
1034}
1035
1036
1037static int handle_ctrl_cmd(char *cmd)
1038{
1039#define CTRL_P	16
1040#define CTRL_N	14
1041
1042	/* initial situation */
1043	if (cmd_head == cmd_tail)
1044		return 0;
1045	switch (*cmd) {
1046	case CTRL_P:
1047		if (cmdptr != cmd_tail)
1048			cmdptr = (cmdptr-1) % KDB_CMD_HISTORY_COUNT;
1049		strncpy(cmd_cur, cmd_hist[cmdptr], CMD_BUFLEN);
1050		return 1;
1051	case CTRL_N:
1052		if (cmdptr != cmd_head)
1053			cmdptr = (cmdptr+1) % KDB_CMD_HISTORY_COUNT;
1054		strncpy(cmd_cur, cmd_hist[cmdptr], CMD_BUFLEN);
1055		return 1;
1056	}
1057	return 0;
1058}
1059
1060/*
1061 * kdb_reboot - This function implements the 'reboot' command.  Reboot
1062 *	the system immediately, or loop for ever on failure.
1063 */
1064static int kdb_reboot(int argc, const char **argv)
1065{
1066	emergency_restart();
1067	kdb_printf("Hmm, kdb_reboot did not reboot, spinning here\n");
1068	while (1)
1069		cpu_relax();
1070	/* NOTREACHED */
1071	return 0;
1072}
1073
1074static void kdb_dumpregs(struct pt_regs *regs)
1075{
1076	int old_lvl = console_loglevel;
1077	console_loglevel = 15;
1078	kdb_trap_printk++;
1079	show_regs(regs);
1080	kdb_trap_printk--;
1081	kdb_printf("\n");
1082	console_loglevel = old_lvl;
1083}
1084
1085void kdb_set_current_task(struct task_struct *p)
1086{
1087	kdb_current_task = p;
1088
1089	if (kdb_task_has_cpu(p)) {
1090		kdb_current_regs = KDB_TSKREGS(kdb_process_cpu(p));
1091		return;
1092	}
1093	kdb_current_regs = NULL;
1094}
1095
 
 
 
 
 
 
 
 
 
 
1096/*
1097 * kdb_local - The main code for kdb.  This routine is invoked on a
1098 *	specific processor, it is not global.  The main kdb() routine
1099 *	ensures that only one processor at a time is in this routine.
1100 *	This code is called with the real reason code on the first
1101 *	entry to a kdb session, thereafter it is called with reason
1102 *	SWITCH, even if the user goes back to the original cpu.
1103 * Inputs:
1104 *	reason		The reason KDB was invoked
1105 *	error		The hardware-defined error code
1106 *	regs		The exception frame at time of fault/breakpoint.
1107 *	db_result	Result code from the break or debug point.
1108 * Returns:
1109 *	0	KDB was invoked for an event which it wasn't responsible
1110 *	1	KDB handled the event for which it was invoked.
1111 *	KDB_CMD_GO	User typed 'go'.
1112 *	KDB_CMD_CPU	User switched to another cpu.
1113 *	KDB_CMD_SS	Single step.
1114 *	KDB_CMD_SSB	Single step until branch.
1115 */
1116static int kdb_local(kdb_reason_t reason, int error, struct pt_regs *regs,
1117		     kdb_dbtrap_t db_result)
1118{
1119	char *cmdbuf;
1120	int diag;
1121	struct task_struct *kdb_current =
1122		kdb_curr_task(raw_smp_processor_id());
1123
1124	KDB_DEBUG_STATE("kdb_local 1", reason);
1125	kdb_go_count = 0;
1126	if (reason == KDB_REASON_DEBUG) {
1127		/* special case below */
1128	} else {
1129		kdb_printf("\nEntering kdb (current=0x%p, pid %d) ",
1130			   kdb_current, kdb_current ? kdb_current->pid : 0);
1131#if defined(CONFIG_SMP)
1132		kdb_printf("on processor %d ", raw_smp_processor_id());
1133#endif
1134	}
1135
1136	switch (reason) {
1137	case KDB_REASON_DEBUG:
1138	{
1139		/*
1140		 * If re-entering kdb after a single step
1141		 * command, don't print the message.
1142		 */
1143		switch (db_result) {
1144		case KDB_DB_BPT:
1145			kdb_printf("\nEntering kdb (0x%p, pid %d) ",
1146				   kdb_current, kdb_current->pid);
1147#if defined(CONFIG_SMP)
1148			kdb_printf("on processor %d ", raw_smp_processor_id());
1149#endif
1150			kdb_printf("due to Debug @ " kdb_machreg_fmt "\n",
1151				   instruction_pointer(regs));
1152			break;
1153		case KDB_DB_SSB:
1154			/*
1155			 * In the midst of ssb command. Just return.
1156			 */
1157			KDB_DEBUG_STATE("kdb_local 3", reason);
1158			return KDB_CMD_SSB;	/* Continue with SSB command */
1159
1160			break;
1161		case KDB_DB_SS:
1162			break;
1163		case KDB_DB_SSBPT:
1164			KDB_DEBUG_STATE("kdb_local 4", reason);
1165			return 1;	/* kdba_db_trap did the work */
1166		default:
1167			kdb_printf("kdb: Bad result from kdba_db_trap: %d\n",
1168				   db_result);
1169			break;
1170		}
1171
1172	}
1173		break;
1174	case KDB_REASON_ENTER:
1175		if (KDB_STATE(KEYBOARD))
1176			kdb_printf("due to Keyboard Entry\n");
1177		else
1178			kdb_printf("due to KDB_ENTER()\n");
1179		break;
1180	case KDB_REASON_KEYBOARD:
1181		KDB_STATE_SET(KEYBOARD);
1182		kdb_printf("due to Keyboard Entry\n");
1183		break;
1184	case KDB_REASON_ENTER_SLAVE:
1185		/* drop through, slaves only get released via cpu switch */
1186	case KDB_REASON_SWITCH:
1187		kdb_printf("due to cpu switch\n");
1188		break;
1189	case KDB_REASON_OOPS:
1190		kdb_printf("Oops: %s\n", kdb_diemsg);
1191		kdb_printf("due to oops @ " kdb_machreg_fmt "\n",
1192			   instruction_pointer(regs));
1193		kdb_dumpregs(regs);
1194		break;
 
 
 
1195	case KDB_REASON_NMI:
1196		kdb_printf("due to NonMaskable Interrupt @ "
1197			   kdb_machreg_fmt "\n",
1198			   instruction_pointer(regs));
1199		kdb_dumpregs(regs);
1200		break;
1201	case KDB_REASON_SSTEP:
1202	case KDB_REASON_BREAK:
1203		kdb_printf("due to %s @ " kdb_machreg_fmt "\n",
1204			   reason == KDB_REASON_BREAK ?
1205			   "Breakpoint" : "SS trap", instruction_pointer(regs));
1206		/*
1207		 * Determine if this breakpoint is one that we
1208		 * are interested in.
1209		 */
1210		if (db_result != KDB_DB_BPT) {
1211			kdb_printf("kdb: error return from kdba_bp_trap: %d\n",
1212				   db_result);
1213			KDB_DEBUG_STATE("kdb_local 6", reason);
1214			return 0;	/* Not for us, dismiss it */
1215		}
1216		break;
1217	case KDB_REASON_RECURSE:
1218		kdb_printf("due to Recursion @ " kdb_machreg_fmt "\n",
1219			   instruction_pointer(regs));
1220		break;
1221	default:
1222		kdb_printf("kdb: unexpected reason code: %d\n", reason);
1223		KDB_DEBUG_STATE("kdb_local 8", reason);
1224		return 0;	/* Not for us, dismiss it */
1225	}
1226
1227	while (1) {
1228		/*
1229		 * Initialize pager context.
1230		 */
1231		kdb_nextline = 1;
1232		KDB_STATE_CLEAR(SUPPRESS);
 
 
 
1233
1234		cmdbuf = cmd_cur;
1235		*cmdbuf = '\0';
1236		*(cmd_hist[cmd_head]) = '\0';
1237
1238		if (KDB_FLAG(ONLY_DO_DUMP)) {
1239			/* kdb is off but a catastrophic error requires a dump.
1240			 * Take the dump and reboot.
1241			 * Turn on logging so the kdb output appears in the log
1242			 * buffer in the dump.
1243			 */
1244			const char *setargs[] = { "set", "LOGGING", "1" };
1245			kdb_set(2, setargs);
1246			kdb_reboot(0, NULL);
1247			/*NOTREACHED*/
1248		}
1249
1250do_full_getstr:
1251#if defined(CONFIG_SMP)
1252		snprintf(kdb_prompt_str, CMD_BUFLEN, kdbgetenv("PROMPT"),
1253			 raw_smp_processor_id());
1254#else
1255		snprintf(kdb_prompt_str, CMD_BUFLEN, kdbgetenv("PROMPT"));
1256#endif
1257		if (defcmd_in_progress)
1258			strncat(kdb_prompt_str, "[defcmd]", CMD_BUFLEN);
1259
1260		/*
1261		 * Fetch command from keyboard
1262		 */
1263		cmdbuf = kdb_getstr(cmdbuf, CMD_BUFLEN, kdb_prompt_str);
1264		if (*cmdbuf != '\n') {
1265			if (*cmdbuf < 32) {
1266				if (cmdptr == cmd_head) {
1267					strncpy(cmd_hist[cmd_head], cmd_cur,
1268						CMD_BUFLEN);
1269					*(cmd_hist[cmd_head] +
1270					  strlen(cmd_hist[cmd_head])-1) = '\0';
1271				}
1272				if (!handle_ctrl_cmd(cmdbuf))
1273					*(cmd_cur+strlen(cmd_cur)-1) = '\0';
1274				cmdbuf = cmd_cur;
1275				goto do_full_getstr;
1276			} else {
1277				strncpy(cmd_hist[cmd_head], cmd_cur,
1278					CMD_BUFLEN);
1279			}
1280
1281			cmd_head = (cmd_head+1) % KDB_CMD_HISTORY_COUNT;
1282			if (cmd_head == cmd_tail)
1283				cmd_tail = (cmd_tail+1) % KDB_CMD_HISTORY_COUNT;
1284		}
1285
1286		cmdptr = cmd_head;
1287		diag = kdb_parse(cmdbuf);
1288		if (diag == KDB_NOTFOUND) {
 
1289			kdb_printf("Unknown kdb command: '%s'\n", cmdbuf);
1290			diag = 0;
1291		}
1292		if (diag == KDB_CMD_GO
1293		 || diag == KDB_CMD_CPU
1294		 || diag == KDB_CMD_SS
1295		 || diag == KDB_CMD_SSB
1296		 || diag == KDB_CMD_KGDB)
1297			break;
1298
1299		if (diag)
1300			kdb_cmderror(diag);
1301	}
1302	KDB_DEBUG_STATE("kdb_local 9", diag);
1303	return diag;
1304}
1305
1306
1307/*
1308 * kdb_print_state - Print the state data for the current processor
1309 *	for debugging.
1310 * Inputs:
1311 *	text		Identifies the debug point
1312 *	value		Any integer value to be printed, e.g. reason code.
1313 */
1314void kdb_print_state(const char *text, int value)
1315{
1316	kdb_printf("state: %s cpu %d value %d initial %d state %x\n",
1317		   text, raw_smp_processor_id(), value, kdb_initial_cpu,
1318		   kdb_state);
1319}
1320
1321/*
1322 * kdb_main_loop - After initial setup and assignment of the
1323 *	controlling cpu, all cpus are in this loop.  One cpu is in
1324 *	control and will issue the kdb prompt, the others will spin
1325 *	until 'go' or cpu switch.
1326 *
1327 *	To get a consistent view of the kernel stacks for all
1328 *	processes, this routine is invoked from the main kdb code via
1329 *	an architecture specific routine.  kdba_main_loop is
1330 *	responsible for making the kernel stacks consistent for all
1331 *	processes, there should be no difference between a blocked
1332 *	process and a running process as far as kdb is concerned.
1333 * Inputs:
1334 *	reason		The reason KDB was invoked
1335 *	error		The hardware-defined error code
1336 *	reason2		kdb's current reason code.
1337 *			Initially error but can change
1338 *			according to kdb state.
1339 *	db_result	Result code from break or debug point.
1340 *	regs		The exception frame at time of fault/breakpoint.
1341 *			should always be valid.
1342 * Returns:
1343 *	0	KDB was invoked for an event which it wasn't responsible
1344 *	1	KDB handled the event for which it was invoked.
1345 */
1346int kdb_main_loop(kdb_reason_t reason, kdb_reason_t reason2, int error,
1347	      kdb_dbtrap_t db_result, struct pt_regs *regs)
1348{
1349	int result = 1;
1350	/* Stay in kdb() until 'go', 'ss[b]' or an error */
1351	while (1) {
1352		/*
1353		 * All processors except the one that is in control
1354		 * will spin here.
1355		 */
1356		KDB_DEBUG_STATE("kdb_main_loop 1", reason);
1357		while (KDB_STATE(HOLD_CPU)) {
1358			/* state KDB is turned off by kdb_cpu to see if the
1359			 * other cpus are still live, each cpu in this loop
1360			 * turns it back on.
1361			 */
1362			if (!KDB_STATE(KDB))
1363				KDB_STATE_SET(KDB);
1364		}
1365
1366		KDB_STATE_CLEAR(SUPPRESS);
1367		KDB_DEBUG_STATE("kdb_main_loop 2", reason);
1368		if (KDB_STATE(LEAVING))
1369			break;	/* Another cpu said 'go' */
1370		/* Still using kdb, this processor is in control */
1371		result = kdb_local(reason2, error, regs, db_result);
1372		KDB_DEBUG_STATE("kdb_main_loop 3", result);
1373
1374		if (result == KDB_CMD_CPU)
1375			break;
1376
1377		if (result == KDB_CMD_SS) {
1378			KDB_STATE_SET(DOING_SS);
1379			break;
1380		}
1381
1382		if (result == KDB_CMD_SSB) {
1383			KDB_STATE_SET(DOING_SS);
1384			KDB_STATE_SET(DOING_SSB);
1385			break;
1386		}
1387
1388		if (result == KDB_CMD_KGDB) {
1389			if (!KDB_STATE(DOING_KGDB))
1390				kdb_printf("Entering please attach debugger "
1391					   "or use $D#44+ or $3#33\n");
1392			break;
1393		}
1394		if (result && result != 1 && result != KDB_CMD_GO)
1395			kdb_printf("\nUnexpected kdb_local return code %d\n",
1396				   result);
1397		KDB_DEBUG_STATE("kdb_main_loop 4", reason);
1398		break;
1399	}
1400	if (KDB_STATE(DOING_SS))
1401		KDB_STATE_CLEAR(SSBPT);
1402
 
 
 
1403	return result;
1404}
1405
1406/*
1407 * kdb_mdr - This function implements the guts of the 'mdr', memory
1408 * read command.
1409 *	mdr  <addr arg>,<byte count>
1410 * Inputs:
1411 *	addr	Start address
1412 *	count	Number of bytes
1413 * Returns:
1414 *	Always 0.  Any errors are detected and printed by kdb_getarea.
1415 */
1416static int kdb_mdr(unsigned long addr, unsigned int count)
1417{
1418	unsigned char c;
1419	while (count--) {
1420		if (kdb_getarea(c, addr))
1421			return 0;
1422		kdb_printf("%02x", c);
1423		addr++;
1424	}
1425	kdb_printf("\n");
1426	return 0;
1427}
1428
1429/*
1430 * kdb_md - This function implements the 'md', 'md1', 'md2', 'md4',
1431 *	'md8' 'mdr' and 'mds' commands.
1432 *
1433 *	md|mds  [<addr arg> [<line count> [<radix>]]]
1434 *	mdWcN	[<addr arg> [<line count> [<radix>]]]
1435 *		where W = is the width (1, 2, 4 or 8) and N is the count.
1436 *		for eg., md1c20 reads 20 bytes, 1 at a time.
1437 *	mdr  <addr arg>,<byte count>
1438 */
1439static void kdb_md_line(const char *fmtstr, unsigned long addr,
1440			int symbolic, int nosect, int bytesperword,
1441			int num, int repeat, int phys)
1442{
1443	/* print just one line of data */
1444	kdb_symtab_t symtab;
1445	char cbuf[32];
1446	char *c = cbuf;
1447	int i;
1448	unsigned long word;
1449
1450	memset(cbuf, '\0', sizeof(cbuf));
1451	if (phys)
1452		kdb_printf("phys " kdb_machreg_fmt0 " ", addr);
1453	else
1454		kdb_printf(kdb_machreg_fmt0 " ", addr);
1455
1456	for (i = 0; i < num && repeat--; i++) {
1457		if (phys) {
1458			if (kdb_getphysword(&word, addr, bytesperword))
1459				break;
1460		} else if (kdb_getword(&word, addr, bytesperword))
1461			break;
1462		kdb_printf(fmtstr, word);
1463		if (symbolic)
1464			kdbnearsym(word, &symtab);
1465		else
1466			memset(&symtab, 0, sizeof(symtab));
1467		if (symtab.sym_name) {
1468			kdb_symbol_print(word, &symtab, 0);
1469			if (!nosect) {
1470				kdb_printf("\n");
1471				kdb_printf("                       %s %s "
1472					   kdb_machreg_fmt " "
1473					   kdb_machreg_fmt " "
1474					   kdb_machreg_fmt, symtab.mod_name,
1475					   symtab.sec_name, symtab.sec_start,
1476					   symtab.sym_start, symtab.sym_end);
1477			}
1478			addr += bytesperword;
1479		} else {
1480			union {
1481				u64 word;
1482				unsigned char c[8];
1483			} wc;
1484			unsigned char *cp;
1485#ifdef	__BIG_ENDIAN
1486			cp = wc.c + 8 - bytesperword;
1487#else
1488			cp = wc.c;
1489#endif
1490			wc.word = word;
1491#define printable_char(c) \
1492	({unsigned char __c = c; isascii(__c) && isprint(__c) ? __c : '.'; })
1493			switch (bytesperword) {
1494			case 8:
1495				*c++ = printable_char(*cp++);
1496				*c++ = printable_char(*cp++);
1497				*c++ = printable_char(*cp++);
1498				*c++ = printable_char(*cp++);
1499				addr += 4;
1500			case 4:
1501				*c++ = printable_char(*cp++);
1502				*c++ = printable_char(*cp++);
1503				addr += 2;
1504			case 2:
1505				*c++ = printable_char(*cp++);
1506				addr++;
1507			case 1:
1508				*c++ = printable_char(*cp++);
1509				addr++;
1510				break;
1511			}
1512#undef printable_char
1513		}
1514	}
1515	kdb_printf("%*s %s\n", (int)((num-i)*(2*bytesperword + 1)+1),
1516		   " ", cbuf);
1517}
1518
1519static int kdb_md(int argc, const char **argv)
1520{
1521	static unsigned long last_addr;
1522	static int last_radix, last_bytesperword, last_repeat;
1523	int radix = 16, mdcount = 8, bytesperword = KDB_WORD_SIZE, repeat;
1524	int nosect = 0;
1525	char fmtchar, fmtstr[64];
1526	unsigned long addr;
1527	unsigned long word;
1528	long offset = 0;
1529	int symbolic = 0;
1530	int valid = 0;
1531	int phys = 0;
 
1532
1533	kdbgetintenv("MDCOUNT", &mdcount);
1534	kdbgetintenv("RADIX", &radix);
1535	kdbgetintenv("BYTESPERWORD", &bytesperword);
1536
1537	/* Assume 'md <addr>' and start with environment values */
1538	repeat = mdcount * 16 / bytesperword;
1539
1540	if (strcmp(argv[0], "mdr") == 0) {
1541		if (argc != 2)
 
 
1542			return KDB_ARGCOUNT;
1543		valid = 1;
1544	} else if (isdigit(argv[0][2])) {
1545		bytesperword = (int)(argv[0][2] - '0');
1546		if (bytesperword == 0) {
1547			bytesperword = last_bytesperword;
1548			if (bytesperword == 0)
1549				bytesperword = 4;
1550		}
1551		last_bytesperword = bytesperword;
1552		repeat = mdcount * 16 / bytesperword;
1553		if (!argv[0][3])
1554			valid = 1;
1555		else if (argv[0][3] == 'c' && argv[0][4]) {
1556			char *p;
1557			repeat = simple_strtoul(argv[0] + 4, &p, 10);
1558			mdcount = ((repeat * bytesperword) + 15) / 16;
1559			valid = !*p;
1560		}
1561		last_repeat = repeat;
1562	} else if (strcmp(argv[0], "md") == 0)
1563		valid = 1;
1564	else if (strcmp(argv[0], "mds") == 0)
1565		valid = 1;
1566	else if (strcmp(argv[0], "mdp") == 0) {
1567		phys = valid = 1;
1568	}
1569	if (!valid)
1570		return KDB_NOTFOUND;
1571
1572	if (argc == 0) {
1573		if (last_addr == 0)
1574			return KDB_ARGCOUNT;
1575		addr = last_addr;
1576		radix = last_radix;
1577		bytesperword = last_bytesperword;
1578		repeat = last_repeat;
1579		mdcount = ((repeat * bytesperword) + 15) / 16;
 
 
 
1580	}
1581
1582	if (argc) {
1583		unsigned long val;
1584		int diag, nextarg = 1;
1585		diag = kdbgetaddrarg(argc, argv, &nextarg, &addr,
1586				     &offset, NULL);
1587		if (diag)
1588			return diag;
1589		if (argc > nextarg+2)
1590			return KDB_ARGCOUNT;
1591
1592		if (argc >= nextarg) {
1593			diag = kdbgetularg(argv[nextarg], &val);
1594			if (!diag) {
1595				mdcount = (int) val;
1596				repeat = mdcount * 16 / bytesperword;
 
 
 
1597			}
1598		}
1599		if (argc >= nextarg+1) {
1600			diag = kdbgetularg(argv[nextarg+1], &val);
1601			if (!diag)
1602				radix = (int) val;
1603		}
1604	}
1605
1606	if (strcmp(argv[0], "mdr") == 0)
1607		return kdb_mdr(addr, mdcount);
 
 
 
 
 
 
 
1608
1609	switch (radix) {
1610	case 10:
1611		fmtchar = 'd';
1612		break;
1613	case 16:
1614		fmtchar = 'x';
1615		break;
1616	case 8:
1617		fmtchar = 'o';
1618		break;
1619	default:
1620		return KDB_BADRADIX;
1621	}
1622
1623	last_radix = radix;
1624
1625	if (bytesperword > KDB_WORD_SIZE)
1626		return KDB_BADWIDTH;
1627
1628	switch (bytesperword) {
1629	case 8:
1630		sprintf(fmtstr, "%%16.16l%c ", fmtchar);
1631		break;
1632	case 4:
1633		sprintf(fmtstr, "%%8.8l%c ", fmtchar);
1634		break;
1635	case 2:
1636		sprintf(fmtstr, "%%4.4l%c ", fmtchar);
1637		break;
1638	case 1:
1639		sprintf(fmtstr, "%%2.2l%c ", fmtchar);
1640		break;
1641	default:
1642		return KDB_BADWIDTH;
1643	}
1644
1645	last_repeat = repeat;
1646	last_bytesperword = bytesperword;
1647
1648	if (strcmp(argv[0], "mds") == 0) {
1649		symbolic = 1;
1650		/* Do not save these changes as last_*, they are temporary mds
1651		 * overrides.
1652		 */
1653		bytesperword = KDB_WORD_SIZE;
1654		repeat = mdcount;
1655		kdbgetintenv("NOSECT", &nosect);
1656	}
1657
1658	/* Round address down modulo BYTESPERWORD */
1659
1660	addr &= ~(bytesperword-1);
1661
1662	while (repeat > 0) {
1663		unsigned long a;
1664		int n, z, num = (symbolic ? 1 : (16 / bytesperword));
1665
1666		if (KDB_FLAG(CMD_INTERRUPT))
1667			return 0;
1668		for (a = addr, z = 0; z < repeat; a += bytesperword, ++z) {
1669			if (phys) {
1670				if (kdb_getphysword(&word, a, bytesperword)
1671						|| word)
1672					break;
1673			} else if (kdb_getword(&word, a, bytesperword) || word)
1674				break;
1675		}
1676		n = min(num, repeat);
1677		kdb_md_line(fmtstr, addr, symbolic, nosect, bytesperword,
1678			    num, repeat, phys);
1679		addr += bytesperword * n;
1680		repeat -= n;
1681		z = (z + num - 1) / num;
1682		if (z > 2) {
1683			int s = num * (z-2);
1684			kdb_printf(kdb_machreg_fmt0 "-" kdb_machreg_fmt0
1685				   " zero suppressed\n",
1686				addr, addr + bytesperword * s - 1);
1687			addr += bytesperword * s;
1688			repeat -= s;
1689		}
1690	}
1691	last_addr = addr;
1692
1693	return 0;
1694}
1695
1696/*
1697 * kdb_mm - This function implements the 'mm' command.
1698 *	mm address-expression new-value
1699 * Remarks:
1700 *	mm works on machine words, mmW works on bytes.
1701 */
1702static int kdb_mm(int argc, const char **argv)
1703{
1704	int diag;
1705	unsigned long addr;
1706	long offset = 0;
1707	unsigned long contents;
1708	int nextarg;
1709	int width;
1710
1711	if (argv[0][2] && !isdigit(argv[0][2]))
1712		return KDB_NOTFOUND;
1713
1714	if (argc < 2)
1715		return KDB_ARGCOUNT;
1716
1717	nextarg = 1;
1718	diag = kdbgetaddrarg(argc, argv, &nextarg, &addr, &offset, NULL);
1719	if (diag)
1720		return diag;
1721
1722	if (nextarg > argc)
1723		return KDB_ARGCOUNT;
1724	diag = kdbgetaddrarg(argc, argv, &nextarg, &contents, NULL, NULL);
1725	if (diag)
1726		return diag;
1727
1728	if (nextarg != argc + 1)
1729		return KDB_ARGCOUNT;
1730
1731	width = argv[0][2] ? (argv[0][2] - '0') : (KDB_WORD_SIZE);
1732	diag = kdb_putword(addr, contents, width);
1733	if (diag)
1734		return diag;
1735
1736	kdb_printf(kdb_machreg_fmt " = " kdb_machreg_fmt "\n", addr, contents);
1737
1738	return 0;
1739}
1740
1741/*
1742 * kdb_go - This function implements the 'go' command.
1743 *	go [address-expression]
1744 */
1745static int kdb_go(int argc, const char **argv)
1746{
1747	unsigned long addr;
1748	int diag;
1749	int nextarg;
1750	long offset;
1751
1752	if (raw_smp_processor_id() != kdb_initial_cpu) {
1753		kdb_printf("go must execute on the entry cpu, "
1754			   "please use \"cpu %d\" and then execute go\n",
1755			   kdb_initial_cpu);
1756		return KDB_BADCPUNUM;
1757	}
1758	if (argc == 1) {
1759		nextarg = 1;
1760		diag = kdbgetaddrarg(argc, argv, &nextarg,
1761				     &addr, &offset, NULL);
1762		if (diag)
1763			return diag;
1764	} else if (argc) {
1765		return KDB_ARGCOUNT;
1766	}
1767
1768	diag = KDB_CMD_GO;
1769	if (KDB_FLAG(CATASTROPHIC)) {
1770		kdb_printf("Catastrophic error detected\n");
1771		kdb_printf("kdb_continue_catastrophic=%d, ",
1772			kdb_continue_catastrophic);
1773		if (kdb_continue_catastrophic == 0 && kdb_go_count++ == 0) {
1774			kdb_printf("type go a second time if you really want "
1775				   "to continue\n");
1776			return 0;
1777		}
1778		if (kdb_continue_catastrophic == 2) {
1779			kdb_printf("forcing reboot\n");
1780			kdb_reboot(0, NULL);
1781		}
1782		kdb_printf("attempting to continue\n");
1783	}
1784	return diag;
1785}
1786
1787/*
1788 * kdb_rd - This function implements the 'rd' command.
1789 */
1790static int kdb_rd(int argc, const char **argv)
1791{
1792	int len = kdb_check_regs();
1793#if DBG_MAX_REG_NUM > 0
1794	int i;
1795	char *rname;
1796	int rsize;
1797	u64 reg64;
1798	u32 reg32;
1799	u16 reg16;
1800	u8 reg8;
1801
1802	if (len)
1803		return len;
1804
1805	for (i = 0; i < DBG_MAX_REG_NUM; i++) {
1806		rsize = dbg_reg_def[i].size * 2;
1807		if (rsize > 16)
1808			rsize = 2;
1809		if (len + strlen(dbg_reg_def[i].name) + 4 + rsize > 80) {
1810			len = 0;
1811			kdb_printf("\n");
1812		}
1813		if (len)
1814			len += kdb_printf("  ");
1815		switch(dbg_reg_def[i].size * 8) {
1816		case 8:
1817			rname = dbg_get_reg(i, &reg8, kdb_current_regs);
1818			if (!rname)
1819				break;
1820			len += kdb_printf("%s: %02x", rname, reg8);
1821			break;
1822		case 16:
1823			rname = dbg_get_reg(i, &reg16, kdb_current_regs);
1824			if (!rname)
1825				break;
1826			len += kdb_printf("%s: %04x", rname, reg16);
1827			break;
1828		case 32:
1829			rname = dbg_get_reg(i, &reg32, kdb_current_regs);
1830			if (!rname)
1831				break;
1832			len += kdb_printf("%s: %08x", rname, reg32);
1833			break;
1834		case 64:
1835			rname = dbg_get_reg(i, &reg64, kdb_current_regs);
1836			if (!rname)
1837				break;
1838			len += kdb_printf("%s: %016llx", rname, reg64);
1839			break;
1840		default:
1841			len += kdb_printf("%s: ??", dbg_reg_def[i].name);
1842		}
1843	}
1844	kdb_printf("\n");
1845#else
1846	if (len)
1847		return len;
1848
1849	kdb_dumpregs(kdb_current_regs);
1850#endif
1851	return 0;
1852}
1853
1854/*
1855 * kdb_rm - This function implements the 'rm' (register modify)  command.
1856 *	rm register-name new-contents
1857 * Remarks:
1858 *	Allows register modification with the same restrictions as gdb
1859 */
1860static int kdb_rm(int argc, const char **argv)
1861{
1862#if DBG_MAX_REG_NUM > 0
1863	int diag;
1864	const char *rname;
1865	int i;
1866	u64 reg64;
1867	u32 reg32;
1868	u16 reg16;
1869	u8 reg8;
1870
1871	if (argc != 2)
1872		return KDB_ARGCOUNT;
1873	/*
1874	 * Allow presence or absence of leading '%' symbol.
1875	 */
1876	rname = argv[1];
1877	if (*rname == '%')
1878		rname++;
1879
1880	diag = kdbgetu64arg(argv[2], &reg64);
1881	if (diag)
1882		return diag;
1883
1884	diag = kdb_check_regs();
1885	if (diag)
1886		return diag;
1887
1888	diag = KDB_BADREG;
1889	for (i = 0; i < DBG_MAX_REG_NUM; i++) {
1890		if (strcmp(rname, dbg_reg_def[i].name) == 0) {
1891			diag = 0;
1892			break;
1893		}
1894	}
1895	if (!diag) {
1896		switch(dbg_reg_def[i].size * 8) {
1897		case 8:
1898			reg8 = reg64;
1899			dbg_set_reg(i, &reg8, kdb_current_regs);
1900			break;
1901		case 16:
1902			reg16 = reg64;
1903			dbg_set_reg(i, &reg16, kdb_current_regs);
1904			break;
1905		case 32:
1906			reg32 = reg64;
1907			dbg_set_reg(i, &reg32, kdb_current_regs);
1908			break;
1909		case 64:
1910			dbg_set_reg(i, &reg64, kdb_current_regs);
1911			break;
1912		}
1913	}
1914	return diag;
1915#else
1916	kdb_printf("ERROR: Register set currently not implemented\n");
1917    return 0;
1918#endif
1919}
1920
1921#if defined(CONFIG_MAGIC_SYSRQ)
1922/*
1923 * kdb_sr - This function implements the 'sr' (SYSRQ key) command
1924 *	which interfaces to the soi-disant MAGIC SYSRQ functionality.
1925 *		sr <magic-sysrq-code>
1926 */
1927static int kdb_sr(int argc, const char **argv)
1928{
 
 
 
1929	if (argc != 1)
1930		return KDB_ARGCOUNT;
 
1931	kdb_trap_printk++;
1932	__handle_sysrq(*argv[1], false);
1933	kdb_trap_printk--;
1934
1935	return 0;
1936}
1937#endif	/* CONFIG_MAGIC_SYSRQ */
1938
1939/*
1940 * kdb_ef - This function implements the 'regs' (display exception
1941 *	frame) command.  This command takes an address and expects to
1942 *	find an exception frame at that address, formats and prints
1943 *	it.
1944 *		regs address-expression
1945 * Remarks:
1946 *	Not done yet.
1947 */
1948static int kdb_ef(int argc, const char **argv)
1949{
1950	int diag;
1951	unsigned long addr;
1952	long offset;
1953	int nextarg;
1954
1955	if (argc != 1)
1956		return KDB_ARGCOUNT;
1957
1958	nextarg = 1;
1959	diag = kdbgetaddrarg(argc, argv, &nextarg, &addr, &offset, NULL);
1960	if (diag)
1961		return diag;
1962	show_regs((struct pt_regs *)addr);
1963	return 0;
1964}
1965
1966#if defined(CONFIG_MODULES)
1967/*
1968 * kdb_lsmod - This function implements the 'lsmod' command.  Lists
1969 *	currently loaded kernel modules.
1970 *	Mostly taken from userland lsmod.
1971 */
1972static int kdb_lsmod(int argc, const char **argv)
1973{
1974	struct module *mod;
1975
1976	if (argc != 0)
1977		return KDB_ARGCOUNT;
1978
1979	kdb_printf("Module                  Size  modstruct     Used by\n");
1980	list_for_each_entry(mod, kdb_modules, list) {
 
 
1981
1982		kdb_printf("%-20s%8u  0x%p ", mod->name,
1983			   mod->core_size, (void *)mod);
1984#ifdef CONFIG_MODULE_UNLOAD
1985		kdb_printf("%4d ", module_refcount(mod));
1986#endif
1987		if (mod->state == MODULE_STATE_GOING)
1988			kdb_printf(" (Unloading)");
1989		else if (mod->state == MODULE_STATE_COMING)
1990			kdb_printf(" (Loading)");
1991		else
1992			kdb_printf(" (Live)");
1993		kdb_printf(" 0x%p", mod->module_core);
1994
1995#ifdef CONFIG_MODULE_UNLOAD
1996		{
1997			struct module_use *use;
1998			kdb_printf(" [ ");
1999			list_for_each_entry(use, &mod->source_list,
2000					    source_list)
2001				kdb_printf("%s ", use->target->name);
2002			kdb_printf("]\n");
2003		}
2004#endif
2005	}
2006
2007	return 0;
2008}
2009
2010#endif	/* CONFIG_MODULES */
2011
2012/*
2013 * kdb_env - This function implements the 'env' command.  Display the
2014 *	current environment variables.
2015 */
2016
2017static int kdb_env(int argc, const char **argv)
2018{
2019	int i;
2020
2021	for (i = 0; i < __nenv; i++) {
2022		if (__env[i])
2023			kdb_printf("%s\n", __env[i]);
2024	}
2025
2026	if (KDB_DEBUG(MASK))
2027		kdb_printf("KDBFLAGS=0x%x\n", kdb_flags);
2028
2029	return 0;
2030}
2031
2032#ifdef CONFIG_PRINTK
2033/*
2034 * kdb_dmesg - This function implements the 'dmesg' command to display
2035 *	the contents of the syslog buffer.
2036 *		dmesg [lines] [adjust]
2037 */
2038static int kdb_dmesg(int argc, const char **argv)
2039{
2040	char *syslog_data[4], *start, *end, c = '\0', *p;
2041	int diag, logging, logsize, lines = 0, adjust = 0, n;
 
 
 
 
 
 
 
2042
2043	if (argc > 2)
2044		return KDB_ARGCOUNT;
2045	if (argc) {
2046		char *cp;
2047		lines = simple_strtol(argv[1], &cp, 0);
2048		if (*cp)
2049			lines = 0;
2050		if (argc > 1) {
2051			adjust = simple_strtoul(argv[2], &cp, 0);
2052			if (*cp || adjust < 0)
2053				adjust = 0;
2054		}
2055	}
2056
2057	/* disable LOGGING if set */
2058	diag = kdbgetintenv("LOGGING", &logging);
2059	if (!diag && logging) {
2060		const char *setargs[] = { "set", "LOGGING", "0" };
2061		kdb_set(2, setargs);
2062	}
2063
2064	/* syslog_data[0,1] physical start, end+1.  syslog_data[2,3]
2065	 * logical start, end+1. */
2066	kdb_syslog_data(syslog_data);
2067	if (syslog_data[2] == syslog_data[3])
2068		return 0;
2069	logsize = syslog_data[1] - syslog_data[0];
2070	start = syslog_data[2];
2071	end = syslog_data[3];
2072#define KDB_WRAP(p) (((p - syslog_data[0]) % logsize) + syslog_data[0])
2073	for (n = 0, p = start; p < end; ++p) {
2074		c = *KDB_WRAP(p);
2075		if (c == '\n')
2076			++n;
2077	}
2078	if (c != '\n')
2079		++n;
2080	if (lines < 0) {
2081		if (adjust >= n)
2082			kdb_printf("buffer only contains %d lines, nothing "
2083				   "printed\n", n);
2084		else if (adjust - lines >= n)
2085			kdb_printf("buffer only contains %d lines, last %d "
2086				   "lines printed\n", n, n - adjust);
2087		if (adjust) {
2088			for (; start < end && adjust; ++start) {
2089				if (*KDB_WRAP(start) == '\n')
2090					--adjust;
2091			}
2092			if (start < end)
2093				++start;
2094		}
2095		for (p = start; p < end && lines; ++p) {
2096			if (*KDB_WRAP(p) == '\n')
2097				++lines;
2098		}
2099		end = p;
2100	} else if (lines > 0) {
2101		int skip = n - (adjust + lines);
 
2102		if (adjust >= n) {
2103			kdb_printf("buffer only contains %d lines, "
2104				   "nothing printed\n", n);
2105			skip = n;
2106		} else if (skip < 0) {
2107			lines += skip;
2108			skip = 0;
2109			kdb_printf("buffer only contains %d lines, first "
2110				   "%d lines printed\n", n, lines);
2111		}
2112		for (; start < end && skip; ++start) {
2113			if (*KDB_WRAP(start) == '\n')
2114				--skip;
2115		}
2116		for (p = start; p < end && lines; ++p) {
2117			if (*KDB_WRAP(p) == '\n')
2118				--lines;
2119		}
2120		end = p;
2121	}
2122	/* Do a line at a time (max 200 chars) to reduce protocol overhead */
2123	c = '\n';
2124	while (start != end) {
2125		char buf[201];
2126		p = buf;
2127		if (KDB_FLAG(CMD_INTERRUPT))
2128			return 0;
2129		while (start < end && (c = *KDB_WRAP(start)) &&
2130		       (p - buf) < sizeof(buf)-1) {
2131			++start;
2132			*p++ = c;
2133			if (c == '\n')
2134				break;
2135		}
2136		*p = '\0';
2137		kdb_printf("%s", buf);
2138	}
2139	if (c != '\n')
2140		kdb_printf("\n");
2141
2142	return 0;
2143}
2144#endif /* CONFIG_PRINTK */
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
2145/*
2146 * kdb_cpu - This function implements the 'cpu' command.
2147 *	cpu	[<cpunum>]
2148 * Returns:
2149 *	KDB_CMD_CPU for success, a kdb diagnostic if error
2150 */
2151static void kdb_cpu_status(void)
2152{
2153	int i, start_cpu, first_print = 1;
2154	char state, prev_state = '?';
2155
2156	kdb_printf("Currently on cpu %d\n", raw_smp_processor_id());
2157	kdb_printf("Available cpus: ");
2158	for (start_cpu = -1, i = 0; i < NR_CPUS; i++) {
2159		if (!cpu_online(i)) {
2160			state = 'F';	/* cpu is offline */
 
 
2161		} else {
2162			state = ' ';	/* cpu is responding to kdb */
2163			if (kdb_task_state_char(KDB_TSK(i)) == 'I')
2164				state = 'I';	/* idle task */
2165		}
2166		if (state != prev_state) {
2167			if (prev_state != '?') {
2168				if (!first_print)
2169					kdb_printf(", ");
2170				first_print = 0;
2171				kdb_printf("%d", start_cpu);
2172				if (start_cpu < i-1)
2173					kdb_printf("-%d", i-1);
2174				if (prev_state != ' ')
2175					kdb_printf("(%c)", prev_state);
2176			}
2177			prev_state = state;
2178			start_cpu = i;
2179		}
2180	}
2181	/* print the trailing cpus, ignoring them if they are all offline */
2182	if (prev_state != 'F') {
2183		if (!first_print)
2184			kdb_printf(", ");
2185		kdb_printf("%d", start_cpu);
2186		if (start_cpu < i-1)
2187			kdb_printf("-%d", i-1);
2188		if (prev_state != ' ')
2189			kdb_printf("(%c)", prev_state);
2190	}
2191	kdb_printf("\n");
2192}
2193
2194static int kdb_cpu(int argc, const char **argv)
2195{
2196	unsigned long cpunum;
2197	int diag;
2198
2199	if (argc == 0) {
2200		kdb_cpu_status();
2201		return 0;
2202	}
2203
2204	if (argc != 1)
2205		return KDB_ARGCOUNT;
2206
2207	diag = kdbgetularg(argv[1], &cpunum);
2208	if (diag)
2209		return diag;
2210
2211	/*
2212	 * Validate cpunum
2213	 */
2214	if ((cpunum > NR_CPUS) || !cpu_online(cpunum))
2215		return KDB_BADCPUNUM;
2216
2217	dbg_switch_cpu = cpunum;
2218
2219	/*
2220	 * Switch to other cpu
2221	 */
2222	return KDB_CMD_CPU;
2223}
2224
2225/* The user may not realize that ps/bta with no parameters does not print idle
2226 * or sleeping system daemon processes, so tell them how many were suppressed.
2227 */
2228void kdb_ps_suppressed(void)
2229{
2230	int idle = 0, daemon = 0;
2231	unsigned long mask_I = kdb_task_state_string("I"),
2232		      mask_M = kdb_task_state_string("M");
2233	unsigned long cpu;
2234	const struct task_struct *p, *g;
2235	for_each_online_cpu(cpu) {
2236		p = kdb_curr_task(cpu);
2237		if (kdb_task_state(p, mask_I))
2238			++idle;
2239	}
2240	kdb_do_each_thread(g, p) {
2241		if (kdb_task_state(p, mask_M))
2242			++daemon;
2243	} kdb_while_each_thread(g, p);
2244	if (idle || daemon) {
2245		if (idle)
2246			kdb_printf("%d idle process%s (state I)%s\n",
2247				   idle, idle == 1 ? "" : "es",
2248				   daemon ? " and " : "");
2249		if (daemon)
2250			kdb_printf("%d sleeping system daemon (state M) "
2251				   "process%s", daemon,
2252				   daemon == 1 ? "" : "es");
2253		kdb_printf(" suppressed,\nuse 'ps A' to see all.\n");
2254	}
2255}
2256
2257/*
2258 * kdb_ps - This function implements the 'ps' command which shows a
2259 *	list of the active processes.
2260 *		ps [DRSTCZEUIMA]   All processes, optionally filtered by state
2261 */
2262void kdb_ps1(const struct task_struct *p)
2263{
2264	int cpu;
2265	unsigned long tmp;
2266
2267	if (!p || probe_kernel_read(&tmp, (char *)p, sizeof(unsigned long)))
2268		return;
2269
2270	cpu = kdb_process_cpu(p);
2271	kdb_printf("0x%p %8d %8d  %d %4d   %c  0x%p %c%s\n",
2272		   (void *)p, p->pid, p->parent->pid,
2273		   kdb_task_has_cpu(p), kdb_process_cpu(p),
2274		   kdb_task_state_char(p),
2275		   (void *)(&p->thread),
2276		   p == kdb_curr_task(raw_smp_processor_id()) ? '*' : ' ',
2277		   p->comm);
2278	if (kdb_task_has_cpu(p)) {
2279		if (!KDB_TSK(cpu)) {
2280			kdb_printf("  Error: no saved data for this cpu\n");
2281		} else {
2282			if (KDB_TSK(cpu) != p)
2283				kdb_printf("  Error: does not match running "
2284				   "process table (0x%p)\n", KDB_TSK(cpu));
2285		}
2286	}
2287}
2288
2289static int kdb_ps(int argc, const char **argv)
2290{
2291	struct task_struct *g, *p;
2292	unsigned long mask, cpu;
2293
2294	if (argc == 0)
2295		kdb_ps_suppressed();
2296	kdb_printf("%-*s      Pid   Parent [*] cpu State %-*s Command\n",
2297		(int)(2*sizeof(void *))+2, "Task Addr",
2298		(int)(2*sizeof(void *))+2, "Thread");
2299	mask = kdb_task_state_string(argc ? argv[1] : NULL);
2300	/* Run the active tasks first */
2301	for_each_online_cpu(cpu) {
2302		if (KDB_FLAG(CMD_INTERRUPT))
2303			return 0;
2304		p = kdb_curr_task(cpu);
2305		if (kdb_task_state(p, mask))
2306			kdb_ps1(p);
2307	}
2308	kdb_printf("\n");
2309	/* Now the real tasks */
2310	kdb_do_each_thread(g, p) {
2311		if (KDB_FLAG(CMD_INTERRUPT))
2312			return 0;
2313		if (kdb_task_state(p, mask))
2314			kdb_ps1(p);
2315	} kdb_while_each_thread(g, p);
2316
2317	return 0;
2318}
2319
2320/*
2321 * kdb_pid - This function implements the 'pid' command which switches
2322 *	the currently active process.
2323 *		pid [<pid> | R]
2324 */
2325static int kdb_pid(int argc, const char **argv)
2326{
2327	struct task_struct *p;
2328	unsigned long val;
2329	int diag;
2330
2331	if (argc > 1)
2332		return KDB_ARGCOUNT;
2333
2334	if (argc) {
2335		if (strcmp(argv[1], "R") == 0) {
2336			p = KDB_TSK(kdb_initial_cpu);
2337		} else {
2338			diag = kdbgetularg(argv[1], &val);
2339			if (diag)
2340				return KDB_BADINT;
2341
2342			p = find_task_by_pid_ns((pid_t)val,	&init_pid_ns);
2343			if (!p) {
2344				kdb_printf("No task with pid=%d\n", (pid_t)val);
2345				return 0;
2346			}
2347		}
2348		kdb_set_current_task(p);
2349	}
2350	kdb_printf("KDB current process is %s(pid=%d)\n",
2351		   kdb_current_task->comm,
2352		   kdb_current_task->pid);
2353
2354	return 0;
2355}
2356
2357/*
2358 * kdb_ll - This function implements the 'll' command which follows a
2359 *	linked list and executes an arbitrary command for each
2360 *	element.
2361 */
2362static int kdb_ll(int argc, const char **argv)
2363{
2364	int diag = 0;
2365	unsigned long addr;
2366	long offset = 0;
2367	unsigned long va;
2368	unsigned long linkoffset;
2369	int nextarg;
2370	const char *command;
2371
2372	if (argc != 3)
2373		return KDB_ARGCOUNT;
2374
2375	nextarg = 1;
2376	diag = kdbgetaddrarg(argc, argv, &nextarg, &addr, &offset, NULL);
2377	if (diag)
2378		return diag;
2379
2380	diag = kdbgetularg(argv[2], &linkoffset);
2381	if (diag)
2382		return diag;
2383
2384	/*
2385	 * Using the starting address as
2386	 * the first element in the list, and assuming that
2387	 * the list ends with a null pointer.
2388	 */
2389
2390	va = addr;
2391	command = kdb_strdup(argv[3], GFP_KDB);
2392	if (!command) {
2393		kdb_printf("%s: cannot duplicate command\n", __func__);
2394		return 0;
2395	}
2396	/* Recursive use of kdb_parse, do not use argv after this point */
2397	argv = NULL;
2398
2399	while (va) {
2400		char buf[80];
2401
2402		if (KDB_FLAG(CMD_INTERRUPT))
2403			goto out;
2404
2405		sprintf(buf, "%s " kdb_machreg_fmt "\n", command, va);
2406		diag = kdb_parse(buf);
2407		if (diag)
2408			goto out;
2409
2410		addr = va + linkoffset;
2411		if (kdb_getword(&va, addr, sizeof(va)))
2412			goto out;
2413	}
2414
2415out:
2416	kfree(command);
2417	return diag;
2418}
2419
2420static int kdb_kgdb(int argc, const char **argv)
2421{
2422	return KDB_CMD_KGDB;
2423}
2424
2425/*
2426 * kdb_help - This function implements the 'help' and '?' commands.
2427 */
2428static int kdb_help(int argc, const char **argv)
2429{
2430	kdbtab_t *kt;
2431	int i;
2432
2433	kdb_printf("%-15.15s %-20.20s %s\n", "Command", "Usage", "Description");
2434	kdb_printf("-----------------------------"
2435		   "-----------------------------\n");
2436	for_each_kdbcmd(kt, i) {
2437		if (kt->cmd_name)
2438			kdb_printf("%-15.15s %-20.20s %s\n", kt->cmd_name,
2439				   kt->cmd_usage, kt->cmd_help);
2440		if (KDB_FLAG(CMD_INTERRUPT))
2441			return 0;
 
 
 
 
 
 
 
 
2442	}
2443	return 0;
2444}
2445
2446/*
2447 * kdb_kill - This function implements the 'kill' commands.
2448 */
2449static int kdb_kill(int argc, const char **argv)
2450{
2451	long sig, pid;
2452	char *endp;
2453	struct task_struct *p;
2454	struct siginfo info;
2455
2456	if (argc != 2)
2457		return KDB_ARGCOUNT;
2458
2459	sig = simple_strtol(argv[1], &endp, 0);
2460	if (*endp)
2461		return KDB_BADINT;
2462	if (sig >= 0) {
2463		kdb_printf("Invalid signal parameter.<-signal>\n");
2464		return 0;
2465	}
2466	sig = -sig;
2467
2468	pid = simple_strtol(argv[2], &endp, 0);
2469	if (*endp)
2470		return KDB_BADINT;
2471	if (pid <= 0) {
2472		kdb_printf("Process ID must be large than 0.\n");
2473		return 0;
2474	}
2475
2476	/* Find the process. */
2477	p = find_task_by_pid_ns(pid, &init_pid_ns);
2478	if (!p) {
2479		kdb_printf("The specified process isn't found.\n");
2480		return 0;
2481	}
2482	p = p->group_leader;
2483	info.si_signo = sig;
2484	info.si_errno = 0;
2485	info.si_code = SI_USER;
2486	info.si_pid = pid;  /* same capabilities as process being signalled */
2487	info.si_uid = 0;    /* kdb has root authority */
2488	kdb_send_sig_info(p, &info);
2489	return 0;
2490}
2491
2492struct kdb_tm {
2493	int tm_sec;	/* seconds */
2494	int tm_min;	/* minutes */
2495	int tm_hour;	/* hours */
2496	int tm_mday;	/* day of the month */
2497	int tm_mon;	/* month */
2498	int tm_year;	/* year */
2499};
2500
2501static void kdb_gmtime(struct timespec *tv, struct kdb_tm *tm)
2502{
2503	/* This will work from 1970-2099, 2100 is not a leap year */
2504	static int mon_day[] = { 31, 29, 31, 30, 31, 30, 31,
2505				 31, 30, 31, 30, 31 };
2506	memset(tm, 0, sizeof(*tm));
2507	tm->tm_sec  = tv->tv_sec % (24 * 60 * 60);
2508	tm->tm_mday = tv->tv_sec / (24 * 60 * 60) +
2509		(2 * 365 + 1); /* shift base from 1970 to 1968 */
2510	tm->tm_min =  tm->tm_sec / 60 % 60;
2511	tm->tm_hour = tm->tm_sec / 60 / 60;
2512	tm->tm_sec =  tm->tm_sec % 60;
2513	tm->tm_year = 68 + 4*(tm->tm_mday / (4*365+1));
2514	tm->tm_mday %= (4*365+1);
2515	mon_day[1] = 29;
2516	while (tm->tm_mday >= mon_day[tm->tm_mon]) {
2517		tm->tm_mday -= mon_day[tm->tm_mon];
2518		if (++tm->tm_mon == 12) {
2519			tm->tm_mon = 0;
2520			++tm->tm_year;
2521			mon_day[1] = 28;
2522		}
2523	}
2524	++tm->tm_mday;
2525}
2526
2527/*
2528 * Most of this code has been lifted from kernel/timer.c::sys_sysinfo().
2529 * I cannot call that code directly from kdb, it has an unconditional
2530 * cli()/sti() and calls routines that take locks which can stop the debugger.
2531 */
2532static void kdb_sysinfo(struct sysinfo *val)
2533{
2534	struct timespec uptime;
2535	do_posix_clock_monotonic_gettime(&uptime);
2536	memset(val, 0, sizeof(*val));
2537	val->uptime = uptime.tv_sec;
2538	val->loads[0] = avenrun[0];
2539	val->loads[1] = avenrun[1];
2540	val->loads[2] = avenrun[2];
2541	val->procs = nr_threads-1;
2542	si_meminfo(val);
2543
2544	return;
2545}
2546
2547/*
2548 * kdb_summary - This function implements the 'summary' command.
2549 */
2550static int kdb_summary(int argc, const char **argv)
2551{
2552	struct timespec now;
2553	struct kdb_tm tm;
2554	struct sysinfo val;
2555
2556	if (argc)
2557		return KDB_ARGCOUNT;
2558
2559	kdb_printf("sysname    %s\n", init_uts_ns.name.sysname);
2560	kdb_printf("release    %s\n", init_uts_ns.name.release);
2561	kdb_printf("version    %s\n", init_uts_ns.name.version);
2562	kdb_printf("machine    %s\n", init_uts_ns.name.machine);
2563	kdb_printf("nodename   %s\n", init_uts_ns.name.nodename);
2564	kdb_printf("domainname %s\n", init_uts_ns.name.domainname);
2565	kdb_printf("ccversion  %s\n", __stringify(CCVERSION));
2566
2567	now = __current_kernel_time();
2568	kdb_gmtime(&now, &tm);
2569	kdb_printf("date       %04d-%02d-%02d %02d:%02d:%02d "
2570		   "tz_minuteswest %d\n",
2571		1900+tm.tm_year, tm.tm_mon+1, tm.tm_mday,
2572		tm.tm_hour, tm.tm_min, tm.tm_sec,
2573		sys_tz.tz_minuteswest);
2574
2575	kdb_sysinfo(&val);
2576	kdb_printf("uptime     ");
2577	if (val.uptime > (24*60*60)) {
2578		int days = val.uptime / (24*60*60);
2579		val.uptime %= (24*60*60);
2580		kdb_printf("%d day%s ", days, days == 1 ? "" : "s");
2581	}
2582	kdb_printf("%02ld:%02ld\n", val.uptime/(60*60), (val.uptime/60)%60);
2583
2584	/* lifted from fs/proc/proc_misc.c::loadavg_read_proc() */
2585
2586#define LOAD_INT(x) ((x) >> FSHIFT)
2587#define LOAD_FRAC(x) LOAD_INT(((x) & (FIXED_1-1)) * 100)
2588	kdb_printf("load avg   %ld.%02ld %ld.%02ld %ld.%02ld\n",
2589		LOAD_INT(val.loads[0]), LOAD_FRAC(val.loads[0]),
2590		LOAD_INT(val.loads[1]), LOAD_FRAC(val.loads[1]),
2591		LOAD_INT(val.loads[2]), LOAD_FRAC(val.loads[2]));
2592#undef LOAD_INT
2593#undef LOAD_FRAC
2594	/* Display in kilobytes */
2595#define K(x) ((x) << (PAGE_SHIFT - 10))
2596	kdb_printf("\nMemTotal:       %8lu kB\nMemFree:        %8lu kB\n"
2597		   "Buffers:        %8lu kB\n",
2598		   val.totalram, val.freeram, val.bufferram);
2599	return 0;
2600}
2601
2602/*
2603 * kdb_per_cpu - This function implements the 'per_cpu' command.
2604 */
2605static int kdb_per_cpu(int argc, const char **argv)
2606{
2607	char fmtstr[64];
2608	int cpu, diag, nextarg = 1;
2609	unsigned long addr, symaddr, val, bytesperword = 0, whichcpu = ~0UL;
2610
2611	if (argc < 1 || argc > 3)
2612		return KDB_ARGCOUNT;
2613
2614	diag = kdbgetaddrarg(argc, argv, &nextarg, &symaddr, NULL, NULL);
2615	if (diag)
2616		return diag;
2617
2618	if (argc >= 2) {
2619		diag = kdbgetularg(argv[2], &bytesperword);
2620		if (diag)
2621			return diag;
2622	}
2623	if (!bytesperword)
2624		bytesperword = KDB_WORD_SIZE;
2625	else if (bytesperword > KDB_WORD_SIZE)
2626		return KDB_BADWIDTH;
2627	sprintf(fmtstr, "%%0%dlx ", (int)(2*bytesperword));
2628	if (argc >= 3) {
2629		diag = kdbgetularg(argv[3], &whichcpu);
2630		if (diag)
2631			return diag;
2632		if (!cpu_online(whichcpu)) {
2633			kdb_printf("cpu %ld is not online\n", whichcpu);
2634			return KDB_BADCPUNUM;
2635		}
2636	}
2637
2638	/* Most architectures use __per_cpu_offset[cpu], some use
2639	 * __per_cpu_offset(cpu), smp has no __per_cpu_offset.
2640	 */
2641#ifdef	__per_cpu_offset
2642#define KDB_PCU(cpu) __per_cpu_offset(cpu)
2643#else
2644#ifdef	CONFIG_SMP
2645#define KDB_PCU(cpu) __per_cpu_offset[cpu]
2646#else
2647#define KDB_PCU(cpu) 0
2648#endif
2649#endif
2650	for_each_online_cpu(cpu) {
2651		if (KDB_FLAG(CMD_INTERRUPT))
2652			return 0;
2653
2654		if (whichcpu != ~0UL && whichcpu != cpu)
2655			continue;
2656		addr = symaddr + KDB_PCU(cpu);
2657		diag = kdb_getword(&val, addr, bytesperword);
2658		if (diag) {
2659			kdb_printf("%5d " kdb_bfd_vma_fmt0 " - unable to "
2660				   "read, diag=%d\n", cpu, addr, diag);
2661			continue;
2662		}
2663		kdb_printf("%5d ", cpu);
2664		kdb_md_line(fmtstr, addr,
2665			bytesperword == KDB_WORD_SIZE,
2666			1, bytesperword, 1, 1, 0);
2667	}
2668#undef KDB_PCU
2669	return 0;
2670}
2671
2672/*
2673 * display help for the use of cmd | grep pattern
2674 */
2675static int kdb_grep_help(int argc, const char **argv)
2676{
2677	kdb_printf("Usage of  cmd args | grep pattern:\n");
2678	kdb_printf("  Any command's output may be filtered through an ");
2679	kdb_printf("emulated 'pipe'.\n");
2680	kdb_printf("  'grep' is just a key word.\n");
2681	kdb_printf("  The pattern may include a very limited set of "
2682		   "metacharacters:\n");
2683	kdb_printf("   pattern or ^pattern or pattern$ or ^pattern$\n");
2684	kdb_printf("  And if there are spaces in the pattern, you may "
2685		   "quote it:\n");
2686	kdb_printf("   \"pat tern\" or \"^pat tern\" or \"pat tern$\""
2687		   " or \"^pat tern$\"\n");
2688	return 0;
2689}
2690
2691/*
2692 * kdb_register_repeat - This function is used to register a kernel
2693 * 	debugger command.
2694 * Inputs:
2695 *	cmd	Command name
2696 *	func	Function to execute the command
2697 *	usage	A simple usage string showing arguments
2698 *	help	A simple help string describing command
2699 *	repeat	Does the command auto repeat on enter?
2700 * Returns:
2701 *	zero for success, one if a duplicate command.
2702 */
2703#define kdb_command_extend 50	/* arbitrary */
2704int kdb_register_repeat(char *cmd,
2705			kdb_func_t func,
2706			char *usage,
2707			char *help,
2708			short minlen,
2709			kdb_repeat_t repeat)
2710{
2711	int i;
2712	kdbtab_t *kp;
2713
2714	/*
2715	 *  Brute force method to determine duplicates
2716	 */
2717	for_each_kdbcmd(kp, i) {
2718		if (kp->cmd_name && (strcmp(kp->cmd_name, cmd) == 0)) {
2719			kdb_printf("Duplicate kdb command registered: "
2720				"%s, func %p help %s\n", cmd, func, help);
2721			return 1;
2722		}
2723	}
2724
2725	/*
2726	 * Insert command into first available location in table
2727	 */
2728	for_each_kdbcmd(kp, i) {
2729		if (kp->cmd_name == NULL)
2730			break;
2731	}
2732
2733	if (i >= kdb_max_commands) {
2734		kdbtab_t *new = kmalloc((kdb_max_commands - KDB_BASE_CMD_MAX +
2735			 kdb_command_extend) * sizeof(*new), GFP_KDB);
2736		if (!new) {
2737			kdb_printf("Could not allocate new kdb_command "
2738				   "table\n");
2739			return 1;
2740		}
2741		if (kdb_commands) {
2742			memcpy(new, kdb_commands,
2743			  (kdb_max_commands - KDB_BASE_CMD_MAX) * sizeof(*new));
2744			kfree(kdb_commands);
2745		}
2746		memset(new + kdb_max_commands, 0,
2747		       kdb_command_extend * sizeof(*new));
2748		kdb_commands = new;
2749		kp = kdb_commands + kdb_max_commands - KDB_BASE_CMD_MAX;
2750		kdb_max_commands += kdb_command_extend;
2751	}
2752
2753	kp->cmd_name   = cmd;
2754	kp->cmd_func   = func;
2755	kp->cmd_usage  = usage;
2756	kp->cmd_help   = help;
2757	kp->cmd_flags  = 0;
2758	kp->cmd_minlen = minlen;
2759	kp->cmd_repeat = repeat;
2760
2761	return 0;
2762}
2763EXPORT_SYMBOL_GPL(kdb_register_repeat);
2764
2765
2766/*
2767 * kdb_register - Compatibility register function for commands that do
2768 *	not need to specify a repeat state.  Equivalent to
2769 *	kdb_register_repeat with KDB_REPEAT_NONE.
2770 * Inputs:
2771 *	cmd	Command name
2772 *	func	Function to execute the command
2773 *	usage	A simple usage string showing arguments
2774 *	help	A simple help string describing command
2775 * Returns:
2776 *	zero for success, one if a duplicate command.
2777 */
2778int kdb_register(char *cmd,
2779	     kdb_func_t func,
2780	     char *usage,
2781	     char *help,
2782	     short minlen)
2783{
2784	return kdb_register_repeat(cmd, func, usage, help, minlen,
2785				   KDB_REPEAT_NONE);
2786}
2787EXPORT_SYMBOL_GPL(kdb_register);
2788
2789/*
2790 * kdb_unregister - This function is used to unregister a kernel
2791 *	debugger command.  It is generally called when a module which
2792 *	implements kdb commands is unloaded.
2793 * Inputs:
2794 *	cmd	Command name
2795 * Returns:
2796 *	zero for success, one command not registered.
2797 */
2798int kdb_unregister(char *cmd)
2799{
2800	int i;
2801	kdbtab_t *kp;
2802
2803	/*
2804	 *  find the command.
2805	 */
2806	for_each_kdbcmd(kp, i) {
2807		if (kp->cmd_name && (strcmp(kp->cmd_name, cmd) == 0)) {
2808			kp->cmd_name = NULL;
2809			return 0;
2810		}
2811	}
2812
2813	/* Couldn't find it.  */
2814	return 1;
2815}
2816EXPORT_SYMBOL_GPL(kdb_unregister);
2817
2818/* Initialize the kdb command table. */
2819static void __init kdb_inittab(void)
2820{
2821	int i;
2822	kdbtab_t *kp;
2823
2824	for_each_kdbcmd(kp, i)
2825		kp->cmd_name = NULL;
2826
2827	kdb_register_repeat("md", kdb_md, "<vaddr>",
2828	  "Display Memory Contents, also mdWcN, e.g. md8c1", 1,
2829			    KDB_REPEAT_NO_ARGS);
2830	kdb_register_repeat("mdr", kdb_md, "<vaddr> <bytes>",
2831	  "Display Raw Memory", 0, KDB_REPEAT_NO_ARGS);
2832	kdb_register_repeat("mdp", kdb_md, "<paddr> <bytes>",
2833	  "Display Physical Memory", 0, KDB_REPEAT_NO_ARGS);
2834	kdb_register_repeat("mds", kdb_md, "<vaddr>",
2835	  "Display Memory Symbolically", 0, KDB_REPEAT_NO_ARGS);
2836	kdb_register_repeat("mm", kdb_mm, "<vaddr> <contents>",
2837	  "Modify Memory Contents", 0, KDB_REPEAT_NO_ARGS);
2838	kdb_register_repeat("go", kdb_go, "[<vaddr>]",
2839	  "Continue Execution", 1, KDB_REPEAT_NONE);
2840	kdb_register_repeat("rd", kdb_rd, "",
2841	  "Display Registers", 0, KDB_REPEAT_NONE);
2842	kdb_register_repeat("rm", kdb_rm, "<reg> <contents>",
2843	  "Modify Registers", 0, KDB_REPEAT_NONE);
2844	kdb_register_repeat("ef", kdb_ef, "<vaddr>",
2845	  "Display exception frame", 0, KDB_REPEAT_NONE);
2846	kdb_register_repeat("bt", kdb_bt, "[<vaddr>]",
2847	  "Stack traceback", 1, KDB_REPEAT_NONE);
2848	kdb_register_repeat("btp", kdb_bt, "<pid>",
2849	  "Display stack for process <pid>", 0, KDB_REPEAT_NONE);
2850	kdb_register_repeat("bta", kdb_bt, "[DRSTCZEUIMA]",
2851	  "Display stack all processes", 0, KDB_REPEAT_NONE);
2852	kdb_register_repeat("btc", kdb_bt, "",
2853	  "Backtrace current process on each cpu", 0, KDB_REPEAT_NONE);
2854	kdb_register_repeat("btt", kdb_bt, "<vaddr>",
 
 
 
 
 
 
 
 
 
 
 
 
2855	  "Backtrace process given its struct task address", 0,
2856			    KDB_REPEAT_NONE);
2857	kdb_register_repeat("ll", kdb_ll, "<first-element> <linkoffset> <cmd>",
2858	  "Execute cmd for each element in linked list", 0, KDB_REPEAT_NONE);
2859	kdb_register_repeat("env", kdb_env, "",
2860	  "Show environment variables", 0, KDB_REPEAT_NONE);
2861	kdb_register_repeat("set", kdb_set, "",
2862	  "Set environment variables", 0, KDB_REPEAT_NONE);
2863	kdb_register_repeat("help", kdb_help, "",
2864	  "Display Help Message", 1, KDB_REPEAT_NONE);
2865	kdb_register_repeat("?", kdb_help, "",
2866	  "Display Help Message", 0, KDB_REPEAT_NONE);
2867	kdb_register_repeat("cpu", kdb_cpu, "<cpunum>",
2868	  "Switch to new cpu", 0, KDB_REPEAT_NONE);
2869	kdb_register_repeat("kgdb", kdb_kgdb, "",
2870	  "Enter kgdb mode", 0, KDB_REPEAT_NONE);
2871	kdb_register_repeat("ps", kdb_ps, "[<flags>|A]",
2872	  "Display active task list", 0, KDB_REPEAT_NONE);
2873	kdb_register_repeat("pid", kdb_pid, "<pidnum>",
2874	  "Switch to another task", 0, KDB_REPEAT_NONE);
2875	kdb_register_repeat("reboot", kdb_reboot, "",
2876	  "Reboot the machine immediately", 0, KDB_REPEAT_NONE);
 
 
 
 
 
 
2877#if defined(CONFIG_MODULES)
2878	kdb_register_repeat("lsmod", kdb_lsmod, "",
2879	  "List loaded kernel modules", 0, KDB_REPEAT_NONE);
 
2880#endif
2881#if defined(CONFIG_MAGIC_SYSRQ)
2882	kdb_register_repeat("sr", kdb_sr, "<key>",
2883	  "Magic SysRq key", 0, KDB_REPEAT_NONE);
 
2884#endif
2885#if defined(CONFIG_PRINTK)
2886	kdb_register_repeat("dmesg", kdb_dmesg, "[lines]",
2887	  "Display syslog buffer", 0, KDB_REPEAT_NONE);
 
2888#endif
2889	kdb_register_repeat("defcmd", kdb_defcmd, "name \"usage\" \"help\"",
2890	  "Define a set of commands, down to endefcmd", 0, KDB_REPEAT_NONE);
2891	kdb_register_repeat("kill", kdb_kill, "<-signal> <pid>",
2892	  "Send a signal to a process", 0, KDB_REPEAT_NONE);
2893	kdb_register_repeat("summary", kdb_summary, "",
2894	  "Summarize the system", 4, KDB_REPEAT_NONE);
2895	kdb_register_repeat("per_cpu", kdb_per_cpu, "<sym> [<bytes>] [<cpu>]",
2896	  "Display per_cpu variables", 3, KDB_REPEAT_NONE);
2897	kdb_register_repeat("grephelp", kdb_grep_help, "",
2898	  "Display help on | grep", 0, KDB_REPEAT_NONE);
 
 
 
 
 
 
 
 
 
 
2899}
2900
2901/* Execute any commands defined in kdb_cmds.  */
2902static void __init kdb_cmd_init(void)
2903{
2904	int i, diag;
2905	for (i = 0; kdb_cmds[i]; ++i) {
2906		diag = kdb_parse(kdb_cmds[i]);
2907		if (diag)
2908			kdb_printf("kdb command %s failed, kdb diag %d\n",
2909				kdb_cmds[i], diag);
2910	}
2911	if (defcmd_in_progress) {
2912		kdb_printf("Incomplete 'defcmd' set, forcing endefcmd\n");
2913		kdb_parse("endefcmd");
2914	}
2915}
2916
2917/* Initialize kdb_printf, breakpoint tables and kdb state */
2918void __init kdb_init(int lvl)
2919{
2920	static int kdb_init_lvl = KDB_NOT_INITIALIZED;
2921	int i;
2922
2923	if (kdb_init_lvl == KDB_INIT_FULL || lvl <= kdb_init_lvl)
2924		return;
2925	for (i = kdb_init_lvl; i < lvl; i++) {
2926		switch (i) {
2927		case KDB_NOT_INITIALIZED:
2928			kdb_inittab();		/* Initialize Command Table */
2929			kdb_initbptab();	/* Initialize Breakpoints */
2930			break;
2931		case KDB_INIT_EARLY:
2932			kdb_cmd_init();		/* Build kdb_cmds tables */
2933			break;
2934		}
2935	}
2936	kdb_init_lvl = lvl;
2937}
v4.17
   1/*
   2 * Kernel Debugger Architecture Independent Main Code
   3 *
   4 * This file is subject to the terms and conditions of the GNU General Public
   5 * License.  See the file "COPYING" in the main directory of this archive
   6 * for more details.
   7 *
   8 * Copyright (C) 1999-2004 Silicon Graphics, Inc.  All Rights Reserved.
   9 * Copyright (C) 2000 Stephane Eranian <eranian@hpl.hp.com>
  10 * Xscale (R) modifications copyright (C) 2003 Intel Corporation.
  11 * Copyright (c) 2009 Wind River Systems, Inc.  All Rights Reserved.
  12 */
  13
  14#include <linux/ctype.h>
  15#include <linux/types.h>
  16#include <linux/string.h>
  17#include <linux/kernel.h>
  18#include <linux/kmsg_dump.h>
  19#include <linux/reboot.h>
  20#include <linux/sched.h>
  21#include <linux/sched/loadavg.h>
  22#include <linux/sched/stat.h>
  23#include <linux/sched/debug.h>
  24#include <linux/sysrq.h>
  25#include <linux/smp.h>
  26#include <linux/utsname.h>
  27#include <linux/vmalloc.h>
  28#include <linux/atomic.h>
  29#include <linux/module.h>
  30#include <linux/moduleparam.h>
  31#include <linux/mm.h>
  32#include <linux/init.h>
  33#include <linux/kallsyms.h>
  34#include <linux/kgdb.h>
  35#include <linux/kdb.h>
  36#include <linux/notifier.h>
  37#include <linux/interrupt.h>
  38#include <linux/delay.h>
  39#include <linux/nmi.h>
  40#include <linux/time.h>
  41#include <linux/ptrace.h>
  42#include <linux/sysctl.h>
  43#include <linux/cpu.h>
  44#include <linux/kdebug.h>
  45#include <linux/proc_fs.h>
  46#include <linux/uaccess.h>
  47#include <linux/slab.h>
  48#include "kdb_private.h"
  49
  50#undef	MODULE_PARAM_PREFIX
  51#define	MODULE_PARAM_PREFIX "kdb."
  52
  53static int kdb_cmd_enabled = CONFIG_KDB_DEFAULT_ENABLE;
  54module_param_named(cmd_enable, kdb_cmd_enabled, int, 0600);
  55
  56char kdb_grep_string[KDB_GREP_STRLEN];
  57int kdb_grepping_flag;
  58EXPORT_SYMBOL(kdb_grepping_flag);
  59int kdb_grep_leading;
  60int kdb_grep_trailing;
  61
  62/*
  63 * Kernel debugger state flags
  64 */
  65int kdb_flags;
 
  66
  67/*
  68 * kdb_lock protects updates to kdb_initial_cpu.  Used to
  69 * single thread processors through the kernel debugger.
  70 */
  71int kdb_initial_cpu = -1;	/* cpu number that owns kdb */
  72int kdb_nextline = 1;
  73int kdb_state;			/* General KDB state */
  74
  75struct task_struct *kdb_current_task;
  76EXPORT_SYMBOL(kdb_current_task);
  77struct pt_regs *kdb_current_regs;
  78
  79const char *kdb_diemsg;
  80static int kdb_go_count;
  81#ifdef CONFIG_KDB_CONTINUE_CATASTROPHIC
  82static unsigned int kdb_continue_catastrophic =
  83	CONFIG_KDB_CONTINUE_CATASTROPHIC;
  84#else
  85static unsigned int kdb_continue_catastrophic;
  86#endif
  87
  88/* kdb_commands describes the available commands. */
  89static kdbtab_t *kdb_commands;
  90#define KDB_BASE_CMD_MAX 50
  91static int kdb_max_commands = KDB_BASE_CMD_MAX;
  92static kdbtab_t kdb_base_commands[KDB_BASE_CMD_MAX];
  93#define for_each_kdbcmd(cmd, num)					\
  94	for ((cmd) = kdb_base_commands, (num) = 0;			\
  95	     num < kdb_max_commands;					\
  96	     num++, num == KDB_BASE_CMD_MAX ? cmd = kdb_commands : cmd++)
  97
  98typedef struct _kdbmsg {
  99	int	km_diag;	/* kdb diagnostic */
 100	char	*km_msg;	/* Corresponding message text */
 101} kdbmsg_t;
 102
 103#define KDBMSG(msgnum, text) \
 104	{ KDB_##msgnum, text }
 105
 106static kdbmsg_t kdbmsgs[] = {
 107	KDBMSG(NOTFOUND, "Command Not Found"),
 108	KDBMSG(ARGCOUNT, "Improper argument count, see usage."),
 109	KDBMSG(BADWIDTH, "Illegal value for BYTESPERWORD use 1, 2, 4 or 8, "
 110	       "8 is only allowed on 64 bit systems"),
 111	KDBMSG(BADRADIX, "Illegal value for RADIX use 8, 10 or 16"),
 112	KDBMSG(NOTENV, "Cannot find environment variable"),
 113	KDBMSG(NOENVVALUE, "Environment variable should have value"),
 114	KDBMSG(NOTIMP, "Command not implemented"),
 115	KDBMSG(ENVFULL, "Environment full"),
 116	KDBMSG(ENVBUFFULL, "Environment buffer full"),
 117	KDBMSG(TOOMANYBPT, "Too many breakpoints defined"),
 118#ifdef CONFIG_CPU_XSCALE
 119	KDBMSG(TOOMANYDBREGS, "More breakpoints than ibcr registers defined"),
 120#else
 121	KDBMSG(TOOMANYDBREGS, "More breakpoints than db registers defined"),
 122#endif
 123	KDBMSG(DUPBPT, "Duplicate breakpoint address"),
 124	KDBMSG(BPTNOTFOUND, "Breakpoint not found"),
 125	KDBMSG(BADMODE, "Invalid IDMODE"),
 126	KDBMSG(BADINT, "Illegal numeric value"),
 127	KDBMSG(INVADDRFMT, "Invalid symbolic address format"),
 128	KDBMSG(BADREG, "Invalid register name"),
 129	KDBMSG(BADCPUNUM, "Invalid cpu number"),
 130	KDBMSG(BADLENGTH, "Invalid length field"),
 131	KDBMSG(NOBP, "No Breakpoint exists"),
 132	KDBMSG(BADADDR, "Invalid address"),
 133	KDBMSG(NOPERM, "Permission denied"),
 134};
 135#undef KDBMSG
 136
 137static const int __nkdb_err = ARRAY_SIZE(kdbmsgs);
 138
 139
 140/*
 141 * Initial environment.   This is all kept static and local to
 142 * this file.   We don't want to rely on the memory allocation
 143 * mechanisms in the kernel, so we use a very limited allocate-only
 144 * heap for new and altered environment variables.  The entire
 145 * environment is limited to a fixed number of entries (add more
 146 * to __env[] if required) and a fixed amount of heap (add more to
 147 * KDB_ENVBUFSIZE if required).
 148 */
 149
 150static char *__env[] = {
 151#if defined(CONFIG_SMP)
 152 "PROMPT=[%d]kdb> ",
 
 153#else
 154 "PROMPT=kdb> ",
 
 155#endif
 156 "MOREPROMPT=more> ",
 157 "RADIX=16",
 158 "MDCOUNT=8",			/* lines of md output */
 159 KDB_PLATFORM_ENV,
 160 "DTABCOUNT=30",
 161 "NOSECT=1",
 162 (char *)0,
 163 (char *)0,
 164 (char *)0,
 165 (char *)0,
 166 (char *)0,
 167 (char *)0,
 168 (char *)0,
 169 (char *)0,
 170 (char *)0,
 171 (char *)0,
 172 (char *)0,
 173 (char *)0,
 174 (char *)0,
 175 (char *)0,
 176 (char *)0,
 177 (char *)0,
 178 (char *)0,
 179 (char *)0,
 180 (char *)0,
 181 (char *)0,
 182 (char *)0,
 183 (char *)0,
 184 (char *)0,
 185 (char *)0,
 186};
 187
 188static const int __nenv = ARRAY_SIZE(__env);
 189
 190struct task_struct *kdb_curr_task(int cpu)
 191{
 192	struct task_struct *p = curr_task(cpu);
 193#ifdef	_TIF_MCA_INIT
 194	if ((task_thread_info(p)->flags & _TIF_MCA_INIT) && KDB_TSK(cpu))
 195		p = krp->p;
 196#endif
 197	return p;
 198}
 199
 200/*
 201 * Check whether the flags of the current command and the permissions
 202 * of the kdb console has allow a command to be run.
 203 */
 204static inline bool kdb_check_flags(kdb_cmdflags_t flags, int permissions,
 205				   bool no_args)
 206{
 207	/* permissions comes from userspace so needs massaging slightly */
 208	permissions &= KDB_ENABLE_MASK;
 209	permissions |= KDB_ENABLE_ALWAYS_SAFE;
 210
 211	/* some commands change group when launched with no arguments */
 212	if (no_args)
 213		permissions |= permissions << KDB_ENABLE_NO_ARGS_SHIFT;
 214
 215	flags |= KDB_ENABLE_ALL;
 216
 217	return permissions & flags;
 218}
 219
 220/*
 221 * kdbgetenv - This function will return the character string value of
 222 *	an environment variable.
 223 * Parameters:
 224 *	match	A character string representing an environment variable.
 225 * Returns:
 226 *	NULL	No environment variable matches 'match'
 227 *	char*	Pointer to string value of environment variable.
 228 */
 229char *kdbgetenv(const char *match)
 230{
 231	char **ep = __env;
 232	int matchlen = strlen(match);
 233	int i;
 234
 235	for (i = 0; i < __nenv; i++) {
 236		char *e = *ep++;
 237
 238		if (!e)
 239			continue;
 240
 241		if ((strncmp(match, e, matchlen) == 0)
 242		 && ((e[matchlen] == '\0')
 243		   || (e[matchlen] == '='))) {
 244			char *cp = strchr(e, '=');
 245			return cp ? ++cp : "";
 246		}
 247	}
 248	return NULL;
 249}
 250
 251/*
 252 * kdballocenv - This function is used to allocate bytes for
 253 *	environment entries.
 254 * Parameters:
 255 *	match	A character string representing a numeric value
 256 * Outputs:
 257 *	*value  the unsigned long representation of the env variable 'match'
 258 * Returns:
 259 *	Zero on success, a kdb diagnostic on failure.
 260 * Remarks:
 261 *	We use a static environment buffer (envbuffer) to hold the values
 262 *	of dynamically generated environment variables (see kdb_set).  Buffer
 263 *	space once allocated is never free'd, so over time, the amount of space
 264 *	(currently 512 bytes) will be exhausted if env variables are changed
 265 *	frequently.
 266 */
 267static char *kdballocenv(size_t bytes)
 268{
 269#define	KDB_ENVBUFSIZE	512
 270	static char envbuffer[KDB_ENVBUFSIZE];
 271	static int envbufsize;
 272	char *ep = NULL;
 273
 274	if ((KDB_ENVBUFSIZE - envbufsize) >= bytes) {
 275		ep = &envbuffer[envbufsize];
 276		envbufsize += bytes;
 277	}
 278	return ep;
 279}
 280
 281/*
 282 * kdbgetulenv - This function will return the value of an unsigned
 283 *	long-valued environment variable.
 284 * Parameters:
 285 *	match	A character string representing a numeric value
 286 * Outputs:
 287 *	*value  the unsigned long represntation of the env variable 'match'
 288 * Returns:
 289 *	Zero on success, a kdb diagnostic on failure.
 290 */
 291static int kdbgetulenv(const char *match, unsigned long *value)
 292{
 293	char *ep;
 294
 295	ep = kdbgetenv(match);
 296	if (!ep)
 297		return KDB_NOTENV;
 298	if (strlen(ep) == 0)
 299		return KDB_NOENVVALUE;
 300
 301	*value = simple_strtoul(ep, NULL, 0);
 302
 303	return 0;
 304}
 305
 306/*
 307 * kdbgetintenv - This function will return the value of an
 308 *	integer-valued environment variable.
 309 * Parameters:
 310 *	match	A character string representing an integer-valued env variable
 311 * Outputs:
 312 *	*value  the integer representation of the environment variable 'match'
 313 * Returns:
 314 *	Zero on success, a kdb diagnostic on failure.
 315 */
 316int kdbgetintenv(const char *match, int *value)
 317{
 318	unsigned long val;
 319	int diag;
 320
 321	diag = kdbgetulenv(match, &val);
 322	if (!diag)
 323		*value = (int) val;
 324	return diag;
 325}
 326
 327/*
 328 * kdbgetularg - This function will convert a numeric string into an
 329 *	unsigned long value.
 330 * Parameters:
 331 *	arg	A character string representing a numeric value
 332 * Outputs:
 333 *	*value  the unsigned long represntation of arg.
 334 * Returns:
 335 *	Zero on success, a kdb diagnostic on failure.
 336 */
 337int kdbgetularg(const char *arg, unsigned long *value)
 338{
 339	char *endp;
 340	unsigned long val;
 341
 342	val = simple_strtoul(arg, &endp, 0);
 343
 344	if (endp == arg) {
 345		/*
 346		 * Also try base 16, for us folks too lazy to type the
 347		 * leading 0x...
 348		 */
 349		val = simple_strtoul(arg, &endp, 16);
 350		if (endp == arg)
 351			return KDB_BADINT;
 352	}
 353
 354	*value = val;
 355
 356	return 0;
 357}
 358
 359int kdbgetu64arg(const char *arg, u64 *value)
 360{
 361	char *endp;
 362	u64 val;
 363
 364	val = simple_strtoull(arg, &endp, 0);
 365
 366	if (endp == arg) {
 367
 368		val = simple_strtoull(arg, &endp, 16);
 369		if (endp == arg)
 370			return KDB_BADINT;
 371	}
 372
 373	*value = val;
 374
 375	return 0;
 376}
 377
 378/*
 379 * kdb_set - This function implements the 'set' command.  Alter an
 380 *	existing environment variable or create a new one.
 381 */
 382int kdb_set(int argc, const char **argv)
 383{
 384	int i;
 385	char *ep;
 386	size_t varlen, vallen;
 387
 388	/*
 389	 * we can be invoked two ways:
 390	 *   set var=value    argv[1]="var", argv[2]="value"
 391	 *   set var = value  argv[1]="var", argv[2]="=", argv[3]="value"
 392	 * - if the latter, shift 'em down.
 393	 */
 394	if (argc == 3) {
 395		argv[2] = argv[3];
 396		argc--;
 397	}
 398
 399	if (argc != 2)
 400		return KDB_ARGCOUNT;
 401
 402	/*
 403	 * Check for internal variables
 404	 */
 405	if (strcmp(argv[1], "KDBDEBUG") == 0) {
 406		unsigned int debugflags;
 407		char *cp;
 408
 409		debugflags = simple_strtoul(argv[2], &cp, 0);
 410		if (cp == argv[2] || debugflags & ~KDB_DEBUG_FLAG_MASK) {
 411			kdb_printf("kdb: illegal debug flags '%s'\n",
 412				    argv[2]);
 413			return 0;
 414		}
 415		kdb_flags = (kdb_flags &
 416			     ~(KDB_DEBUG_FLAG_MASK << KDB_DEBUG_FLAG_SHIFT))
 417			| (debugflags << KDB_DEBUG_FLAG_SHIFT);
 418
 419		return 0;
 420	}
 421
 422	/*
 423	 * Tokenizer squashed the '=' sign.  argv[1] is variable
 424	 * name, argv[2] = value.
 425	 */
 426	varlen = strlen(argv[1]);
 427	vallen = strlen(argv[2]);
 428	ep = kdballocenv(varlen + vallen + 2);
 429	if (ep == (char *)0)
 430		return KDB_ENVBUFFULL;
 431
 432	sprintf(ep, "%s=%s", argv[1], argv[2]);
 433
 434	ep[varlen+vallen+1] = '\0';
 435
 436	for (i = 0; i < __nenv; i++) {
 437		if (__env[i]
 438		 && ((strncmp(__env[i], argv[1], varlen) == 0)
 439		   && ((__env[i][varlen] == '\0')
 440		    || (__env[i][varlen] == '=')))) {
 441			__env[i] = ep;
 442			return 0;
 443		}
 444	}
 445
 446	/*
 447	 * Wasn't existing variable.  Fit into slot.
 448	 */
 449	for (i = 0; i < __nenv-1; i++) {
 450		if (__env[i] == (char *)0) {
 451			__env[i] = ep;
 452			return 0;
 453		}
 454	}
 455
 456	return KDB_ENVFULL;
 457}
 458
 459static int kdb_check_regs(void)
 460{
 461	if (!kdb_current_regs) {
 462		kdb_printf("No current kdb registers."
 463			   "  You may need to select another task\n");
 464		return KDB_BADREG;
 465	}
 466	return 0;
 467}
 468
 469/*
 470 * kdbgetaddrarg - This function is responsible for parsing an
 471 *	address-expression and returning the value of the expression,
 472 *	symbol name, and offset to the caller.
 473 *
 474 *	The argument may consist of a numeric value (decimal or
 475 *	hexidecimal), a symbol name, a register name (preceded by the
 476 *	percent sign), an environment variable with a numeric value
 477 *	(preceded by a dollar sign) or a simple arithmetic expression
 478 *	consisting of a symbol name, +/-, and a numeric constant value
 479 *	(offset).
 480 * Parameters:
 481 *	argc	- count of arguments in argv
 482 *	argv	- argument vector
 483 *	*nextarg - index to next unparsed argument in argv[]
 484 *	regs	- Register state at time of KDB entry
 485 * Outputs:
 486 *	*value	- receives the value of the address-expression
 487 *	*offset - receives the offset specified, if any
 488 *	*name   - receives the symbol name, if any
 489 *	*nextarg - index to next unparsed argument in argv[]
 490 * Returns:
 491 *	zero is returned on success, a kdb diagnostic code is
 492 *      returned on error.
 493 */
 494int kdbgetaddrarg(int argc, const char **argv, int *nextarg,
 495		  unsigned long *value,  long *offset,
 496		  char **name)
 497{
 498	unsigned long addr;
 499	unsigned long off = 0;
 500	int positive;
 501	int diag;
 502	int found = 0;
 503	char *symname;
 504	char symbol = '\0';
 505	char *cp;
 506	kdb_symtab_t symtab;
 507
 508	/*
 509	 * If the enable flags prohibit both arbitrary memory access
 510	 * and flow control then there are no reasonable grounds to
 511	 * provide symbol lookup.
 512	 */
 513	if (!kdb_check_flags(KDB_ENABLE_MEM_READ | KDB_ENABLE_FLOW_CTRL,
 514			     kdb_cmd_enabled, false))
 515		return KDB_NOPERM;
 516
 517	/*
 518	 * Process arguments which follow the following syntax:
 519	 *
 520	 *  symbol | numeric-address [+/- numeric-offset]
 521	 *  %register
 522	 *  $environment-variable
 523	 */
 524
 525	if (*nextarg > argc)
 526		return KDB_ARGCOUNT;
 527
 528	symname = (char *)argv[*nextarg];
 529
 530	/*
 531	 * If there is no whitespace between the symbol
 532	 * or address and the '+' or '-' symbols, we
 533	 * remember the character and replace it with a
 534	 * null so the symbol/value can be properly parsed
 535	 */
 536	cp = strpbrk(symname, "+-");
 537	if (cp != NULL) {
 538		symbol = *cp;
 539		*cp++ = '\0';
 540	}
 541
 542	if (symname[0] == '$') {
 543		diag = kdbgetulenv(&symname[1], &addr);
 544		if (diag)
 545			return diag;
 546	} else if (symname[0] == '%') {
 547		diag = kdb_check_regs();
 548		if (diag)
 549			return diag;
 550		/* Implement register values with % at a later time as it is
 551		 * arch optional.
 552		 */
 553		return KDB_NOTIMP;
 554	} else {
 555		found = kdbgetsymval(symname, &symtab);
 556		if (found) {
 557			addr = symtab.sym_start;
 558		} else {
 559			diag = kdbgetularg(argv[*nextarg], &addr);
 560			if (diag)
 561				return diag;
 562		}
 563	}
 564
 565	if (!found)
 566		found = kdbnearsym(addr, &symtab);
 567
 568	(*nextarg)++;
 569
 570	if (name)
 571		*name = symname;
 572	if (value)
 573		*value = addr;
 574	if (offset && name && *name)
 575		*offset = addr - symtab.sym_start;
 576
 577	if ((*nextarg > argc)
 578	 && (symbol == '\0'))
 579		return 0;
 580
 581	/*
 582	 * check for +/- and offset
 583	 */
 584
 585	if (symbol == '\0') {
 586		if ((argv[*nextarg][0] != '+')
 587		 && (argv[*nextarg][0] != '-')) {
 588			/*
 589			 * Not our argument.  Return.
 590			 */
 591			return 0;
 592		} else {
 593			positive = (argv[*nextarg][0] == '+');
 594			(*nextarg)++;
 595		}
 596	} else
 597		positive = (symbol == '+');
 598
 599	/*
 600	 * Now there must be an offset!
 601	 */
 602	if ((*nextarg > argc)
 603	 && (symbol == '\0')) {
 604		return KDB_INVADDRFMT;
 605	}
 606
 607	if (!symbol) {
 608		cp = (char *)argv[*nextarg];
 609		(*nextarg)++;
 610	}
 611
 612	diag = kdbgetularg(cp, &off);
 613	if (diag)
 614		return diag;
 615
 616	if (!positive)
 617		off = -off;
 618
 619	if (offset)
 620		*offset += off;
 621
 622	if (value)
 623		*value += off;
 624
 625	return 0;
 626}
 627
 628static void kdb_cmderror(int diag)
 629{
 630	int i;
 631
 632	if (diag >= 0) {
 633		kdb_printf("no error detected (diagnostic is %d)\n", diag);
 634		return;
 635	}
 636
 637	for (i = 0; i < __nkdb_err; i++) {
 638		if (kdbmsgs[i].km_diag == diag) {
 639			kdb_printf("diag: %d: %s\n", diag, kdbmsgs[i].km_msg);
 640			return;
 641		}
 642	}
 643
 644	kdb_printf("Unknown diag %d\n", -diag);
 645}
 646
 647/*
 648 * kdb_defcmd, kdb_defcmd2 - This function implements the 'defcmd'
 649 *	command which defines one command as a set of other commands,
 650 *	terminated by endefcmd.  kdb_defcmd processes the initial
 651 *	'defcmd' command, kdb_defcmd2 is invoked from kdb_parse for
 652 *	the following commands until 'endefcmd'.
 653 * Inputs:
 654 *	argc	argument count
 655 *	argv	argument vector
 656 * Returns:
 657 *	zero for success, a kdb diagnostic if error
 658 */
 659struct defcmd_set {
 660	int count;
 661	int usable;
 662	char *name;
 663	char *usage;
 664	char *help;
 665	char **command;
 666};
 667static struct defcmd_set *defcmd_set;
 668static int defcmd_set_count;
 669static int defcmd_in_progress;
 670
 671/* Forward references */
 672static int kdb_exec_defcmd(int argc, const char **argv);
 673
 674static int kdb_defcmd2(const char *cmdstr, const char *argv0)
 675{
 676	struct defcmd_set *s = defcmd_set + defcmd_set_count - 1;
 677	char **save_command = s->command;
 678	if (strcmp(argv0, "endefcmd") == 0) {
 679		defcmd_in_progress = 0;
 680		if (!s->count)
 681			s->usable = 0;
 682		if (s->usable)
 683			/* macros are always safe because when executed each
 684			 * internal command re-enters kdb_parse() and is
 685			 * safety checked individually.
 686			 */
 687			kdb_register_flags(s->name, kdb_exec_defcmd, s->usage,
 688					   s->help, 0,
 689					   KDB_ENABLE_ALWAYS_SAFE);
 690		return 0;
 691	}
 692	if (!s->usable)
 693		return KDB_NOTIMP;
 694	s->command = kzalloc((s->count + 1) * sizeof(*(s->command)), GFP_KDB);
 695	if (!s->command) {
 696		kdb_printf("Could not allocate new kdb_defcmd table for %s\n",
 697			   cmdstr);
 698		s->usable = 0;
 699		return KDB_NOTIMP;
 700	}
 701	memcpy(s->command, save_command, s->count * sizeof(*(s->command)));
 702	s->command[s->count++] = kdb_strdup(cmdstr, GFP_KDB);
 703	kfree(save_command);
 704	return 0;
 705}
 706
 707static int kdb_defcmd(int argc, const char **argv)
 708{
 709	struct defcmd_set *save_defcmd_set = defcmd_set, *s;
 710	if (defcmd_in_progress) {
 711		kdb_printf("kdb: nested defcmd detected, assuming missing "
 712			   "endefcmd\n");
 713		kdb_defcmd2("endefcmd", "endefcmd");
 714	}
 715	if (argc == 0) {
 716		int i;
 717		for (s = defcmd_set; s < defcmd_set + defcmd_set_count; ++s) {
 718			kdb_printf("defcmd %s \"%s\" \"%s\"\n", s->name,
 719				   s->usage, s->help);
 720			for (i = 0; i < s->count; ++i)
 721				kdb_printf("%s", s->command[i]);
 722			kdb_printf("endefcmd\n");
 723		}
 724		return 0;
 725	}
 726	if (argc != 3)
 727		return KDB_ARGCOUNT;
 728	if (in_dbg_master()) {
 729		kdb_printf("Command only available during kdb_init()\n");
 
 
 
 
 730		return KDB_NOTIMP;
 731	}
 732	defcmd_set = kmalloc((defcmd_set_count + 1) * sizeof(*defcmd_set),
 733			     GFP_KDB);
 734	if (!defcmd_set)
 735		goto fail_defcmd;
 736	memcpy(defcmd_set, save_defcmd_set,
 737	       defcmd_set_count * sizeof(*defcmd_set));
 
 738	s = defcmd_set + defcmd_set_count;
 739	memset(s, 0, sizeof(*s));
 740	s->usable = 1;
 741	s->name = kdb_strdup(argv[1], GFP_KDB);
 742	if (!s->name)
 743		goto fail_name;
 744	s->usage = kdb_strdup(argv[2], GFP_KDB);
 745	if (!s->usage)
 746		goto fail_usage;
 747	s->help = kdb_strdup(argv[3], GFP_KDB);
 748	if (!s->help)
 749		goto fail_help;
 750	if (s->usage[0] == '"') {
 751		strcpy(s->usage, argv[2]+1);
 752		s->usage[strlen(s->usage)-1] = '\0';
 753	}
 754	if (s->help[0] == '"') {
 755		strcpy(s->help, argv[3]+1);
 756		s->help[strlen(s->help)-1] = '\0';
 757	}
 758	++defcmd_set_count;
 759	defcmd_in_progress = 1;
 760	kfree(save_defcmd_set);
 761	return 0;
 762fail_help:
 763	kfree(s->usage);
 764fail_usage:
 765	kfree(s->name);
 766fail_name:
 767	kfree(defcmd_set);
 768fail_defcmd:
 769	kdb_printf("Could not allocate new defcmd_set entry for %s\n", argv[1]);
 770	defcmd_set = save_defcmd_set;
 771	return KDB_NOTIMP;
 772}
 773
 774/*
 775 * kdb_exec_defcmd - Execute the set of commands associated with this
 776 *	defcmd name.
 777 * Inputs:
 778 *	argc	argument count
 779 *	argv	argument vector
 780 * Returns:
 781 *	zero for success, a kdb diagnostic if error
 782 */
 783static int kdb_exec_defcmd(int argc, const char **argv)
 784{
 785	int i, ret;
 786	struct defcmd_set *s;
 787	if (argc != 0)
 788		return KDB_ARGCOUNT;
 789	for (s = defcmd_set, i = 0; i < defcmd_set_count; ++i, ++s) {
 790		if (strcmp(s->name, argv[0]) == 0)
 791			break;
 792	}
 793	if (i == defcmd_set_count) {
 794		kdb_printf("kdb_exec_defcmd: could not find commands for %s\n",
 795			   argv[0]);
 796		return KDB_NOTIMP;
 797	}
 798	for (i = 0; i < s->count; ++i) {
 799		/* Recursive use of kdb_parse, do not use argv after
 800		 * this point */
 801		argv = NULL;
 802		kdb_printf("[%s]kdb> %s\n", s->name, s->command[i]);
 803		ret = kdb_parse(s->command[i]);
 804		if (ret)
 805			return ret;
 806	}
 807	return 0;
 808}
 809
 810/* Command history */
 811#define KDB_CMD_HISTORY_COUNT	32
 812#define CMD_BUFLEN		200	/* kdb_printf: max printline
 813					 * size == 256 */
 814static unsigned int cmd_head, cmd_tail;
 815static unsigned int cmdptr;
 816static char cmd_hist[KDB_CMD_HISTORY_COUNT][CMD_BUFLEN];
 817static char cmd_cur[CMD_BUFLEN];
 818
 819/*
 820 * The "str" argument may point to something like  | grep xyz
 821 */
 822static void parse_grep(const char *str)
 823{
 824	int	len;
 825	char	*cp = (char *)str, *cp2;
 826
 827	/* sanity check: we should have been called with the \ first */
 828	if (*cp != '|')
 829		return;
 830	cp++;
 831	while (isspace(*cp))
 832		cp++;
 833	if (strncmp(cp, "grep ", 5)) {
 834		kdb_printf("invalid 'pipe', see grephelp\n");
 835		return;
 836	}
 837	cp += 5;
 838	while (isspace(*cp))
 839		cp++;
 840	cp2 = strchr(cp, '\n');
 841	if (cp2)
 842		*cp2 = '\0'; /* remove the trailing newline */
 843	len = strlen(cp);
 844	if (len == 0) {
 845		kdb_printf("invalid 'pipe', see grephelp\n");
 846		return;
 847	}
 848	/* now cp points to a nonzero length search string */
 849	if (*cp == '"') {
 850		/* allow it be "x y z" by removing the "'s - there must
 851		   be two of them */
 852		cp++;
 853		cp2 = strchr(cp, '"');
 854		if (!cp2) {
 855			kdb_printf("invalid quoted string, see grephelp\n");
 856			return;
 857		}
 858		*cp2 = '\0'; /* end the string where the 2nd " was */
 859	}
 860	kdb_grep_leading = 0;
 861	if (*cp == '^') {
 862		kdb_grep_leading = 1;
 863		cp++;
 864	}
 865	len = strlen(cp);
 866	kdb_grep_trailing = 0;
 867	if (*(cp+len-1) == '$') {
 868		kdb_grep_trailing = 1;
 869		*(cp+len-1) = '\0';
 870	}
 871	len = strlen(cp);
 872	if (!len)
 873		return;
 874	if (len >= KDB_GREP_STRLEN) {
 875		kdb_printf("search string too long\n");
 876		return;
 877	}
 878	strcpy(kdb_grep_string, cp);
 879	kdb_grepping_flag++;
 880	return;
 881}
 882
 883/*
 884 * kdb_parse - Parse the command line, search the command table for a
 885 *	matching command and invoke the command function.  This
 886 *	function may be called recursively, if it is, the second call
 887 *	will overwrite argv and cbuf.  It is the caller's
 888 *	responsibility to save their argv if they recursively call
 889 *	kdb_parse().
 890 * Parameters:
 891 *      cmdstr	The input command line to be parsed.
 892 *	regs	The registers at the time kdb was entered.
 893 * Returns:
 894 *	Zero for success, a kdb diagnostic if failure.
 895 * Remarks:
 896 *	Limited to 20 tokens.
 897 *
 898 *	Real rudimentary tokenization. Basically only whitespace
 899 *	is considered a token delimeter (but special consideration
 900 *	is taken of the '=' sign as used by the 'set' command).
 901 *
 902 *	The algorithm used to tokenize the input string relies on
 903 *	there being at least one whitespace (or otherwise useless)
 904 *	character between tokens as the character immediately following
 905 *	the token is altered in-place to a null-byte to terminate the
 906 *	token string.
 907 */
 908
 909#define MAXARGC	20
 910
 911int kdb_parse(const char *cmdstr)
 912{
 913	static char *argv[MAXARGC];
 914	static int argc;
 915	static char cbuf[CMD_BUFLEN+2];
 916	char *cp;
 917	char *cpp, quoted;
 918	kdbtab_t *tp;
 919	int i, escaped, ignore_errors = 0, check_grep = 0;
 920
 921	/*
 922	 * First tokenize the command string.
 923	 */
 924	cp = (char *)cmdstr;
 
 925
 926	if (KDB_FLAG(CMD_INTERRUPT)) {
 927		/* Previous command was interrupted, newline must not
 928		 * repeat the command */
 929		KDB_FLAG_CLEAR(CMD_INTERRUPT);
 930		KDB_STATE_SET(PAGER);
 931		argc = 0;	/* no repeat */
 932	}
 933
 934	if (*cp != '\n' && *cp != '\0') {
 935		argc = 0;
 936		cpp = cbuf;
 937		while (*cp) {
 938			/* skip whitespace */
 939			while (isspace(*cp))
 940				cp++;
 941			if ((*cp == '\0') || (*cp == '\n') ||
 942			    (*cp == '#' && !defcmd_in_progress))
 943				break;
 944			/* special case: check for | grep pattern */
 945			if (*cp == '|') {
 946				check_grep++;
 947				break;
 948			}
 949			if (cpp >= cbuf + CMD_BUFLEN) {
 950				kdb_printf("kdb_parse: command buffer "
 951					   "overflow, command ignored\n%s\n",
 952					   cmdstr);
 953				return KDB_NOTFOUND;
 954			}
 955			if (argc >= MAXARGC - 1) {
 956				kdb_printf("kdb_parse: too many arguments, "
 957					   "command ignored\n%s\n", cmdstr);
 958				return KDB_NOTFOUND;
 959			}
 960			argv[argc++] = cpp;
 961			escaped = 0;
 962			quoted = '\0';
 963			/* Copy to next unquoted and unescaped
 964			 * whitespace or '=' */
 965			while (*cp && *cp != '\n' &&
 966			       (escaped || quoted || !isspace(*cp))) {
 967				if (cpp >= cbuf + CMD_BUFLEN)
 968					break;
 969				if (escaped) {
 970					escaped = 0;
 971					*cpp++ = *cp++;
 972					continue;
 973				}
 974				if (*cp == '\\') {
 975					escaped = 1;
 976					++cp;
 977					continue;
 978				}
 979				if (*cp == quoted)
 980					quoted = '\0';
 981				else if (*cp == '\'' || *cp == '"')
 982					quoted = *cp;
 983				*cpp = *cp++;
 984				if (*cpp == '=' && !quoted)
 985					break;
 986				++cpp;
 987			}
 988			*cpp++ = '\0';	/* Squash a ws or '=' character */
 989		}
 990	}
 991	if (!argc)
 992		return 0;
 993	if (check_grep)
 994		parse_grep(cp);
 995	if (defcmd_in_progress) {
 996		int result = kdb_defcmd2(cmdstr, argv[0]);
 997		if (!defcmd_in_progress) {
 998			argc = 0;	/* avoid repeat on endefcmd */
 999			*(argv[0]) = '\0';
1000		}
1001		return result;
1002	}
1003	if (argv[0][0] == '-' && argv[0][1] &&
1004	    (argv[0][1] < '0' || argv[0][1] > '9')) {
1005		ignore_errors = 1;
1006		++argv[0];
1007	}
1008
1009	for_each_kdbcmd(tp, i) {
1010		if (tp->cmd_name) {
1011			/*
1012			 * If this command is allowed to be abbreviated,
1013			 * check to see if this is it.
1014			 */
1015
1016			if (tp->cmd_minlen
1017			 && (strlen(argv[0]) <= tp->cmd_minlen)) {
1018				if (strncmp(argv[0],
1019					    tp->cmd_name,
1020					    tp->cmd_minlen) == 0) {
1021					break;
1022				}
1023			}
1024
1025			if (strcmp(argv[0], tp->cmd_name) == 0)
1026				break;
1027		}
1028	}
1029
1030	/*
1031	 * If we don't find a command by this name, see if the first
1032	 * few characters of this match any of the known commands.
1033	 * e.g., md1c20 should match md.
1034	 */
1035	if (i == kdb_max_commands) {
1036		for_each_kdbcmd(tp, i) {
1037			if (tp->cmd_name) {
1038				if (strncmp(argv[0],
1039					    tp->cmd_name,
1040					    strlen(tp->cmd_name)) == 0) {
1041					break;
1042				}
1043			}
1044		}
1045	}
1046
1047	if (i < kdb_max_commands) {
1048		int result;
1049
1050		if (!kdb_check_flags(tp->cmd_flags, kdb_cmd_enabled, argc <= 1))
1051			return KDB_NOPERM;
1052
1053		KDB_STATE_SET(CMD);
1054		result = (*tp->cmd_func)(argc-1, (const char **)argv);
1055		if (result && ignore_errors && result > KDB_CMD_GO)
1056			result = 0;
1057		KDB_STATE_CLEAR(CMD);
1058
1059		if (tp->cmd_flags & KDB_REPEAT_WITH_ARGS)
1060			return result;
1061
1062		argc = tp->cmd_flags & KDB_REPEAT_NO_ARGS ? 1 : 0;
1063		if (argv[argc])
1064			*(argv[argc]) = '\0';
 
 
 
 
 
 
 
1065		return result;
1066	}
1067
1068	/*
1069	 * If the input with which we were presented does not
1070	 * map to an existing command, attempt to parse it as an
1071	 * address argument and display the result.   Useful for
1072	 * obtaining the address of a variable, or the nearest symbol
1073	 * to an address contained in a register.
1074	 */
1075	{
1076		unsigned long value;
1077		char *name = NULL;
1078		long offset;
1079		int nextarg = 0;
1080
1081		if (kdbgetaddrarg(0, (const char **)argv, &nextarg,
1082				  &value, &offset, &name)) {
1083			return KDB_NOTFOUND;
1084		}
1085
1086		kdb_printf("%s = ", argv[0]);
1087		kdb_symbol_print(value, NULL, KDB_SP_DEFAULT);
1088		kdb_printf("\n");
1089		return 0;
1090	}
1091}
1092
1093
1094static int handle_ctrl_cmd(char *cmd)
1095{
1096#define CTRL_P	16
1097#define CTRL_N	14
1098
1099	/* initial situation */
1100	if (cmd_head == cmd_tail)
1101		return 0;
1102	switch (*cmd) {
1103	case CTRL_P:
1104		if (cmdptr != cmd_tail)
1105			cmdptr = (cmdptr-1) % KDB_CMD_HISTORY_COUNT;
1106		strncpy(cmd_cur, cmd_hist[cmdptr], CMD_BUFLEN);
1107		return 1;
1108	case CTRL_N:
1109		if (cmdptr != cmd_head)
1110			cmdptr = (cmdptr+1) % KDB_CMD_HISTORY_COUNT;
1111		strncpy(cmd_cur, cmd_hist[cmdptr], CMD_BUFLEN);
1112		return 1;
1113	}
1114	return 0;
1115}
1116
1117/*
1118 * kdb_reboot - This function implements the 'reboot' command.  Reboot
1119 *	the system immediately, or loop for ever on failure.
1120 */
1121static int kdb_reboot(int argc, const char **argv)
1122{
1123	emergency_restart();
1124	kdb_printf("Hmm, kdb_reboot did not reboot, spinning here\n");
1125	while (1)
1126		cpu_relax();
1127	/* NOTREACHED */
1128	return 0;
1129}
1130
1131static void kdb_dumpregs(struct pt_regs *regs)
1132{
1133	int old_lvl = console_loglevel;
1134	console_loglevel = CONSOLE_LOGLEVEL_MOTORMOUTH;
1135	kdb_trap_printk++;
1136	show_regs(regs);
1137	kdb_trap_printk--;
1138	kdb_printf("\n");
1139	console_loglevel = old_lvl;
1140}
1141
1142void kdb_set_current_task(struct task_struct *p)
1143{
1144	kdb_current_task = p;
1145
1146	if (kdb_task_has_cpu(p)) {
1147		kdb_current_regs = KDB_TSKREGS(kdb_process_cpu(p));
1148		return;
1149	}
1150	kdb_current_regs = NULL;
1151}
1152
1153static void drop_newline(char *buf)
1154{
1155	size_t len = strlen(buf);
1156
1157	if (len == 0)
1158		return;
1159	if (*(buf + len - 1) == '\n')
1160		*(buf + len - 1) = '\0';
1161}
1162
1163/*
1164 * kdb_local - The main code for kdb.  This routine is invoked on a
1165 *	specific processor, it is not global.  The main kdb() routine
1166 *	ensures that only one processor at a time is in this routine.
1167 *	This code is called with the real reason code on the first
1168 *	entry to a kdb session, thereafter it is called with reason
1169 *	SWITCH, even if the user goes back to the original cpu.
1170 * Inputs:
1171 *	reason		The reason KDB was invoked
1172 *	error		The hardware-defined error code
1173 *	regs		The exception frame at time of fault/breakpoint.
1174 *	db_result	Result code from the break or debug point.
1175 * Returns:
1176 *	0	KDB was invoked for an event which it wasn't responsible
1177 *	1	KDB handled the event for which it was invoked.
1178 *	KDB_CMD_GO	User typed 'go'.
1179 *	KDB_CMD_CPU	User switched to another cpu.
1180 *	KDB_CMD_SS	Single step.
 
1181 */
1182static int kdb_local(kdb_reason_t reason, int error, struct pt_regs *regs,
1183		     kdb_dbtrap_t db_result)
1184{
1185	char *cmdbuf;
1186	int diag;
1187	struct task_struct *kdb_current =
1188		kdb_curr_task(raw_smp_processor_id());
1189
1190	KDB_DEBUG_STATE("kdb_local 1", reason);
1191	kdb_go_count = 0;
1192	if (reason == KDB_REASON_DEBUG) {
1193		/* special case below */
1194	} else {
1195		kdb_printf("\nEntering kdb (current=0x%p, pid %d) ",
1196			   kdb_current, kdb_current ? kdb_current->pid : 0);
1197#if defined(CONFIG_SMP)
1198		kdb_printf("on processor %d ", raw_smp_processor_id());
1199#endif
1200	}
1201
1202	switch (reason) {
1203	case KDB_REASON_DEBUG:
1204	{
1205		/*
1206		 * If re-entering kdb after a single step
1207		 * command, don't print the message.
1208		 */
1209		switch (db_result) {
1210		case KDB_DB_BPT:
1211			kdb_printf("\nEntering kdb (0x%p, pid %d) ",
1212				   kdb_current, kdb_current->pid);
1213#if defined(CONFIG_SMP)
1214			kdb_printf("on processor %d ", raw_smp_processor_id());
1215#endif
1216			kdb_printf("due to Debug @ " kdb_machreg_fmt "\n",
1217				   instruction_pointer(regs));
1218			break;
 
 
 
 
 
 
 
 
1219		case KDB_DB_SS:
1220			break;
1221		case KDB_DB_SSBPT:
1222			KDB_DEBUG_STATE("kdb_local 4", reason);
1223			return 1;	/* kdba_db_trap did the work */
1224		default:
1225			kdb_printf("kdb: Bad result from kdba_db_trap: %d\n",
1226				   db_result);
1227			break;
1228		}
1229
1230	}
1231		break;
1232	case KDB_REASON_ENTER:
1233		if (KDB_STATE(KEYBOARD))
1234			kdb_printf("due to Keyboard Entry\n");
1235		else
1236			kdb_printf("due to KDB_ENTER()\n");
1237		break;
1238	case KDB_REASON_KEYBOARD:
1239		KDB_STATE_SET(KEYBOARD);
1240		kdb_printf("due to Keyboard Entry\n");
1241		break;
1242	case KDB_REASON_ENTER_SLAVE:
1243		/* drop through, slaves only get released via cpu switch */
1244	case KDB_REASON_SWITCH:
1245		kdb_printf("due to cpu switch\n");
1246		break;
1247	case KDB_REASON_OOPS:
1248		kdb_printf("Oops: %s\n", kdb_diemsg);
1249		kdb_printf("due to oops @ " kdb_machreg_fmt "\n",
1250			   instruction_pointer(regs));
1251		kdb_dumpregs(regs);
1252		break;
1253	case KDB_REASON_SYSTEM_NMI:
1254		kdb_printf("due to System NonMaskable Interrupt\n");
1255		break;
1256	case KDB_REASON_NMI:
1257		kdb_printf("due to NonMaskable Interrupt @ "
1258			   kdb_machreg_fmt "\n",
1259			   instruction_pointer(regs));
 
1260		break;
1261	case KDB_REASON_SSTEP:
1262	case KDB_REASON_BREAK:
1263		kdb_printf("due to %s @ " kdb_machreg_fmt "\n",
1264			   reason == KDB_REASON_BREAK ?
1265			   "Breakpoint" : "SS trap", instruction_pointer(regs));
1266		/*
1267		 * Determine if this breakpoint is one that we
1268		 * are interested in.
1269		 */
1270		if (db_result != KDB_DB_BPT) {
1271			kdb_printf("kdb: error return from kdba_bp_trap: %d\n",
1272				   db_result);
1273			KDB_DEBUG_STATE("kdb_local 6", reason);
1274			return 0;	/* Not for us, dismiss it */
1275		}
1276		break;
1277	case KDB_REASON_RECURSE:
1278		kdb_printf("due to Recursion @ " kdb_machreg_fmt "\n",
1279			   instruction_pointer(regs));
1280		break;
1281	default:
1282		kdb_printf("kdb: unexpected reason code: %d\n", reason);
1283		KDB_DEBUG_STATE("kdb_local 8", reason);
1284		return 0;	/* Not for us, dismiss it */
1285	}
1286
1287	while (1) {
1288		/*
1289		 * Initialize pager context.
1290		 */
1291		kdb_nextline = 1;
1292		KDB_STATE_CLEAR(SUPPRESS);
1293		kdb_grepping_flag = 0;
1294		/* ensure the old search does not leak into '/' commands */
1295		kdb_grep_string[0] = '\0';
1296
1297		cmdbuf = cmd_cur;
1298		*cmdbuf = '\0';
1299		*(cmd_hist[cmd_head]) = '\0';
1300
 
 
 
 
 
 
 
 
 
 
 
 
1301do_full_getstr:
1302#if defined(CONFIG_SMP)
1303		snprintf(kdb_prompt_str, CMD_BUFLEN, kdbgetenv("PROMPT"),
1304			 raw_smp_processor_id());
1305#else
1306		snprintf(kdb_prompt_str, CMD_BUFLEN, kdbgetenv("PROMPT"));
1307#endif
1308		if (defcmd_in_progress)
1309			strncat(kdb_prompt_str, "[defcmd]", CMD_BUFLEN);
1310
1311		/*
1312		 * Fetch command from keyboard
1313		 */
1314		cmdbuf = kdb_getstr(cmdbuf, CMD_BUFLEN, kdb_prompt_str);
1315		if (*cmdbuf != '\n') {
1316			if (*cmdbuf < 32) {
1317				if (cmdptr == cmd_head) {
1318					strncpy(cmd_hist[cmd_head], cmd_cur,
1319						CMD_BUFLEN);
1320					*(cmd_hist[cmd_head] +
1321					  strlen(cmd_hist[cmd_head])-1) = '\0';
1322				}
1323				if (!handle_ctrl_cmd(cmdbuf))
1324					*(cmd_cur+strlen(cmd_cur)-1) = '\0';
1325				cmdbuf = cmd_cur;
1326				goto do_full_getstr;
1327			} else {
1328				strncpy(cmd_hist[cmd_head], cmd_cur,
1329					CMD_BUFLEN);
1330			}
1331
1332			cmd_head = (cmd_head+1) % KDB_CMD_HISTORY_COUNT;
1333			if (cmd_head == cmd_tail)
1334				cmd_tail = (cmd_tail+1) % KDB_CMD_HISTORY_COUNT;
1335		}
1336
1337		cmdptr = cmd_head;
1338		diag = kdb_parse(cmdbuf);
1339		if (diag == KDB_NOTFOUND) {
1340			drop_newline(cmdbuf);
1341			kdb_printf("Unknown kdb command: '%s'\n", cmdbuf);
1342			diag = 0;
1343		}
1344		if (diag == KDB_CMD_GO
1345		 || diag == KDB_CMD_CPU
1346		 || diag == KDB_CMD_SS
 
1347		 || diag == KDB_CMD_KGDB)
1348			break;
1349
1350		if (diag)
1351			kdb_cmderror(diag);
1352	}
1353	KDB_DEBUG_STATE("kdb_local 9", diag);
1354	return diag;
1355}
1356
1357
1358/*
1359 * kdb_print_state - Print the state data for the current processor
1360 *	for debugging.
1361 * Inputs:
1362 *	text		Identifies the debug point
1363 *	value		Any integer value to be printed, e.g. reason code.
1364 */
1365void kdb_print_state(const char *text, int value)
1366{
1367	kdb_printf("state: %s cpu %d value %d initial %d state %x\n",
1368		   text, raw_smp_processor_id(), value, kdb_initial_cpu,
1369		   kdb_state);
1370}
1371
1372/*
1373 * kdb_main_loop - After initial setup and assignment of the
1374 *	controlling cpu, all cpus are in this loop.  One cpu is in
1375 *	control and will issue the kdb prompt, the others will spin
1376 *	until 'go' or cpu switch.
1377 *
1378 *	To get a consistent view of the kernel stacks for all
1379 *	processes, this routine is invoked from the main kdb code via
1380 *	an architecture specific routine.  kdba_main_loop is
1381 *	responsible for making the kernel stacks consistent for all
1382 *	processes, there should be no difference between a blocked
1383 *	process and a running process as far as kdb is concerned.
1384 * Inputs:
1385 *	reason		The reason KDB was invoked
1386 *	error		The hardware-defined error code
1387 *	reason2		kdb's current reason code.
1388 *			Initially error but can change
1389 *			according to kdb state.
1390 *	db_result	Result code from break or debug point.
1391 *	regs		The exception frame at time of fault/breakpoint.
1392 *			should always be valid.
1393 * Returns:
1394 *	0	KDB was invoked for an event which it wasn't responsible
1395 *	1	KDB handled the event for which it was invoked.
1396 */
1397int kdb_main_loop(kdb_reason_t reason, kdb_reason_t reason2, int error,
1398	      kdb_dbtrap_t db_result, struct pt_regs *regs)
1399{
1400	int result = 1;
1401	/* Stay in kdb() until 'go', 'ss[b]' or an error */
1402	while (1) {
1403		/*
1404		 * All processors except the one that is in control
1405		 * will spin here.
1406		 */
1407		KDB_DEBUG_STATE("kdb_main_loop 1", reason);
1408		while (KDB_STATE(HOLD_CPU)) {
1409			/* state KDB is turned off by kdb_cpu to see if the
1410			 * other cpus are still live, each cpu in this loop
1411			 * turns it back on.
1412			 */
1413			if (!KDB_STATE(KDB))
1414				KDB_STATE_SET(KDB);
1415		}
1416
1417		KDB_STATE_CLEAR(SUPPRESS);
1418		KDB_DEBUG_STATE("kdb_main_loop 2", reason);
1419		if (KDB_STATE(LEAVING))
1420			break;	/* Another cpu said 'go' */
1421		/* Still using kdb, this processor is in control */
1422		result = kdb_local(reason2, error, regs, db_result);
1423		KDB_DEBUG_STATE("kdb_main_loop 3", result);
1424
1425		if (result == KDB_CMD_CPU)
1426			break;
1427
1428		if (result == KDB_CMD_SS) {
1429			KDB_STATE_SET(DOING_SS);
1430			break;
1431		}
1432
 
 
 
 
 
 
1433		if (result == KDB_CMD_KGDB) {
1434			if (!KDB_STATE(DOING_KGDB))
1435				kdb_printf("Entering please attach debugger "
1436					   "or use $D#44+ or $3#33\n");
1437			break;
1438		}
1439		if (result && result != 1 && result != KDB_CMD_GO)
1440			kdb_printf("\nUnexpected kdb_local return code %d\n",
1441				   result);
1442		KDB_DEBUG_STATE("kdb_main_loop 4", reason);
1443		break;
1444	}
1445	if (KDB_STATE(DOING_SS))
1446		KDB_STATE_CLEAR(SSBPT);
1447
1448	/* Clean up any keyboard devices before leaving */
1449	kdb_kbd_cleanup_state();
1450
1451	return result;
1452}
1453
1454/*
1455 * kdb_mdr - This function implements the guts of the 'mdr', memory
1456 * read command.
1457 *	mdr  <addr arg>,<byte count>
1458 * Inputs:
1459 *	addr	Start address
1460 *	count	Number of bytes
1461 * Returns:
1462 *	Always 0.  Any errors are detected and printed by kdb_getarea.
1463 */
1464static int kdb_mdr(unsigned long addr, unsigned int count)
1465{
1466	unsigned char c;
1467	while (count--) {
1468		if (kdb_getarea(c, addr))
1469			return 0;
1470		kdb_printf("%02x", c);
1471		addr++;
1472	}
1473	kdb_printf("\n");
1474	return 0;
1475}
1476
1477/*
1478 * kdb_md - This function implements the 'md', 'md1', 'md2', 'md4',
1479 *	'md8' 'mdr' and 'mds' commands.
1480 *
1481 *	md|mds  [<addr arg> [<line count> [<radix>]]]
1482 *	mdWcN	[<addr arg> [<line count> [<radix>]]]
1483 *		where W = is the width (1, 2, 4 or 8) and N is the count.
1484 *		for eg., md1c20 reads 20 bytes, 1 at a time.
1485 *	mdr  <addr arg>,<byte count>
1486 */
1487static void kdb_md_line(const char *fmtstr, unsigned long addr,
1488			int symbolic, int nosect, int bytesperword,
1489			int num, int repeat, int phys)
1490{
1491	/* print just one line of data */
1492	kdb_symtab_t symtab;
1493	char cbuf[32];
1494	char *c = cbuf;
1495	int i;
1496	unsigned long word;
1497
1498	memset(cbuf, '\0', sizeof(cbuf));
1499	if (phys)
1500		kdb_printf("phys " kdb_machreg_fmt0 " ", addr);
1501	else
1502		kdb_printf(kdb_machreg_fmt0 " ", addr);
1503
1504	for (i = 0; i < num && repeat--; i++) {
1505		if (phys) {
1506			if (kdb_getphysword(&word, addr, bytesperword))
1507				break;
1508		} else if (kdb_getword(&word, addr, bytesperword))
1509			break;
1510		kdb_printf(fmtstr, word);
1511		if (symbolic)
1512			kdbnearsym(word, &symtab);
1513		else
1514			memset(&symtab, 0, sizeof(symtab));
1515		if (symtab.sym_name) {
1516			kdb_symbol_print(word, &symtab, 0);
1517			if (!nosect) {
1518				kdb_printf("\n");
1519				kdb_printf("                       %s %s "
1520					   kdb_machreg_fmt " "
1521					   kdb_machreg_fmt " "
1522					   kdb_machreg_fmt, symtab.mod_name,
1523					   symtab.sec_name, symtab.sec_start,
1524					   symtab.sym_start, symtab.sym_end);
1525			}
1526			addr += bytesperword;
1527		} else {
1528			union {
1529				u64 word;
1530				unsigned char c[8];
1531			} wc;
1532			unsigned char *cp;
1533#ifdef	__BIG_ENDIAN
1534			cp = wc.c + 8 - bytesperword;
1535#else
1536			cp = wc.c;
1537#endif
1538			wc.word = word;
1539#define printable_char(c) \
1540	({unsigned char __c = c; isascii(__c) && isprint(__c) ? __c : '.'; })
1541			switch (bytesperword) {
1542			case 8:
1543				*c++ = printable_char(*cp++);
1544				*c++ = printable_char(*cp++);
1545				*c++ = printable_char(*cp++);
1546				*c++ = printable_char(*cp++);
1547				addr += 4;
1548			case 4:
1549				*c++ = printable_char(*cp++);
1550				*c++ = printable_char(*cp++);
1551				addr += 2;
1552			case 2:
1553				*c++ = printable_char(*cp++);
1554				addr++;
1555			case 1:
1556				*c++ = printable_char(*cp++);
1557				addr++;
1558				break;
1559			}
1560#undef printable_char
1561		}
1562	}
1563	kdb_printf("%*s %s\n", (int)((num-i)*(2*bytesperword + 1)+1),
1564		   " ", cbuf);
1565}
1566
1567static int kdb_md(int argc, const char **argv)
1568{
1569	static unsigned long last_addr;
1570	static int last_radix, last_bytesperword, last_repeat;
1571	int radix = 16, mdcount = 8, bytesperword = KDB_WORD_SIZE, repeat;
1572	int nosect = 0;
1573	char fmtchar, fmtstr[64];
1574	unsigned long addr;
1575	unsigned long word;
1576	long offset = 0;
1577	int symbolic = 0;
1578	int valid = 0;
1579	int phys = 0;
1580	int raw = 0;
1581
1582	kdbgetintenv("MDCOUNT", &mdcount);
1583	kdbgetintenv("RADIX", &radix);
1584	kdbgetintenv("BYTESPERWORD", &bytesperword);
1585
1586	/* Assume 'md <addr>' and start with environment values */
1587	repeat = mdcount * 16 / bytesperword;
1588
1589	if (strcmp(argv[0], "mdr") == 0) {
1590		if (argc == 2 || (argc == 0 && last_addr != 0))
1591			valid = raw = 1;
1592		else
1593			return KDB_ARGCOUNT;
 
1594	} else if (isdigit(argv[0][2])) {
1595		bytesperword = (int)(argv[0][2] - '0');
1596		if (bytesperword == 0) {
1597			bytesperword = last_bytesperword;
1598			if (bytesperword == 0)
1599				bytesperword = 4;
1600		}
1601		last_bytesperword = bytesperword;
1602		repeat = mdcount * 16 / bytesperword;
1603		if (!argv[0][3])
1604			valid = 1;
1605		else if (argv[0][3] == 'c' && argv[0][4]) {
1606			char *p;
1607			repeat = simple_strtoul(argv[0] + 4, &p, 10);
1608			mdcount = ((repeat * bytesperword) + 15) / 16;
1609			valid = !*p;
1610		}
1611		last_repeat = repeat;
1612	} else if (strcmp(argv[0], "md") == 0)
1613		valid = 1;
1614	else if (strcmp(argv[0], "mds") == 0)
1615		valid = 1;
1616	else if (strcmp(argv[0], "mdp") == 0) {
1617		phys = valid = 1;
1618	}
1619	if (!valid)
1620		return KDB_NOTFOUND;
1621
1622	if (argc == 0) {
1623		if (last_addr == 0)
1624			return KDB_ARGCOUNT;
1625		addr = last_addr;
1626		radix = last_radix;
1627		bytesperword = last_bytesperword;
1628		repeat = last_repeat;
1629		if (raw)
1630			mdcount = repeat;
1631		else
1632			mdcount = ((repeat * bytesperword) + 15) / 16;
1633	}
1634
1635	if (argc) {
1636		unsigned long val;
1637		int diag, nextarg = 1;
1638		diag = kdbgetaddrarg(argc, argv, &nextarg, &addr,
1639				     &offset, NULL);
1640		if (diag)
1641			return diag;
1642		if (argc > nextarg+2)
1643			return KDB_ARGCOUNT;
1644
1645		if (argc >= nextarg) {
1646			diag = kdbgetularg(argv[nextarg], &val);
1647			if (!diag) {
1648				mdcount = (int) val;
1649				if (raw)
1650					repeat = mdcount;
1651				else
1652					repeat = mdcount * 16 / bytesperword;
1653			}
1654		}
1655		if (argc >= nextarg+1) {
1656			diag = kdbgetularg(argv[nextarg+1], &val);
1657			if (!diag)
1658				radix = (int) val;
1659		}
1660	}
1661
1662	if (strcmp(argv[0], "mdr") == 0) {
1663		int ret;
1664		last_addr = addr;
1665		ret = kdb_mdr(addr, mdcount);
1666		last_addr += mdcount;
1667		last_repeat = mdcount;
1668		last_bytesperword = bytesperword; // to make REPEAT happy
1669		return ret;
1670	}
1671
1672	switch (radix) {
1673	case 10:
1674		fmtchar = 'd';
1675		break;
1676	case 16:
1677		fmtchar = 'x';
1678		break;
1679	case 8:
1680		fmtchar = 'o';
1681		break;
1682	default:
1683		return KDB_BADRADIX;
1684	}
1685
1686	last_radix = radix;
1687
1688	if (bytesperword > KDB_WORD_SIZE)
1689		return KDB_BADWIDTH;
1690
1691	switch (bytesperword) {
1692	case 8:
1693		sprintf(fmtstr, "%%16.16l%c ", fmtchar);
1694		break;
1695	case 4:
1696		sprintf(fmtstr, "%%8.8l%c ", fmtchar);
1697		break;
1698	case 2:
1699		sprintf(fmtstr, "%%4.4l%c ", fmtchar);
1700		break;
1701	case 1:
1702		sprintf(fmtstr, "%%2.2l%c ", fmtchar);
1703		break;
1704	default:
1705		return KDB_BADWIDTH;
1706	}
1707
1708	last_repeat = repeat;
1709	last_bytesperword = bytesperword;
1710
1711	if (strcmp(argv[0], "mds") == 0) {
1712		symbolic = 1;
1713		/* Do not save these changes as last_*, they are temporary mds
1714		 * overrides.
1715		 */
1716		bytesperword = KDB_WORD_SIZE;
1717		repeat = mdcount;
1718		kdbgetintenv("NOSECT", &nosect);
1719	}
1720
1721	/* Round address down modulo BYTESPERWORD */
1722
1723	addr &= ~(bytesperword-1);
1724
1725	while (repeat > 0) {
1726		unsigned long a;
1727		int n, z, num = (symbolic ? 1 : (16 / bytesperword));
1728
1729		if (KDB_FLAG(CMD_INTERRUPT))
1730			return 0;
1731		for (a = addr, z = 0; z < repeat; a += bytesperword, ++z) {
1732			if (phys) {
1733				if (kdb_getphysword(&word, a, bytesperword)
1734						|| word)
1735					break;
1736			} else if (kdb_getword(&word, a, bytesperword) || word)
1737				break;
1738		}
1739		n = min(num, repeat);
1740		kdb_md_line(fmtstr, addr, symbolic, nosect, bytesperword,
1741			    num, repeat, phys);
1742		addr += bytesperword * n;
1743		repeat -= n;
1744		z = (z + num - 1) / num;
1745		if (z > 2) {
1746			int s = num * (z-2);
1747			kdb_printf(kdb_machreg_fmt0 "-" kdb_machreg_fmt0
1748				   " zero suppressed\n",
1749				addr, addr + bytesperword * s - 1);
1750			addr += bytesperword * s;
1751			repeat -= s;
1752		}
1753	}
1754	last_addr = addr;
1755
1756	return 0;
1757}
1758
1759/*
1760 * kdb_mm - This function implements the 'mm' command.
1761 *	mm address-expression new-value
1762 * Remarks:
1763 *	mm works on machine words, mmW works on bytes.
1764 */
1765static int kdb_mm(int argc, const char **argv)
1766{
1767	int diag;
1768	unsigned long addr;
1769	long offset = 0;
1770	unsigned long contents;
1771	int nextarg;
1772	int width;
1773
1774	if (argv[0][2] && !isdigit(argv[0][2]))
1775		return KDB_NOTFOUND;
1776
1777	if (argc < 2)
1778		return KDB_ARGCOUNT;
1779
1780	nextarg = 1;
1781	diag = kdbgetaddrarg(argc, argv, &nextarg, &addr, &offset, NULL);
1782	if (diag)
1783		return diag;
1784
1785	if (nextarg > argc)
1786		return KDB_ARGCOUNT;
1787	diag = kdbgetaddrarg(argc, argv, &nextarg, &contents, NULL, NULL);
1788	if (diag)
1789		return diag;
1790
1791	if (nextarg != argc + 1)
1792		return KDB_ARGCOUNT;
1793
1794	width = argv[0][2] ? (argv[0][2] - '0') : (KDB_WORD_SIZE);
1795	diag = kdb_putword(addr, contents, width);
1796	if (diag)
1797		return diag;
1798
1799	kdb_printf(kdb_machreg_fmt " = " kdb_machreg_fmt "\n", addr, contents);
1800
1801	return 0;
1802}
1803
1804/*
1805 * kdb_go - This function implements the 'go' command.
1806 *	go [address-expression]
1807 */
1808static int kdb_go(int argc, const char **argv)
1809{
1810	unsigned long addr;
1811	int diag;
1812	int nextarg;
1813	long offset;
1814
1815	if (raw_smp_processor_id() != kdb_initial_cpu) {
1816		kdb_printf("go must execute on the entry cpu, "
1817			   "please use \"cpu %d\" and then execute go\n",
1818			   kdb_initial_cpu);
1819		return KDB_BADCPUNUM;
1820	}
1821	if (argc == 1) {
1822		nextarg = 1;
1823		diag = kdbgetaddrarg(argc, argv, &nextarg,
1824				     &addr, &offset, NULL);
1825		if (diag)
1826			return diag;
1827	} else if (argc) {
1828		return KDB_ARGCOUNT;
1829	}
1830
1831	diag = KDB_CMD_GO;
1832	if (KDB_FLAG(CATASTROPHIC)) {
1833		kdb_printf("Catastrophic error detected\n");
1834		kdb_printf("kdb_continue_catastrophic=%d, ",
1835			kdb_continue_catastrophic);
1836		if (kdb_continue_catastrophic == 0 && kdb_go_count++ == 0) {
1837			kdb_printf("type go a second time if you really want "
1838				   "to continue\n");
1839			return 0;
1840		}
1841		if (kdb_continue_catastrophic == 2) {
1842			kdb_printf("forcing reboot\n");
1843			kdb_reboot(0, NULL);
1844		}
1845		kdb_printf("attempting to continue\n");
1846	}
1847	return diag;
1848}
1849
1850/*
1851 * kdb_rd - This function implements the 'rd' command.
1852 */
1853static int kdb_rd(int argc, const char **argv)
1854{
1855	int len = kdb_check_regs();
1856#if DBG_MAX_REG_NUM > 0
1857	int i;
1858	char *rname;
1859	int rsize;
1860	u64 reg64;
1861	u32 reg32;
1862	u16 reg16;
1863	u8 reg8;
1864
1865	if (len)
1866		return len;
1867
1868	for (i = 0; i < DBG_MAX_REG_NUM; i++) {
1869		rsize = dbg_reg_def[i].size * 2;
1870		if (rsize > 16)
1871			rsize = 2;
1872		if (len + strlen(dbg_reg_def[i].name) + 4 + rsize > 80) {
1873			len = 0;
1874			kdb_printf("\n");
1875		}
1876		if (len)
1877			len += kdb_printf("  ");
1878		switch(dbg_reg_def[i].size * 8) {
1879		case 8:
1880			rname = dbg_get_reg(i, &reg8, kdb_current_regs);
1881			if (!rname)
1882				break;
1883			len += kdb_printf("%s: %02x", rname, reg8);
1884			break;
1885		case 16:
1886			rname = dbg_get_reg(i, &reg16, kdb_current_regs);
1887			if (!rname)
1888				break;
1889			len += kdb_printf("%s: %04x", rname, reg16);
1890			break;
1891		case 32:
1892			rname = dbg_get_reg(i, &reg32, kdb_current_regs);
1893			if (!rname)
1894				break;
1895			len += kdb_printf("%s: %08x", rname, reg32);
1896			break;
1897		case 64:
1898			rname = dbg_get_reg(i, &reg64, kdb_current_regs);
1899			if (!rname)
1900				break;
1901			len += kdb_printf("%s: %016llx", rname, reg64);
1902			break;
1903		default:
1904			len += kdb_printf("%s: ??", dbg_reg_def[i].name);
1905		}
1906	}
1907	kdb_printf("\n");
1908#else
1909	if (len)
1910		return len;
1911
1912	kdb_dumpregs(kdb_current_regs);
1913#endif
1914	return 0;
1915}
1916
1917/*
1918 * kdb_rm - This function implements the 'rm' (register modify)  command.
1919 *	rm register-name new-contents
1920 * Remarks:
1921 *	Allows register modification with the same restrictions as gdb
1922 */
1923static int kdb_rm(int argc, const char **argv)
1924{
1925#if DBG_MAX_REG_NUM > 0
1926	int diag;
1927	const char *rname;
1928	int i;
1929	u64 reg64;
1930	u32 reg32;
1931	u16 reg16;
1932	u8 reg8;
1933
1934	if (argc != 2)
1935		return KDB_ARGCOUNT;
1936	/*
1937	 * Allow presence or absence of leading '%' symbol.
1938	 */
1939	rname = argv[1];
1940	if (*rname == '%')
1941		rname++;
1942
1943	diag = kdbgetu64arg(argv[2], &reg64);
1944	if (diag)
1945		return diag;
1946
1947	diag = kdb_check_regs();
1948	if (diag)
1949		return diag;
1950
1951	diag = KDB_BADREG;
1952	for (i = 0; i < DBG_MAX_REG_NUM; i++) {
1953		if (strcmp(rname, dbg_reg_def[i].name) == 0) {
1954			diag = 0;
1955			break;
1956		}
1957	}
1958	if (!diag) {
1959		switch(dbg_reg_def[i].size * 8) {
1960		case 8:
1961			reg8 = reg64;
1962			dbg_set_reg(i, &reg8, kdb_current_regs);
1963			break;
1964		case 16:
1965			reg16 = reg64;
1966			dbg_set_reg(i, &reg16, kdb_current_regs);
1967			break;
1968		case 32:
1969			reg32 = reg64;
1970			dbg_set_reg(i, &reg32, kdb_current_regs);
1971			break;
1972		case 64:
1973			dbg_set_reg(i, &reg64, kdb_current_regs);
1974			break;
1975		}
1976	}
1977	return diag;
1978#else
1979	kdb_printf("ERROR: Register set currently not implemented\n");
1980    return 0;
1981#endif
1982}
1983
1984#if defined(CONFIG_MAGIC_SYSRQ)
1985/*
1986 * kdb_sr - This function implements the 'sr' (SYSRQ key) command
1987 *	which interfaces to the soi-disant MAGIC SYSRQ functionality.
1988 *		sr <magic-sysrq-code>
1989 */
1990static int kdb_sr(int argc, const char **argv)
1991{
1992	bool check_mask =
1993	    !kdb_check_flags(KDB_ENABLE_ALL, kdb_cmd_enabled, false);
1994
1995	if (argc != 1)
1996		return KDB_ARGCOUNT;
1997
1998	kdb_trap_printk++;
1999	__handle_sysrq(*argv[1], check_mask);
2000	kdb_trap_printk--;
2001
2002	return 0;
2003}
2004#endif	/* CONFIG_MAGIC_SYSRQ */
2005
2006/*
2007 * kdb_ef - This function implements the 'regs' (display exception
2008 *	frame) command.  This command takes an address and expects to
2009 *	find an exception frame at that address, formats and prints
2010 *	it.
2011 *		regs address-expression
2012 * Remarks:
2013 *	Not done yet.
2014 */
2015static int kdb_ef(int argc, const char **argv)
2016{
2017	int diag;
2018	unsigned long addr;
2019	long offset;
2020	int nextarg;
2021
2022	if (argc != 1)
2023		return KDB_ARGCOUNT;
2024
2025	nextarg = 1;
2026	diag = kdbgetaddrarg(argc, argv, &nextarg, &addr, &offset, NULL);
2027	if (diag)
2028		return diag;
2029	show_regs((struct pt_regs *)addr);
2030	return 0;
2031}
2032
2033#if defined(CONFIG_MODULES)
2034/*
2035 * kdb_lsmod - This function implements the 'lsmod' command.  Lists
2036 *	currently loaded kernel modules.
2037 *	Mostly taken from userland lsmod.
2038 */
2039static int kdb_lsmod(int argc, const char **argv)
2040{
2041	struct module *mod;
2042
2043	if (argc != 0)
2044		return KDB_ARGCOUNT;
2045
2046	kdb_printf("Module                  Size  modstruct     Used by\n");
2047	list_for_each_entry(mod, kdb_modules, list) {
2048		if (mod->state == MODULE_STATE_UNFORMED)
2049			continue;
2050
2051		kdb_printf("%-20s%8u  0x%p ", mod->name,
2052			   mod->core_layout.size, (void *)mod);
2053#ifdef CONFIG_MODULE_UNLOAD
2054		kdb_printf("%4d ", module_refcount(mod));
2055#endif
2056		if (mod->state == MODULE_STATE_GOING)
2057			kdb_printf(" (Unloading)");
2058		else if (mod->state == MODULE_STATE_COMING)
2059			kdb_printf(" (Loading)");
2060		else
2061			kdb_printf(" (Live)");
2062		kdb_printf(" 0x%p", mod->core_layout.base);
2063
2064#ifdef CONFIG_MODULE_UNLOAD
2065		{
2066			struct module_use *use;
2067			kdb_printf(" [ ");
2068			list_for_each_entry(use, &mod->source_list,
2069					    source_list)
2070				kdb_printf("%s ", use->target->name);
2071			kdb_printf("]\n");
2072		}
2073#endif
2074	}
2075
2076	return 0;
2077}
2078
2079#endif	/* CONFIG_MODULES */
2080
2081/*
2082 * kdb_env - This function implements the 'env' command.  Display the
2083 *	current environment variables.
2084 */
2085
2086static int kdb_env(int argc, const char **argv)
2087{
2088	int i;
2089
2090	for (i = 0; i < __nenv; i++) {
2091		if (__env[i])
2092			kdb_printf("%s\n", __env[i]);
2093	}
2094
2095	if (KDB_DEBUG(MASK))
2096		kdb_printf("KDBFLAGS=0x%x\n", kdb_flags);
2097
2098	return 0;
2099}
2100
2101#ifdef CONFIG_PRINTK
2102/*
2103 * kdb_dmesg - This function implements the 'dmesg' command to display
2104 *	the contents of the syslog buffer.
2105 *		dmesg [lines] [adjust]
2106 */
2107static int kdb_dmesg(int argc, const char **argv)
2108{
2109	int diag;
2110	int logging;
2111	int lines = 0;
2112	int adjust = 0;
2113	int n = 0;
2114	int skip = 0;
2115	struct kmsg_dumper dumper = { .active = 1 };
2116	size_t len;
2117	char buf[201];
2118
2119	if (argc > 2)
2120		return KDB_ARGCOUNT;
2121	if (argc) {
2122		char *cp;
2123		lines = simple_strtol(argv[1], &cp, 0);
2124		if (*cp)
2125			lines = 0;
2126		if (argc > 1) {
2127			adjust = simple_strtoul(argv[2], &cp, 0);
2128			if (*cp || adjust < 0)
2129				adjust = 0;
2130		}
2131	}
2132
2133	/* disable LOGGING if set */
2134	diag = kdbgetintenv("LOGGING", &logging);
2135	if (!diag && logging) {
2136		const char *setargs[] = { "set", "LOGGING", "0" };
2137		kdb_set(2, setargs);
2138	}
2139
2140	kmsg_dump_rewind_nolock(&dumper);
2141	while (kmsg_dump_get_line_nolock(&dumper, 1, NULL, 0, NULL))
2142		n++;
2143
 
 
 
 
 
 
 
 
 
 
 
 
2144	if (lines < 0) {
2145		if (adjust >= n)
2146			kdb_printf("buffer only contains %d lines, nothing "
2147				   "printed\n", n);
2148		else if (adjust - lines >= n)
2149			kdb_printf("buffer only contains %d lines, last %d "
2150				   "lines printed\n", n, n - adjust);
2151		skip = adjust;
2152		lines = abs(lines);
 
 
 
 
 
 
 
 
 
 
 
2153	} else if (lines > 0) {
2154		skip = n - lines - adjust;
2155		lines = abs(lines);
2156		if (adjust >= n) {
2157			kdb_printf("buffer only contains %d lines, "
2158				   "nothing printed\n", n);
2159			skip = n;
2160		} else if (skip < 0) {
2161			lines += skip;
2162			skip = 0;
2163			kdb_printf("buffer only contains %d lines, first "
2164				   "%d lines printed\n", n, lines);
2165		}
2166	} else {
2167		lines = n;
2168	}
2169
2170	if (skip >= n || skip < 0)
2171		return 0;
2172
2173	kmsg_dump_rewind_nolock(&dumper);
2174	while (kmsg_dump_get_line_nolock(&dumper, 1, buf, sizeof(buf), &len)) {
2175		if (skip) {
2176			skip--;
2177			continue;
2178		}
2179		if (!lines--)
2180			break;
2181		if (KDB_FLAG(CMD_INTERRUPT))
2182			return 0;
2183
2184		kdb_printf("%.*s\n", (int)len - 1, buf);
 
 
 
 
 
 
 
2185	}
 
 
2186
2187	return 0;
2188}
2189#endif /* CONFIG_PRINTK */
2190
2191/* Make sure we balance enable/disable calls, must disable first. */
2192static atomic_t kdb_nmi_disabled;
2193
2194static int kdb_disable_nmi(int argc, const char *argv[])
2195{
2196	if (atomic_read(&kdb_nmi_disabled))
2197		return 0;
2198	atomic_set(&kdb_nmi_disabled, 1);
2199	arch_kgdb_ops.enable_nmi(0);
2200	return 0;
2201}
2202
2203static int kdb_param_enable_nmi(const char *val, const struct kernel_param *kp)
2204{
2205	if (!atomic_add_unless(&kdb_nmi_disabled, -1, 0))
2206		return -EINVAL;
2207	arch_kgdb_ops.enable_nmi(1);
2208	return 0;
2209}
2210
2211static const struct kernel_param_ops kdb_param_ops_enable_nmi = {
2212	.set = kdb_param_enable_nmi,
2213};
2214module_param_cb(enable_nmi, &kdb_param_ops_enable_nmi, NULL, 0600);
2215
2216/*
2217 * kdb_cpu - This function implements the 'cpu' command.
2218 *	cpu	[<cpunum>]
2219 * Returns:
2220 *	KDB_CMD_CPU for success, a kdb diagnostic if error
2221 */
2222static void kdb_cpu_status(void)
2223{
2224	int i, start_cpu, first_print = 1;
2225	char state, prev_state = '?';
2226
2227	kdb_printf("Currently on cpu %d\n", raw_smp_processor_id());
2228	kdb_printf("Available cpus: ");
2229	for (start_cpu = -1, i = 0; i < NR_CPUS; i++) {
2230		if (!cpu_online(i)) {
2231			state = 'F';	/* cpu is offline */
2232		} else if (!kgdb_info[i].enter_kgdb) {
2233			state = 'D';	/* cpu is online but unresponsive */
2234		} else {
2235			state = ' ';	/* cpu is responding to kdb */
2236			if (kdb_task_state_char(KDB_TSK(i)) == 'I')
2237				state = 'I';	/* idle task */
2238		}
2239		if (state != prev_state) {
2240			if (prev_state != '?') {
2241				if (!first_print)
2242					kdb_printf(", ");
2243				first_print = 0;
2244				kdb_printf("%d", start_cpu);
2245				if (start_cpu < i-1)
2246					kdb_printf("-%d", i-1);
2247				if (prev_state != ' ')
2248					kdb_printf("(%c)", prev_state);
2249			}
2250			prev_state = state;
2251			start_cpu = i;
2252		}
2253	}
2254	/* print the trailing cpus, ignoring them if they are all offline */
2255	if (prev_state != 'F') {
2256		if (!first_print)
2257			kdb_printf(", ");
2258		kdb_printf("%d", start_cpu);
2259		if (start_cpu < i-1)
2260			kdb_printf("-%d", i-1);
2261		if (prev_state != ' ')
2262			kdb_printf("(%c)", prev_state);
2263	}
2264	kdb_printf("\n");
2265}
2266
2267static int kdb_cpu(int argc, const char **argv)
2268{
2269	unsigned long cpunum;
2270	int diag;
2271
2272	if (argc == 0) {
2273		kdb_cpu_status();
2274		return 0;
2275	}
2276
2277	if (argc != 1)
2278		return KDB_ARGCOUNT;
2279
2280	diag = kdbgetularg(argv[1], &cpunum);
2281	if (diag)
2282		return diag;
2283
2284	/*
2285	 * Validate cpunum
2286	 */
2287	if ((cpunum >= CONFIG_NR_CPUS) || !kgdb_info[cpunum].enter_kgdb)
2288		return KDB_BADCPUNUM;
2289
2290	dbg_switch_cpu = cpunum;
2291
2292	/*
2293	 * Switch to other cpu
2294	 */
2295	return KDB_CMD_CPU;
2296}
2297
2298/* The user may not realize that ps/bta with no parameters does not print idle
2299 * or sleeping system daemon processes, so tell them how many were suppressed.
2300 */
2301void kdb_ps_suppressed(void)
2302{
2303	int idle = 0, daemon = 0;
2304	unsigned long mask_I = kdb_task_state_string("I"),
2305		      mask_M = kdb_task_state_string("M");
2306	unsigned long cpu;
2307	const struct task_struct *p, *g;
2308	for_each_online_cpu(cpu) {
2309		p = kdb_curr_task(cpu);
2310		if (kdb_task_state(p, mask_I))
2311			++idle;
2312	}
2313	kdb_do_each_thread(g, p) {
2314		if (kdb_task_state(p, mask_M))
2315			++daemon;
2316	} kdb_while_each_thread(g, p);
2317	if (idle || daemon) {
2318		if (idle)
2319			kdb_printf("%d idle process%s (state I)%s\n",
2320				   idle, idle == 1 ? "" : "es",
2321				   daemon ? " and " : "");
2322		if (daemon)
2323			kdb_printf("%d sleeping system daemon (state M) "
2324				   "process%s", daemon,
2325				   daemon == 1 ? "" : "es");
2326		kdb_printf(" suppressed,\nuse 'ps A' to see all.\n");
2327	}
2328}
2329
2330/*
2331 * kdb_ps - This function implements the 'ps' command which shows a
2332 *	list of the active processes.
2333 *		ps [DRSTCZEUIMA]   All processes, optionally filtered by state
2334 */
2335void kdb_ps1(const struct task_struct *p)
2336{
2337	int cpu;
2338	unsigned long tmp;
2339
2340	if (!p || probe_kernel_read(&tmp, (char *)p, sizeof(unsigned long)))
2341		return;
2342
2343	cpu = kdb_process_cpu(p);
2344	kdb_printf("0x%p %8d %8d  %d %4d   %c  0x%p %c%s\n",
2345		   (void *)p, p->pid, p->parent->pid,
2346		   kdb_task_has_cpu(p), kdb_process_cpu(p),
2347		   kdb_task_state_char(p),
2348		   (void *)(&p->thread),
2349		   p == kdb_curr_task(raw_smp_processor_id()) ? '*' : ' ',
2350		   p->comm);
2351	if (kdb_task_has_cpu(p)) {
2352		if (!KDB_TSK(cpu)) {
2353			kdb_printf("  Error: no saved data for this cpu\n");
2354		} else {
2355			if (KDB_TSK(cpu) != p)
2356				kdb_printf("  Error: does not match running "
2357				   "process table (0x%p)\n", KDB_TSK(cpu));
2358		}
2359	}
2360}
2361
2362static int kdb_ps(int argc, const char **argv)
2363{
2364	struct task_struct *g, *p;
2365	unsigned long mask, cpu;
2366
2367	if (argc == 0)
2368		kdb_ps_suppressed();
2369	kdb_printf("%-*s      Pid   Parent [*] cpu State %-*s Command\n",
2370		(int)(2*sizeof(void *))+2, "Task Addr",
2371		(int)(2*sizeof(void *))+2, "Thread");
2372	mask = kdb_task_state_string(argc ? argv[1] : NULL);
2373	/* Run the active tasks first */
2374	for_each_online_cpu(cpu) {
2375		if (KDB_FLAG(CMD_INTERRUPT))
2376			return 0;
2377		p = kdb_curr_task(cpu);
2378		if (kdb_task_state(p, mask))
2379			kdb_ps1(p);
2380	}
2381	kdb_printf("\n");
2382	/* Now the real tasks */
2383	kdb_do_each_thread(g, p) {
2384		if (KDB_FLAG(CMD_INTERRUPT))
2385			return 0;
2386		if (kdb_task_state(p, mask))
2387			kdb_ps1(p);
2388	} kdb_while_each_thread(g, p);
2389
2390	return 0;
2391}
2392
2393/*
2394 * kdb_pid - This function implements the 'pid' command which switches
2395 *	the currently active process.
2396 *		pid [<pid> | R]
2397 */
2398static int kdb_pid(int argc, const char **argv)
2399{
2400	struct task_struct *p;
2401	unsigned long val;
2402	int diag;
2403
2404	if (argc > 1)
2405		return KDB_ARGCOUNT;
2406
2407	if (argc) {
2408		if (strcmp(argv[1], "R") == 0) {
2409			p = KDB_TSK(kdb_initial_cpu);
2410		} else {
2411			diag = kdbgetularg(argv[1], &val);
2412			if (diag)
2413				return KDB_BADINT;
2414
2415			p = find_task_by_pid_ns((pid_t)val,	&init_pid_ns);
2416			if (!p) {
2417				kdb_printf("No task with pid=%d\n", (pid_t)val);
2418				return 0;
2419			}
2420		}
2421		kdb_set_current_task(p);
2422	}
2423	kdb_printf("KDB current process is %s(pid=%d)\n",
2424		   kdb_current_task->comm,
2425		   kdb_current_task->pid);
2426
2427	return 0;
2428}
2429
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
2430static int kdb_kgdb(int argc, const char **argv)
2431{
2432	return KDB_CMD_KGDB;
2433}
2434
2435/*
2436 * kdb_help - This function implements the 'help' and '?' commands.
2437 */
2438static int kdb_help(int argc, const char **argv)
2439{
2440	kdbtab_t *kt;
2441	int i;
2442
2443	kdb_printf("%-15.15s %-20.20s %s\n", "Command", "Usage", "Description");
2444	kdb_printf("-----------------------------"
2445		   "-----------------------------\n");
2446	for_each_kdbcmd(kt, i) {
2447		char *space = "";
 
 
2448		if (KDB_FLAG(CMD_INTERRUPT))
2449			return 0;
2450		if (!kt->cmd_name)
2451			continue;
2452		if (!kdb_check_flags(kt->cmd_flags, kdb_cmd_enabled, true))
2453			continue;
2454		if (strlen(kt->cmd_usage) > 20)
2455			space = "\n                                    ";
2456		kdb_printf("%-15.15s %-20s%s%s\n", kt->cmd_name,
2457			   kt->cmd_usage, space, kt->cmd_help);
2458	}
2459	return 0;
2460}
2461
2462/*
2463 * kdb_kill - This function implements the 'kill' commands.
2464 */
2465static int kdb_kill(int argc, const char **argv)
2466{
2467	long sig, pid;
2468	char *endp;
2469	struct task_struct *p;
 
2470
2471	if (argc != 2)
2472		return KDB_ARGCOUNT;
2473
2474	sig = simple_strtol(argv[1], &endp, 0);
2475	if (*endp)
2476		return KDB_BADINT;
2477	if ((sig >= 0) || !valid_signal(-sig)) {
2478		kdb_printf("Invalid signal parameter.<-signal>\n");
2479		return 0;
2480	}
2481	sig = -sig;
2482
2483	pid = simple_strtol(argv[2], &endp, 0);
2484	if (*endp)
2485		return KDB_BADINT;
2486	if (pid <= 0) {
2487		kdb_printf("Process ID must be large than 0.\n");
2488		return 0;
2489	}
2490
2491	/* Find the process. */
2492	p = find_task_by_pid_ns(pid, &init_pid_ns);
2493	if (!p) {
2494		kdb_printf("The specified process isn't found.\n");
2495		return 0;
2496	}
2497	p = p->group_leader;
2498	kdb_send_sig(p, sig);
 
 
 
 
 
2499	return 0;
2500}
2501
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
2502/*
2503 * Most of this code has been lifted from kernel/timer.c::sys_sysinfo().
2504 * I cannot call that code directly from kdb, it has an unconditional
2505 * cli()/sti() and calls routines that take locks which can stop the debugger.
2506 */
2507static void kdb_sysinfo(struct sysinfo *val)
2508{
2509	u64 uptime = ktime_get_mono_fast_ns();
2510
2511	memset(val, 0, sizeof(*val));
2512	val->uptime = div_u64(uptime, NSEC_PER_SEC);
2513	val->loads[0] = avenrun[0];
2514	val->loads[1] = avenrun[1];
2515	val->loads[2] = avenrun[2];
2516	val->procs = nr_threads-1;
2517	si_meminfo(val);
2518
2519	return;
2520}
2521
2522/*
2523 * kdb_summary - This function implements the 'summary' command.
2524 */
2525static int kdb_summary(int argc, const char **argv)
2526{
2527	time64_t now;
2528	struct tm tm;
2529	struct sysinfo val;
2530
2531	if (argc)
2532		return KDB_ARGCOUNT;
2533
2534	kdb_printf("sysname    %s\n", init_uts_ns.name.sysname);
2535	kdb_printf("release    %s\n", init_uts_ns.name.release);
2536	kdb_printf("version    %s\n", init_uts_ns.name.version);
2537	kdb_printf("machine    %s\n", init_uts_ns.name.machine);
2538	kdb_printf("nodename   %s\n", init_uts_ns.name.nodename);
2539	kdb_printf("domainname %s\n", init_uts_ns.name.domainname);
2540	kdb_printf("ccversion  %s\n", __stringify(CCVERSION));
2541
2542	now = __ktime_get_real_seconds();
2543	time64_to_tm(now, 0, &tm);
2544	kdb_printf("date       %04ld-%02d-%02d %02d:%02d:%02d "
2545		   "tz_minuteswest %d\n",
2546		1900+tm.tm_year, tm.tm_mon+1, tm.tm_mday,
2547		tm.tm_hour, tm.tm_min, tm.tm_sec,
2548		sys_tz.tz_minuteswest);
2549
2550	kdb_sysinfo(&val);
2551	kdb_printf("uptime     ");
2552	if (val.uptime > (24*60*60)) {
2553		int days = val.uptime / (24*60*60);
2554		val.uptime %= (24*60*60);
2555		kdb_printf("%d day%s ", days, days == 1 ? "" : "s");
2556	}
2557	kdb_printf("%02ld:%02ld\n", val.uptime/(60*60), (val.uptime/60)%60);
2558
2559	/* lifted from fs/proc/proc_misc.c::loadavg_read_proc() */
2560
2561#define LOAD_INT(x) ((x) >> FSHIFT)
2562#define LOAD_FRAC(x) LOAD_INT(((x) & (FIXED_1-1)) * 100)
2563	kdb_printf("load avg   %ld.%02ld %ld.%02ld %ld.%02ld\n",
2564		LOAD_INT(val.loads[0]), LOAD_FRAC(val.loads[0]),
2565		LOAD_INT(val.loads[1]), LOAD_FRAC(val.loads[1]),
2566		LOAD_INT(val.loads[2]), LOAD_FRAC(val.loads[2]));
2567#undef LOAD_INT
2568#undef LOAD_FRAC
2569	/* Display in kilobytes */
2570#define K(x) ((x) << (PAGE_SHIFT - 10))
2571	kdb_printf("\nMemTotal:       %8lu kB\nMemFree:        %8lu kB\n"
2572		   "Buffers:        %8lu kB\n",
2573		   K(val.totalram), K(val.freeram), K(val.bufferram));
2574	return 0;
2575}
2576
2577/*
2578 * kdb_per_cpu - This function implements the 'per_cpu' command.
2579 */
2580static int kdb_per_cpu(int argc, const char **argv)
2581{
2582	char fmtstr[64];
2583	int cpu, diag, nextarg = 1;
2584	unsigned long addr, symaddr, val, bytesperword = 0, whichcpu = ~0UL;
2585
2586	if (argc < 1 || argc > 3)
2587		return KDB_ARGCOUNT;
2588
2589	diag = kdbgetaddrarg(argc, argv, &nextarg, &symaddr, NULL, NULL);
2590	if (diag)
2591		return diag;
2592
2593	if (argc >= 2) {
2594		diag = kdbgetularg(argv[2], &bytesperword);
2595		if (diag)
2596			return diag;
2597	}
2598	if (!bytesperword)
2599		bytesperword = KDB_WORD_SIZE;
2600	else if (bytesperword > KDB_WORD_SIZE)
2601		return KDB_BADWIDTH;
2602	sprintf(fmtstr, "%%0%dlx ", (int)(2*bytesperword));
2603	if (argc >= 3) {
2604		diag = kdbgetularg(argv[3], &whichcpu);
2605		if (diag)
2606			return diag;
2607		if (!cpu_online(whichcpu)) {
2608			kdb_printf("cpu %ld is not online\n", whichcpu);
2609			return KDB_BADCPUNUM;
2610		}
2611	}
2612
2613	/* Most architectures use __per_cpu_offset[cpu], some use
2614	 * __per_cpu_offset(cpu), smp has no __per_cpu_offset.
2615	 */
2616#ifdef	__per_cpu_offset
2617#define KDB_PCU(cpu) __per_cpu_offset(cpu)
2618#else
2619#ifdef	CONFIG_SMP
2620#define KDB_PCU(cpu) __per_cpu_offset[cpu]
2621#else
2622#define KDB_PCU(cpu) 0
2623#endif
2624#endif
2625	for_each_online_cpu(cpu) {
2626		if (KDB_FLAG(CMD_INTERRUPT))
2627			return 0;
2628
2629		if (whichcpu != ~0UL && whichcpu != cpu)
2630			continue;
2631		addr = symaddr + KDB_PCU(cpu);
2632		diag = kdb_getword(&val, addr, bytesperword);
2633		if (diag) {
2634			kdb_printf("%5d " kdb_bfd_vma_fmt0 " - unable to "
2635				   "read, diag=%d\n", cpu, addr, diag);
2636			continue;
2637		}
2638		kdb_printf("%5d ", cpu);
2639		kdb_md_line(fmtstr, addr,
2640			bytesperword == KDB_WORD_SIZE,
2641			1, bytesperword, 1, 1, 0);
2642	}
2643#undef KDB_PCU
2644	return 0;
2645}
2646
2647/*
2648 * display help for the use of cmd | grep pattern
2649 */
2650static int kdb_grep_help(int argc, const char **argv)
2651{
2652	kdb_printf("Usage of  cmd args | grep pattern:\n");
2653	kdb_printf("  Any command's output may be filtered through an ");
2654	kdb_printf("emulated 'pipe'.\n");
2655	kdb_printf("  'grep' is just a key word.\n");
2656	kdb_printf("  The pattern may include a very limited set of "
2657		   "metacharacters:\n");
2658	kdb_printf("   pattern or ^pattern or pattern$ or ^pattern$\n");
2659	kdb_printf("  And if there are spaces in the pattern, you may "
2660		   "quote it:\n");
2661	kdb_printf("   \"pat tern\" or \"^pat tern\" or \"pat tern$\""
2662		   " or \"^pat tern$\"\n");
2663	return 0;
2664}
2665
2666/*
2667 * kdb_register_flags - This function is used to register a kernel
2668 * 	debugger command.
2669 * Inputs:
2670 *	cmd	Command name
2671 *	func	Function to execute the command
2672 *	usage	A simple usage string showing arguments
2673 *	help	A simple help string describing command
2674 *	repeat	Does the command auto repeat on enter?
2675 * Returns:
2676 *	zero for success, one if a duplicate command.
2677 */
2678#define kdb_command_extend 50	/* arbitrary */
2679int kdb_register_flags(char *cmd,
2680		       kdb_func_t func,
2681		       char *usage,
2682		       char *help,
2683		       short minlen,
2684		       kdb_cmdflags_t flags)
2685{
2686	int i;
2687	kdbtab_t *kp;
2688
2689	/*
2690	 *  Brute force method to determine duplicates
2691	 */
2692	for_each_kdbcmd(kp, i) {
2693		if (kp->cmd_name && (strcmp(kp->cmd_name, cmd) == 0)) {
2694			kdb_printf("Duplicate kdb command registered: "
2695				"%s, func %p help %s\n", cmd, func, help);
2696			return 1;
2697		}
2698	}
2699
2700	/*
2701	 * Insert command into first available location in table
2702	 */
2703	for_each_kdbcmd(kp, i) {
2704		if (kp->cmd_name == NULL)
2705			break;
2706	}
2707
2708	if (i >= kdb_max_commands) {
2709		kdbtab_t *new = kmalloc((kdb_max_commands - KDB_BASE_CMD_MAX +
2710			 kdb_command_extend) * sizeof(*new), GFP_KDB);
2711		if (!new) {
2712			kdb_printf("Could not allocate new kdb_command "
2713				   "table\n");
2714			return 1;
2715		}
2716		if (kdb_commands) {
2717			memcpy(new, kdb_commands,
2718			  (kdb_max_commands - KDB_BASE_CMD_MAX) * sizeof(*new));
2719			kfree(kdb_commands);
2720		}
2721		memset(new + kdb_max_commands - KDB_BASE_CMD_MAX, 0,
2722		       kdb_command_extend * sizeof(*new));
2723		kdb_commands = new;
2724		kp = kdb_commands + kdb_max_commands - KDB_BASE_CMD_MAX;
2725		kdb_max_commands += kdb_command_extend;
2726	}
2727
2728	kp->cmd_name   = cmd;
2729	kp->cmd_func   = func;
2730	kp->cmd_usage  = usage;
2731	kp->cmd_help   = help;
 
2732	kp->cmd_minlen = minlen;
2733	kp->cmd_flags  = flags;
2734
2735	return 0;
2736}
2737EXPORT_SYMBOL_GPL(kdb_register_flags);
2738
2739
2740/*
2741 * kdb_register - Compatibility register function for commands that do
2742 *	not need to specify a repeat state.  Equivalent to
2743 *	kdb_register_flags with flags set to 0.
2744 * Inputs:
2745 *	cmd	Command name
2746 *	func	Function to execute the command
2747 *	usage	A simple usage string showing arguments
2748 *	help	A simple help string describing command
2749 * Returns:
2750 *	zero for success, one if a duplicate command.
2751 */
2752int kdb_register(char *cmd,
2753	     kdb_func_t func,
2754	     char *usage,
2755	     char *help,
2756	     short minlen)
2757{
2758	return kdb_register_flags(cmd, func, usage, help, minlen, 0);
 
2759}
2760EXPORT_SYMBOL_GPL(kdb_register);
2761
2762/*
2763 * kdb_unregister - This function is used to unregister a kernel
2764 *	debugger command.  It is generally called when a module which
2765 *	implements kdb commands is unloaded.
2766 * Inputs:
2767 *	cmd	Command name
2768 * Returns:
2769 *	zero for success, one command not registered.
2770 */
2771int kdb_unregister(char *cmd)
2772{
2773	int i;
2774	kdbtab_t *kp;
2775
2776	/*
2777	 *  find the command.
2778	 */
2779	for_each_kdbcmd(kp, i) {
2780		if (kp->cmd_name && (strcmp(kp->cmd_name, cmd) == 0)) {
2781			kp->cmd_name = NULL;
2782			return 0;
2783		}
2784	}
2785
2786	/* Couldn't find it.  */
2787	return 1;
2788}
2789EXPORT_SYMBOL_GPL(kdb_unregister);
2790
2791/* Initialize the kdb command table. */
2792static void __init kdb_inittab(void)
2793{
2794	int i;
2795	kdbtab_t *kp;
2796
2797	for_each_kdbcmd(kp, i)
2798		kp->cmd_name = NULL;
2799
2800	kdb_register_flags("md", kdb_md, "<vaddr>",
2801	  "Display Memory Contents, also mdWcN, e.g. md8c1", 1,
2802	  KDB_ENABLE_MEM_READ | KDB_REPEAT_NO_ARGS);
2803	kdb_register_flags("mdr", kdb_md, "<vaddr> <bytes>",
2804	  "Display Raw Memory", 0,
2805	  KDB_ENABLE_MEM_READ | KDB_REPEAT_NO_ARGS);
2806	kdb_register_flags("mdp", kdb_md, "<paddr> <bytes>",
2807	  "Display Physical Memory", 0,
2808	  KDB_ENABLE_MEM_READ | KDB_REPEAT_NO_ARGS);
2809	kdb_register_flags("mds", kdb_md, "<vaddr>",
2810	  "Display Memory Symbolically", 0,
2811	  KDB_ENABLE_MEM_READ | KDB_REPEAT_NO_ARGS);
2812	kdb_register_flags("mm", kdb_mm, "<vaddr> <contents>",
2813	  "Modify Memory Contents", 0,
2814	  KDB_ENABLE_MEM_WRITE | KDB_REPEAT_NO_ARGS);
2815	kdb_register_flags("go", kdb_go, "[<vaddr>]",
2816	  "Continue Execution", 1,
2817	  KDB_ENABLE_REG_WRITE | KDB_ENABLE_ALWAYS_SAFE_NO_ARGS);
2818	kdb_register_flags("rd", kdb_rd, "",
2819	  "Display Registers", 0,
2820	  KDB_ENABLE_REG_READ);
2821	kdb_register_flags("rm", kdb_rm, "<reg> <contents>",
2822	  "Modify Registers", 0,
2823	  KDB_ENABLE_REG_WRITE);
2824	kdb_register_flags("ef", kdb_ef, "<vaddr>",
2825	  "Display exception frame", 0,
2826	  KDB_ENABLE_MEM_READ);
2827	kdb_register_flags("bt", kdb_bt, "[<vaddr>]",
2828	  "Stack traceback", 1,
2829	  KDB_ENABLE_MEM_READ | KDB_ENABLE_INSPECT_NO_ARGS);
2830	kdb_register_flags("btp", kdb_bt, "<pid>",
2831	  "Display stack for process <pid>", 0,
2832	  KDB_ENABLE_INSPECT);
2833	kdb_register_flags("bta", kdb_bt, "[D|R|S|T|C|Z|E|U|I|M|A]",
2834	  "Backtrace all processes matching state flag", 0,
2835	  KDB_ENABLE_INSPECT);
2836	kdb_register_flags("btc", kdb_bt, "",
2837	  "Backtrace current process on each cpu", 0,
2838	  KDB_ENABLE_INSPECT);
2839	kdb_register_flags("btt", kdb_bt, "<vaddr>",
2840	  "Backtrace process given its struct task address", 0,
2841	  KDB_ENABLE_MEM_READ | KDB_ENABLE_INSPECT_NO_ARGS);
2842	kdb_register_flags("env", kdb_env, "",
2843	  "Show environment variables", 0,
2844	  KDB_ENABLE_ALWAYS_SAFE);
2845	kdb_register_flags("set", kdb_set, "",
2846	  "Set environment variables", 0,
2847	  KDB_ENABLE_ALWAYS_SAFE);
2848	kdb_register_flags("help", kdb_help, "",
2849	  "Display Help Message", 1,
2850	  KDB_ENABLE_ALWAYS_SAFE);
2851	kdb_register_flags("?", kdb_help, "",
2852	  "Display Help Message", 0,
2853	  KDB_ENABLE_ALWAYS_SAFE);
2854	kdb_register_flags("cpu", kdb_cpu, "<cpunum>",
2855	  "Switch to new cpu", 0,
2856	  KDB_ENABLE_ALWAYS_SAFE_NO_ARGS);
2857	kdb_register_flags("kgdb", kdb_kgdb, "",
2858	  "Enter kgdb mode", 0, 0);
2859	kdb_register_flags("ps", kdb_ps, "[<flags>|A]",
2860	  "Display active task list", 0,
2861	  KDB_ENABLE_INSPECT);
2862	kdb_register_flags("pid", kdb_pid, "<pidnum>",
2863	  "Switch to another task", 0,
2864	  KDB_ENABLE_INSPECT);
2865	kdb_register_flags("reboot", kdb_reboot, "",
2866	  "Reboot the machine immediately", 0,
2867	  KDB_ENABLE_REBOOT);
2868#if defined(CONFIG_MODULES)
2869	kdb_register_flags("lsmod", kdb_lsmod, "",
2870	  "List loaded kernel modules", 0,
2871	  KDB_ENABLE_INSPECT);
2872#endif
2873#if defined(CONFIG_MAGIC_SYSRQ)
2874	kdb_register_flags("sr", kdb_sr, "<key>",
2875	  "Magic SysRq key", 0,
2876	  KDB_ENABLE_ALWAYS_SAFE);
2877#endif
2878#if defined(CONFIG_PRINTK)
2879	kdb_register_flags("dmesg", kdb_dmesg, "[lines]",
2880	  "Display syslog buffer", 0,
2881	  KDB_ENABLE_ALWAYS_SAFE);
2882#endif
2883	if (arch_kgdb_ops.enable_nmi) {
2884		kdb_register_flags("disable_nmi", kdb_disable_nmi, "",
2885		  "Disable NMI entry to KDB", 0,
2886		  KDB_ENABLE_ALWAYS_SAFE);
2887	}
2888	kdb_register_flags("defcmd", kdb_defcmd, "name \"usage\" \"help\"",
2889	  "Define a set of commands, down to endefcmd", 0,
2890	  KDB_ENABLE_ALWAYS_SAFE);
2891	kdb_register_flags("kill", kdb_kill, "<-signal> <pid>",
2892	  "Send a signal to a process", 0,
2893	  KDB_ENABLE_SIGNAL);
2894	kdb_register_flags("summary", kdb_summary, "",
2895	  "Summarize the system", 4,
2896	  KDB_ENABLE_ALWAYS_SAFE);
2897	kdb_register_flags("per_cpu", kdb_per_cpu, "<sym> [<bytes>] [<cpu>]",
2898	  "Display per_cpu variables", 3,
2899	  KDB_ENABLE_MEM_READ);
2900	kdb_register_flags("grephelp", kdb_grep_help, "",
2901	  "Display help on | grep", 0,
2902	  KDB_ENABLE_ALWAYS_SAFE);
2903}
2904
2905/* Execute any commands defined in kdb_cmds.  */
2906static void __init kdb_cmd_init(void)
2907{
2908	int i, diag;
2909	for (i = 0; kdb_cmds[i]; ++i) {
2910		diag = kdb_parse(kdb_cmds[i]);
2911		if (diag)
2912			kdb_printf("kdb command %s failed, kdb diag %d\n",
2913				kdb_cmds[i], diag);
2914	}
2915	if (defcmd_in_progress) {
2916		kdb_printf("Incomplete 'defcmd' set, forcing endefcmd\n");
2917		kdb_parse("endefcmd");
2918	}
2919}
2920
2921/* Initialize kdb_printf, breakpoint tables and kdb state */
2922void __init kdb_init(int lvl)
2923{
2924	static int kdb_init_lvl = KDB_NOT_INITIALIZED;
2925	int i;
2926
2927	if (kdb_init_lvl == KDB_INIT_FULL || lvl <= kdb_init_lvl)
2928		return;
2929	for (i = kdb_init_lvl; i < lvl; i++) {
2930		switch (i) {
2931		case KDB_NOT_INITIALIZED:
2932			kdb_inittab();		/* Initialize Command Table */
2933			kdb_initbptab();	/* Initialize Breakpoints */
2934			break;
2935		case KDB_INIT_EARLY:
2936			kdb_cmd_init();		/* Build kdb_cmds tables */
2937			break;
2938		}
2939	}
2940	kdb_init_lvl = lvl;
2941}