![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to proca.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv10no / sys / fs|
Return to proca.c CVS log | Up to [Research Unix] / researchv10no / sys / fs |
1.1 ! root 1: #include "sys/param.h" ! 2: #include "sys/systm.h" ! 3: #include "sys/inode.h" ! 4: #include "sys/dir.h" ! 5: #include "sys/user.h" ! 6: #include "sys/psl.h" ! 7: #include "sys/stat.h" ! 8: #include "sys/buf.h" ! 9: #include "sys/pte.h" ! 10: #include "sys/cmap.h" ! 11: #include "sys/mtpr.h" ! 12: #include "sys/vmparam.h" ! 13: #include "sys/vmmac.h" ! 14: #include "sys/proc.h" ! 15: #include "sys/text.h" ! 16: #include "sys/file.h" ! 17: #include "sys/reg.h" ! 18: #include "sys/pioctl.h" ! 19: #include "sys/conf.h" ! 20: ! 21: /* I/O via /proc returns EBUSY if any of these bits are set in p_flag: */ ! 22: ! 23: #define SPRBUSY (SLOCK|SPAGE|SKEEP|SWEXIT|SPROCIO) ! 24: ! 25: #define SYSADR ((caddr_t)0x80000000) /* virtual address of system seg. */ ! 26: #define SYSP btop(0x80000000) /* virtual page no. of system seg. */ ! 27: ! 28: /* <text page no.> + P1OFF(p) == <stack page no.> of same location */ ! 29: ! 30: #define P1OFF(p) (SYSP - (p)->p_szpt*NPTEPG) ! 31: ! 32: #define TEXT 0 ! 33: #define DATA 1 ! 34: #define STACK 2 ! 35: #define USERAREA 3 ! 36: ! 37: #define min(a,b) ((a) <= (b) ? (a) : (b)) ! 38: ! 39: /* inumber to pid */ ! 40: #define PRMAGIC 64 ! 41: ! 42: #define PROCDEV (dev_t)0 ! 43: #define PRROOT 2 ! 44: ! 45: struct proc *prpidlock, *prpidwant, *pritop(); ! 46: ! 47: struct pte *Prbufmap; char *priobuf; ! 48: struct pte *Prusrmap; struct user *prusrutl; ! 49: struct pte *prclmap(); ! 50: ! 51: int prput(), prread(), prwrite(), prstat(); ! 52: int prmount(), prioctl(), prnami(); ! 53: ! 54: struct fstypsw prfs = ! 55: fsinit(prput, nulldev, prread, prwrite, nulldev, prstat, ! 56: prnami, prmount, prioctl, nullopen, nodev); ! 57: ! 58: prput(ip) ! 59: struct inode *ip; ! 60: { struct proc *p; ! 61: if(ip->i_number == PRROOT) ! 62: return; ! 63: if ((p = pritop(ip)) == NULL) ! 64: return; ! 65: p->p_trace = 0; ! 66: } ! 67: ! 68: #define SDSIZ sizeof(struct direct) ! 69: ! 70: prread(ip) ! 71: struct inode *ip; ! 72: { ! 73: static struct direct dotbuf[] = { ! 74: { PRROOT, "."}, ! 75: { PRROOT, ".."} ! 76: }; ! 77: struct direct dirbuf; ! 78: register int i, n, j; ! 79: int minproc, maxproc, modoff; ! 80: struct proc *p; ! 81: ! 82: if (ip->i_number == PRROOT) { /* fake up . .. and the proc inodes */ ! 83: if (Lsign(u.u_offset) < 0 || Ltol(u.u_offset) >= ip->i_size || ! 84: u.u_count <= 0) ! 85: return; ! 86: if (Ltol(u.u_offset) < 2*SDSIZ) { ! 87: iomove((caddr_t)dotbuf + Ltol(u.u_offset), ! 88: min(u.u_count, 2*SDSIZ - Ltol(u.u_offset)), B_READ); ! 89: if (u.u_count <= 0 || u.u_error) ! 90: return; ! 91: } ! 92: minproc = (Ltol(u.u_offset) - 2*SDSIZ)/SDSIZ; ! 93: maxproc = (Ltol(u.u_offset) + u.u_count - 1)/SDSIZ; ! 94: modoff = Ltol(u.u_offset) % SDSIZ; ! 95: for (j = 0; j < DIRSIZ; j++) ! 96: dirbuf.d_name[j] = 0; ! 97: for (i=minproc; i<min(maxproc,proccnt); i++) { ! 98: if (proc[i].p_stat == 0) ! 99: dirbuf.d_ino = 0; ! 100: else { ! 101: n = proc[i].p_pid; ! 102: dirbuf.d_ino = n + PRMAGIC; ! 103: for (j = 4; j >= 0; j--) ! 104: dirbuf.d_name[j] = n%10 + '0', n /= 10; ! 105: } ! 106: iomove((caddr_t)&dirbuf + modoff, ! 107: min(u.u_count, SDSIZ - modoff), B_READ); ! 108: if (u.u_count <= 0 || u.u_error) ! 109: return; ! 110: modoff = 0; ! 111: } ! 112: } else if ((p = pritop(ip)) != NULL) { ! 113: if (prlock(p)) ! 114: return; ! 115: prusrio(p, B_READ); ! 116: prunlock(p); ! 117: } ! 118: } ! 119: ! 120: prwrite(ip) ! 121: struct inode *ip; ! 122: { ! 123: register struct proc *p; ! 124: if (ip->i_number == PRROOT) { ! 125: u.u_error = EISDIR; ! 126: } else if ((p = pritop(ip)) != NULL) { ! 127: if (prlock(p)) ! 128: return; ! 129: prusrio(p, B_WRITE); ! 130: prunlock(p); ! 131: } ! 132: } ! 133: ! 134: prstat(ip, ub) ! 135: struct inode *ip; ! 136: struct stat *ub; ! 137: { struct stat ds; struct proc *p = (struct proc *)0; ! 138: if(ip->i_number == PRROOT || (p = pritop(ip)) != NULL) { ! 139: ds.st_dev = -1; /* who knows */ ! 140: ds.st_ino = ip->i_number; ! 141: ds.st_mode = ip->i_mode; ! 142: ds.st_nlink = ip->i_nlink; ! 143: ds.st_uid = ip->i_uid; ! 144: ds.st_gid = ip->i_gid; ! 145: ds.st_rdev = -1; ! 146: if (p) ip->i_size = ! 147: (int)ptob(p->p_tsize+p->p_dsize+p->p_ssize+UPAGES); ! 148: ds.st_size = ip->i_size; ! 149: ds.st_atime = ds.st_mtime = ds.st_ctime = time; ! 150: if(copyout((caddr_t)&ds, (caddr_t)ub, sizeof(ds)) < 0) ! 151: u.u_error = EFAULT; ! 152: } ! 153: } ! 154: ! 155: prnami(p, flagp, follow) ! 156: register struct nx *p; ! 157: struct argnamei *flagp; ! 158: { ! 159: register struct inode *dp; ! 160: register char *cp; ! 161: register int n; ! 162: ! 163: cp = p->cp; ! 164: dp = p->dp; ! 165: if ((dp->i_mode & IFMT) != IFDIR) { ! 166: u.u_error = ENOTDIR; ! 167: goto error; ! 168: } ! 169: if (access(dp, IEXEC)) ! 170: goto error; ! 171: if (flagp->flag != NI_SEARCH) { ! 172: u.u_error = EACCES; ! 173: goto error; ! 174: } ! 175: rootloop: ! 176: if (cp[0] == 0) /* "" == root */ ! 177: return (0); ! 178: if (cp[0] == '.') { ! 179: if (cp[1] == 0) /* "." */ ! 180: return (0); ! 181: if (cp[1] == '/') { /* "./" ... */ ! 182: cp += 2; ! 183: p->cp = cp; ! 184: goto rootloop; ! 185: } ! 186: if (cp[1] == '.' && (cp[2] == 0 || cp[2] == '/')) { /* ".." */ ! 187: p->dp = dp->i_mpoint; ! 188: iput(dp); ! 189: plock(p->dp); ! 190: p->dp->i_count++; ! 191: return (1); /* cp still points to ".." */ ! 192: } ! 193: u.u_error = ENOENT; /* ".somethingelse" */ ! 194: goto error; ! 195: } ! 196: n = 0; ! 197: while (*cp >= '0' && *cp <= '9') { ! 198: n *= 10; ! 199: n += *cp++ - '0'; ! 200: } ! 201: if (*cp) { /* non-digit, or /proc/123/... */ ! 202: u.u_error = ENOENT; ! 203: goto error; ! 204: } ! 205: p->dp = iget(dp, PROCDEV, n + PRMAGIC); ! 206: if (p->dp == NULL) ! 207: goto error; ! 208: if (p->dp->i_count == 1 && prfillin(p->dp)) ! 209: goto error; ! 210: iput(dp); ! 211: return (0); ! 212: ! 213: error: ! 214: p->dp = NULL; ! 215: iput(dp); ! 216: return (0); ! 217: } ! 218: ! 219: prfillin(ip) ! 220: register struct inode *ip; ! 221: { ! 222: register struct proc *p; ! 223: register int n; ! 224: ! 225: ip->i_un.i_proc = NULL; /* safety */ ! 226: n = ip->i_number - PRMAGIC; ! 227: for (p = proc; p < procNPROC; p++) ! 228: if (p->p_stat && p->p_pid == n) ! 229: break; ! 230: if (p == procNPROC || p->p_stat == SZOMB || p->p_trace) { ! 231: iput(ip); ! 232: u.u_error = ENOENT; ! 233: return (1); ! 234: } ! 235: p->p_trace = ip; ! 236: if (p->p_textp && p->p_textp->x_iptr && access(p->p_textp->x_iptr, IREAD)) ! 237: ip->i_mode = IFREG; /* regular, no permissions */ ! 238: else ! 239: ip->i_mode = IFREG | 0600; /* regular, r/w only by owner */ ! 240: ip->i_nlink = 1; ! 241: ip->i_uid = p->p_uid; ! 242: ip->i_gid = 1; /* who cares */ ! 243: ip->i_size = (int)ptob(p->p_tsize+p->p_dsize+p->p_ssize+UPAGES); ! 244: ip->i_un.i_proc = p; ! 245: ip->i_un.i_sigmask = 0; /* signal trace mask */ ! 246: return (0); ! 247: } ! 248: ! 249: prmount(sip, ip, flag, mnt, fstyp) ! 250: struct inode *sip, *ip; ! 251: { ! 252: if (!suser()) ! 253: return; ! 254: if (mnt) ! 255: pron(sip, ip, flag, fstyp); ! 256: else ! 257: proff(ip, fstyp); ! 258: } ! 259: ! 260: pron(sip, ip, flag, fstyp) ! 261: struct inode *sip; ! 262: register struct inode *ip; ! 263: { ! 264: register struct inode *rip; ! 265: struct inode pi; ! 266: ! 267: if (ip->i_fstyp == fstyp) { ! 268: u.u_error = EBUSY; ! 269: return; ! 270: } ! 271: pi.i_fstyp = fstyp; ! 272: pi.i_mpoint = NULL; ! 273: if ((rip = iget(&pi, PROCDEV, (ino_t)PRROOT)) == NULL) ! 274: return; ! 275: if (rip->i_count != 1) { /* already mounted */ ! 276: iput(rip); ! 277: u.u_error = EBUSY; ! 278: return; ! 279: } ! 280: rip->i_mpoint = ip; ! 281: rip->i_mode = IFDIR|0555; ! 282: rip->i_nlink = 2; ! 283: rip->i_uid = rip->i_gid = 0; ! 284: rip->i_size = (proccnt+2) * sizeof(struct direct); ! 285: prele(rip); ! 286: ip->i_mroot = rip; ! 287: ip->i_count++; ! 288: } ! 289: ! 290: proff(mip, fstyp) ! 291: struct inode *mip; ! 292: { ! 293: struct inode *rip; ! 294: ! 295: plock(mip); ! 296: rip = mip->i_mroot; ! 297: mip->i_mroot = NULL; ! 298: iput(mip); ! 299: plock(rip); ! 300: iput(rip); ! 301: } ! 302: ! 303: /* special tracing stuff */ ! 304: prioctl(ip, cmd, cmaddr) ! 305: struct inode *ip; ! 306: caddr_t cmaddr; ! 307: { ! 308: register struct proc *p; struct text *xp; struct inode *ixp; ! 309: int n; /* mostly for integer arguments */ ! 310: ! 311: if ((p = pritop(ip)) == NULL) ! 312: return; ! 313: switch (cmd) { ! 314: default: ! 315: u.u_error = ENOTTY; ! 316: return; ! 317: ! 318: case PIOCGETPR: /* read struct proc */ ! 319: if (copyout((char *)p, cmaddr, sizeof(struct proc))) ! 320: u.u_error = EFAULT; ! 321: return; ! 322: ! 323: case PIOCOPENT: /* open text file for reading */ ! 324: if ((xp = p->p_textp) && (ixp = xp->x_iptr)) { ! 325: plock(ixp); ! 326: ixp->i_count++; ! 327: open1(ixp, FREAD, 0); /* fairly magic linkage */ ! 328: } else ! 329: u.u_error = ENOENT; ! 330: return; ! 331: ! 332: case PIOCSTOP: /* send STOP signal and... */ ! 333: if (p->p_stat != SSTOP) ! 334: psignal(p, SIGSTOP); ! 335: /* fall through */ ! 336: case PIOCWSTOP: /* wait for process to STOP */ ! 337: if (p->p_stat != SSTOP) ! 338: tsleep((caddr_t)p->p_trace, PZERO+1, 0); ! 339: if (p->p_pid != (ip->i_number - PRMAGIC) ! 340: || p->p_stat == SZOMB) ! 341: u.u_error = ENOENT; ! 342: else if (p->p_stat != SSTOP) ! 343: u.u_error = EINTR; ! 344: return; ! 345: ! 346: case PIOCRUN: /* make process runnable */ ! 347: if (p->p_stat == SSTOP) ! 348: setrun(p); ! 349: return; ! 350: ! 351: case PIOCSMASK: /* set signal trace mask */ ! 352: if (copyin(cmaddr, (caddr_t)&ip->i_un.i_sigmask, sizeof(long))) { ! 353: u.u_error = EFAULT; ! 354: return; ! 355: } ! 356: if (ip->i_un.i_sigmask) ! 357: p->p_flag |= (STRC|SPROCTR); ! 358: else ! 359: p->p_flag &= ~(STRC|SPROCTR); ! 360: return; ! 361: ! 362: case PIOCCSIG: /* clear current signal */ ! 363: p->p_cursig = 0; ! 364: return; ! 365: ! 366: case PIOCSSIG: /* set current signal */ ! 367: if (p->p_stat != SSTOP) ! 368: u.u_error = EBUSY; ! 369: else if (copyin(cmaddr, (caddr_t)&n, sizeof(n))) ! 370: u.u_error = EFAULT; ! 371: else if ((unsigned)n > NSIG) ! 372: u.u_error = EINVAL; ! 373: else ! 374: p->p_cursig = n; ! 375: return; ! 376: ! 377: case PIOCKILL: /* send signal */ ! 378: if (copyin(cmaddr, (caddr_t)&n, sizeof(n))) ! 379: u.u_error = EFAULT; ! 380: else if ((unsigned)n > NSIG) ! 381: u.u_error = EINVAL; ! 382: else ! 383: psignal(p, n); ! 384: return; ! 385: ! 386: case PIOCSEXEC: /* stop on exec */ ! 387: p->p_flag |= SSEXEC; ! 388: return; ! 389: ! 390: case PIOCREXEC: /* run on exec */ ! 391: p->p_flag &= ~SSEXEC; ! 392: return; ! 393: ! 394: case PIOCNICE: /* set nice priority */ ! 395: if (copyin(cmaddr, (caddr_t)&n, sizeof(n))) { ! 396: u.u_error = EFAULT; ! 397: return; ! 398: } ! 399: n += p->p_nice; ! 400: if (n >= 2*NZERO) ! 401: n = 2*NZERO -1; ! 402: if (n < 0) ! 403: n = 0; ! 404: if (n < p->p_nice && !suser()) ! 405: return; ! 406: p->p_nice = n; ! 407: (void) setpri(p); ! 408: return; ! 409: } ! 410: } ! 411: ! 412: /* Lock the process p. */ ! 413: ! 414: prlock(p) ! 415: register struct proc *p; ! 416: { ! 417: int s; ! 418: ! 419: if (p != u.u_procp) { ! 420: waitloop: ! 421: if (prpidlock == p) { /* wait if p has the interlock */ ! 422: prpidwant = u.u_procp; ! 423: if (tsleep((caddr_t)&prpidlock, PZERO+1, 0) == TS_SIG) ! 424: return (u.u_error = EINTR); ! 425: goto waitloop; ! 426: } ! 427: if (p->p_flag & SPAGE) { /* wait if p is paging */ ! 428: p->p_flag |= SPROCWT; ! 429: if (tsleep((caddr_t)&(p->p_stat), PZERO+1, 0) == TS_SIG) ! 430: return (u.u_error = EINTR); ! 431: goto waitloop; ! 432: } ! 433: ! 434: s = spl6(); /* keep clock out */ ! 435: ! 436: if (p->p_flag&SPRBUSY || (p->p_stat != SSLEEP && ! 437: p->p_stat != SRUN && p->p_stat != SSTOP)) { ! 438: splx(s); ! 439: return (u.u_error = EBUSY); ! 440: } ! 441: if (p->p_flag&SLOAD && p->p_stat == SRUN) ! 442: remrq(p); /* he's now invisible to swtch() */ ! 443: ! 444: /* interlock; also causes swapin, inhibits swapout, setrq, remrq */ ! 445: ! 446: p->p_flag |= SPROCIO; ! 447: ! 448: splx(s); /* now do your worst, we don't care */ ! 449: } ! 450: u.u_procp->p_flag |= SKEEP; /* if we get swapped, could deadlock */ ! 451: ! 452: while ((p->p_flag&SLOAD) == 0) { ! 453: /* sched will see SPROCIO, swap him in, and signal us */ ! 454: if (tsleep((caddr_t)&p->p_addr, PZERO+1, 0) == TS_SIG) { ! 455: prunlock(p); ! 456: return (u.u_error = EINTR); ! 457: } ! 458: } ! 459: while (prpidlock) { ! 460: prpidwant = u.u_procp; ! 461: if (tsleep((caddr_t)&prpidlock, PZERO+1, 0) == TS_SIG) { ! 462: prunlock(p); ! 463: return (u.u_error = EINTR); ! 464: } ! 465: } ! 466: prpidlock = u.u_procp; ! 467: /* now map his user area into kernel space */ ! 468: uaccess(p, Prusrmap, prusrutl); ! 469: ! 470: return (u.u_error = 0); ! 471: } ! 472: ! 473: /* Undo prlock. */ ! 474: ! 475: prunlock(p) ! 476: register struct proc *p; ! 477: { ! 478: int s; ! 479: ! 480: u.u_procp->p_flag &= ~SKEEP; ! 481: ! 482: if (p != u.u_procp) { ! 483: s = spl6(); /* keep clock out during process state change */ ! 484: p->p_flag &= ~SPROCIO; ! 485: if (p->p_flag&SLOAD && p->p_stat == SRUN) ! 486: setrq(p); /* visible again to swtch() */ ! 487: splx(s); ! 488: } ! 489: if (prpidlock == u.u_procp) { ! 490: prpidlock = 0; ! 491: if (prpidwant) { ! 492: prpidwant = 0; ! 493: wakeup((caddr_t)&prpidlock); ! 494: } ! 495: } ! 496: return 0; ! 497: } ! 498: ! 499: /* Read/write from/to process p. */ ! 500: ! 501: #define REGADR(i) ((caddr_t)(regbase + i)) ! 502: #define SEEKADR ((caddr_t)Ltol(u.u_offset)) ! 503: ! 504: prusrio(p, flag) ! 505: register struct proc *p; int flag; ! 506: { ! 507: register int *regbase; ! 508: caddr_t maxadr; int segment, resid; ! 509: ! 510: u.u_error = 0; ! 511: if ((u_long)SEEKADR >= (u_long)(maxadr = SYSADR)) ! 512: u.u_error = EIO; ! 513: else if (SEEKADR >= (caddr_t)USRSTACK) ! 514: segment = USERAREA; ! 515: else if (SEEKADR >= (maxadr = (caddr_t)USRSTACK) - (int)ptob(p->p_ssize)) ! 516: segment = STACK; ! 517: else if (SEEKADR < (maxadr = ptob(p->p_tsize))) ! 518: segment = TEXT; ! 519: else if (SEEKADR < (maxadr = ptob(p->p_tsize+p->p_dsize))) ! 520: segment = DATA; ! 521: else ! 522: u.u_error = EIO; ! 523: if (p->p_flag & SSYS && segment != USERAREA) /* too conservative? */ ! 524: u.u_error = EIO; ! 525: ! 526: if (u.u_error) return; ! 527: ! 528: if ((flag & B_READ) == 0) switch(segment) { ! 529: case TEXT: ! 530: prxdup(p); ! 531: break; ! 532: case USERAREA: ! 533: regbase = prusrutl->u_ar0; ! 534: if (SEEKADR < REGADR(AP) || ! 535: (u_long)SEEKADR >= (u_long)(maxadr = REGADR(PS+1))) ! 536: u.u_error = EIO; ! 537: else if (SEEKADR >= REGADR(PC)) ; ! 538: else if (SEEKADR < (maxadr = REGADR(FP+1))) ; ! 539: else if (SEEKADR < REGADR(R0)) ! 540: u.u_error = EIO; ! 541: else if (SEEKADR < (maxadr = REGADR(R11+1))) ; ! 542: else if (SEEKADR < REGADR(SP) || SEEKADR >= (maxadr = REGADR(SP+1))) ! 543: u.u_error = EIO; ! 544: regbase = (int *)((u_long)prusrutl + (u_long)regbase - (u_long)&u); ! 545: if ((regbase[PS]&PSL_USERSET) != PSL_USERSET || ! 546: (regbase[PS]&PSL_USERCLR) != 0) ! 547: u.u_error = EBUSY; ! 548: break; ! 549: } ! 550: ! 551: if (u.u_error) return; ! 552: ! 553: resid = u.u_count; ! 554: if ((u_long)(Ltol(u.u_offset) + u.u_count) >= (u_long)maxadr) ! 555: u.u_count = maxadr - (caddr_t)Ltol(u.u_offset); ! 556: resid -= u.u_count; ! 557: ! 558: if (segment == USERAREA) { ! 559: iomove((caddr_t)prusrutl + ((u_long)Ltol(u.u_offset) - (u_long)&u), ! 560: u.u_count, flag); ! 561: if ((flag & B_READ) == 0) { ! 562: regbase[PS] |= PSL_USERSET; ! 563: regbase[PS] &= ~PSL_USERCLR; ! 564: } ! 565: } else ! 566: priomove(p, flag); ! 567: ! 568: u.u_count += resid; ! 569: } ! 570: ! 571: /* Move data between the object process and us. */ ! 572: ! 573: priomove(p, flag) ! 574: register struct proc *p; ! 575: { ! 576: register struct pte *pte; ! 577: register clofset, clcount; ! 578: int waslocked; ! 579: ! 580: while (u.u_count > 0 && u.u_error == 0) { ! 581: pte = prclmap(p, (caddr_t)Ltol(u.u_offset), &waslocked); ! 582: clofset = Ltol(u.u_offset) & CLOFSET; ! 583: clcount = min(u.u_count, CLSIZE*NBPG - clofset); ! 584: iomove(&priobuf[clofset], clcount, flag); ! 585: prclunmap(pte, flag | waslocked); ! 586: } ! 587: } ! 588: ! 589: /* Map and lock a cluster from process into system space. */ ! 590: ! 591: struct pte * ! 592: prclmap(p, vaddr, flagp) ! 593: register struct proc *p; ! 594: register caddr_t vaddr; ! 595: int *flagp; ! 596: { ! 597: register i; ! 598: register struct pte *pte; ! 599: i = clbase(btop(vaddr)); ! 600: if (isassv(p, i)) ! 601: i -= P1OFF(p); ! 602: pte = p->p_p0br + i; ! 603: ! 604: *flagp = 0; ! 605: if (pte->pg_v) { ! 606: if (cmap[pgtocm(pte->pg_pfnum)].c_lock) ! 607: *flagp = B_PHYS; ! 608: else ! 609: mlock(pte->pg_pfnum); ! 610: } else { ! 611: p->p_flag |= SDLYU; ! 612: pagein(vaddr, prusrutl); ! 613: p->p_flag &= ~SDLYU; ! 614: if (!pte->pg_v) ! 615: panic("prclmap: pte not valid after pagein"); ! 616: } ! 617: for (i=0; i<CLSIZE; i++) { ! 618: *(int *)(Prbufmap + i) = PG_V | PG_KW | (pte->pg_pfnum + i); ! 619: mtpr(TBIS, &priobuf[i*NBPG]); ! 620: } ! 621: return pte; ! 622: } ! 623: ! 624: /* Release a cluster, updating its pte's. */ ! 625: ! 626: prclunmap(pte, flag) ! 627: register struct pte *pte; ! 628: { ! 629: register i; ! 630: if ((flag & B_PHYS) == 0) ! 631: munlock(pte->pg_pfnum); ! 632: if ((flag & B_READ) == 0) /* Write to device writes memory */ ! 633: for (i=0; i<CLSIZE; i++) ! 634: (pte+i)->pg_m = 1; ! 635: } ! 636: ! 637: /* Prepare the process' text segment for writing, duplicating it if necessary. */ ! 638: ! 639: prxdup(p) ! 640: register struct proc *p; ! 641: { ! 642: register struct text *xp, *pxp; ! 643: ! 644: if ((pxp = p->p_textp) == 0) ! 645: return 0; ! 646: if (!(pxp->x_flag&XPAGI) && pxp->x_count == 1) { ! 647: pxp->x_flag |= XTRC|XWRIT; ! 648: return 0; ! 649: } ! 650: if (pxp->x_flag&XTRC) ! 651: panic("prxdup"); ! 652: ! 653: for (xp = text; xp < textNTEXT && xp->x_iptr; xp++) ! 654: /* void */ ; ! 655: if (xp >= textNTEXT) ! 656: return (u.u_error = ENOSPC); ! 657: ! 658: xp->x_flag = XLOCK|XTRC|XLOAD; ! 659: xp->x_size = pxp->x_size; ! 660: if (vsxalloc(xp) == NULL) ! 661: return (u.u_error = ENOSPC); ! 662: ! 663: xp->x_count = 1; ! 664: xp->x_ccount = 0; ! 665: xp->x_rssize = 0; ! 666: (xp->x_iptr = pxp->x_iptr)->i_count++; ! 667: ! 668: xlock(pxp); ! 669: --pxp->x_count; ! 670: pxp->x_flag &= ~XLOCK; ! 671: xccdec(pxp, p); ! 672: ! 673: p->p_textp = xp; ! 674: xlink(p); ! 675: p->p_flag &= ~SPAGI; ! 676: ! 677: prxread(p, prusrutl); ! 678: ! 679: xp->x_flag |= XWRIT; ! 680: xp->x_flag &= ~XLOAD; ! 681: xunlock(xp); ! 682: return u.u_error; ! 683: } ! 684: ! 685: prxread(p, up) ! 686: register struct proc *p; ! 687: struct user *up; ! 688: { ! 689: register struct inode *ip = p->p_textp->x_iptr; ! 690: register count; register struct pte *pte; ! 691: register caddr_t vaddr = 0; int waslocked; ! 692: ! 693: caddr_t ubase = u.u_base; unsigned int ucount = u.u_count; ! 694: off_t uoffset = Ltol(u.u_offset); ! 695: ! 696: plock(ip); ! 697: ip->i_flag |= ITEXT; ! 698: ! 699: count = up->u_exdata.ux_tsize; ! 700: if (up->u_exdata.ux_mag == 0413) /* 0413 on 4k file sys */ ! 701: u.u_offset = ltoL(BSIZE(0)); ! 702: else ! 703: u.u_offset = ltoL(sizeof(u.u_exdata)); ! 704: ! 705: u.u_segflg = SEGSYS; ! 706: u.u_count = 0; ! 707: while (count > 0 && u.u_count == 0) { ! 708: pte = prclmap(p, vaddr, &waslocked); ! 709: u.u_base = (caddr_t)priobuf; ! 710: count -= u.u_count = min(count, CLSIZE*NBPG); ! 711: vaddr += u.u_count; ! 712: readi(ip); ! 713: prclunmap(pte, B_WRITE | waslocked); ! 714: } ! 715: prele(ip); ! 716: ! 717: u.u_base = ubase; u.u_count = ucount; ! 718: u.u_offset = ltoL(uoffset); u.u_segflg = SEGUDATA; ! 719: ! 720: return (count ? (u.u_error = EIO) : 0); ! 721: } ! 722: ! 723: struct proc * ! 724: pritop(ip) ! 725: struct inode *ip; ! 726: { ! 727: register struct proc *p; ! 728: ! 729: if ((p = ip->i_un.i_proc) == NULL ! 730: || p->p_pid != ip->i_number - PRMAGIC ! 731: || p->p_stat == 0 || p->p_stat == SZOMB) { ! 732: u.u_error = ENOENT; /* should really be ENXIO */ ! 733: return (NULL); ! 734: } ! 735: return (p); ! 736: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.