![[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 / b / kernel / coh.386|
Return to seg.c CVS log | Up to [MW Coherent from dump] / coherent / b / kernel / coh.386 |
1.1 ! root 1: /* $Header: /src386/kernel/coh.386/RCS/seg.c,v 1.6 93/06/14 13:35:09 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: */ ! 20: #include <sys/coherent.h> ! 21: #include <sys/buf.h> ! 22: #include <errno.h> ! 23: #include <sys/ino.h> ! 24: #include <sys/inode.h> ! 25: #include <sys/proc.h> ! 26: #include <sys/sched.h> ! 27: #include <sys/seg.h> ! 28: #include <a.out.h> ! 29: ! 30: ! 31: #define min(a, b) ((a) < (b) ? (a) : (b)) ! 32: ! 33: /* ! 34: * Initialisation code. ! 35: */ ! 36: seginit() ! 37: { ! 38: /* ! 39: * Create empty circular-list of memory segments. ! 40: */ ! 41: segmq.s_forw = &segmq; ! 42: segmq.s_back = &segmq; ! 43: ! 44: /* ! 45: * Create empty circular-list of disk segments. ! 46: */ ! 47: segdq.s_forw = &segdq; ! 48: segdq.s_back = &segdq; ! 49: } ! 50: ! 51: /* ! 52: * Given an inode, `ip', and flags, `ff', describing a segment associated ! 53: * with the inode, see if the segment already exists and if so, return a ! 54: * copy. If the segment does not exist, allocate the segment having size ! 55: * `ss', and read the segment using the inode at seek offset `dq' with a ! 56: * size of `ds'. ! 57: */ ! 58: SEG * ! 59: ssalloc(ip, ff, ss) ! 60: register INODE *ip; ! 61: { ! 62: register SEG *sp; ! 63: register int f; ! 64: ! 65: lock(seglink); ! 66: f = ff & (SFSHRX|SFTEXT); ! 67: ! 68: /* ! 69: * Look for the segment in the memory queue. ! 70: */ ! 71: for (sp=segmq.s_forw; sp!=&segmq; sp=sp->s_forw) { ! 72: if (sp->s_ip==ip && (sp->s_flags&(SFSHRX|SFTEXT))==f) { ! 73: unlock(seglink); ! 74: if (sp = segdupl(sp)) ! 75: segfinm(sp); ! 76: return (sp); ! 77: } ! 78: } ! 79: ! 80: /* ! 81: * Look for the segment on the disk queue. ! 82: */ ! 83: for (sp=segdq.s_forw; sp!=&segdq; sp=sp->s_forw) { ! 84: if (sp->s_ip==ip && (sp->s_flags&(SFSHRX|SFTEXT))==f) { ! 85: unlock(seglink); ! 86: if (sp = segdupl(sp)) ! 87: segfinm(sp); ! 88: return (sp); ! 89: } ! 90: } ! 91: unlock(seglink); ! 92: ! 93: /* ! 94: * Allocate and create the segment. ! 95: */ ! 96: return salloc(roundu(ss, NBPC), ff); ! 97: } ! 98: ! 99: /* ! 100: * Given a pointer to a newly created process, copy all of our segments ! 101: * into the given process. ! 102: * ! 103: * Return nonzero if successful. ! 104: */ ! 105: int ! 106: segadup(cpp) ! 107: register PROC *cpp; ! 108: { ! 109: register SEG *sp; ! 110: register int n; ! 111: register PROC *pp; ! 112: ! 113: pp = SELF; ! 114: cpp->p_flags |= PFSWIO; ! 115: for (n=0; n<NUSEG; n++) { ! 116: if ((sp=pp->p_segp[n]) == NULL) ! 117: continue; ! 118: if ((sp=segdupl(sp)) == NULL) ! 119: break; ! 120: cpp->p_segp[n] = sp; ! 121: if ((sp->s_flags&SFCORE) == 0) ! 122: cpp->p_flags &= ~PFCORE; ! 123: } ! 124: ! 125: /* ! 126: * One of the calls to segdupl() failed. ! 127: * Undo any that succeeded. ! 128: */ ! 129: if (n < NUSEG) { ! 130: while (n > 0) { ! 131: if (sp=cpp->p_segp[--n]) { ! 132: cpp->p_segp[n] = NULL; ! 133: sfree(sp); ! 134: } ! 135: } ! 136: } ! 137: cpp->p_flags &= ~PFSWIO; ! 138: return n; ! 139: } ! 140: ! 141: /* ! 142: * Duplicate a segment. ! 143: */ ! 144: SEG * ! 145: segdupl(sp) ! 146: register SEG *sp; ! 147: { ! 148: register SEG *sp1; ! 149: ! 150: if (sp->s_flags & SFSHRX) { ! 151: sp->s_urefc++; ! 152: sp->s_lrefc++; ! 153: return (sp); ! 154: } ! 155: if ((sp->s_flags&SFCORE) == 0) ! 156: panic("Cannot duplicate non shared swapped segment"); ! 157: if ((sp1=salloc(sp->s_size, sp->s_flags|SFNSWP|SFNCLR)) == NULL) ! 158: sp1 = segdupd(sp); ! 159: else { ! 160: sp1->s_flags = sp->s_flags; ! 161: dmacopy( btoc(sp->s_size), sp->s_vmem, sp1->s_vmem) ; ! 162: } ! 163: return sp1; ! 164: } ! 165: ! 166: /* ! 167: * Allocate a segment `bytes_wanted' bytes long. ! 168: * `flags' contains some pseudo flags. ! 169: */ ! 170: SEG * ! 171: salloc(bytes_wanted, flags) ! 172: int bytes_wanted, flags; ! 173: { ! 174: register SEG *sp; ! 175: register int r; ! 176: ! 177: r = (flags & (SFSYST|SFTEXT|SFSHRX|SFDOWN)) | SFCORE; ! 178: ! 179: /* ! 180: #ifdef _I386 ! 181: bytes_wanted += (sizeof(char *) - 1); ! 182: bytes_wanted &= ~(sizeof(char *) - 1); ! 183: #else ! 184: bytes_wanted += (BSIZE - 1); ! 185: bytes_wanted &= ~(BSIZE - 1); ! 186: #endif ! 187: */ ! 188: ! 189: lock(seglink); ! 190: sp = smalloc(bytes_wanted); ! 191: unlock(seglink); ! 192: ! 193: if (sp) { ! 194: sp->s_flags = r; ! 195: } else { ! 196: #if 0 ! 197: /* no room now - let the swapper try to grow it */ ! 198: if (flags & SFNSWP) ! 199: return 0; ! 200: if ((sp=kalloc(sizeof(SEG))) == NULL) ! 201: return 0; ! 202: sp->s_forw = sp; ! 203: sp->s_back = sp; ! 204: sp->s_flags = r; ! 205: sp->s_urefc = 1; ! 206: sp->s_lrefc = 1; ! 207: if (segsext(sp, bytes_wanted) == NULL) { ! 208: kfree(sp); ! 209: return 0; ! 210: } ! 211: #else ! 212: return 0; ! 213: #endif ! 214: } ! 215: if ((flags&SFNCLR) == 0) ! 216: dmaclear(sp->s_size, MAPIO(sp->s_vmem, 0), 0L); ! 217: return sp; ! 218: } ! 219: ! 220: /* ! 221: * Free the given segment pointer. ! 222: */ ! 223: sfree(sp) ! 224: register SEG *sp; ! 225: { ! 226: register INODE *ip; ! 227: ! 228: if ( sp->s_urefc != 1 ) { ! 229: sp->s_urefc--; ! 230: sp->s_lrefc--; ! 231: return; ! 232: } ! 233: ! 234: lock(seglink); ! 235: ! 236: --sp->s_lrefc; ! 237: ! 238: sp->s_back->s_forw = sp->s_forw; ! 239: sp->s_forw->s_back = sp->s_back; ! 240: ! 241: c_free(sp->s_vmem, btoc(sp->s_size)); ! 242: ! 243: unlock(seglink); ! 244: if (sp->s_lrefc) ! 245: panic("Bad segment count"); ! 246: ! 247: /* ! 248: * Check if inode is ilocked, in order to allow the process ! 249: * to exec itself (file with the same inode as parent). Vlad. ! 250: */ ! 251: if ((ip=sp->s_ip) && !ilocked(ip)) { ! 252: ldetach(ip); ! 253: } ! 254: kfree(sp); ! 255: } ! 256: ! 257: /* ! 258: * Grow or shrink the segment `sp' so that it has size `new_bytes' bytes. ! 259: * ! 260: * downward growing segments not done yet! ! 261: */ ! 262: seggrow(sp, new_bytes) ! 263: register SEG *sp; ! 264: unsigned int new_bytes; ! 265: { ! 266: register SEG *sp1; ! 267: register int dowflag; ! 268: unsigned int old_bytes, common_clicks; ! 269: ! 270: dowflag = sp->s_flags & SFDOWN; ! 271: old_bytes = sp->s_size; ! 272: ! 273: /* ! 274: * If we want a larger segment AND c_grow() succeeds ! 275: * boost segment size to new_bytes ! 276: */ ! 277: if (new_bytes >= old_bytes && c_grow(sp, new_bytes)==0) { ! 278: T_HAL(0x100, printf("c_grow(%d) ", new_bytes)); ! 279: sp->s_size = new_bytes; ! 280: dmaclear(new_bytes - old_bytes, ! 281: MAPIO(sp->s_vmem, old_bytes), 0); ! 282: return 1; ! 283: } ! 284: dont_c_grow: ! 285: ! 286: if (sp1 = salloc(new_bytes, (sp->s_flags|SFNSWP|SFNCLR))) { ! 287: T_HAL(0x100, printf("salloc(%d) ", new_bytes)); ! 288: if (dowflag == 0) { ! 289: common_clicks = btoc(min(new_bytes, old_bytes)); ! 290: dmacopy(common_clicks, sp->s_vmem, sp1->s_vmem); ! 291: if (new_bytes > old_bytes) { ! 292: dmaclear(new_bytes - old_bytes, ! 293: MAPIO(sp1->s_vmem, old_bytes), 0); ! 294: } ! 295: } else ! 296: panic("downflag"); ! 297: lock(seglink); ! 298: c_free(sp->s_vmem, btoc(old_bytes)); ! 299: satcopy(sp, sp1); ! 300: unlock(seglink); ! 301: ! 302: return 1; ! 303: } ! 304: ! 305: #if 1 ! 306: return 0; ! 307: #else ! 308: /* ! 309: * Last chance. Extend the segment by swapping it. ! 310: */ ! 311: if (!segsext(sp, new_bytes)) ! 312: return 0; ! 313: ! 314: if (dowflag == 0) { ! 315: if (new_bytes > old_bytes) ! 316: dmaclear(new_bytes - old_bytes, MAPIO(sp->s_vmem,old_bytes), 0); ! 317: } else ! 318: panic("downflag"); ! 319: ! 320: return (1); ! 321: #endif ! 322: } ! 323: ! 324: /* ! 325: * Given a segment pointer, `sp' and a segment size, grow the given segment ! 326: * to the given size. ! 327: */ ! 328: segsize(sp, s2) ! 329: register SEG *sp; ! 330: caddr_t s2; ! 331: { ! 332: register caddr_t s1; ! 333: ! 334: s1 = (caddr_t) sp->s_size; ! 335: if (s2 == 0 || seggrow(sp, (off_t)s2) == 0) { ! 336: SET_U_ERROR( ENOMEM, "can not grow segment" ); ! 337: return; ! 338: } ! 339: if (sproto(0) == 0) { ! 340: if (seggrow(sp, (off_t)s1)==0 || sproto(0)==0) { ! 341: T_PIGGY( 0x2000000, printf("auto SEGV\n"); ); ! 342: sendsig(SIGSEGV, SELF); ! 343: } ! 344: } ! 345: segload(); ! 346: } ! 347: ! 348: /* ! 349: * Grow the segment `sp1' to the size `s' in bytes by swapping it out ! 350: * and back in. The segment may not be locked. ! 351: */ ! 352: SEG * ! 353: segsext(sp1, s) ! 354: register SEG *sp1; ! 355: register off_t s; ! 356: { ! 357: #if 0 ! 358: register SEG *sp2; ! 359: ! 360: #if MONITOR ! 361: if (swmflag) ! 362: printf("Segsext(%p, %u)\n", SELF, SELF->p_pid); ! 363: #endif ! 364: if (sexflag == 0) { ! 365: SET_U_ERROR( ENOMEM, "can not extend, swapping is off" ); ! 366: return (NULL); ! 367: } ! 368: lock(seglink); ! 369: if ((sp2=sdalloc(s)) == NULL) { ! 370: unlock(seglink); ! 371: return (NULL); ! 372: } ! 373: unlock(seglink); ! 374: sp1->s_lrefc++; ! 375: if (sp1->s_size != 0) ! 376: swapio(1, MAPIO(sp1->s_vmem, 0), sp2->s_daddr, sp1->s_size); ! 377: lock(seglink); ! 378: satcopy(sp1, sp2); ! 379: unlock(seglink); ! 380: sp1->s_flags &= ~SFCORE; ! 381: sp1->s_lrefc--; ! 382: segfinm(sp1); ! 383: return (sp1); ! 384: #else ! 385: return 0; ! 386: #endif ! 387: } ! 388: ! 389: /* ! 390: * Force the given segment to be in memory. One can only force ! 391: * one segment to be in memory at a time. ! 392: */ ! 393: segfinm(sp) ! 394: register SEG *sp; ! 395: { ! 396: register PROC *pp; ! 397: register int s; ! 398: ! 399: if (sp->s_flags&SFCORE) ! 400: return; ! 401: pp = SELF; ! 402: sp->s_urefc++; ! 403: sp->s_lrefc++; ! 404: pp->p_segp[SIAUXIL] = sp; ! 405: pp->p_flags &= ~PFCORE; ! 406: #ifndef QWAKEUP ! 407: s = sphi(); ! 408: #endif ! 409: setrun(pp); ! 410: dispatch(); ! 411: #ifndef QWAKEUP ! 412: spl(s); ! 413: #endif ! 414: pp->p_segp[SIAUXIL] = NULL; ! 415: sfree(sp); ! 416: } ! 417: ! 418: /* ! 419: * Make a copy of the segment `sp1' which is in memory by writing ! 420: * it out to disk. ! 421: */ ! 422: SEG * ! 423: segdupd(sp1) ! 424: register SEG *sp1; ! 425: { ! 426: register SEG *sp2; ! 427: ! 428: if (sexflag == 0) ! 429: return (NULL); ! 430: lock(seglink); ! 431: if ((sp2=sdalloc(sp1->s_size)) == NULL) { ! 432: unlock(seglink); ! 433: return (NULL); ! 434: } ! 435: sp1->s_lrefc++; ! 436: unlock(seglink); ! 437: swapio(1, MAPIO(sp1->s_vmem, 0), sp2->s_daddr, sp1->s_size); ! 438: sp1->s_lrefc--; ! 439: sp2->s_flags = sp1->s_flags & ~SFCORE; ! 440: sp2->s_size = sp1->s_size; ! 441: return (sp2); ! 442: } ! 443: ! 444: /* ! 445: * Given a flag, a physical core address, a disk address and a count in ! 446: * bytes, perform an I/O operation between core and disk. If `flag' is ! 447: * set, the transfer is to the disk otherwise it is to memory. As you may ! 448: * have guessed, this is used by the swapper. ! 449: * ! 450: */ ! 451: swapio(f, p, d, n) ! 452: paddr_t p; ! 453: daddr_t d; ! 454: off_t n; ! 455: { ! 456: register BUF * bp; ! 457: register SEG * sp; ! 458: register int s; ! 459: register int nb; ! 460: ! 461: #if MONITOR ! 462: if (swmflag > 1) ! 463: printf("swapio(%s,%x,%x,%x)\n",f?"out":"in",(int)p,(int)d,n); ! 464: #endif ! 465: if (d < swapbot || d+(n/BSIZE) > swaptop) ! 466: panic("Swapio bad parameter"); ! 467: ! 468: bp = &swapbuf; ! 469: lock(bp->b_gate); ! 470: SELF->p_flags |= PFSWIO; ! 471: bp->b_paddr = p; ! 472: ! 473: while (n) { ! 474: nb = (n > SCHUNK) ? SCHUNK : n; ! 475: /* ! 476: * Prevent I/O transfer from crossing 64 Kbyte boundary. ! 477: */ ! 478: if ( (p & 0xFFFF0000L) != ((p+nb) & 0xFFFF0000L) ) ! 479: nb = 0x10000L - (p & 0x0000FFFFL); ! 480: bp->b_flag = BFNTP; ! 481: bp->b_req = f ? BWRITE : BREAD; ! 482: bp->b_dev = swapdev; ! 483: bp->b_bno = d; ! 484: bp->b_paddr = p; ! 485: bp->b_count = nb; ! 486: s = sphi(); ! 487: dblock(swapdev, bp); ! 488: while ((bp->b_flag&BFNTP) != 0) { ! 489: x_sleep((char *)bp, pridisk, slpriNoSig, "swap"); ! 490: /* Sleeping in the swapper. */ ! 491: } ! 492: spl(s); ! 493: if ((bp->b_flag&BFERR) != 0) ! 494: panic("Swapio error"); ! 495: bp->b_vaddr += nb; ! 496: p += nb; ! 497: d += nb / BSIZE; ! 498: n -= nb; ! 499: } ! 500: unlock(bp->b_gate); ! 501: SELF->p_flags &= ~PFSWIO; ! 502: } ! 503: ! 504: /* ! 505: * Make the segment descriptor pointed to by `sp1' have the attributes ! 506: * of `sp2' including it's position in the segment queue and release ! 507: * `sp2'. `seglink' must be locked when this routine is called. ! 508: */ ! 509: satcopy(sp1, sp2) ! 510: register SEG *sp1; ! 511: register SEG *sp2; ! 512: { ! 513: sp1->s_back->s_forw = sp1->s_forw; ! 514: sp1->s_forw->s_back = sp1->s_back; ! 515: sp2->s_back->s_forw = sp1; ! 516: sp1->s_back = sp2->s_back; ! 517: sp2->s_forw->s_back = sp1; ! 518: sp1->s_forw = sp2->s_forw; ! 519: sp1->s_daddr = sp2->s_daddr; ! 520: sp1->s_size = sp2->s_size; ! 521: sp1->s_vmem = sp2->s_vmem; ! 522: kfree(sp2); ! 523: } ! 524: ! 525: /* ! 526: * Allocate a segment on disk that is `n' bytes long. ! 527: * The `seglink' gate should be locked before this routine is called. ! 528: */ ! 529: SEG * ! 530: sdalloc( s ) ! 531: off_t s; ! 532: { ! 533: register SEG *sp1; ! 534: register SEG *sp2; ! 535: register daddr_t d; ! 536: register daddr_t d1; ! 537: register daddr_t d2; ! 538: ! 539: d = s / BSIZE; ! 540: d1 = swapbot; ! 541: sp1 = &segdq; ! 542: do { ! 543: if (d1 >= swaptop) ! 544: return (NULL); ! 545: if ((sp1=sp1->s_forw) != &segdq) ! 546: d2 = sp1->s_daddr; ! 547: else ! 548: d2 = swaptop; ! 549: if (d2-d1 >= d) { ! 550: if ((sp2=kalloc(sizeof(SEG))) == NULL) ! 551: return (NULL); ! 552: sp1->s_back->s_forw = sp2; ! 553: sp2->s_back = sp1->s_back; ! 554: sp1->s_back = sp2; ! 555: sp2->s_forw = sp1; ! 556: sp2->s_urefc = 1; ! 557: sp2->s_lrefc = 1; ! 558: sp2->s_size = s; ! 559: sp2->s_daddr = d1; ! 560: return (sp2); ! 561: } ! 562: d1 = sp1->s_daddr + (sp1->s_size / BSIZE); ! 563: } while (sp1 != &segdq); ! 564: return (NULL); ! 565: } ! 566: ! 567: /* ! 568: * Allocate a segment in memory that is `bytes_wanted' bytes long. ! 569: * The `seglink' gate should be locked before this routine is called. ! 570: * ! 571: * if successful, return allocated SEG * ! 572: * else, return 0 ! 573: */ ! 574: SEG * ! 575: smalloc(bytes_wanted) ! 576: off_t bytes_wanted; ! 577: { ! 578: register SEG *sp1; ! 579: register SEG *new_seg; ! 580: unsigned clicks_wanted; ! 581: ! 582: clicks_wanted = btoc(bytes_wanted); ! 583: ! 584: /* ! 585: * Estimate space needed for new segment and its overhead. ! 586: * Fail if not enough free RAM available. ! 587: */ ! 588: if (countsize(clicks_wanted) > allocno()) ! 589: return 0; ! 590: /* ! 591: * Allocate a new SEG struct to keep track of the segment, if possible. ! 592: */ ! 593: if ((new_seg = kalloc(sizeof (SEG))) == NULL) ! 594: return 0; ! 595: ! 596: if ((new_seg->s_vmem = c_alloc(clicks_wanted)) == 0) { ! 597: kfree(new_seg); ! 598: return 0; ! 599: } ! 600: ! 601: /* link new_seg in at start of segmq */ ! 602: sp1 = segmq.s_forw; ! 603: sp1->s_back->s_forw = new_seg; ! 604: new_seg->s_back = sp1->s_back; ! 605: sp1->s_back = new_seg; ! 606: new_seg->s_forw = sp1; ! 607: ! 608: new_seg->s_urefc = 1; ! 609: new_seg->s_lrefc = 1; ! 610: new_seg->s_size = bytes_wanted; ! 611: ! 612: return new_seg; ! 613: } ! 614: ! 615: /* ! 616: * Set up `SR' structure in user area from segments descriptors in ! 617: * process structure. Also set up the user segmentation registers. ! 618: */ ! 619: sproto(xhp) ! 620: struct xechdr *xhp; ! 621: { ! 622: register int n; ! 623: register SEG *sp; ! 624: ! 625: for (n=0; n<NUSEG; n++) { ! 626: u.u_segl[n].sr_flag = u.u_segl[n].sr_size = 0; ! 627: u.u_segl[n].sr_segp = 0; ! 628: if ((sp=SELF->p_segp[n]) == NULL) ! 629: continue; ! 630: if (n == SIUSERP) ! 631: u.u_segl[n].sr_base = &u; ! 632: else { ! 633: if (xhp) ! 634: u.u_segl[n].sr_base = xhp->segs[n].mbase; ! 635: u.u_segl[n].sr_flag |= SRFPMAP; ! 636: } ! 637: if (n!=SISTEXT) ! 638: u.u_segl[n].sr_flag |= SRFDUMP; ! 639: if (n!=SIUSERP && n!=SISTEXT) ! 640: u.u_segl[n].sr_flag |= SRFDATA; ! 641: u.u_segl[n].sr_size = sp->s_size; ! 642: u.u_segl[n].sr_segp = sp; ! 643: } ! 644: return (mproto()); ! 645: } ! 646: ! 647: /* ! 648: * Search for a busy text inode. ! 649: */ ! 650: sbusy(ip) ! 651: register INODE *ip; ! 652: { ! 653: register SEG *sp; ! 654: ! 655: lock(seglink); ! 656: /* ! 657: * Look for the segment in the memory queue. ! 658: */ ! 659: for (sp=segmq.s_forw; sp!=&segmq; sp=sp->s_forw) { ! 660: if (sp->s_ip==ip ! 661: && (sp->s_flags&(SFSHRX|SFTEXT))==(SFSHRX|SFTEXT)) { ! 662: unlock(seglink); ! 663: return (1); ! 664: } ! 665: } ! 666: ! 667: /* ! 668: * Look for the segment on the disk queue. ! 669: */ ! 670: for (sp=segdq.s_forw; sp!=&segdq; sp=sp->s_forw) { ! 671: if (sp->s_ip==ip ! 672: && (sp->s_flags&(SFSHRX|SFTEXT))==(SFSHRX|SFTEXT)) { ! 673: unlock(seglink); ! 674: return (1); ! 675: } ! 676: } ! 677: unlock(seglink); ! 678: return 0; ! 679: } ! 680: ! 681: /* ! 682: * Segment consistency checks for the paranoid. ! 683: segchk() ! 684: { ! 685: register SEG *sp; ! 686: register int nbad; ! 687: off_t s; ! 688: daddr_t d; ! 689: ! 690: nbad = 0; ! 691: sp = &segdq; ! 692: d = swapbot; ! 693: while ((sp=sp->s_forw) != &segdq) { ! 694: if (sp->s_daddr < d) ! 695: nbad += badseg("disk", (int)sp->s_daddr, 0); ! 696: d = sp->s_daddr + (sp->s_size / BSIZE); ! 697: } ! 698: if (swaptop < d) ! 699: nbad += badseg("disk", sp->s_back->s_daddr, sp->s_back->s_size); ! 700: } ! 701: ! 702: badseg(t, b, s) ! 703: char *t; ! 704: daddr_t b; ! 705: off_t s; ! 706: { ! 707: printf( "Bad %s segment at %X of len %X\n", t, b, s ); ! 708: return (1); ! 709: } ! 710: */
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.