![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to debug.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Atari MiNT] / MiNT / src|
Return to debug.c CVS log | Up to [Atari MiNT] / MiNT / src |
1.1 root 1: /*
2:
1.1.1.3 root 3: Copyright 1990,1991,1992 Eric R. Smith.
4:
1.1.1.4 ! root 5: Copyright 1992,1993 Atari Corporation.
1.1.1.3 root 6:
7: All rights reserved.
1.1 root 8:
9: */
10:
11:
12:
13: /* MiNT debugging output routines */
14:
15: /* also, ksprintf is put here, for lack of any better place to put it */
16:
17:
18:
19: #include "mint.h"
20:
21: #include <stdarg.h>
22:
23:
24:
1.1.1.3 root 25: static void VDEBUGOUT P_((int, const char *, va_list));
1.1 root 26:
27:
28:
29: /*
30:
31: * ksprintf implements a very crude sprintf() function that provides only
32:
33: * what MiNT needs...
34:
35: *
36:
37: * NOTE: this sprintf probably doesn't conform to any standard at
38:
39: * all. It's only use in life is that it won't overflow fixed
40:
41: * size buffers (i.e. it won't try to write more than SPRINTF_MAX
42:
43: * characters into a string)
44:
45: */
46:
47:
48:
49: static int
50:
51: PUTC(char *p, int c, int *cnt, int width) {
52:
53: int put = 1;
54:
55:
56:
57: if (*cnt <= 0) return 0;
58:
59: *p++ = c;
60:
61: *cnt -= 1;
62:
63: while (*cnt > 0 && --width > 0) {
64:
65: *p++ = ' ';
66:
67: *cnt -= 1;
68:
69: put++;
70:
71: }
72:
73: return put;
74:
75: }
76:
77:
78:
79: static int
80:
81: PUTS(char *p, const char *s, int *cnt, int width) {
82:
83: int put = 0;
84:
85:
86:
87: if (s == 0) s = "(null)";
88:
89:
90:
91: while (*cnt > 0 && *s) {
92:
93: *p++ = *s++;
94:
95: put++;
96:
97: *cnt -= 1;
98:
99: width--;
100:
101: }
102:
103: while (width-- > 0 && *cnt > 0) {
104:
105: *p++ = ' ';
106:
107: put++;
108:
109: *cnt -= 1;
110:
111: }
112:
113: return put;
114:
115: }
116:
117:
118:
119: static int
120:
121: PUTL(char *p, unsigned long u, int base, int *cnt, int width, int fill_char)
122:
123: {
124:
125: int put = 0;
126:
127: static char obuf[32];
128:
129: char *t;
130:
131:
132:
133: t = obuf;
134:
135:
136:
137: do {
138:
1.1.1.3 root 139: *t++ = "0123456789ABCDEF"[u % base];
1.1 root 140:
141: u /= base;
142:
143: width--;
144:
145: } while (u > 0);
146:
147:
148:
149: while (width-- > 0 && *cnt > 0) {
150:
151: *p++ = fill_char;
152:
153: put++;
154:
155: *cnt -= 1;
156:
157: }
158:
159: while (*cnt > 0 && t != obuf) {
160:
161: *p++ = *--t;
162:
163: put++;
164:
165: *cnt -= 1;
166:
167: }
168:
169: return put;
170:
171: }
172:
173:
174:
175: int
176:
177: vksprintf(char *buf, const char *fmt, va_list args)
178:
179: {
180:
181: char *p = buf, c, fill_char;
182:
183: char *s_arg;
184:
185: int i_arg;
186:
187: long l_arg;
188:
189: int cnt;
190:
191: int width, long_flag;
192:
193:
194:
195: cnt = SPRINTF_MAX - 1;
196:
197: while( (c = *fmt++) != 0 ) {
198:
199: if (c != '%') {
200:
201: p += PUTC(p, c, &cnt, 1);
202:
203: continue;
204:
205: }
206:
207: c = *fmt++;
208:
209: width = 0;
210:
211: long_flag = 0;
212:
213: fill_char = ' ';
214:
215: if (c == '0') fill_char = '0';
216:
217: while (c && isdigit(c)) {
218:
219: width = 10*width + (c-'0');
220:
221: c = *fmt++;
222:
223: }
224:
225: if (c == 'l' || c == 'L') {
226:
227: long_flag = 1;
228:
229: c = *fmt++;
230:
231: }
232:
233: if (!c) break;
234:
235:
236:
237: switch (c) {
238:
239: case '%':
240:
241: p += PUTC(p, c, &cnt, width);
242:
243: break;
244:
245: case 'c':
246:
247: i_arg = va_arg(args, int);
248:
249: p += PUTC(p, i_arg, &cnt, width);
250:
251: break;
252:
253: case 's':
254:
255: s_arg = va_arg(args, char *);
256:
257: p += PUTS(p, s_arg, &cnt, width);
258:
259: break;
260:
261: case 'd':
262:
263: if (long_flag) {
264:
265: l_arg = va_arg(args, long);
266:
267: } else {
268:
269: l_arg = va_arg(args, int);
270:
271: }
272:
273: if (l_arg < 0) {
274:
275: p += PUTC(p, '-', &cnt, 1);
276:
277: width--;
278:
279: l_arg = -l_arg;
280:
281: }
282:
283: p += PUTL(p, l_arg, 10, &cnt, width, fill_char);
284:
285: break;
286:
287: case 'o':
288:
289: if (long_flag) {
290:
291: l_arg = va_arg(args, long);
292:
293: } else {
294:
295: l_arg = va_arg(args, unsigned int);
296:
297: }
298:
299: p += PUTL(p, l_arg, 8, &cnt, width, fill_char);
300:
301: break;
302:
303: case 'x':
304:
305: if (long_flag) {
306:
307: l_arg = va_arg(args, long);
308:
309: } else {
310:
311: l_arg = va_arg(args, unsigned int);
312:
313: }
314:
315: p += PUTL(p, l_arg, 16, &cnt, width, fill_char);
316:
317: break;
318:
319: case 'u':
320:
321: if (long_flag) {
322:
323: l_arg = va_arg(args, long);
324:
325: } else {
326:
327: l_arg = va_arg(args, unsigned int);
328:
329: }
330:
331: p += PUTL(p, l_arg, 10, &cnt, width, fill_char);
332:
333: break;
334:
335:
336:
337: }
338:
339: }
340:
341: *p = 0;
342:
1.1.1.2 root 343: return (int)(p - buf);
1.1 root 344:
345: }
346:
347:
348:
1.1.1.2 root 349: int ARGS_ON_STACK
1.1 root 350:
351: ksprintf(char *buf, const char *fmt, ...)
352:
353: {
354:
355: va_list args;
356:
357: int foo;
358:
359:
360:
361: va_start(args, fmt);
362:
363: foo = vksprintf(buf, fmt, args);
364:
365: va_end(args);
366:
367: return foo;
368:
369: }
370:
371:
372:
1.1.1.3 root 373: int debug_level = 1; /* how much debugging info should we print? */
1.1 root 374:
375: int out_device = 2; /* BIOS device to write errors to */
376:
377:
378:
379: /*
380:
381: * out_next[i] is the out_device value to use when the current
382:
383: * device is i and the user hits F3.
384:
385: * Cycle is CON -> PRN -> AUX -> MIDI -> 6 -> 7 -> 8 -> 9 -> CON
386:
387: * (Note: BIOS devices 6-8 exist on Mega STe and TT, 9 on TT.)
388:
389: *
390:
391: * out_device and this table are exported to bios.c and used here in HALT().
392:
393: */
394:
395:
396:
397: /* 0 1 2 3 4 5 6 7 8 9 */
398:
399: char out_next[] = { 1, 3, 0, 6, 0, 0, 7, 8, 9, 2 };
400:
401:
402:
1.1.1.3 root 403: /*
404:
405: * debug log modes:
406:
407: *
408:
409: * 0: no logging.
410:
411: * 1: log all messages, dump the log any time something happens at
412:
413: * a level that gets shown. Thus, if you're at debug_level 2,
414:
415: * everything is logged, and if something at levels 1 or 2 happens,
416:
417: * the log is dumped.
418:
419: *
420:
421: * LB_LINE_LEN is 20 greater than SPRINTF_MAX because up to 20 bytes
422:
423: * are prepended to the buffer string passed to ksprintf.
424:
425: */
426:
427:
428:
429: #define LBSIZE 50 /* number of lines */
430:
431: #define LB_LINE_LEN (SPRINTF_MAX+20) /* width of a line */
432:
433: int debug_logging;
434:
435: int logptr;
436:
437: static char logbuf[LBSIZE][LB_LINE_LEN];
438:
439: static short logtime[LBSIZE]; /* low 16 bits of 200Hz: timestamp of msg */
440:
441:
442:
443: /*
444:
445: * Extra terse settings - don't even output ALERTs unless asked to.
446:
447: *
448:
449: * Things that happen in on an idle Desktop are at LOW_LEVEL:
450:
451: * Psemaphore, Pmsg, Syield.
452:
453: */
454:
455:
456:
457: #define FORCE_LEVEL 0
458:
459: #define ALERT_LEVEL 1
460:
461: #define DEBUG_LEVEL 2
462:
463: #define TRACE_LEVEL 3
464:
465: #define LOW_LEVEL 4
466:
467:
468:
469: /*
470:
471: * The inner loop does this: at each newline, the keyboard is polled. If
472:
473: * you've hit a key, then it's checked: if it's ctl-alt, do_func_key is
474:
475: * called to do what it says, and that's that. If not, then you pause the
476:
477: * output. If you now hit a ctl-alt key, it gets done and you're still
478:
479: * paused. Only hitting a non-ctl-alt key will get you out of the pause.
480:
481: * (And only a non-ctl-alt key got you into it, too!)
482:
483: *
484:
485: * When out_device isn't the screen, number keys give you the same effects
486:
487: * as function keys. The only way to get into this code, however, is to
488:
489: * have something produce debug output in the first place! This is
490:
491: * awkward: Hit a key on out_device, then hit ctl-alt-F5 on the console so
492:
493: * bios.c will call DUMPPROC, which will call ALERT, which will call this.
494:
495: * It'll see the key you hit on out_device and drop you into this loop.
496:
497: * CTL-ALT keys make BIOS call do_func_key even when out_device isn't the
498:
499: * console.
500:
501: */
502:
503:
504:
1.1 root 505: void
506:
507: debug_ws(s)
508:
509: const char *s;
510:
511: {
512:
1.1.1.3 root 513: long key;
514:
515: int scan;
516:
517: int stopped;
518:
519:
520:
521: while (*s) {
522:
523: (void)Bconout(out_device, *s);
524:
525: while (*s == '\n' && out_device != 0 && Bconstat(out_device)) {
1.1 root 526:
1.1.1.3 root 527: stopped = 0;
1.1 root 528:
1.1.1.3 root 529: while (1) {
1.1 root 530:
1.1.1.3 root 531: /* got a key; if ctl-alt then do it */
1.1 root 532:
1.1.1.3 root 533: key = Bconin(out_device);
1.1 root 534:
1.1.1.3 root 535: if (out_device == 2) {
1.1 root 536:
1.1.1.3 root 537: if ((Kbshift(-1) & 0x0c) == 0x0c) {
1.1 root 538:
1.1.1.3 root 539: scan = (int) (((key >> 16) & 0xff));
1.1 root 540:
1.1.1.3 root 541: do_func_key(scan);
1.1 root 542:
1.1.1.3 root 543: }
1.1 root 544:
1.1.1.3 root 545: else goto ptoggle;
1.1 root 546:
1.1.1.3 root 547: }
548:
549: else {
550:
551: if (key < '0' || key > '9') {
552:
553: ptoggle: /* not a func key */
554:
555: if (stopped) break;
556:
557: else stopped = 1;
1.1 root 558:
1.1.1.3 root 559: }
1.1 root 560:
1.1.1.3 root 561: else {
1.1 root 562:
1.1.1.3 root 563: /* digit key from debug device == Fn */
1.1 root 564:
1.1.1.3 root 565: if (key == '0') scan = 0x44;
566:
567: else scan = (int) (key - '0' + 0x3a);
568:
569: do_func_key(scan);
570:
571: }
572:
573: }
1.1 root 574:
1.1.1.3 root 575: }
576:
577: }
578:
579: s++;
580:
581: }
582:
583: }
584:
585:
586:
587: /*
588:
589: * _ALERT(s) returns 1 for success and 0 for failure.
590:
591: * It attempts to write the string to "the alert pipe," u:\pipe\alert.
592:
593: * If the write fails because the pipe is full, we "succeed" anyway.
594:
595: *
596:
597: * This is called in vdebugout and also in memprot.c for memory violations.
598:
599: * It's also used by the Salert() system call in dos.c.
600:
601: */
602:
603:
604:
605: int
606:
607: _ALERT(s)
608:
609: char *s;
610:
611: {
612:
613: FILEPTR *f;
614:
615: char alertbuf[SPRINTF_MAX+10], *ptr, *lastspace;
616:
617: int counter;
618:
619: char *alert;
620:
621: int olddebug = debug_level;
622:
623: int oldlogging = debug_logging;
624:
625:
626:
627: /* temporarily reduce the debug level, so errors finding
628:
629: * u:\pipe\alert don't get reported
630:
631: */
632:
633: debug_level = debug_logging = 0;
634:
635: f = do_open("u:\\pipe\\alert",(O_WRONLY | O_NDELAY),0,(XATTR *)0);
636:
637: debug_level = olddebug;
638:
639: debug_logging = oldlogging;
640:
641:
642:
643: if (f) {
644:
645: /*
646:
647: * format the string into an alert box
648:
649: */
650:
651: if (*s == '[') { /* already an alert */
652:
653: alert = s;
654:
655: } else {
656:
657: alert = alertbuf;
658:
659: ksprintf(alertbuf, "[1][%s", s);
660:
661: /*
662:
663: * make sure no lines exceed 30 characters; also, filter out any
664:
665: * reserved characters like '[' or ']'
666:
667: */
668:
669: ptr = alertbuf+4;
670:
671: counter = 0;
672:
673: lastspace = 0;
674:
675: while(*ptr) {
676:
677: if (*ptr == ' ') {
678:
679: lastspace = ptr;
680:
681: } else if (*ptr == '[') {
682:
683: *ptr = '(';
684:
685: } else if (*ptr == ']') {
686:
687: *ptr = ')';
688:
689: } else if (*ptr == '|') {
690:
691: *ptr = ':';
1.1 root 692:
693: }
694:
1.1.1.3 root 695: if (counter++ >= 29) {
696:
697: if (lastspace) {
698:
699: *lastspace = '|';
700:
701: counter = (int) (ptr - lastspace);
702:
703: lastspace = 0;
704:
705: } else {
706:
707: *ptr = '|';
708:
709: counter = 0;
710:
711: }
712:
713: }
714:
715: ptr++;
716:
1.1 root 717: }
718:
1.1.1.3 root 719: strcpy(ptr, "][ OK ]");
1.1 root 720:
721: }
722:
1.1.1.3 root 723:
724:
725: (*f->dev->write)(f,alert,(long)strlen(alert)+1);
726:
727: do_close(f);
728:
729: return 1;
730:
731: }
732:
733: else return 0;
734:
1.1 root 735: }
736:
737:
738:
739: static void
740:
1.1.1.3 root 741: VDEBUGOUT(level, s, args)
742:
743: int level;
1.1 root 744:
745: const char *s;
746:
747: va_list args;
748:
749: {
750:
1.1.1.3 root 751: char *lp;
752:
753: char *lptemp;
754:
755:
756:
757: logtime[logptr] = (short)(*(long *)0x4baL);
758:
759: lp = logbuf[logptr];
760:
761: if (++logptr == LBSIZE) logptr = 0;
762:
763:
764:
765: if (curproc) {
766:
767: ksprintf(lp,"pid %3d (%s): ", curproc->pid, curproc->name);
768:
769: lptemp = lp+strlen(lp);
770:
771: }
772:
773: else {
774:
775: lptemp = lp;
776:
777: }
778:
779:
780:
781: vksprintf(lptemp, s, args);
782:
783:
784:
785: /* for alerts, try the alert pipe unconditionally */
786:
787: if (level == ALERT_LEVEL && _ALERT(lp)) return;
788:
789:
790:
791: if (debug_level >= level) {
792:
793: debug_ws(lp);
794:
795: debug_ws("\r\n");
796:
797: }
798:
799: }
800:
801:
802:
803: void ARGS_ON_STACK Tracelow(const char *s, ...)
804:
805: {
806:
807: va_list args;
1.1 root 808:
809:
810:
1.1.1.3 root 811: if (debug_logging || (debug_level >= LOW_LEVEL)) {
1.1 root 812:
1.1.1.3 root 813: va_start(args, s);
1.1 root 814:
1.1.1.3 root 815: VDEBUGOUT(LOW_LEVEL, s, args);
1.1 root 816:
1.1.1.3 root 817: va_end(args);
1.1 root 818:
1.1.1.3 root 819: }
1.1 root 820:
821: }
822:
823:
824:
1.1.1.2 root 825: void ARGS_ON_STACK Trace(const char *s, ...)
1.1 root 826:
827: {
828:
829: va_list args;
830:
831:
832:
1.1.1.3 root 833: if (debug_logging || (debug_level >= TRACE_LEVEL)) {
1.1 root 834:
835: va_start(args, s);
836:
1.1.1.3 root 837: VDEBUGOUT(TRACE_LEVEL, s, args);
1.1 root 838:
839: va_end(args);
840:
841: }
842:
843: }
844:
845:
846:
1.1.1.2 root 847: void ARGS_ON_STACK Debug(const char *s, ...)
1.1 root 848:
849: {
850:
851: va_list args;
852:
853:
854:
1.1.1.3 root 855: if (debug_logging || (debug_level >= DEBUG_LEVEL)) {
1.1 root 856:
857: va_start(args, s);
858:
1.1.1.3 root 859: VDEBUGOUT(DEBUG_LEVEL, s, args);
1.1 root 860:
861: va_end(args);
862:
863: }
864:
1.1.1.3 root 865: if (debug_logging && debug_level >= DEBUG_LEVEL) DUMPLOG();
866:
1.1 root 867: }
868:
869:
870:
1.1.1.2 root 871: void ARGS_ON_STACK ALERT(const char *s, ...)
1.1 root 872:
873: {
874:
875: va_list args;
876:
877:
878:
1.1.1.3 root 879: if (debug_logging || debug_level >= ALERT_LEVEL) {
880:
881: va_start(args, s);
882:
883: VDEBUGOUT(ALERT_LEVEL, s, args);
884:
885: va_end(args);
886:
887: }
888:
889: if (debug_logging && debug_level >= ALERT_LEVEL) DUMPLOG();
890:
891: }
892:
893:
894:
895: void ARGS_ON_STACK FORCE(const char *s, ...)
896:
897: {
898:
899: va_list args;
900:
901:
902:
1.1 root 903: va_start(args, s);
904:
1.1.1.3 root 905: VDEBUGOUT(FORCE_LEVEL, s, args);
1.1 root 906:
907: va_end(args);
908:
1.1.1.3 root 909: /* don't dump log here - hardly ever what you mean to do. */
910:
1.1 root 911: }
912:
913:
914:
1.1.1.3 root 915: void
916:
917: DUMPLOG()
918:
919: {
920:
921: char *end;
922:
923: char *start;
924:
925: short *timeptr;
926:
927: char timebuf[6];
928:
929:
930:
931: /* logbuf[logptr] is the oldest string here */
932:
933:
934:
935: end = start = logbuf[logptr];
936:
937: timeptr = &logtime[logptr];
938:
939:
940:
941: do {
942:
943: if (*start) {
944:
945: ksprintf(timebuf,"%04x ",*timeptr);
946:
947: debug_ws(timebuf);
948:
949: debug_ws(start);
950:
951: debug_ws("\r\n");
952:
953: *start = '\0';
954:
955: }
956:
957: start += LB_LINE_LEN;
958:
959: timeptr++;
960:
961: #ifdef LATTICE
962:
963: #pragma ignore 83 /* [reference beyond object size] */
964:
965: #endif
966:
967: if (start == logbuf[LBSIZE]) {
968:
969: #ifdef LATTICE
970:
971: #pragma warning 83 /* [reference beyond object size] */
972:
973: #endif
974:
975: start = logbuf[0];
976:
977: timeptr = &logtime[0];
978:
979: }
980:
981: } while (start != end);
982:
983:
984:
985: logptr = 0;
986:
987: }
988:
989:
990:
991: /* wait for a key to be pressed */
992:
993: void
994:
995: PAUSE()
996:
997: {
998:
999: debug_ws("Hit a key\r\n");
1000:
1001: (void)Bconin(2);
1002:
1003: }
1004:
1005:
1006:
1.1 root 1007: EXITING
1008:
1.1.1.2 root 1009: void ARGS_ON_STACK FATAL(const char *s, ...)
1.1 root 1010:
1011: {
1012:
1013: va_list args;
1014:
1015:
1016:
1017: va_start(args, s);
1018:
1.1.1.3 root 1019: VDEBUGOUT(-1, s, args);
1.1 root 1020:
1021: va_end(args);
1022:
1.1.1.3 root 1023: if (debug_logging) {
1024:
1025: DUMPLOG();
1026:
1027: }
1028:
1029:
1030:
1.1 root 1031: HALT();
1032:
1033: }
1034:
1035:
1036:
1037:
1038:
1.1.1.4 ! root 1039: static const char *rebootmsg[MAXLANG] = {
! 1040:
! 1041: "FATAL ERROR. You must reboot the system.\r\n",
! 1042:
! 1043: "FATALER FEHLER. Das System mu� neu gestartet werden.\r\n", /* German */
! 1044:
! 1045: "FATAL ERROR. You must reboot the system.\r\n", /* French */
! 1046:
! 1047: "FATAL ERROR. You must reboot the system.\r\n", /* UK */
! 1048:
! 1049: "FATAL ERROR. You must reboot the system.\r\n", /* Spanish */
! 1050:
! 1051: "FATAL ERROR. You must reboot the system.\r\n" /* Italian */
! 1052:
! 1053: };
! 1054:
! 1055:
! 1056:
1.1 root 1057: EXITING
1058:
1059: void HALT()
1060:
1061: {
1062:
1063: long r;
1064:
1.1.1.3 root 1065: long key;
1066:
1067: int scan;
1068:
1.1 root 1069: extern long tosssp; /* in main.c */
1070:
1.1.1.3 root 1071: #ifdef PROFILING
1.1 root 1072:
1.1.1.3 root 1073: extern EXITING _exit P_((int));
1074:
1075: #endif
1.1 root 1076:
1077: restr_intr(); /* restore interrupts to normal */
1078:
1.1.1.4 ! root 1079: #ifdef DEBUG_INFO
! 1080:
1.1 root 1081: debug_ws("Fatal MiNT error: adjust debug level and hit a key...\r\n");
1082:
1.1.1.4 ! root 1083: #else
! 1084:
! 1085: debug_ws(rebootmsg[gl_lang]);
! 1086:
! 1087: #endif
! 1088:
1.1 root 1089: sys_q[READY_Q] = 0; /* prevent context switches */
1090:
1091:
1092:
1093: for(;;) {
1094:
1.1.1.3 root 1095: /* get a key; if ctl-alt then do it, else halt */
1.1 root 1096:
1.1.1.3 root 1097: key = Bconin(out_device);
1.1 root 1098:
1.1.1.3 root 1099: if ((key & 0x0c000000L) == 0x0c000000L) {
1.1 root 1100:
1.1.1.3 root 1101: scan = (int) ((key >> 16) & 0xff);
1.1 root 1102:
1.1.1.3 root 1103: do_func_key(scan);
1.1.1.2 root 1104:
1105: }
1106:
1.1.1.3 root 1107: else {
1.1 root 1108:
1109: break;
1110:
1.1.1.3 root 1111: }
1112:
1.1 root 1113: }
1114:
1115: for(;;) {
1116:
1.1.1.4 ! root 1117: debug_ws(rebootmsg[gl_lang]);
1.1 root 1118:
1119: r = Bconin(2);
1120:
1121:
1122:
1123: if ( (r & 0x0ff) == 'x' ) {
1124:
1.1.1.4 ! root 1125: extern int no_mem_prot;
! 1126:
1.1 root 1127: close_filesys();
1128:
1.1.1.4 ! root 1129: if (!no_mem_prot)
! 1130:
! 1131: restr_mmu();
! 1132:
1.1 root 1133: (void)Super((void *)tosssp); /* gratuitous (void *) for Lattice */
1134:
1.1.1.2 root 1135: #ifdef PROFILING
1136:
1137: _exit(0);
1138:
1139: #else
1140:
1141: Pterm0();
1142:
1143: #endif
1.1 root 1144:
1145: }
1146:
1147: }
1148:
1149: }
1150:
1151:
1152:
1153:
1154:
1155: /* some key definitions */
1156:
1157: #define CTRLALT 0xc
1158:
1159: #define DEL 0x53 /* scan code of delete key */
1160:
1161: #define UNDO 0x61 /* scan code of undo key */
1162:
1163:
1164:
1165: void
1166:
1167: do_func_key(scan)
1168:
1169: int scan;
1170:
1171: {
1172:
1173: extern struct tty con_tty;
1174:
1175:
1176:
1177: switch (scan) {
1178:
1179: case DEL:
1180:
1181: reboot();
1182:
1183: break;
1184:
1185: case UNDO:
1186:
1187: killgroup(con_tty.pgrp, SIGQUIT);
1188:
1189: break;
1190:
1.1.1.4 ! root 1191: #ifdef DEBUG_INFO
1.1.1.2 root 1192:
1.1.1.3 root 1193: case 0x3b: /* F1: increase debugging level */
1.1 root 1194:
1195: debug_level++;
1196:
1197: break;
1198:
1.1.1.3 root 1199: case 0x3c: /* F2: reduce debugging level */
1.1 root 1200:
1201: if (debug_level > 0)
1202:
1203: --debug_level;
1204:
1205: break;
1206:
1.1.1.3 root 1207: case 0x3d: /* F3: cycle out_device */
1.1 root 1208:
1209: out_device = out_next[out_device];
1210:
1211: break;
1212:
1.1.1.3 root 1213: case 0x3e: /* F4: set out_device to console */
1.1 root 1214:
1215: out_device = 2;
1216:
1217: break;
1218:
1.1.1.3 root 1219: case 0x3f: /* F5: dump memory */
1220:
1221: DUMPMEM(ker);
1.1 root 1222:
1223: DUMPMEM(core);
1224:
1.1.1.2 root 1225: DUMPMEM(alt);
1226:
1.1 root 1227: break;
1228:
1.1.1.3 root 1229: case 0x40: /* F6: dump processes */
1.1 root 1230:
1231: DUMPPROC();
1232:
1233: break;
1234:
1.1.1.3 root 1235: case 0x41: /* F7: toggle debug_logging */
1236:
1237: debug_logging ^= 1;
1238:
1239: break;
1240:
1241: case 0x42: /* F8: dump log */
1242:
1243: DUMPLOG();
1244:
1245: break;
1246:
1247: case 0x43: /* F9: dump the global memory table */
1248:
1249: QUICKDUMP();
1250:
1251: break;
1252:
1253: case 0x5c: /* shift-F9: dump the mmu tree */
1254:
1255: BIG_MEM_DUMP(1,curproc);
1256:
1257: break;
1258:
1259: case 0x44: /* F10: do an annotated dump of memory */
1260:
1261: BIG_MEM_DUMP(0,0);
1262:
1263: break;
1264:
1.1.1.2 root 1265: #endif
1266:
1.1 root 1267: }
1268:
1269: }
1270:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.