Return to db2.c CVS log

Up to [MW Coherent from dump] / coherent / b / bin / db

Annotation of coherent/b/bin/db/db2.c, revision 1.1.1.1

1.1       root        1: /*
                      2:  * db/db2.c
                      3:  * A debugger.
                      4:  * Segmentation maps.
                      5:  */
                      6: 
                      7: #include "db.h"
                      8: 
                      9: /*
                     10:  * Return the segment map in which the address in segment 's' falls.
                     11:  */
                     12: MAP *
                     13: map_addr(s, addr) int s; ADDR_T addr;
                     14: {
                     15:        register MAP *mp;
                     16: 
                     17:        for (mp = seg_map[s]; mp != (MAP *)NULL; mp = mp->m_next) {
                     18:                if (mp->m_base <= addr && addr < mp->m_bend)
                     19:                        break;
                     20:        }
                     21: #if    0
                     22:        if (mp == NULL)
                     23:                printf("map_addr failed, s=%d addr=%lX\n", s, addr);
                     24: #endif
                     25:        return mp;
                     26: }
                     27: 
                     28: /*
                     29:  * Clear the segment map for segment 's' until 'endp'.
                     30:  * 'endp' allows leaving pure data while clearing impure data.
                     31:  */
                     32: void
                     33: map_clear(s, endp) int s; MAP *endp;
                     34: {
                     35:        register MAP *mp, *nmp;
                     36: 
                     37:        dbprintf(("map_clear(%d, %X):\n", s, endp));
                     38:        for (mp = seg_map[s]; mp != endp; mp = nmp) {
                     39:                dbprintf((" map_clear clearing %X\n", mp));
                     40:                nmp = mp->m_next;
                     41:                nfree(mp);
                     42:        }
                     43:        seg_map[s] = mp;
                     44: }
                     45: 
                     46: /*
                     47:  * Clear all maps.
                     48:  * The maps can share the same information, e.g. after ISPACE = DSPACE,
                     49:  * hence the silly equality check kludge below.
                     50:  */
                     51: void
                     52: map_init()
                     53: {
                     54:        register int n;
                     55: 
                     56:        dbprintf(("map_init()\n"));
                     57:        for (n = 0; n < NSEGS; n++) {
                     58:                while (n < NSEGS - 1 && seg_map[n] == seg_map[n+1])
                     59:                        seg_map[n++] = (MAP *)NULL;
                     60:                map_clear(n, (MAP *)NULL);
                     61:        }
                     62: }
                     63: 
                     64: /*
                     65:  * Print a segmentation map for the :m request.
                     66:  */
                     67: void
                     68: map_print()
                     69: {
                     70:        register MAP *mp;
                     71:        register int n;
                     72: 
                     73:        for (n = 0; n < NSEGS; n++) {
                     74:                for (mp = seg_map[n]; mp != (MAP *)NULL; mp = mp->m_next) {
                     75:                        if (testint())
                     76:                                return;
                     77:                        if (mp == seg_map[n]) {
                     78:                                printx("%s", seg_name[n]);
                     79:                                while (n < NSEGS-1 && seg_map[n+1]==mp)
                     80:                                        printx(" == %s", seg_name[++n]);
                     81:                                printx(":\n");
                     82:                        }
                     83:                        printx("[");
                     84:                        printx(addr_fmt, mp->m_base);
                     85:                        printx(", ");
                     86:                        printx(addr_fmt, mp->m_bend);
                     87:                        printx("] => ");
                     88:                        printx(addr_fmt, mp->m_offt);
                     89:                        printx(" (%d)", mp->m_segi);
                     90:                        if (mp->m_flag == MAP_CHILD)
                     91:                                printx(" [child]\n");
                     92:                        else
                     93:                                printx(" \"%s\"\n", (mp->m_flag == MAP_PROG) ? lfn : cfn);
                     94:                }
                     95:        }
                     96: }
                     97: 
                     98: /*
                     99:  * Initialize an element of a segment map.
                    100:  */
                    101: void
                    102: map_set(s, base, size, offt, flag) int s; ADDR_T base, size; off_t offt; int flag;
                    103: {
                    104:        register MAP *mp;
                    105: 
                    106:        dbprintf(("map_set(s=%d base=%lX size=%lX offt=%lX flag=%d)\n", s, base, size, offt, flag));
                    107:        if (size == (ADDR_T)0)
                    108:                return;                         /* ignore empty segments */
                    109:        mp = (MAP *)nalloc(sizeof(MAP), "segment map");
                    110:        mp->m_next = seg_map[s];
                    111:        seg_map[s] = mp;                        /* link into list */
                    112:        mp->m_base = base;
                    113:        mp->m_bend = base + size;
                    114:        mp->m_offt = offt;
                    115:        mp->m_segi = s;
                    116:        mp->m_flag = flag;
                    117: }
                    118: 
                    119: /* end of db/db2.c */

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