Return to vmsys.c CVS log

Up to [Research Unix] / researchv10no / sys / vm

Annotation of researchv10no/sys/vm/vmsys.c, revision 1.1

1.1     ! root        1: #include "sys/param.h"
        !             2: #include "sys/user.h"
        !             3: #include "sys/proc.h"
        !             4: #include "sys/vm.h"
        !             5: #include "sys/pte.h"
        !             6: #include "sys/cmap.h"
        !             7: #include "sys/mtpr.h"
        !             8: #include "sys/vlimit.h"
        !             9: #include "sys/vadvise.h"
        !            10: 
        !            11: int    both;
        !            12: 
        !            13: vadvise()
        !            14: {
        !            15:        register struct a {
        !            16:                int     anom;
        !            17:        } *uap;
        !            18:        register struct proc *rp = u.u_procp;
        !            19:        int oanom = rp->p_flag & SUANOM;
        !            20:        register struct pte *pte;
        !            21:        register struct cmap *c;
        !            22:        register int i;
        !            23: 
        !            24:        uap = (struct a *)u.u_ap;
        !            25:        rp->p_flag &= ~(SSEQL|SUANOM);
        !            26:        switch (uap->anom) {
        !            27: 
        !            28:        case VA_ANOM:
        !            29:                rp->p_flag |= SUANOM;
        !            30:                break;
        !            31: 
        !            32:        case VA_SEQL:
        !            33:                rp->p_flag |= SSEQL;
        !            34:                break;
        !            35:        }
        !            36:        if (both || (oanom && (rp->p_flag & SUANOM) == 0)) {
        !            37:                for (i = 0; i < rp->p_dsize; i += CLSIZE) {
        !            38:                        pte = dptopte(rp, i);
        !            39:                        if (pte->pg_v) {
        !            40:                                c = &cmap[pgtocm(pte->pg_pfnum)];
        !            41:                                if (c->c_lock)
        !            42:                                        continue;
        !            43:                                pte->pg_v = 0;
        !            44:                                if (anycl(pte, pg_m))
        !            45:                                        pte->pg_m = 1;
        !            46:                                distcl(pte);
        !            47:                        }
        !            48:                }
        !            49:                mtpr(TBIA, 0);
        !            50:        }
        !            51: }
        !            52: 
        !            53: vtimes()
        !            54: {
        !            55:        register struct a {
        !            56:                struct  vtimes *par_vm;
        !            57:                struct  vtimes *ch_vm;
        !            58:        } *uap = (struct a *)u.u_ap;
        !            59:        if (uap->par_vm) {
        !            60:                if (copyout((caddr_t)&u.u_vm, (caddr_t)uap->par_vm,
        !            61:                    sizeof(struct vtimes)) < 0)
        !            62:                        u.u_error = EFAULT;
        !            63:        }
        !            64:        if (uap->ch_vm == 0)
        !            65:                return;
        !            66:        if (copyout((caddr_t)&u.u_cvm, (caddr_t)uap->ch_vm,
        !            67:            sizeof(struct vtimes)) < 0)
        !            68:                u.u_error = EFAULT;
        !            69: }
        !            70: 
        !            71: vmsadd(vp, wp)
        !            72:        register struct vtimes *vp, *wp;
        !            73: {
        !            74: 
        !            75:        vp->vm_utime += wp->vm_utime;
        !            76:        vp->vm_stime += wp->vm_stime;
        !            77:        vp->vm_nswap += wp->vm_nswap;
        !            78:        vp->vm_idsrss += wp->vm_idsrss;
        !            79:        vp->vm_ixrss += wp->vm_ixrss;
        !            80:        if (vp->vm_maxrss < wp->vm_maxrss)
        !            81:                vp->vm_maxrss = wp->vm_maxrss;
        !            82:        vp->vm_majflt += wp->vm_majflt;
        !            83:        vp->vm_minflt += wp->vm_minflt;
        !            84:        vp->vm_inblk += wp->vm_inblk;
        !            85:        vp->vm_oublk += wp->vm_oublk;
        !            86: }
        !            87: 
        !            88: /*
        !            89:  * Affect per-process limits.
        !            90:  * To just return old limit, specify negative new limit.
        !            91:  */
        !            92: vlimit()
        !            93: {
        !            94:        register struct a {
        !            95:                unsigned which;
        !            96:                int     limit;
        !            97:        } *uap;
        !            98: 
        !            99:        uap = (struct a *)u.u_ap;
        !           100:        if (uap->which > NLIMITS) {
        !           101:                u.u_error = EINVAL;
        !           102:                return;
        !           103:        }
        !           104:        u.u_r.r_val1 = u.u_limit[uap->which];
        !           105:        if (uap->limit < 0)
        !           106:                return;
        !           107:        switch (uap->which) {
        !           108: 
        !           109:        case LIM_DATA:
        !           110:                if (uap->limit > ctob(maxdsize))
        !           111:                        uap->limit = ctob(maxdsize);
        !           112:                break;
        !           113: 
        !           114:        case LIM_TEXT:
        !           115:                if (uap->limit > ctob(maxtsize))
        !           116:                        uap->limit = ctob(maxtsize);
        !           117:                break;
        !           118: 
        !           119:        case LIM_STACK:
        !           120:                if (uap->limit > ctob(maxssize))
        !           121:                        uap->limit = ctob(maxssize);
        !           122:                break;
        !           123:        }
        !           124:        if (u.u_limit[LIM_NORAISE] && uap->limit > u.u_limit[uap->which] &&
        !           125:            !suser()) {
        !           126:                u.u_error = EACCES;
        !           127:                return;
        !           128:        }
        !           129:        u.u_limit[uap->which] = uap->limit;
        !           130:        if (uap->which == LIM_MAXRSS)
        !           131:                u.u_procp->p_maxrss = uap->limit/NBPG;
        !           132: }

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