usr/src/old/adb/common_source/access.c

/*-
 * Copyright (c) 1991 The Regents of the University of California.
 * All rights reserved.
 *
 * This module is believed to contain source code proprietary to AT&T.
 * Use and redistribution is subject to the Berkeley Software License
 * Agreement and your Software Agreement with AT&T (Western Electric).
 */

#ifndef lint
static char sccsid[] = "@(#)access.c    5.4 (Berkeley) 4/4/91";
#endif /* not lint */

/*
 * Adb: access data in file/process address space.
 */

#include "defs.h"
#include <sys/file.h>
#include <sys/ptrace.h>

off_t   lseek();

/*
 * Read or write from or to the given address, accessing or altering
 * only the given byte(s).  Return the number of bytes transferred.
 * Remote (debuggee) addresses are specified as a <space,address> pair.
 * Neither the remote nor the local address need be aligned.
 *
 * If there is a current process, ask the system to do this (via ptrace
 * [ick]).  If debugging the kernel, use vtophys() to map virtual to
 * physical locations (in a system-dependent manner).  Otherwise we
 * can just read or write the files being debugged directly.
 */
int
adbio(rw, space, rmtaddr, localaddr, cnt)
        enum rwmode rw;
        int space;
        addr_t rmtaddr;
        caddr_t localaddr;
        int cnt;
{
        register int ret;
        register struct map *mp;
        struct m1 *mm;

        static char *derr = "data address not found";
        static char *terr = "text address not found";
#define rwerr() errflag = space & SP_DATA ? derr : terr
#define within(which) (rmtaddr >= which.b && rmtaddr < which.e)

        if (space == SP_NONE) {
                /* The no-space is all zero. */
                bzero(localaddr, cnt);
                return (cnt);
        }
        if (pid) {
                ret = io_ptrace(rw, space, rmtaddr, localaddr, cnt);
                if (ret != cnt)
                        rwerr();
                return (ret);
        }
        if (rw == RWMODE_WRITE && !wtflag)
                error("not in write mode");
        mp = space & SP_DATA ? &datmap : &txtmap;
        if ((space & SP_STAR) == 0 && within(mp->m1))
                mm = &mp->m1;
        else if (within(mp->m2))
                mm = &mp->m2;
        else {
                rwerr();
                return (0);
        }
        rmtaddr += mm->f - mm->b;
        if (kernel && space == SP_DATA) {
                char *err = NULL;

                rmtaddr = vtophys(rmtaddr, &err);
                if (err) {
                        errflag = err;
                        return (0);
                }
        }
        if (lseek(mp->ufd, (off_t)rmtaddr, 0) == -1) {
                rwerr();
                return (0);
        }
        if (rw == RWMODE_READ) {
                ret = read(mp->ufd, localaddr, cnt);
                /* gratuitously supply extra zeroes at end of file */
                if (ret > 0 && ret < cnt) {
                        bzero(localaddr + ret, cnt - ret);
                        ret = cnt;
                }
        } else
                ret = write(mp->ufd, localaddr, cnt);
        if (ret != cnt)
                rwerr();
        return (ret);
#undef rwerr
#undef within
}

/*
 * Read a single object of length `len' from the core file at the
 * given offset.  Return the length read.  (This routine allows vtophys
 * and kernel crash startup code to read ptes, etc.)
 */
int
readcore(off, addr, len)
        off_t off;
        caddr_t addr;
        int len;
{

        if (lseek(corefile.fd, off, L_SET) == -1)
                return (-1);
        return (read(corefile.fd, addr, len));
}

/*
 * THE FOLLOWING IS GROSS.  WE SHOULD REPLACE PTRACE WITH SPECIAL
 * FILES A LA /proc.
 *
 * Read or write using ptrace.  io_ptrace arranges that the
 * addresses passed to ptrace are an even multiple of sizeof(int),
 * and is able to read or write single bytes.
 *
 * Since ptrace is so horribly slow, and some commands do repeated
 * reading of units smaller than an `int', io_ptrace calls cptrace
 * (cached ptrace) to allow some cacheing.  cptrace also converts a
 * read/write op and a space into a ptrace op, and returns 0 on success
 * and hence takes a pointer to the value cell rather than the value.
 */
struct cache {
        short   rop, wop;               /* ptrace ops for read and write */
        int     valid;                  /* true iff cache entry valid */
        int     *addr;                  /* address of cached value */
        int     val;                    /* and the value */
};
static struct cache icache = { PT_READ_I, PT_WRITE_I };
static struct cache dcache = { PT_READ_D, PT_WRITE_D };

/*
 * Invalidate one or both caches.
 * This is the only function that accepts two spaces simultaneously.
 */
cacheinval(space)
        int space;
{

        if (space & SP_INSTR)
                icache.valid = 0;
        if (space & SP_DATA)
                dcache.valid = 0;
}

int     cachehit, cachemiss;            /* statistics */

static int
cptrace(rw, space, p, addr, val)
        enum rwmode rw;
        int space, p, *addr, *val;
{
        register struct cache *c = space & SP_DATA ? &dcache : &icache;
        int v;

        if (rw == RWMODE_READ) {
                if (c->valid && c->addr == addr) {
                        cachehit++;
                        *val = c->val;
                        return (0);
                }
                cachemiss++;
                errno = 0;
                if ((v = ptrace(c->rop, p, addr, 0)) == -1 && errno)
                        return (-1);
                *val = v;
        } else {
                c->valid = 0;           /* paranoia */
                errno = 0;
                if (ptrace(c->wop, p, addr, v = *val) == -1 && errno)
                        return (-1);
        }
        c->valid = 1;
        c->addr = addr;
        c->val = v;
        return (0);
}

int
io_ptrace(rw, space, rmtaddr, localaddr, cnt)
        register enum rwmode rw;
        register int space;
        addr_t rmtaddr;
        register caddr_t localaddr;
        register int cnt;
{
        register addr_t addr;
        register int nbytes, ret = 0, off;
        int tmp;

        /*
         * Start by aligning rmtaddr; set nbytes to the number of bytes of
         * useful data we shall obtain.
         */
        off = rmtaddr % sizeof(int);    /* addr_t is unsigned */
        addr = rmtaddr - off;
        nbytes = sizeof(int) - off;
        while (cnt != 0) {
                if (cnt < nbytes)
                        nbytes = cnt;
                if (rw == RWMODE_READ) {
                        if (cptrace(rw, space, pid, (int *)addr, &tmp))
                                return (ret);
                        bcopy((caddr_t)&tmp + off, localaddr, nbytes);
                } else {
                        if (nbytes < sizeof(int) &&
                            cptrace(RWMODE_READ, space, pid, (int *)addr, &tmp))
                                return (ret);
                        bcopy(localaddr, (caddr_t)&tmp + off, nbytes);
                        if (cptrace(rw, space, pid, (int *)addr, &tmp))
                                return (ret);
                }
                addr += sizeof(int);
                localaddr += nbytes;
                ret += nbytes;
                cnt -= nbytes;
                /*
                 * For the rest of the loop, the offset is 0 and we can
                 * use all the bytes obtained.
                 */
                off = 0;
                nbytes = sizeof(int);
        }
        return (ret);
}