Return to mchsys.c CVS log

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

Annotation of researchv9/cmd/adb/vax/mchsys.c, revision 1.1

1.1     ! root        1: /*
        !             2:  * system-mode mapping
        !             3:  * vax version
        !             4:  */
        !             5: 
        !             6: #include "defs.h"
        !             7: #include "space.h"
        !             8: #include <sys/param.h>
        !             9: #include <sys/pte.h>
        !            10: #include <sys/pcb.h>
        !            11: #include "machine.h"
        !            12: 
        !            13: static struct pte *sbr;
        !            14: static WORD svpcbb;
        !            15: static struct pcb pcb;
        !            16: #define        HWPAGE  512
        !            17: 
        !            18: printkm()
        !            19: {
        !            20: 
        !            21:        if (sbr)
        !            22:                printf("%R$k\n", (WORD)sbr);
        !            23:        if (svpcbb)
        !            24:                printf("%R$p\np0 %R %R; p1 %R %R\n", svpcbb,
        !            25:                        (WORD)pcb.pcb_p0br, (WORD)pcb.pcb_p0lr,
        !            26:                        (WORD)pcb.pcb_p1br, (WORD)pcb.pcb_p1lr);
        !            27: }
        !            28: 
        !            29: kmsys()
        !            30: {
        !            31: 
        !            32:        if (adrflg)
        !            33:                sbr = (struct pte *)adrval;
        !            34:        else
        !            35:                printkm();
        !            36: }
        !            37: 
        !            38: kmproc()
        !            39: {
        !            40:        struct pte pte;
        !            41: 
        !            42:        if (adrflg == 0) {
        !            43:                printkm();
        !            44:                return;
        !            45:        }
        !            46:        if (adrval == -1) {
        !            47:                svpcbb = 0;
        !            48:                return;
        !            49:        }
        !            50:        if (sbr == 0)
        !            51:                error("map the kernel first");
        !            52:        if (INKERNEL(adrval)) {
        !            53:                *(long *)&pte = lget((ADDR)adrval, CORF|DATASP);
        !            54:                if (pte.pg_v == 0)
        !            55:                        error("pcb address not found");
        !            56:                adrval = pte.pg_pfnum * HWPAGE;
        !            57:        }
        !            58:        if (fget((ADDR)adrval, CORF|DATASP|RAWADDR, (char *)&pcb, sizeof(pcb)) == 0) {
        !            59:                svpcbb = 0;
        !            60:                chkerr();
        !            61:        }
        !            62:        svpcbb = adrval;
        !            63: }
        !            64: 
        !            65: /*
        !            66:  * map a kernel address to a physical address
        !            67:  * arg is a pointer to be filled in
        !            68:  * returns nonzero if address is valid
        !            69:  */
        !            70: 
        !            71: int
        !            72: kmap(paddr, sp)
        !            73: ADDR *paddr;
        !            74: {
        !            75:        long a;
        !            76:        long pte;
        !            77: #define        Ppte    (*(struct pte *)&pte)
        !            78:        register int off, pfn;
        !            79: 
        !            80:        if (sbr == 0)
        !            81:                return (1);
        !            82:        sp &=~ RAWADDR;
        !            83:        a = (long)*paddr & ~0xc0000000;
        !            84:        off = a % HWPAGE;
        !            85:        pfn = (a / HWPAGE);
        !            86:        switch ((int)*paddr & 0xc0000000) {
        !            87:        case 0xc0000000:                /* really illegal, but who cares? */
        !            88:        case 0x80000000:                /* system space */
        !            89:                pte = (long)lget((ADDR)(sbr + pfn), sp | RAWADDR);
        !            90:                break;
        !            91: 
        !            92:        case 0x40000000:                /* p1 */
        !            93:                if (svpcbb == 0)
        !            94:                        return (1);
        !            95:                if (pfn <= pcb.pcb_p1lr)
        !            96:                        return (0);
        !            97:                pte = lget((ADDR)(pcb.pcb_p1br + pfn), sp);
        !            98:                if (errflg)
        !            99:                        return (0);
        !           100:                break;
        !           101: 
        !           102:        case 0x00000000:                /* p0 */
        !           103:                if (svpcbb == 0)
        !           104:                        return (1);
        !           105:                if (pfn > pcb.pcb_p0lr)
        !           106:                        return (0);
        !           107:                pte = lget((ADDR)(pcb.pcb_p0br + pfn), sp);
        !           108:                if (errflg)
        !           109:                        return (0);
        !           110:                break;
        !           111:        }
        !           112:        if (Ppte.pg_v == 0)
        !           113:                return (0);
        !           114:        *paddr = (ADDR)(Ppte.pg_pfnum * HWPAGE + off);
        !           115:        return (1);
        !           116: }

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