1
2
3
4
5
6
7
8
9
10
11
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
65
66unsigned int kdb_flags;
67
68
69
70
71
72int kdb_initial_cpu = -1;
73int kdb_nextline = 1;
74int 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
89static LIST_HEAD(kdb_cmds_head);
90
91typedef struct _kdbmsg {
92 int km_diag;
93 char *km_msg;
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
135
136
137
138
139
140
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",
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
171
172
173static inline bool kdb_check_flags(kdb_cmdflags_t flags, int permissions,
174 bool no_args)
175{
176
177 permissions &= KDB_ENABLE_MASK;
178 permissions |= KDB_ENABLE_ALWAYS_SAFE;
179
180
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
191
192
193
194
195
196
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
222
223
224
225
226
227
228
229
230
231
232
233
234
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
252
253
254
255
256
257
258
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
277
278
279
280
281
282
283
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
298
299
300
301
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
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
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
355
356
357
358
359
360
361
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
373
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
406
407
408int kdb_set(int argc, const char **argv)
409{
410
411
412
413
414
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
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
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
452
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
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
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
508
509
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
517
518
519
520
521
522
523 if (*nextarg > argc)
524 return KDB_ARGCOUNT;
525
526 symname = (char *)argv[*nextarg];
527
528
529
530
531
532
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
549
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
581
582
583 if (symbol == '\0') {
584 if ((argv[*nextarg][0] != '+')
585 && (argv[*nextarg][0] != '-')) {
586
587
588
589 return 0;
590 } else {
591 positive = (argv[*nextarg][0] == '+');
592 (*nextarg)++;
593 }
594 } else
595 positive = (symbol == '+');
596
597
598
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
647
648
649
650
651
652
653
654
655
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
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
682
683
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
774
775
776
777
778
779
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
798
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
809#define KDB_CMD_HISTORY_COUNT 32
810#define CMD_BUFLEN 200
811
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
819
820static void parse_grep(const char *str)
821{
822 int len;
823 char *cp = (char *)str, *cp2;
824
825
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';
841 len = strlen(cp);
842 if (len == 0) {
843 kdb_printf("invalid 'pipe', see grephelp\n");
844 return;
845 }
846
847 if (*cp == '"') {
848
849
850 cp++;
851 cp2 = strchr(cp, '"');
852 if (!cp2) {
853 kdb_printf("invalid quoted string, see grephelp\n");
854 return;
855 }
856 *cp2 = '\0';
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
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
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
921
922 cp = (char *)cmdstr;
923
924 if (KDB_FLAG(CMD_INTERRUPT)) {
925
926
927 KDB_FLAG_CLEAR(CMD_INTERRUPT);
928 KDB_STATE_SET(PAGER);
929 argc = 0;
930 }
931
932 if (*cp != '\n' && *cp != '\0') {
933 argc = 0;
934 cpp = cbuf;
935 while (*cp) {
936
937 while (isspace(*cp))
938 cp++;
939 if ((*cp == '\0') || (*cp == '\n') ||
940 (*cp == '#' && !defcmd_in_progress))
941 break;
942
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
962
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';
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;
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
1010
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
1022
1023
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
1056
1057
1058
1059
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
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
1106
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
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
1152
1153
1154
1155
1156
1157
1158
1159
1160
1161
1162
1163
1164
1165
1166
1167
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
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
1194
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;
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
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
1255
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;
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;
1272 }
1273
1274 while (1) {
1275
1276
1277
1278 kdb_nextline = 1;
1279 KDB_STATE_CLEAR(SUPPRESS);
1280 kdb_grepping_flag = 0;
1281
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
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
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
1344
1345
1346
1347
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
1358
1359
1360
1361
1362
1363
1364
1365
1366
1367
1368
1369
1370
1371
1372
1373
1374
1375
1376
1377
1378
1379
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
1386 while (1) {
1387
1388
1389
1390
1391 KDB_DEBUG_STATE("kdb_main_loop 1", reason);
1392 while (KDB_STATE(HOLD_CPU)) {
1393
1394
1395
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;
1405
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
1433 kdb_kbd_cleanup_state();
1434
1435 return result;
1436}
1437
1438
1439
1440
1441
1442
1443
1444
1445
1446
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
1463
1464
1465
1466
1467
1468
1469
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
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
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;
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
1683
1684
1685 bytesperword = KDB_WORD_SIZE;
1686 repeat = mdcount;
1687 kdbgetintenv("NOSECT", &nosect);
1688 }
1689
1690
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
1730
1731
1732
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
1775
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
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, ®8, 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, ®16, 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, ®32, 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, ®64, 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
1888
1889
1890
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
1907
1908 rname = argv[1];
1909 if (*rname == '%')
1910 rname++;
1911
1912 diag = kdbgetu64arg(argv[2], ®64);
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, ®8, kdb_current_regs);
1932 break;
1933 case 16:
1934 reg16 = reg64;
1935 dbg_set_reg(i, ®16, kdb_current_regs);
1936 break;
1937 case 32:
1938 reg32 = reg64;
1939 dbg_set_reg(i, ®32, kdb_current_regs);
1940 break;
1941 case 64:
1942 dbg_set_reg(i, ®64, 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
1956
1957
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
1974
1975
1976
1977
1978
1979
1980
1981
1982
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
2005
2006
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
2049
2050
2051
2052
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
2069
2070
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
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
2155
2156
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
2183
2184
2185
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';
2197 } else if (!kgdb_info[i].enter_kgdb) {
2198 state = 'D';
2199 } else {
2200 state = ' ';
2201 if (kdb_task_state_char(KDB_TSK(i)) == 'I')
2202 state = 'I';
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
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
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
2259
2260 return KDB_CMD_CPU;
2261}
2262
2263
2264
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
2297
2298
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
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
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
2361
2362
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
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
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
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
2467
2468
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
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
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
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
2564
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
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
2618
2619
2620
2621
2622
2623
2624
2625
2626
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
2667
2668
2669
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
2681
2682
2683
2684
2685
2686
2687
2688
2689
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
2703
2704
2705
2706
2707
2708
2709
2710int kdb_unregister(char *cmd)
2711{
2712 kdbtab_t *kp;
2713
2714
2715
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
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
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
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
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();
2977 kdb_initbptab();
2978 break;
2979 case KDB_INIT_EARLY:
2980 kdb_cmd_init();
2981 break;
2982 }
2983 }
2984 kdb_init_lvl = lvl;
2985}
2986