Return to vmsys.c CVS log

Up to [Research Unix] / researchv9 / sys.vax / sys

Annotation of researchv9/sys.vax/sys/vmsys.c, revision 1.1

1.1     ! root        1: /*     vmsys.c 4.11    81/04/23        */
        !             2: 
        !             3: #include "../h/param.h"
        !             4: #include "../h/systm.h"
        !             5: #include "../h/dir.h"
        !             6: #include "../h/user.h"
        !             7: #include "../h/proc.h"
        !             8: #include "../h/reg.h"
        !             9: #include "../h/file.h"
        !            10: #include "../h/inode.h"
        !            11: #include "../h/vm.h"
        !            12: #include "../h/buf.h"
        !            13: #include "../h/pte.h"
        !            14: #include "../h/cmap.h"
        !            15: #include "../h/mtpr.h"
        !            16: #include "../h/vlimit.h"
        !            17: #include "../h/trace.h"
        !            18: #include "../h/vadvise.h"
        !            19: 
        !            20: vfork()
        !            21: {
        !            22: 
        !            23:        fork1(1);
        !            24: }
        !            25: 
        !            26: resuba()
        !            27: {
        !            28: 
        !            29:        if (suser())
        !            30:                ubareset(u.u_arg[0]);
        !            31: }
        !            32: 
        !            33: futz()
        !            34: {
        !            35: 
        !            36: }
        !            37: 
        !            38: int    both;
        !            39: 
        !            40: vadvise()
        !            41: {
        !            42:        register struct a {
        !            43:                int     anom;
        !            44:        } *uap;
        !            45:        register struct proc *rp = u.u_procp;
        !            46:        int oanom = rp->p_flag & SUANOM;
        !            47:        register struct pte *pte;
        !            48:        register struct cmap *c;
        !            49:        register int i;
        !            50: 
        !            51:        uap = (struct a *)u.u_ap;
        !            52: #ifdef TRACE
        !            53:        trace(TR_VADVISE, uap->anom, u.u_procp->p_pid);
        !            54: #endif
        !            55:        rp->p_flag &= ~(SSEQL|SUANOM);
        !            56:        switch (uap->anom) {
        !            57: 
        !            58:        case VA_ANOM:
        !            59:                rp->p_flag |= SUANOM;
        !            60:                break;
        !            61: 
        !            62:        case VA_SEQL:
        !            63:                rp->p_flag |= SSEQL;
        !            64:                break;
        !            65:        }
        !            66:        if (both || (oanom && (rp->p_flag & SUANOM) == 0)) {
        !            67:                for (i = 0; i < rp->p_dsize; i += CLSIZE) {
        !            68:                        pte = dptopte(rp, i);
        !            69:                        if (pte->pg_v) {
        !            70:                                c = &cmap[pgtocm(pte->pg_pfnum)];
        !            71:                                if (c->c_lock)
        !            72:                                        continue;
        !            73:                                pte->pg_v = 0;
        !            74:                                if (anycl(pte, pg_m))
        !            75:                                        pte->pg_m = 1;
        !            76:                                distcl(pte);
        !            77:                        }
        !            78:                }
        !            79:                mtpr(TBIA, 0);
        !            80:        }
        !            81: }
        !            82: 
        !            83: vtimes()
        !            84: {
        !            85:        register struct a {
        !            86:                struct  vtimes *par_vm;
        !            87:                struct  vtimes *ch_vm;
        !            88:        } *uap = (struct a *)u.u_ap;
        !            89:        if (uap->par_vm) {
        !            90:                if (copyout((caddr_t)&u.u_vm, (caddr_t)uap->par_vm,
        !            91:                    sizeof(struct vtimes)) < 0)
        !            92:                        u.u_error = EFAULT;
        !            93:        }
        !            94:        if (uap->ch_vm == 0)
        !            95:                return;
        !            96:        if (copyout((caddr_t)&u.u_cvm, (caddr_t)uap->ch_vm,
        !            97:            sizeof(struct vtimes)) < 0)
        !            98:                u.u_error = EFAULT;
        !            99: }
        !           100: 
        !           101: vmsadd(vp, wp)
        !           102:        register struct vtimes *vp, *wp;
        !           103: {
        !           104: 
        !           105:        vp->vm_utime += wp->vm_utime;
        !           106:        vp->vm_stime += wp->vm_stime;
        !           107:        vp->vm_nswap += wp->vm_nswap;
        !           108:        vp->vm_idsrss += wp->vm_idsrss;
        !           109:        vp->vm_ixrss += wp->vm_ixrss;
        !           110:        if (vp->vm_maxrss < wp->vm_maxrss)
        !           111:                vp->vm_maxrss = wp->vm_maxrss;
        !           112:        vp->vm_majflt += wp->vm_majflt;
        !           113:        vp->vm_minflt += wp->vm_minflt;
        !           114:        vp->vm_inblk += wp->vm_inblk;
        !           115:        vp->vm_oublk += wp->vm_oublk;
        !           116: }
        !           117: 
        !           118: /*
        !           119:  * Affect per-process limits.
        !           120:  * To just return old limit, specify negative new limit.
        !           121:  */
        !           122: vlimit()
        !           123: {
        !           124:        register struct a {
        !           125:                unsigned which;
        !           126:                int     limit;
        !           127:        } *uap;
        !           128: 
        !           129:        uap = (struct a *)u.u_ap;
        !           130:        if (uap->which > NLIMITS) {
        !           131:                u.u_error = EINVAL;
        !           132:                return;
        !           133:        }
        !           134:        u.u_r.r_val1 = u.u_limit[uap->which];
        !           135:        if (uap->limit < 0)
        !           136:                return;
        !           137:        switch (uap->which) {
        !           138: 
        !           139:        case LIM_DATA:
        !           140:                if (uap->limit > ctob(MAXDSIZ))
        !           141:                        uap->limit = ctob(MAXDSIZ);
        !           142:                break;
        !           143: 
        !           144:        case LIM_TEXT:
        !           145:                if (uap->limit > ctob(MAXTSIZ))
        !           146:                        uap->limit = ctob(MAXTSIZ);
        !           147:                break;
        !           148: 
        !           149:        case LIM_STACK:
        !           150:                if (uap->limit > ctob(MAXSSIZ))
        !           151:                        uap->limit = ctob(MAXSSIZ);
        !           152:                break;
        !           153:        }
        !           154:        if (u.u_limit[LIM_NORAISE] && uap->limit > u.u_limit[uap->which] &&
        !           155:            !suser()) {
        !           156:                u.u_error = EACCES;
        !           157:                return;
        !           158:        }
        !           159:        u.u_limit[uap->which] = uap->limit;
        !           160:        if (uap->which == LIM_MAXRSS)
        !           161:                u.u_procp->p_maxrss = uap->limit/NBPG;
        !           162: }
        !           163: 
        !           164: #ifdef TRACE
        !           165: int    nvualarm;
        !           166: 
        !           167: vtrace()
        !           168: {
        !           169:        register struct a {
        !           170:                int     request;
        !           171:                int     value;
        !           172:        } *uap;
        !           173:        int vdoualarm();
        !           174: 
        !           175:        uap = (struct a *)u.u_ap;
        !           176:        switch (uap->request) {
        !           177: 
        !           178:        case VTR_DISABLE:               /* disable a trace point */
        !           179:        case VTR_ENABLE:                /* enable a trace point */
        !           180:                if (uap->value < 0 || uap->value >= TR_NFLAGS)
        !           181:                        u.u_error = EINVAL;
        !           182:                else {
        !           183:                        u.u_r.r_val1 = traceflags[uap->value];
        !           184:                        traceflags[uap->value] = uap->request;
        !           185:                }
        !           186:                break;
        !           187: 
        !           188:        case VTR_VALUE:         /* return a trace point setting */
        !           189:                if (uap->value < 0 || uap->value >= TR_NFLAGS)
        !           190:                        u.u_error = EINVAL;
        !           191:                else
        !           192:                        u.u_r.r_val1 = traceflags[uap->value];
        !           193:                break;
        !           194: 
        !           195:        case VTR_UALARM:        /* set a real-time ualarm, less than 1 min */
        !           196:                if (uap->value <= 0 || uap->value > 60 * hz ||
        !           197:                    nvualarm > 5)
        !           198:                        u.u_error = EINVAL;
        !           199:                else {
        !           200:                        nvualarm++;
        !           201:                        timeout(vdoualarm, (caddr_t)u.u_procp->p_pid,
        !           202:                            uap->value);
        !           203:                }
        !           204:                break;
        !           205: 
        !           206:        case VTR_STAMP:
        !           207:                trace(TR_STAMP, uap->value, 0);
        !           208:                break;
        !           209:        }
        !           210: }
        !           211: 
        !           212: vdoualarm(arg)
        !           213:        int arg;
        !           214: {
        !           215:        register struct proc *p;
        !           216: 
        !           217:        p = pfind(arg);
        !           218:        if (p)
        !           219:                psignal(p, 16);
        !           220:        nvualarm--;
        !           221: }
        !           222: #endif

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