Return to access.c CVS log

Up to [Plan 9 NeXT] / lucent / sys / src / libmach

Annotation of lucent/sys/src/libmach/access.c, revision 1.1.1.1

1.1       root        1: /*
                      2:  * functions to read and write an executable or file image
                      3:  */
                      4: 
                      5: #include <u.h>
                      6: #include <libc.h>
                      7: #include <bio.h>
                      8: #include <mach.h>
                      9: 
                     10: static int     mget(Map*, ulong, char*, int);
                     11: static int     mput(Map*, ulong, char*, int);
                     12: static int     reloc(Map*, ulong, long*);
                     13: 
                     14: /*
                     15:  * routines to get/put various types
                     16:  */
                     17: 
                     18: int
                     19: get4(Map *map, ulong addr, long *x)
                     20: {
                     21:        if (!map) {
                     22:                werrstr("get4: invalid map");
                     23:                return -1;
                     24:        }
                     25: 
                     26:        if (map->fd < 0) {
                     27:                *x = addr;
                     28:                return 1;
                     29:        }
                     30:        if (mget(map, addr, (char *)x, 4) < 0)
                     31:                return -1;
                     32:        *x = machdata->swal(*x);
                     33:        return (1);
                     34: }
                     35: 
                     36: int
                     37: get2(Map *map, ulong addr, ushort *x)
                     38: {
                     39:        if (!map) {
                     40:                werrstr("get2: invalid map");
                     41:                return -1;
                     42:        }
                     43: 
                     44:        if (map->fd < 0) {
                     45:                *x = addr;
                     46:                return 1;
                     47:        }
                     48:        if (mget(map, addr, (char *)x, 2) < 0)
                     49:                return -1;
                     50:        *x = machdata->swab(*x);
                     51:        return (1);
                     52: }
                     53: 
                     54: int
                     55: get1(Map *map, ulong addr, uchar *x, int size)
                     56: {
                     57:        uchar *cp;
                     58: 
                     59:        if (!map) {
                     60:                werrstr("get1: invalid map");
                     61:                return -1;
                     62:        }
                     63: 
                     64:        if (map->fd < 0) {
                     65:                cp = (uchar*)&addr;
                     66:                while (cp < (uchar*)(&addr+1) && size-- > 0)
                     67:                        *x++ = *cp++;
                     68:                while (size-- > 0)
                     69:                        *x++ = 0;
                     70:        } else
                     71:                return mget(map, addr, (char*)x, size);
                     72:        return 1;
                     73: }
                     74: 
                     75: int
                     76: put4(Map *map, ulong addr, long v)
                     77: {
                     78:        if (!map || map->fd < 0) {
                     79:                werrstr("put4: missing or unopened map");
                     80:                return -1;
                     81:        }
                     82:        v = machdata->swal(v);
                     83:        return mput(map, addr, (char *)&v, 4);
                     84: }
                     85: 
                     86: int
                     87: put2(Map *map, ulong addr, ushort v)
                     88: {
                     89:        if (!map || map->fd < 0) {
                     90:                werrstr("put2: missing or unopened map");
                     91:                return -1;
                     92:        }
                     93:        v = machdata->swab(v);
                     94:        return mput(map, addr, (char *)&v, 2);
                     95: }
                     96: 
                     97: int
                     98: put1(Map *map, ulong addr, uchar *v, int size)
                     99: {
                    100:        if (!map || map->fd < 0) {
                    101:                werrstr("put1: missing or unopened map");
                    102:                return -1;
                    103:        }
                    104:        return mput(map, addr, (char *)v, size);
                    105: }
                    106: 
                    107: static int
                    108: mget(Map *map, ulong addr, char *buf, int size)
                    109: {
                    110:        long off;
                    111:        int i, j, k;
                    112: 
                    113:        if (reloc(map, addr, &off) < 0)
                    114:                return -1;
                    115: 
                    116:        seek(map->fd, off, 0);
                    117:        for (i = j = 0; i < 2; i++) {   /* in case read crosses page */
                    118:                k = read(map->fd, buf, size-j);
                    119:                if (k < 0) {
                    120:                        werrstr("can't read address %lux: %r", addr);
                    121:                        return -1;
                    122:                }
                    123:                j += k;
                    124:                if (j == size)
                    125:                        return j;
                    126:        }
                    127:        werrstr("partial read at address %lux", addr);
                    128:        return -1;
                    129: }
                    130: 
                    131: static int
                    132: mput(Map *map, ulong addr, char *buf, int size)
                    133: {
                    134:        long off;
                    135:        int i, j, k;
                    136: 
                    137:        if (reloc(map, addr,&off) < 0)
                    138:                return -1;
                    139: 
                    140:        seek(map->fd, off, 0);
                    141:        for (i = j = 0; i < 2; i++) {   /* in case read crosses page */
                    142:                k = write(map->fd, buf, size-j);
                    143:                if (k < 0) {
                    144:                        werrstr("can't write address %lux: %r", addr);
                    145:                        return -1;
                    146:                }
                    147:                j += k;
                    148:                if (j == size)
                    149:                        return j;
                    150:        }
                    151:        werrstr("partial write at address %lux", addr);
                    152:        return -1;
                    153: }
                    154: 
                    155: /*
                    156:  *     convert address to file offset; returns nonzero if ok
                    157:  */
                    158: static int
                    159: reloc(Map *map, ulong addr, long *offp)
                    160: {
                    161:        int i;
                    162: 
                    163:        for (i = 0; i < map->nsegs; i++) {
                    164:                if (map->seg[i].inuse)
                    165:                if (map->seg[i].b <= addr && addr < map->seg[i].e) {
                    166:                        *offp = addr + map->seg[i].f - map->seg[i].b;
                    167:                        return 1;
                    168:                }
                    169:        }
                    170:        werrstr("can't translate address %lux", addr);
                    171:        return -1;
                    172: }

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