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