Return to diffs CVS log

Up to [Research Unix] / researchv9 / cmd / adb / comm

Annotation of researchv9/cmd/adb/comm/diffs, revision 1.1

1.1     ! root        1: The most important difference is that adb now uses /proc to control programs,
        !             2: rather than ptrace.  The most noticeable one is that local variables work.
        !             3: 
        !             4: Process control:
        !             5: adb uses /proc.  One thing goes away: you can't send a specific signal any
        !             6: more (:s and :c).  `:c 0' still continues the process being debugged without
        !             7: sending a signal; `:c' still sends the signal with which the process stopped.
        !             8: `:c n' where n is nonzero does the same as `:c'.
        !             9: 
        !            10: If the right-hand file is a process file (/proc/something), adb recognizes
        !            11: the fact, sets up mapping sensibly, and in particular figures out where the
        !            12: registers are.  If the process in question is still running, of course, the
        !            13: registers may change underneath you.  This will be made less severe
        !            14: eventually.  It will also eventually be possible to take over such a process
        !            15: (stop it, set breakpoints, &c).
        !            16: 
        !            17: Local variables:
        !            18: When debugging programs compiled with the -g option, adb can examine local
        !            19: variables, roughly as it could on the PDP-11.  For example, main.argc/X
        !            20: prints 4 bytes of argc in hex from the outermost stack frame associated
        !            21: with main.  $C (traceback with locals) works too.  Register variables work,
        !            22: even if they're in registers; they appear to have funny addresses with a
        !            23: % in front (which means they live in a funny `register' address space;
        !            24: you can type the % addresses if you want, but you can't store them in a
        !            25: variable and expect them to work).
        !            26: 
        !            27: Mapping:
        !            28: No longer are there just two maps for each file; there are several, and
        !            29: each is tagged with the type of thing mapped (instruction space, data
        !            30: space, user block).  ? tries for instruction space; / tries for data
        !            31: space; ?* (/*) tries data (instruction).  Even on the VAX, these are
        !            32: different kinds of space; however, if a desired instruction space address
        !            33: isn't found, data space is checked too, so things still work naturally.
        !            34: If a process isn't using separate ID space (always true on the VAX),
        !            35: its text segment is considered to be data space.
        !            36: 
        !            37: a.outs on the left-hand side, and cores and process files on the right-
        !            38: hand side, are recognized and mapped accordingly.  Other kinds of files
        !            39: are mapped in the time-honoured way (a single large, direct map of data).
        !            40: The ?m and /m commands affect the first map; ?*m and /*m affect the
        !            41: second map; what that means depends on the kind of file; in no case is
        !            42: the already-set type of thing changed.  This is a foggy (and probably
        !            43: buggy) area.
        !            44: 
        !            45: Kernel debugging:
        !            46: The -k option is gone.  In its place are two commands:
        !            47: address$k sets adb's idea of the system base register;
        !            48:        address is a physical address, usually Sysmap
        !            49: address$u sets the address of a pcb; address may be either a physical pcb
        !            50:        address (as found in PCBB and masterpcbb) or the kernel virtual
        !            51:        address of the page table entry for the pcb.  (The latter curious
        !            52:        quantity is stored in the p_addr.)
        !            53: 0$k turns off virtual address mapping; 0$u turns off mapping for user space.
        !            54: $<crash will set up the registers and mapping from a standard crash dump.
        !            55: 
        !            56: Miscellaneous appearances:
        !            57: Some attempt has been made to print things in forms that can be reused
        !            58: as input.  Addresses are printed as `main+0d/' or `main+0d?' rather than
        !            59: `main+d:'.  0$d turns on magic variable radix mode, like the old default
        !            60: on the PDP-11: numbers are read in in hex, octal, or decimal if they begin
        !            61: with #, 0, or something else; octal and hex numbers are printed with leading
        !            62: 0 and # to match.
        !            63: 
        !            64: If you have a very old kernel, it will take adb up to 10 seconds to learn
        !            65: that the process you're watching has terminated.  The recent kernel change
        !            66: that broke pi doesn't affect adb, though.  I don't know why it hurts pi.

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.