Return to mchsys.c CVS log

Up to [Research Unix] / researchv10no / cmd / adb / seq

Annotation of researchv10no/cmd/adb/seq/mchsys.c, revision 1.1.1.1

1.1       root        1: /*
                      2:  * system-mode mapping
                      3:  * 32032/sequent version
                      4:  */
                      5: 
                      6: #include "defs.h"
                      7: #include "machine.h"
                      8: #include "space.h"
                      9: #include <machine/pte.h>
                     10: #include <machine/param.h>
                     11: 
                     12: static long sysptb, usrptb;
                     13: static int kmode;
                     14: 
                     15: #define        KOFF    0
                     16: #define        KSYS    1
                     17: #define        KUSR    2
                     18: 
                     19: printkm()
                     20: {
                     21: 
                     22:        printf("%R$k\n%R$u\n", sysptb, usrptb);
                     23:        if (kmode == KSYS)
                     24:                printf("sys\n");
                     25:        else if (kmode == KUSR)
                     26:                printf("user\n");
                     27:        else
                     28:                printf("off\n");
                     29: }
                     30: 
                     31: kmsys()
                     32: {
                     33: 
                     34:        if (adrflg) {
                     35:                sysptb = dot;
                     36:                kmode = KSYS;
                     37:                return;
                     38:        }
                     39:        if (expr(0)) {
                     40:                if (expv)
                     41:                        kmode = KSYS;
                     42:                else
                     43:                        kmode = KUSR;
                     44:                return;
                     45:        }
                     46:        printkm();
                     47: }
                     48: 
                     49: kmproc()
                     50: {
                     51: 
                     52:        if (adrflg) {
                     53:                sysptb = dot;
                     54:                kmode = KUSR;
                     55:                return;
                     56:        }
                     57:        if (expr(0)) {
                     58:                if (expv)
                     59:                        kmode = KUSR;
                     60:                else
                     61:                        kmode = KSYS;
                     62:                return;
                     63:        }
                     64:        printkm();
                     65: }
                     66: 
                     67: /*
                     68:  * map a kernel address to a physical address
                     69:  * arg is a pointer to be filled in
                     70:  * returns nonzero if address is valid
                     71:  */
                     72: 
                     73: int
                     74: kmap(paddr, sp)
                     75: ADDR *paddr;
                     76: {
                     77:        switch (kmode) {
                     78:        case KUSR:
                     79:                return (transl(paddr, sp, usrptb));
                     80: 
                     81:        case KSYS:
                     82:                return (transl(paddr, sp, sysptb));
                     83: 
                     84:        default:
                     85:                return (1);
                     86:        }
                     87: }
                     88: 
                     89: /*
                     90:  * virtual -> physical addr, given the right pt base
                     91:  */
                     92: static long
                     93: transl(ap, sp, ptb)
                     94: register long *ap;
                     95: int sp;
                     96: long ptb;
                     97: {
                     98:        long pt;
                     99: 
                    100:        pt = ltow(lget((ADDR)(ptb + L1IDX(*ap) * sizeof(struct pte)), sp|RAWADDR));
                    101:        if (errflg)
                    102:                return (0);
                    103:        if ((pt & PG_V) == 0)
                    104:                return (0);
                    105:        pt = PTETOPHYS(pt) + L2IDX(*ap) * sizeof(struct pte);
                    106:        pt = ltow(lget((ADDR)pt, sp|RAWADDR));
                    107:        if (errflg)
                    108:                return (0);
                    109:        *ap = (*ap & PGOFSET) + PTETOPHYS(pt);
                    110:        return (1);
                    111: }

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