Return to mubits.c CVS log

Up to [Power 6/32 Unix Tahoe 4.2BSD] / cci / d / memman

Annotation of cci/d/memman/mubits.c, revision 1.1

1.1     ! root        1: 
        !             2: #include "definitions"
        !             3: 
        !             4: extern long savvec4, unused, iob0, iob1, iob2, iob3, u0p1pt, u0p2pt;
        !             5: extern long ss1, test_va, Tpsl, Failpc;
        !             6: 
        !             7: /*   This test validate that TAHOE update the M(odify), U(used) bit
        !             8:      correctly after reference to PTE.
        !             9: */
        !            10: 
        !            11: mu_test()
        !            12: {      long pte, pg_no, pte_sys, *temp, pte_p0;
        !            13: 
        !            14:        if (ss1) writes("** Subtest4 : PTE modify bit test\n");
        !            15:        pg_no = 0;
        !            16:        asm("mfpr $SBR,_savvec4");
        !            17:        savvec4 |= 0xc0000000;
        !            18:        asm("mtpr _savvec4,$P0BR");     /* Double map P0 into System space */
        !            19:        asm("mfpr $SLR,_savvec4");
        !            20:        asm("mtpr _savvec4,$P0LR");
        !            21: 
        !            22:        asm("mtpr $5,$DCK");
        !            23:        asm("mtpr $0,$TBIA");
        !            24:        asm("mtpr $0,$PADC");
        !            25:        asm("mtpr $1,$MME");
        !            26:        asm("jmp  *$0f");               /* Go virtual */
        !            27: asm("0:");
        !            28: 
        !            29:        /* Set up P1PT  */
        !            30:        temp = &u0p1pt;
        !            31:        *temp = (IOB2) | (PTE_V | PTE_KW);      /* 1st PTE in P1 map to IOB2 */
        !            32:        savvec4 = ((long)temp) | SADDR;
        !            33:        asm("mtpr _savvec4,$P1BR");
        !            34:        asm("mtpr $1,$P1LR");
        !            35: 
        !            36:        /* Set up P2PT  */
        !            37:        temp = &u0p2pt;
        !            38:        *temp = (IOB3) | (PTE_V | PTE_KW);      /* 1st PTE in P2 map to IOB3 */
        !            39:        savvec4 = ((long)temp) | SADDR;
        !            40:        savvec4 -= (LAST_VPGNO << 2);
        !            41:        asm("mtpr _savvec4, $P2BR");
        !            42:        asm("mtpr $0xffffe, $P2LR");    /* Use only 1 entry */
        !            43: 
        !            44: /*     1st machine donot implement the Used bit        
        !            45:        ubit_chk();
        !            46: */
        !            47:        mbit_chk();
        !            48: 
        !            49:        asm("mtpr $0,$MME");            /* Back to physical */
        !            50:        asm("mtpr $0,$P0LR");           /* Invalidate P0 space */
        !            51:        asm("mtpr $0,$P1LR");           /* Invalidate P1 space */
        !            52:        asm("mtpr $0,$P2LR");           /* Invalidate P2 space */
        !            53: }
        !            54: 
        !            55: 
        !            56: /*  This test check the Used bit in PTE */
        !            57: ubit_chk()
        !            58: {
        !            59:        mubits_chk(SBR,SADDR,IOB0,'u',"System");   /* Test on System space*/
        !            60:        mubits_chk(P0BR,P0ADDR,IOB1,'u',"P0");     /* Test on P0 space */
        !            61:        mubits_chk(P1BR,P1ADDR,TEST_PTEP1,'u',"P1");    /* Test on P1 space */
        !            62:        mubits_chk(P2BR,P2ADDR,TEST_PTEP2,'u',"P2");    /* Test on P2 space */
        !            63: }
        !            64: 
        !            65: 
        !            66: 
        !            67: /*  This test check the Modify bit in PTE */
        !            68: mbit_chk()
        !            69: {
        !            70:        mubits_chk(SBR,SADDR,IOB0,'m',"System");   /* Test on System space*/
        !            71:        mubits_chk(P0BR,P0ADDR,IOB1,'m',"P0");     /* Test on P0 space */
        !            72:        mubits_chk(P1BR,P1ADDR,TEST_PTEP1,'m',"P1");    /* Test on P1 space */
        !            73:        mubits_chk(P2BR,P2ADDR,TEST_PTEP2,'m',"P2");    /* Test on P2 space */
        !            74: }
        !            75: 
        !            76: 
        !            77: mubits_chk(pg_table, addr_space, pte_no, bit, str)
        !            78: long pg_table, addr_space, pte_no;
        !            79: char bit, *str;
        !            80: {      long old_pte, mask;
        !            81:        register long *r12, val;
        !            82: 
        !            83:        mask = 0;
        !            84:        /* Set the test bit (Used/Modified) off */
        !            85:        fixmuc_pte(pg_table, pte_no, &old_pte, mask);
        !            86:        r12 = (long *) ((pte_no<<PGSHIFT) | addr_space);
        !            87:        test_va = (long)r12;    /* Virtual address of test location */
        !            88:        asm("movpsl _Tpsl");
        !            89:        if (bit == 'm')  {      /* Test Modify bit */
        !            90:                asm("movab Mbit,_Failpc");
        !            91:                asm("Mbit:");
        !            92:                *r12 = 0; }     /* Write to a location mapped by this pte */
        !            93:            else  {             /* Test Used bit */
        !            94:                asm("movab Ubit,_Failpc");
        !            95:                asm("Ubit:");
        !            96:                val = *r12; }   /* Read from a location mapped by this pte */
        !            97:        mask = -1;
        !            98:        asm("mtpr $0,$PADC");   /* Purge all data cache */
        !            99:        fixmuc_pte(pg_table, pte_no, &old_pte, mask);   /* Read this PTE back */
        !           100:        if ( bit == 'm')
        !           101:                 { if (!(old_pte&PTE_M)) {
        !           102:                        writes("** Modify bit is not set after a write\n");
        !           103:                        ac_error1();
        !           104:                        writes("** Actual PTE : ");writeh(old_pte);writec('\n');
        !           105:                        asm("halt");
        !           106:                        }
        !           107: /*                The 1st machine donot implement Used bit
        !           108:                   if (!(old_pte & PTE_U))
        !           109:                        {
        !           110:                        writes("** Used bit is not set after a write\n");
        !           111:                        ac_error1();
        !           112:                        writes("** Actual PTE : ");writeh(old_pte);writec('\n');
        !           113:                        asm("halt");
        !           114:                        }
        !           115: */
        !           116:                 }
        !           117:            else  
        !           118:                 { if (!(old_pte & PTE_U))
        !           119:                        {
        !           120:                        writes("** Test in ");writes(str);writes(" space **\n");
        !           121:                        writes("** Used bit is not set after a read..\n");
        !           122:                        }
        !           123:                   if (old_pte & PTE_M) 
        !           124:                        {
        !           125:                        writes("** Test in ");writes(str);writes(" space **\n");
        !           126:                        writes("** Modify bit is set after a read..\n");
        !           127:                        }
        !           128:                 }
        !           129: }
        !           130: 

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