Return to mipslock.c CVS log

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

Annotation of lucent/sys/src/liblock/mipslock.c, revision 1.1.1.1

1.1       root        1: #include <u.h>
                      2: #include <libc.h>
                      3: #include <lock.h>
                      4: 
                      5: enum
                      6: {
                      7:        Pagesize        = 4096,
                      8:        Semperpg        = Pagesize/(16*sizeof(uint)),
                      9:        Lockaddr        = 0x60000000,
                     10: 
                     11:        POWER           = 0x320,
                     12:        MAGNUM          = 0x330,
                     13:        MAGNUMII        = 0x340,
                     14:        R4K             = 0x500,
                     15: };
                     16: 
                     17: static int arch;
                     18: extern int C_3ktas(int*);
                     19: extern int C_4ktas(int*);
                     20: extern int C_fcr0(void);
                     21: 
                     22: void
                     23: lockinit()
                     24: {
                     25:        int n;
                     26: 
                     27:        arch = C_fcr0();
                     28:        switch(arch) {
                     29:        case POWER:
                     30:                n = segattach(SG_CEXEC, "lock", (void*)Lockaddr, Pagesize);
                     31:                if(n < 0) {
                     32:                        arch = MAGNUM;
                     33:                        break;
                     34:                }
                     35:                memset((void*)Lockaddr, 0, Pagesize);
                     36:                break;
                     37:        case MAGNUM:
                     38:        case MAGNUMII:
                     39:        case R4K:
                     40:                break;
                     41:        default:
                     42:                abort();
                     43:        }
                     44:        
                     45: }
                     46: 
                     47: void
                     48: lock(Lock *lk)
                     49: {
                     50:        int *hwsem;
                     51:        int hash;
                     52: 
                     53:        switch(arch) {
                     54:        case MAGNUM:
                     55:        case MAGNUMII:
                     56:                while(C_3ktas(&lk->val))
                     57:                        sleep(0);
                     58:                return;
                     59:        case R4K:
                     60:                for(;;){
                     61:                        while(lk->val)
                     62:                                ;
                     63:                        if(C_4ktas(&lk->val) == 0)
                     64:                                return;
                     65:                }
                     66:                break;
                     67:        case POWER:
                     68:                /* Use low order lock bits to generate hash */
                     69:                hash = ((int)lk/sizeof(int)) & (Semperpg-1);
                     70:                hwsem = (int*)Lockaddr+hash;
                     71: 
                     72:                for(;;) {
                     73:                        if((*hwsem & 1) == 0) {
                     74:                                if(lk->val)
                     75:                                        *hwsem = 0;
                     76:                                else {
                     77:                                        lk->val = 1;
                     78:                                        *hwsem = 0;
                     79:                                        return;
                     80:                                }
                     81:                        }
                     82:                        while(lk->val)
                     83:                                ;
                     84:                }
                     85:        }       
                     86: }
                     87: 
                     88: int
                     89: canlock(Lock *lk)
                     90: {
                     91:        int *hwsem;
                     92:        int hash;
                     93: 
                     94:        switch(arch) {
                     95:        case MAGNUM:
                     96:        case MAGNUMII:
                     97:                if(C_3ktas(&lk->val))
                     98:                        return 0;
                     99:                return 1;
                    100:        case R4K:
                    101:                if(C_4ktas(&lk->val))
                    102:                        return 0;
                    103:                return 1;
                    104:        case POWER:
                    105:                /* Use low order lock bits to generate hash */
                    106:                hash = ((int)lk/sizeof(int)) & (Semperpg-1);
                    107:                hwsem = (int*)Lockaddr+hash;
                    108: 
                    109:                if((*hwsem & 1) == 0) {
                    110:                        if(lk->val)
                    111:                                *hwsem = 0;
                    112:                        else {
                    113:                                lk->val = 1;
                    114:                                *hwsem = 0;
                    115:                                return 1;
                    116:                        }
                    117:                }
                    118:                return 0;
                    119:        }       
                    120: }
                    121: 
                    122: void
                    123: unlock(Lock *lk)
                    124: {
                    125:        lk->val = 0;
                    126: }

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