Linux Audio

Check our new training course

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