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