X-Git-Url: http://repo.macrolet.net/gitweb/?a=blobdiff_plain;f=src%2Fruntime%2Fmonitor.c;h=14d1d431814852ad76c8db2294b8b911da5d9097;hb=6fb6e66f531dfb6140ec3e0cc8f84f6ecd1927ca;hp=56e91e17d5297c95721e4eaf715e5ddb446146d0;hpb=dfa55a883f94470267b626dae77ce7e7dfac3df6;p=sbcl.git diff --git a/src/runtime/monitor.c b/src/runtime/monitor.c index 56e91e1..14d1d43 100644 --- a/src/runtime/monitor.c +++ b/src/runtime/monitor.c @@ -16,16 +16,14 @@ #include #include #include +#include #include "runtime.h" #include "sbcl.h" -#include "globals.h" -#include "vars.h" -#include "parse.h" -#include "os.h" -#include "interrupt.h" -#include "lispregs.h" -#include "monitor.h" + +/* Almost all of this file can be skipped if we're not supporting LDB. */ +#if defined(LISP_FEATURE_SB_LDB) + #include "print.h" #include "arch.h" #include "interr.h" @@ -33,11 +31,22 @@ #include "search.h" #include "purify.h" -extern boolean isatty(int fd); +/* When we need to do command input, we use this stream, which is not + * in general stdin, so that things will "work" (as well as being + * thrown into ldb can be considered "working":-) even in a process + * where standard input has been redirected to a file or pipe. + * + * (We could set up output to go to a special ldb_out stream for the + * same reason, but there's been no pressure for that so far.) + * + * The enter-the-ldb-monitor function is responsible for setting up + * this stream. */ +static FILE *ldb_in = 0; +static int ldb_in_fd = -1; typedef void cmd(char **ptr); -static cmd call_cmd, dump_cmd, print_cmd, quit, help; +static cmd call_cmd, dump_cmd, print_cmd, quit_cmd, help_cmd; static cmd flush_cmd, search_cmd, regs_cmd, exit_cmd; static cmd print_context_cmd; static cmd backtrace_cmd, purify_cmd, catchers_cmd; @@ -47,15 +56,15 @@ static cmd kill_cmd; static struct cmd { char *cmd, *help; void (*fn)(char **ptr); -} Cmds[] = { - {"help", "Display this help information.", help}, - {"?", "help", help}, +} supported_cmds[] = { + {"help", "Display this help information.", help_cmd}, + {"?", "(an alias for help)", help_cmd}, {"backtrace", "Backtrace up to N frames.", backtrace_cmd}, {"call", "Call FUNCTION with ARG1, ARG2, ...", call_cmd}, {"catchers", "Print a list of all the active catchers.", catchers_cmd}, {"context", "Print interrupt context number I.", print_context_cmd}, {"dump", "Dump memory starting at ADDRESS for COUNT words.", dump_cmd}, - {"d", "Alias for dump", dump_cmd}, + {"d", "(an alias for dump)", dump_cmd}, {"exit", "Exit this instance of the monitor.", exit_cmd}, {"flush", "Flush all temp variables.", flush_cmd}, /* (Classic CMU CL had a "gc" command here, which seems like a @@ -66,17 +75,18 @@ static struct cmd { kill_cmd}, {"purify", "Purify. (Caveat purifier!)", purify_cmd}, {"print", "Print object at ADDRESS.", print_cmd}, - {"p", "Alias for print", print_cmd}, - {"quit", "Quit.", quit}, - {"regs", "Display current Lisp regs.", regs_cmd}, + {"p", "(an alias for print)", print_cmd}, + {"quit", "Quit.", quit_cmd}, + {"regs", "Display current Lisp registers.", regs_cmd}, {"search", "Search for TYPE starting at ADDRESS for a max of COUNT words.", search_cmd}, - {"s", "search", search_cmd}, + {"s", "(an alias for search)", search_cmd}, {NULL, NULL, NULL} }; static jmp_buf curbuf; -static int visible(unsigned char c) +static int +visible(unsigned char c) { if (c < ' ' || c > '~') return ' '; @@ -84,7 +94,8 @@ static int visible(unsigned char c) return c; } -static void dump_cmd(char **ptr) +static void +dump_cmd(char **ptr) { static char *lastaddr = 0; static int lastcount = 20; @@ -139,23 +150,26 @@ static void dump_cmd(char **ptr) lastaddr = addr; } -static void print_cmd(char **ptr) +static void +print_cmd(char **ptr) { lispobj obj = parse_lispobj(ptr); print(obj); } -static void kill_cmd(char **ptr) +static void +kill_cmd(char **ptr) { kill(getpid(), parse_number(ptr)); } -static void regs_cmd(char **ptr) +static void +regs_cmd(char **ptr) { printf("CSP\t=\t0x%08lX\n", (unsigned long)current_control_stack_pointer); printf("FP\t=\t0x%08lX\n", (unsigned long)current_control_frame_pointer); -#if !defined(ibmrt) && !defined(__i386__) +#if !defined(__i386__) printf("BSP\t=\t0x%08X\n", (unsigned long)current_binding_stack_pointer); #endif #ifdef __i386__ @@ -164,7 +178,7 @@ static void regs_cmd(char **ptr) #endif printf("DYNAMIC\t=\t0x%08lx\n", (unsigned long)DYNAMIC_SPACE_START); -#if defined(ibmrt) || defined(__i386__) +#if defined(__i386__) printf("ALLOC\t=\t0x%08lx\n", (unsigned long)SymbolValue(ALLOCATION_POINTER)); printf("TRIGGER\t=\t0x%08lx\n", @@ -184,7 +198,8 @@ static void regs_cmd(char **ptr) #endif } -static void search_cmd(char **ptr) +static void +search_cmd(char **ptr) { static int lastval = 0, lastcount = 0; static lispobj *start = 0, *end = 0; @@ -194,27 +209,27 @@ static void search_cmd(char **ptr) if (more_p(ptr)) { val = parse_number(ptr); if (val < 0 || val > 0xff) { - printf("Can only search for single bytes.\n"); + printf("can only search for single bytes\n"); return; } if (more_p(ptr)) { - addr = (lispobj *)PTR((long)parse_addr(ptr)); + addr = (lispobj *)native_pointer((long)parse_addr(ptr)); if (more_p(ptr)) { count = parse_number(ptr); } else { - /* Speced value and address, but no count. Only one. */ + /* Specified value and address, but no count. Only one. */ count = -1; } } else { - /* Speced a value, but no address, so search same range. */ + /* Specified a value, but no address, so search same range. */ addr = start; count = lastcount; } } else { - /* Speced nothing, search again for val. */ + /* Specified nothing, search again for val. */ val = lastval; addr = end; count = lastcount; @@ -231,24 +246,27 @@ static void search_cmd(char **ptr) obj = *end; addr = end; end += 2; - if (TypeOf(obj) == type_FunctionHeader) - print((long)addr | type_FunctionPointer); - else if (LowtagOf(obj) == type_OtherImmediate0 || LowtagOf(obj) == type_OtherImmediate1) - print((lispobj)addr | type_OtherPointer); - else + if (TypeOf(obj) == type_SimpleFunHeader) { + print((long)addr | FUN_POINTER_LOWTAG); + } else if (lowtagof(obj) == OTHER_IMMEDIATE_0_LOWTAG || + lowtagof(obj) == OTHER_IMMEDIATE_1_LOWTAG) { + print((lispobj)addr | OTHER_POINTER_LOWTAG); + } else { print((lispobj)addr); - if (count == -1) + } if (count == -1) { return; + } } } -static void call_cmd(char **ptr) +static void +call_cmd(char **ptr) { lispobj thing = parse_lispobj(ptr), function, result = 0, cons, args[3]; int numargs; - if (LowtagOf(thing) == type_OtherPointer) { - switch (TypeOf(*(lispobj *)(thing-type_OtherPointer))) { + if (lowtagof(thing) == OTHER_POINTER_LOWTAG) { + switch (TypeOf(*(lispobj *)(thing-OTHER_POINTER_LOWTAG))) { case type_SymbolHeader: for (cons = SymbolValue(INITIAL_FDEFN_OBJECTS); cons != NIL; @@ -258,14 +276,14 @@ static void call_cmd(char **ptr) goto fdefn; } } - printf("symbol 0x%08lx is undefined.\n", (long unsigned)thing); + printf("Symbol 0x%08lx is undefined.\n", (long unsigned)thing); return; case type_Fdefn: fdefn: - function = FDEFN(thing)->function; + function = FDEFN(thing)->fun; if (function == NIL) { - printf("fdefn 0x%08lx is undefined.\n", (long unsigned)thing); + printf("Fdefn 0x%08lx is undefined.\n", (long unsigned)thing); return; } break; @@ -276,7 +294,7 @@ static void call_cmd(char **ptr) return; } } - else if (LowtagOf(thing) != type_FunctionPointer) { + else if (lowtagof(thing) != FUN_POINTER_LOWTAG) { printf("0x%08lx is not a function pointer, symbol, or fdefn object.\n", (long unsigned)thing); return; @@ -287,7 +305,7 @@ static void call_cmd(char **ptr) numargs = 0; while (more_p(ptr)) { if (numargs >= 3) { - printf("too many arguments (no more than 3 allowed)\n"); + printf("too many arguments (no more than 3 supported)\n"); return; } args[numargs++] = parse_lispobj(ptr); @@ -307,50 +325,56 @@ static void call_cmd(char **ptr) result = funcall3(function, args[0], args[1], args[2]); break; default: - lose("unsupported argument count"); + lose("unsupported arg count made it past validity check?!"); } print(result); } -static void flush_cmd(char **ptr) +static void +flush_cmd(char **ptr) { flush_vars(); } -static void quit(char **ptr) +static void +quit_cmd(char **ptr) { char buf[10]; printf("Really quit? [y] "); fflush(stdout); - fgets(buf, sizeof(buf), stdin); + fgets(buf, sizeof(buf), ldb_in); if (buf[0] == 'y' || buf[0] == 'Y' || buf[0] == '\n') exit(0); } -static void help(char **ptr) +static void +help_cmd(char **ptr) { struct cmd *cmd; - for (cmd = Cmds; cmd->cmd != NULL; cmd++) + for (cmd = supported_cmds; cmd->cmd != NULL; cmd++) if (cmd->help != NULL) printf("%s\t%s\n", cmd->cmd, cmd->help); } static int done; -static void exit_cmd(char **ptr) +static void +exit_cmd(char **ptr) { done = 1; } -static void purify_cmd(char **ptr) +static void +purify_cmd(char **ptr) { purify(NIL, NIL); } -static void print_context(os_context_t *context) +static void +print_context(os_context_t *context) { int i; @@ -367,7 +391,8 @@ static void print_context(os_context_t *context) (unsigned long)(*os_context_pc_addr(context))); } -static void print_context_cmd(char **ptr) +static void +print_context_cmd(char **ptr) { int free; @@ -380,7 +405,7 @@ static void print_context_cmd(char **ptr) if ((index >= 0) && (index < free)) { printf("There are %d interrupt contexts.\n", free); - printf("Printing context %d\n", index); + printf("printing context %d\n", index); print_context(lisp_interrupt_contexts[index]); } else { printf("There aren't that many/few contexts.\n"); @@ -391,13 +416,14 @@ static void print_context_cmd(char **ptr) printf("There are no interrupt contexts!\n"); else { printf("There are %d interrupt contexts.\n", free); - printf("Printing context %d\n", free - 1); + printf("printing context %d\n", free - 1); print_context(lisp_interrupt_contexts[free - 1]); } } } -static void backtrace_cmd(char **ptr) +static void +backtrace_cmd(char **ptr) { void backtrace(int frames); int n; @@ -411,7 +437,8 @@ static void backtrace_cmd(char **ptr) backtrace(n); } -static void catchers_cmd(char **ptr) +static void +catchers_cmd(char **ptr) { struct catch_block *catch; @@ -432,7 +459,7 @@ static void catchers_cmd(char **ptr) (unsigned long)catch, (unsigned long)(catch->current_uwp), (unsigned long)(catch->current_cont), (unsigned long)component_ptr_from_pc((void*)catch->entry_pc) + - type_OtherPointer, + OTHER_POINTER_LOWTAG, (unsigned long)catch->entry_pc); #endif brief_print((lispobj)catch->tag); @@ -441,7 +468,8 @@ static void catchers_cmd(char **ptr) } } -static void grab_sigs_cmd(char **ptr) +static void +grab_sigs_cmd(char **ptr) { extern void sigint_init(void); @@ -449,26 +477,25 @@ static void grab_sigs_cmd(char **ptr) sigint_init(); } -static FILE *devtty; -static int devttyfd=-1; - -static void sub_monitor(void) +static void +sub_monitor(void) { struct cmd *cmd, *found; char buf[256]; char *line, *ptr, *token; int ambig; - if(devtty==0) { - devtty=fopen("/dev/tty","r+"); - devttyfd=fileno(devtty); + if (!ldb_in) { + ldb_in = fopen("/dev/tty","r+"); + ldb_in_fd = fileno(ldb_in); } + while (!done) { printf("ldb> "); fflush(stdout); - line = fgets(buf, sizeof(buf), devtty); + line = fgets(buf, sizeof(buf), ldb_in); if (line == NULL) { - if (isatty(devttyfd)) { + if (isatty(ldb_in_fd)) { putchar('\n'); continue; } @@ -482,7 +509,7 @@ static void sub_monitor(void) continue; ambig = 0; found = NULL; - for (cmd = Cmds; cmd->cmd != NULL; cmd++) { + for (cmd = supported_cmds; cmd->cmd != NULL; cmd++) { if (strcmp(token, cmd->cmd) == 0) { found = cmd; ambig = 0; @@ -506,7 +533,8 @@ static void sub_monitor(void) } } -void ldb_monitor() +void +ldb_monitor() { jmp_buf oldbuf; @@ -523,7 +551,22 @@ void ldb_monitor() bcopy(oldbuf, curbuf, sizeof(curbuf)); } -void throw_to_monitor() +void +throw_to_monitor() { longjmp(curbuf, 1); } + +#endif /* defined(LISP_FEATURE_SB_LDB) */ + +/* what we do when things go badly wrong at a low level */ +void +monitor_or_something() +{ +#if defined(LISP_FEATURE_SB_LDB) + ldb_monitor(); +#else + fprintf(stderr, "There's no LDB in this build; exiting.\n"); + exit(1); +#endif +}