![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to seg.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [MW Coherent from dump] / coherent / d / PS2_KERNEL / coh.286|
Return to seg.c CVS log | Up to [MW Coherent from dump] / coherent / d / PS2_KERNEL / coh.286 |
1.1 ! root 1: /* $Header: /kernel/kersrc/coh.286/RCS/seg.c,v 1.1 92/07/17 15:18:10 bin Exp Locker: bin $ */ ! 2: /* (lgl- ! 3: * The information contained herein is a trade secret of Mark Williams ! 4: * Company, and is confidential information. It is provided under a ! 5: * license agreement, and may be copied or disclosed only under the ! 6: * terms of that agreement. Any reproduction or disclosure of this ! 7: * material without the express written authorization of Mark Williams ! 8: * Company or persuant to the license agreement is unlawful. ! 9: * ! 10: * COHERENT Version 2.3.37 ! 11: * Copyright (c) 1982, 1983, 1984. ! 12: * An unpublished work by Mark Williams Company, Chicago. ! 13: * All rights reserved. ! 14: -lgl) */ ! 15: /* ! 16: * Coherent. ! 17: * Segment manipulation. ! 18: * ! 19: * $Log: seg.c,v $ ! 20: * Revision 1.1 92/07/17 15:18:10 bin ! 21: * Initial revision ! 22: * ! 23: * Revision 1.1 88/03/24 16:14:20 src ! 24: * Initial revision ! 25: * ! 26: * 88/02/26 Allan Cornish /usr/src/sys/coh/seg.c ! 27: * swapio() now avoids 64 Kbyte page [dma] straddles. ! 28: * ! 29: * 88/01/22 Allan Cornish /usr/src/sys/coh/seg.c ! 30: * salloc() now invokes krunch(1000) if initial allocation fails. ! 31: * sfree() now invokes krunch(0). ! 32: * ! 33: * 88/01/21 Allan Cornish /usr/src/sys/coh/seg.c ! 34: * sfree() modified to eliminate critical race on ref cnts and segment gate. ! 35: * segfinm() now properly maintains segment reference counts. ! 36: * ! 37: * 87/11/13 Allan Cornish /usr/src/sys/coh/seg.c ! 38: * Support for protected mode segmentation added. ! 39: */ ! 40: #include <sys/coherent.h> ! 41: #include <sys/buf.h> ! 42: #include <errno.h> ! 43: #include <sys/ino.h> ! 44: #include <sys/inode.h> ! 45: #include <sys/proc.h> ! 46: #include <sys/sched.h> ! 47: #include <sys/seg.h> ! 48: ! 49: /* ! 50: * Initialisation code. ! 51: */ ! 52: seginit() ! 53: { ! 54: /* ! 55: * Create empty circular-list of memory segments. ! 56: */ ! 57: segmq.s_forw = &segmq; ! 58: segmq.s_back = &segmq; ! 59: ! 60: /* ! 61: * Create empty circular-list of disk segments. ! 62: */ ! 63: segdq.s_forw = &segdq; ! 64: segdq.s_back = &segdq; ! 65: ! 66: if ( holebot != holetop ) { ! 67: /* ! 68: * Define the I/O mem hole between low memory and extended mem. ! 69: * NOTE: Setting lrefc to urefc+1 stopx segment from moving. ! 70: */ ! 71: segiom.s_paddr = holebot; ! 72: segiom.s_size = holetop - holebot; ! 73: segiom.s_flags = SFCORE | SFSYST; ! 74: segiom.s_urefc = 1; ! 75: segiom.s_lrefc = 2; ! 76: ! 77: /* ! 78: * Insert I/O memory segment into memory list. ! 79: */ ! 80: segiom.s_forw = &segmq; ! 81: segiom.s_back = &segmq; ! 82: segmq.s_forw = &segiom; ! 83: segmq.s_back = &segiom; ! 84: } ! 85: } ! 86: ! 87: /* ! 88: * Given an inode, `ip', and flags, `ff', describing a segment associated ! 89: * with the inode, see if the segment already exists and if so, return a ! 90: * copy. If the segment does not exists, allocate the segment having size ! 91: * `ss', and read the segment using the inode at seek offset `dq' with a ! 92: * size of `ds'. ! 93: */ ! 94: SEG * ! 95: ssalloc(rp, ip, ff, ss, dq, ds) ! 96: int *rp; ! 97: register INODE *ip; ! 98: fsize_t ss; ! 99: fsize_t dq; ! 100: fsize_t ds; ! 101: { ! 102: register SEG *sp; ! 103: register int f; ! 104: ! 105: *rp = -1; ! 106: if (ss == 0) { ! 107: *rp = 1; ! 108: return (NULL); ! 109: } ! 110: lock(seglink); ! 111: f = ff & (SFSHRX|SFTEXT); ! 112: ! 113: /* ! 114: * Look for the segment in the memory queue. ! 115: */ ! 116: for (sp=segmq.s_forw; sp!=&segmq; sp=sp->s_forw) { ! 117: if (sp->s_ip==ip && (sp->s_flags&(SFSHRX|SFTEXT))==f) { ! 118: unlock(seglink); ! 119: if ((sp = segdupl(sp)) != NULL) { ! 120: segfinm(sp); ! 121: *rp = 1; ! 122: } ! 123: return (sp); ! 124: } ! 125: } ! 126: ! 127: /* ! 128: * Look for the segment on the disk queue. ! 129: */ ! 130: for (sp=segdq.s_forw; sp!=&segdq; sp=sp->s_forw) { ! 131: if (sp->s_ip==ip && (sp->s_flags&(SFSHRX|SFTEXT))==f) { ! 132: unlock(seglink); ! 133: if ((sp = segdupl(sp)) != NULL) { ! 134: segfinm(sp); ! 135: *rp = 1; ! 136: } ! 137: return (sp); ! 138: } ! 139: } ! 140: unlock(seglink); ! 141: ! 142: /* ! 143: * Allocate and create the segment. ! 144: */ ! 145: if ((sp=salloc(ss, ff)) == NULL) ! 146: return (NULL); ! 147: if (exsread(sp, ip, ds, dq, (fsize_t)0) == 0) { ! 148: sfree(sp); ! 149: return (NULL); ! 150: } ! 151: if ((ff&SFSHRX) != 0) { ! 152: sp->s_ip = ip; ! 153: ip->i_refc++; ! 154: } ! 155: *rp = 0; ! 156: return (sp); ! 157: } ! 158: ! 159: /* ! 160: * Given a pointer to a newly created process, copy all of our segments ! 161: * into the given process. ! 162: */ ! 163: segadup(cpp) ! 164: register PROC *cpp; ! 165: { ! 166: register SEG *sp; ! 167: register int n; ! 168: register PROC *pp; ! 169: ! 170: pp = SELF; ! 171: cpp->p_flags |= PFSWIO; ! 172: for (n=0; n<NUSEG; n++) { ! 173: if ((sp=pp->p_segp[n]) == NULL) ! 174: continue; ! 175: if ((sp=segdupl(sp)) == NULL) ! 176: break; ! 177: cpp->p_segp[n] = sp; ! 178: if ((sp->s_flags&SFCORE) == 0) ! 179: cpp->p_flags &= ~PFCORE; ! 180: } ! 181: if (n < NUSEG) { ! 182: while (n > 0) { ! 183: if ((sp=cpp->p_segp[--n]) != NULL) { ! 184: cpp->p_segp[n] = NULL; ! 185: sfree(sp); ! 186: } ! 187: } ! 188: } ! 189: cpp->p_flags &= ~PFSWIO; ! 190: return (n); ! 191: } ! 192: ! 193: /* ! 194: * Duplicate a segment. ! 195: */ ! 196: SEG * ! 197: segdupl(sp) ! 198: register SEG *sp; ! 199: { ! 200: register SEG *sp1; ! 201: ! 202: if ((sp->s_flags&SFSHRX) != 0) { ! 203: sp->s_urefc++; ! 204: sp->s_lrefc++; ! 205: return (sp); ! 206: } ! 207: if ((sp->s_flags&SFCORE) == 0) ! 208: panic("Cannot duplicate non shared swapped segment"); ! 209: if ((sp1=salloc(sp->s_size, sp->s_flags|SFNSWP|SFNCLR)) == NULL) ! 210: sp1 = segdupd(sp); ! 211: else { ! 212: sp1->s_flags = sp->s_flags; ! 213: plrcopy( sp->s_paddr, sp1->s_paddr, sp->s_size ); ! 214: } ! 215: return (sp1); ! 216: } ! 217: ! 218: /* ! 219: * Allocate a segment `n' bytes long. `f' contains some pseudo flags. ! 220: */ ! 221: SEG * ! 222: salloc(n, f) ! 223: fsize_t n; ! 224: { ! 225: register SEG *sp; ! 226: register int r; ! 227: ! 228: r = (f&(SFSYST|SFHIGH|SFTEXT|SFSHRX|SFDOWN)) | SFCORE; ! 229: n += (BSIZE-1); ! 230: n &= ~(BSIZE-1); ! 231: ! 232: lock(seglink); ! 233: sp = sxalloc(n, f); ! 234: unlock(seglink); ! 235: ! 236: if ( sp == NULL ) { ! 237: krunch(1000); ! 238: lock(seglink); ! 239: sp = sxalloc(n, f); ! 240: unlock(seglink); ! 241: } ! 242: ! 243: if (sp != NULL) { ! 244: sp->s_flags = r; ! 245: vremap( sp ); ! 246: } ! 247: else { ! 248: if ((f&SFNSWP) != 0) ! 249: return (NULL); ! 250: if ((sp=kalloc(sizeof(SEG))) == NULL) ! 251: return (NULL); ! 252: sp->s_forw = sp; ! 253: sp->s_back = sp; ! 254: sp->s_flags = r; ! 255: sp->s_urefc = 1; ! 256: sp->s_lrefc = 1; ! 257: if (segsext(sp, n) == NULL) { ! 258: kfree(sp); ! 259: return (NULL); ! 260: } ! 261: } ! 262: if ((f&SFNCLR) == 0) ! 263: pclear( sp->s_paddr, n ); ! 264: return (sp); ! 265: } ! 266: ! 267: /* ! 268: * Free the given segment pointer. ! 269: */ ! 270: sfree(sp) ! 271: register SEG *sp; ! 272: { ! 273: register INODE *ip; ! 274: ! 275: if ( sp->s_urefc != 1 ) { ! 276: sp->s_urefc--; ! 277: sp->s_lrefc--; ! 278: return; ! 279: } ! 280: ! 281: lock(seglink); ! 282: --sp->s_lrefc; ! 283: if (--sp->s_urefc != 0) { ! 284: unlock(seglink); ! 285: return; ! 286: } ! 287: ! 288: sp->s_back->s_forw = sp->s_forw; ! 289: sp->s_forw->s_back = sp->s_back; ! 290: unlock(seglink); ! 291: ! 292: if (sp->s_lrefc != 0) ! 293: panic("Bad segment count"); ! 294: if ((ip=sp->s_ip) != NULL) ! 295: ldetach(ip); ! 296: vrelse( sp->s_faddr ); ! 297: kfree(sp); ! 298: krunch(0); ! 299: } ! 300: ! 301: /* ! 302: * Grow or shrink the segment `sp' so that it has size `n'. ! 303: */ ! 304: seggrow(sp, n) ! 305: register SEG *sp; ! 306: fsize_t n; ! 307: { ! 308: register SEG *sp1; ! 309: register fsize_t d; ! 310: register paddr_t pb; ! 311: register paddr_t nb; ! 312: register int dowflag; ! 313: ! 314: dowflag = sp->s_flags&SFDOWN; ! 315: ! 316: /* ! 317: * Size of new segment is smaller or the same size as the old ! 318: * segment. ! 319: */ ! 320: lock(seglink); ! 321: d = n - sp->s_size; ! 322: if (n <= sp->s_size) { ! 323: sp->s_size = n; ! 324: if (dowflag) ! 325: sp->s_paddr -= d; ! 326: ! 327: vremap( sp ); ! 328: unlock(seglink); ! 329: return (1); ! 330: } ! 331: ! 332: if ((sp1=sp->s_back) == &segmq) ! 333: pb = corebot; ! 334: else ! 335: pb = sp1->s_paddr + sp1->s_size; ! 336: ! 337: if ((sp1=sp->s_forw) == &segmq) ! 338: nb = coretop; ! 339: else ! 340: nb = sp1->s_paddr; ! 341: ! 342: /* ! 343: * If the segment does not grow down, see if there is enough ! 344: * space after the segment. ! 345: */ ! 346: if (dowflag==0 && nb-sp->s_paddr>=n) { ! 347: pclear(sp->s_paddr+sp->s_size, d); ! 348: sp->s_size = n; ! 349: vremap( sp ); ! 350: unlock(seglink); ! 351: return (1); ! 352: } ! 353: ! 354: /* ! 355: * If the segment grows down, see if there is enough space ! 356: * before the segment. ! 357: */ ! 358: if (dowflag!=0 && sp->s_paddr+sp->s_size-pb>=n) { ! 359: sp->s_paddr -= d; ! 360: sp->s_size = n; ! 361: pclear( sp->s_paddr, d ); ! 362: vremap( sp ); ! 363: unlock(seglink); ! 364: return (1); ! 365: } ! 366: ! 367: /* ! 368: * Is there enough space in total counting the gaps on either ! 369: * side of us? ! 370: */ ! 371: if (nb-pb >= n) { ! 372: if (dowflag == 0) { ! 373: plrcopy(sp->s_paddr, pb, sp->s_size); ! 374: pclear(pb+sp->s_size, d); ! 375: sp->s_paddr = pb; ! 376: } else { ! 377: prlcopy( sp->s_paddr, nb-sp->s_size, sp->s_size ); ! 378: pclear(nb-n, d); ! 379: sp->s_paddr = nb-n; ! 380: } ! 381: sp->s_size = n; ! 382: vremap( sp ); ! 383: unlock(seglink); ! 384: return (1); ! 385: } ! 386: ! 387: /* ! 388: * Try to allocate a segment somewhere else on the segment queue ! 389: * and copy ourselves there. ! 390: */ ! 391: unlock(seglink); ! 392: if ((sp1=salloc((fsize_t)n, sp->s_flags|SFNSWP|SFNCLR)) != NULL) { ! 393: if (dowflag == 0) { ! 394: plrcopy(sp->s_paddr, sp1->s_paddr, sp->s_size); ! 395: pclear(sp1->s_paddr+sp->s_size, d); ! 396: } else { ! 397: plrcopy(sp->s_paddr, sp1->s_paddr+d, sp->s_size); ! 398: pclear(sp1->s_paddr, d); ! 399: } ! 400: lock(seglink); ! 401: satcopy(sp, sp1); ! 402: unlock(seglink); ! 403: return (1); ! 404: } ! 405: ! 406: /* ! 407: * Last chance. Extend the segment by swapping it. ! 408: */ ! 409: if (segsext(sp, n) != NULL) { ! 410: if (dowflag == 0) ! 411: pclear(sp->s_paddr+n-d, d); ! 412: else { ! 413: prlcopy(sp->s_paddr, sp->s_paddr+d, n-d); ! 414: pclear(sp->s_paddr, d); ! 415: } ! 416: return (1); ! 417: } ! 418: ! 419: /* ! 420: * At least we tried. ! 421: */ ! 422: return (0); ! 423: } ! 424: ! 425: /* ! 426: * Given a segment pointer, `sp' and a segment size, grow the given segment ! 427: * to the given size. ! 428: */ ! 429: segsize(sp, s2) ! 430: register SEG *sp; ! 431: vaddr_t s2; ! 432: { ! 433: register vaddr_t s1; ! 434: ! 435: s1 = (vaddr_t) sp->s_size; ! 436: if (seggrow(sp, (fsize_t)s2) == 0) { ! 437: u.u_error = ENOMEM; ! 438: return; ! 439: } ! 440: if (sproto() == 0) ! 441: if (seggrow(sp, (fsize_t)s1)==0 || sproto()==0) ! 442: sendsig(SIGSEGV, SELF); ! 443: segload(); ! 444: } ! 445: ! 446: /* ! 447: * Grow the segment `sp1' to the size `s' in bytes by swapping it out ! 448: * and back in. The segment may not be locked. ! 449: */ ! 450: SEG * ! 451: segsext(sp1, s) ! 452: register SEG *sp1; ! 453: register fsize_t s; ! 454: { ! 455: register SEG *sp2; ! 456: ! 457: #ifndef NOMONITOR ! 458: if (swmflag) ! 459: printf("Segsext(%p, %u)\n", SELF, SELF->p_pid); ! 460: #endif ! 461: if (sexflag == 0) { ! 462: u.u_error = ENOMEM; ! 463: return (NULL); ! 464: } ! 465: lock(seglink); ! 466: if ((sp2=sdalloc(s)) == NULL) { ! 467: unlock(seglink); ! 468: return (NULL); ! 469: } ! 470: unlock(seglink); ! 471: sp1->s_lrefc++; ! 472: if (sp1->s_size != 0) ! 473: swapio(1, sp1->s_paddr, sp2->s_daddr, sp1->s_size); ! 474: lock(seglink); ! 475: satcopy(sp1, sp2); ! 476: unlock(seglink); ! 477: sp1->s_flags &= ~SFCORE; ! 478: sp1->s_lrefc--; ! 479: vremap(sp1); ! 480: segfinm(sp1); ! 481: return (sp1); ! 482: } ! 483: ! 484: /* ! 485: * Force the given segment to be in memory. One can only force ! 486: * one segment to be in memory at a time. ! 487: */ ! 488: segfinm(sp) ! 489: register SEG *sp; ! 490: { ! 491: register PROC *pp; ! 492: register int s; ! 493: ! 494: if ((sp->s_flags&SFCORE) != 0) ! 495: return; ! 496: pp = SELF; ! 497: sp->s_urefc++; ! 498: sp->s_lrefc++; ! 499: pp->p_segp[SIAUXIL] = sp; ! 500: pp->p_flags &= ~PFCORE; ! 501: #ifndef QWAKEUP ! 502: s = sphi(); ! 503: #endif ! 504: setrun(pp); ! 505: dispatch(); ! 506: #ifndef QWAKEUP ! 507: spl(s); ! 508: #endif ! 509: pp->p_segp[SIAUXIL] = NULL; ! 510: sfree(sp); ! 511: } ! 512: ! 513: /* ! 514: * Make a copy of the segment `sp1' which is in memory by writing ! 515: * it out to disk. ! 516: */ ! 517: SEG * ! 518: segdupd(sp1) ! 519: register SEG *sp1; ! 520: { ! 521: register SEG *sp2; ! 522: ! 523: if (sexflag == 0) ! 524: return (NULL); ! 525: lock(seglink); ! 526: if ((sp2=sdalloc(sp1->s_size)) == NULL) { ! 527: unlock(seglink); ! 528: return (NULL); ! 529: } ! 530: sp1->s_lrefc++; ! 531: unlock(seglink); ! 532: swapio(1, sp1->s_paddr, sp2->s_daddr, sp1->s_size); ! 533: sp1->s_lrefc--; ! 534: sp2->s_flags = sp1->s_flags & ~SFCORE; ! 535: sp2->s_size = sp1->s_size; ! 536: vremap( sp2 ); ! 537: return (sp2); ! 538: } ! 539: ! 540: /* ! 541: * Given a flag, a physical core address, a disk address and a count in ! 542: * bytes, perform an I/O operation between core and disk. If `flag' is ! 543: * set, the transfer is to the disk otherwise it is to memory. As you may ! 544: * have guessed, this is used by the swapper. ! 545: */ ! 546: swapio(f, p, d, n) ! 547: paddr_t p; ! 548: daddr_t d; ! 549: fsize_t n; ! 550: { ! 551: register BUF * bp; ! 552: register SEG * sp; ! 553: register int s; ! 554: register int nb; ! 555: static SEG swapseg; /* NOTE: FP_SEL(swapseg.s_faddr) must stay */ ! 556: ! 557: #ifndef NOMONITOR ! 558: if (swmflag > 1) ! 559: printf("swapio(%s,%x,%x,%x)\n",f?"out":"in",(int)p,(int)d,n); ! 560: #endif ! 561: if (d < swapbot || d+(n/BSIZE) > swaptop ! 562: || p < corebot || p+n > coretop) ! 563: panic("Swapio bad parameter"); ! 564: ! 565: bp = &swapbuf; ! 566: sp = &swapseg; ! 567: lock(bp->b_gate); ! 568: SELF->p_flags |= PFSWIO; ! 569: sp->s_flags = SFCORE; ! 570: sp->s_paddr = p; ! 571: sp->s_size = n; ! 572: vremap( sp ); ! 573: bp->b_faddr = sp->s_faddr; ! 574: ! 575: while (n != 0) { ! 576: nb = (n > SCHUNK) ? SCHUNK : n; ! 577: /* ! 578: * Prevent I/O transfer from crossing 64 Kbyte boundary. ! 579: */ ! 580: if ( (p & 0xFFFF0000L) != ((p+nb) & 0xFFFF0000L) ) ! 581: nb = 0x10000L - (p & 0x0000FFFFL); ! 582: bp->b_flag = BFNTP; ! 583: bp->b_req = f ? BWRITE : BREAD; ! 584: bp->b_dev = swapdev; ! 585: bp->b_bno = d; ! 586: bp->b_paddr = p; ! 587: bp->b_count = nb; ! 588: s = sphi(); ! 589: dblock(swapdev, bp); ! 590: while ((bp->b_flag&BFNTP) != 0) ! 591: sleep((char *)bp, CVBLKIO, IVBLKIO, SVBLKIO); ! 592: spl(s); ! 593: if ((bp->b_flag&BFERR) != 0) ! 594: panic("Swapio error"); ! 595: FP_OFF(bp->b_faddr) += nb; ! 596: p += nb; ! 597: d += nb / BSIZE; ! 598: n -= nb; ! 599: } ! 600: sp->s_flags = 0; ! 601: vremap( sp ); ! 602: unlock(bp->b_gate); ! 603: SELF->p_flags &= ~PFSWIO; ! 604: } ! 605: ! 606: /* ! 607: * Make the segment descriptor pointed to by `sp1' have the attributes ! 608: * of `sp2' including it's position in the segment queue and release ! 609: * `sp2'. `seglink' must be locked when this routine is called. ! 610: */ ! 611: satcopy(sp1, sp2) ! 612: register SEG *sp1; ! 613: register SEG *sp2; ! 614: { ! 615: if ( FP_SEL(sp2->s_faddr) != 0 ) ! 616: vrelse( sp2->s_faddr ); ! 617: ! 618: sp1->s_back->s_forw = sp1->s_forw; ! 619: sp1->s_forw->s_back = sp1->s_back; ! 620: sp2->s_back->s_forw = sp1; ! 621: sp1->s_back = sp2->s_back; ! 622: sp2->s_forw->s_back = sp1; ! 623: sp1->s_forw = sp2->s_forw; ! 624: sp1->s_size = sp2->s_size; ! 625: sp1->s_paddr = sp2->s_paddr; ! 626: sp1->s_daddr = sp2->s_daddr; ! 627: vremap(sp1); ! 628: kfree(sp2); ! 629: } ! 630: ! 631: /* ! 632: * Allocate a segment on disk that is `n' bytes long. ! 633: * The `seglink' gate should be locked before this routine is called. ! 634: */ ! 635: SEG * ! 636: sdalloc( s ) ! 637: fsize_t s; ! 638: { ! 639: register SEG *sp1; ! 640: register SEG *sp2; ! 641: register daddr_t d; ! 642: register daddr_t d1; ! 643: register daddr_t d2; ! 644: ! 645: d = s / BSIZE; ! 646: d1 = swapbot; ! 647: sp1 = &segdq; ! 648: do { ! 649: if (d1 >= swaptop) ! 650: return (NULL); ! 651: if ((sp1=sp1->s_forw) != &segdq) ! 652: d2 = sp1->s_daddr; ! 653: else ! 654: d2 = swaptop; ! 655: if (d2-d1 >= d) { ! 656: if ((sp2=kalloc(sizeof(SEG))) == NULL) ! 657: return (NULL); ! 658: sp1->s_back->s_forw = sp2; ! 659: sp2->s_back = sp1->s_back; ! 660: sp1->s_back = sp2; ! 661: sp2->s_forw = sp1; ! 662: sp2->s_urefc = 1; ! 663: sp2->s_lrefc = 1; ! 664: sp2->s_size = s; ! 665: sp2->s_daddr = d1; ! 666: return (sp2); ! 667: } ! 668: d1 = sp1->s_daddr + (sp1->s_size / BSIZE); ! 669: } while (sp1 != &segdq); ! 670: return (NULL); ! 671: } ! 672: ! 673: /* ! 674: * Allocate a segment in memory that is `n' bytes long. ! 675: * The `seglink' gate should be locked before this routine is called. ! 676: */ ! 677: SEG * ! 678: smalloc(s) ! 679: fsize_t s; ! 680: { ! 681: register SEG *sp1; ! 682: register SEG *sp2; ! 683: paddr_t p1; ! 684: paddr_t p2; ! 685: ! 686: p1 = corebot; ! 687: sp1 = &segmq; ! 688: do { ! 689: if ((sp1=sp1->s_forw) != &segmq) ! 690: p2 = sp1->s_paddr; ! 691: else ! 692: p2 = coretop; ! 693: ! 694: if (p2-p1 >= s) { ! 695: if ((sp2=kalloc(sizeof (SEG))) == NULL) ! 696: return (NULL); ! 697: sp1->s_back->s_forw = sp2; ! 698: sp2->s_back = sp1->s_back; ! 699: sp1->s_back = sp2; ! 700: sp2->s_forw = sp1; ! 701: sp2->s_urefc = 1; ! 702: sp2->s_lrefc = 1; ! 703: sp2->s_size = s; ! 704: sp2->s_paddr = p1; ! 705: /* s_faddr = 0; */ ! 706: /* s_flags = 0; */ ! 707: vremap( sp2 ); ! 708: return (sp2); ! 709: } ! 710: p1 = sp1->s_paddr + sp1->s_size; ! 711: } while (sp1 != &segmq); ! 712: return (NULL); ! 713: } ! 714: ! 715: /* ! 716: * Allocate a segment from the high end of memory that is `n' bytes long. ! 717: * The `seglink' gate should be locked before this routine is called. ! 718: */ ! 719: SEG * ! 720: shalloc( s ) ! 721: fsize_t s; ! 722: { ! 723: register SEG *sp1; ! 724: register SEG *sp2; ! 725: paddr_t p1; ! 726: paddr_t p2; ! 727: ! 728: sp1 = &segmq; ! 729: p2 = coretop; ! 730: do { ! 731: if ((sp1=sp1->s_back) != &segmq) ! 732: p1 = sp1->s_paddr + sp1->s_size; ! 733: else ! 734: p1 = corebot; ! 735: ! 736: if (p2-p1 >= s) { ! 737: if ((sp2=kalloc(sizeof (SEG))) == NULL) ! 738: return (NULL); ! 739: sp1->s_forw->s_back = sp2; ! 740: sp2->s_forw = sp1->s_forw; ! 741: sp1->s_forw = sp2; ! 742: sp2->s_back = sp1; ! 743: sp2->s_urefc = 1; ! 744: sp2->s_lrefc = 1; ! 745: sp2->s_size = s; ! 746: sp2->s_paddr = p2-s; ! 747: /* s_faddr = 0; */ ! 748: /* s_flags = 0; */ ! 749: vremap( sp2 ); ! 750: return (sp2); ! 751: } ! 752: p2 = sp1->s_paddr; ! 753: } while (sp1 != &segmq); ! 754: return (NULL); ! 755: } ! 756: ! 757: /* ! 758: * Set up `SR' structure in user area from segments descriptors in ! 759: * process structure. Also set up the user segmentation registers. ! 760: */ ! 761: sproto() ! 762: { ! 763: register int n; ! 764: register SEG *sp; ! 765: ! 766: kclear(u.u_segl, sizeof(u.u_segl)); ! 767: for (n=0; n<NUSEG; n++) { ! 768: if ((sp=SELF->p_segp[n]) == NULL) ! 769: continue; ! 770: if (n == SIUSERP) ! 771: u.u_segl[n].sr_base = &u; ! 772: else ! 773: u.u_segl[n].sr_flag |= SRFPMAP; ! 774: if (n!=SISTEXT && n!=SISDATA) ! 775: u.u_segl[n].sr_flag |= SRFDUMP; ! 776: if (n!=SIUSERP && n!=SISTEXT && n!=SIPTEXT) ! 777: u.u_segl[n].sr_flag |= SRFDATA; ! 778: u.u_segl[n].sr_size = sp->s_size; ! 779: u.u_segl[n].sr_segp = sp; ! 780: } ! 781: return (mproto()); ! 782: } ! 783: ! 784: /* ! 785: * Search for a busy text inode. ! 786: */ ! 787: sbusy(ip) ! 788: register INODE *ip; ! 789: { ! 790: register SEG *sp; ! 791: ! 792: lock(seglink); ! 793: /* ! 794: * Look for the segment in the memory queue. ! 795: */ ! 796: for (sp=segmq.s_forw; sp!=&segmq; sp=sp->s_forw) { ! 797: if (sp->s_ip==ip ! 798: && (sp->s_flags&(SFSHRX|SFTEXT))==(SFSHRX|SFTEXT)) { ! 799: unlock(seglink); ! 800: return (1); ! 801: } ! 802: } ! 803: ! 804: /* ! 805: * Look for the segment on the disk queue. ! 806: */ ! 807: for (sp=segdq.s_forw; sp!=&segdq; sp=sp->s_forw) { ! 808: if (sp->s_ip==ip ! 809: && (sp->s_flags&(SFSHRX|SFTEXT))==(SFSHRX|SFTEXT)) { ! 810: unlock(seglink); ! 811: return (1); ! 812: } ! 813: } ! 814: unlock(seglink); ! 815: return (0); ! 816: } ! 817: ! 818: /* ! 819: * Segment consistency checks for the paranoid. ! 820: segchk() ! 821: { ! 822: register SEG *sp; ! 823: register int nbad; ! 824: fsize_t s; ! 825: daddr_t d; ! 826: ! 827: nbad = 0; ! 828: sp = &segmq; ! 829: s = corebot; ! 830: while ((sp=sp->s_forw) != &segmq) { ! 831: if (sp->s_paddr < s) ! 832: nbad += badseg("mem", sp->s_paddr, 0); ! 833: s = sp->s_paddr + sp->s_size; ! 834: } ! 835: if (coretop < s) ! 836: nbad += badseg("mem", sp->s_back->s_paddr, sp->s_back->s_size); ! 837: sp = &segdq; ! 838: d = swapbot; ! 839: while ((sp=sp->s_forw) != &segdq) { ! 840: if (sp->s_daddr < d) ! 841: nbad += badseg("disk", (int)sp->s_daddr, 0); ! 842: d = sp->s_daddr + (sp->s_size / BSIZE); ! 843: } ! 844: if (swaptop < d) ! 845: nbad += badseg("disk", sp->s_back->s_daddr, sp->s_back->s_size); ! 846: } ! 847: ! 848: badseg(t, b, s) ! 849: char *t; ! 850: daddr_t b; ! 851: fsize_t s; ! 852: { ! 853: printf( "Bad %s segment at %X of len %X\n", t, b, s ); ! 854: return (1); ! 855: } ! 856: */
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.