![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to bio.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.386|
Return to bio.c CVS log | Up to [MW Coherent from dump] / coherent / d / PS2_KERNEL / coh.386 |
1.1 ! root 1: /* $Header: /kernel/kersrc/coh.386/RCS/bio.c,v 1.2 92/08/04 12:30:18 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: * Buffered I/O. ! 18: * ! 19: * $Log: bio.c,v $ ! 20: * Revision 1.2 92/08/04 12:30:18 bin ! 21: * changed for kernel 59 ! 22: * ! 23: * Revision 1.2 92/01/06 11:58:35 hal ! 24: * Compile with cc.mwc. ! 25: * ! 26: * Revision 1.1 88/03/24 16:13:29 src ! 27: * Initial revision ! 28: * ! 29: * 87/11/05 Allan Cornish /usr/src/sys/coh/bio.c ! 30: * New seg struct now used to allow extended addressing. ! 31: * ! 32: * 87/01/05 Allan Cornish /usr/src/sys/coh/bio.c ! 33: * ioreq() now only wakes &stimer if the swap timer is active. ! 34: * ! 35: * 86/12/12 Allan Cornish /usr/src/sys/coh/bio.c ! 36: * Added 3rd arg to dpoll() to specify blocking poll if non-zero. ! 37: * ! 38: * 86/11/19 Allan Cornish /usr/src/sys/coh/bio.c ! 39: * Added dpoll() routine to perform device polls [System V.3 compatible]. ! 40: * ! 41: * 86/07/24 Allan Cornish /usr/src/sys/coh/bio.c ! 42: * Added check in devinit() for null dp->d_conp->c_load function pointer. ! 43: */ ! 44: #include <sys/coherent.h> ! 45: #include <sys/buf.h> ! 46: #include <sys/con.h> ! 47: #include <errno.h> ! 48: #include <sys/io.h> ! 49: #include <sys/proc.h> ! 50: #include <sys/sched.h> ! 51: #include <sys/seg.h> ! 52: #include <sys/stat.h> ! 53: ! 54: static BUF **hasharray; /* pointer to hash buckets */ ! 55: static BUF *firstbuf; /* pointer to first in LRU chain */ ! 56: static BUF *lastbuf; /* pointer to last in LRU chain */ ! 57: ! 58: /* ! 59: * The following hashing algorithm is used by bclaim(). ! 60: */ ! 61: #define HASH(device, blockno) ((device * 257) + blockno) ! 62: ! 63: #if BDEBUG ! 64: #include <sys/bufdebug.h> ! 65: ! 66: static BUFDEBUG bufdebug; /* actual counters used in profiling */ ! 67: ! 68: /* ! 69: * Perform buffer cache debugging ioctl's. ! 70: * These will not stay in the production release! ! 71: */ ! 72: bufioctl(cmd, vec) ! 73: BUFDEBUG *vec; ! 74: { ! 75: switch (cmd) { ! 76: case BDINIT: /* clear (init) all counters */ ! 77: kclear(&bufdebug, sizeof(bufdebug)); ! 78: bufdebug.nbuf = NBUF; ! 79: bufdebug.version = BDVERSION; ! 80: break; ! 81: case BDGETVAL: /* return current counters to user */ ! 82: kucopy(&bufdebug, vec, sizeof(bufdebug)); ! 83: break; ! 84: default: ! 85: SET_U_ERROR(EINVAL, "bufioctl()"); ! 86: } ! 87: } ! 88: #endif ! 89: ! 90: /* ! 91: * Allocate and initialize buffer headers. ! 92: */ ! 93: bufinit() ! 94: { ! 95: register BUF *bp; ! 96: paddr_t p; ! 97: vaddr_t v; ! 98: int i; ! 99: ! 100: p = MAPIO(blockp.sr_segp->s_vmem, 0); ! 101: v = blockp.sr_base; ! 102: ! 103: if (NBUF < 32) ! 104: panic("NBUF not set correctly"); ! 105: if (NHASH < 32) ! 106: panic("NHASH not set correctly"); ! 107: ! 108: bufl = kalloc(NBUF * sizeof(BUF)); ! 109: hasharray = kalloc(NHASH * sizeof(BUF *)); ! 110: if (bufl == BNULL || hasharray == BNULL) ! 111: panic("bufinit: insufficient memory for %d buffers", NBUF); ! 112: ! 113: for (i = 0; i < NHASH; ++i) ! 114: hasharray[i] = BNULL; ! 115: ! 116: /* ! 117: * initialize the buffer header array with the physical and ! 118: * virtual addresses of the buffers, NULL values for the ! 119: * hash chain pointers, and pointers to the successor and ! 120: * predecessor of the current node. ! 121: */ ! 122: firstbuf = &bufl[0]; ! 123: for (bp = lastbuf = &bufl[NBUF-1]; bp >= bufl; --bp) { ! 124: bp->b_dev = NODEV; ! 125: bp->b_paddr = p; ! 126: bp->b_vaddr = v; ! 127: bp->b_hashf = BNULL; ! 128: bp->b_hashb = BNULL; ! 129: bp->b_LRUf = bp + 1; /* next entry in chain */ ! 130: bp->b_LRUb = bp - 1; /* prev entry in chain */ ! 131: p += BSIZE; ! 132: v += BSIZE; ! 133: } ! 134: /* ! 135: * the first and last headers are special cases. ! 136: */ ! 137: bufl[0].b_LRUb = BNULL; /* no predecessor */ ! 138: bufl[NBUF-1].b_LRUf = BNULL; /* no successor */ ! 139: } ! 140: ! 141: /* ! 142: * Synchronise the buffer cache. ! 143: */ ! 144: bsync() ! 145: { ! 146: register BUF *bp; ! 147: ! 148: #if BDEBUG ! 149: ++bufdebug.bsync; ! 150: #endif ! 151: for (bp = &bufl[NBUF-1]; bp >= bufl; --bp) { ! 152: if ((bp->b_flag&BFMOD) == 0) ! 153: continue; ! 154: lock(bp->b_gate); ! 155: if (bp->b_flag&BFMOD) ! 156: bwrite(bp, 1); ! 157: unlock(bp->b_gate); ! 158: } ! 159: } ! 160: ! 161: /* ! 162: * Synchronise all block for a particular device in the buffer cache ! 163: * and invalidate all references. ! 164: */ ! 165: bflush(dev) ! 166: register dev_t dev; ! 167: { ! 168: register BUF *bp; ! 169: ! 170: #if BDEBUG ! 171: ++bufdebug.bflush; ! 172: #endif ! 173: for (bp = &bufl[NBUF-1]; bp >= bufl; --bp) { ! 174: if (bp->b_dev != dev) ! 175: continue; ! 176: lock(bp->b_gate); ! 177: if (bp->b_dev == dev) { ! 178: if (bp->b_flag&BFMOD) ! 179: bwrite(bp, 1); ! 180: bp->b_dev = NODEV; ! 181: } ! 182: unlock(bp->b_gate); ! 183: } ! 184: } ! 185: ! 186: /* ! 187: * Return a buffer containing the given block from the given device. ! 188: * If `sync' is not set, the read is asynchronous and no buffer is returned. ! 189: */ ! 190: BUF * ! 191: bread(dev, bno, sync) ! 192: dev_t dev; ! 193: daddr_t bno; ! 194: register int sync; ! 195: { ! 196: register BUF *bp; ! 197: register int s; ! 198: ! 199: #if BDEBUG ! 200: ++bufdebug.bread; ! 201: #endif ! 202: bp = bclaim(dev, bno); ! 203: if (bp->b_flag&BFNTP) { ! 204: if (sync) ! 205: bp->b_flag &= ~BFASY; ! 206: else { ! 207: bp->b_flag |= BFASY; ! 208: bumap(bp); ! 209: } ! 210: bp->b_req = BREAD; ! 211: bp->b_count = BSIZE; ! 212: s = sphi(); ! 213: dblock(dev, bp); ! 214: if (!sync) { ! 215: spl(s); ! 216: return (NULL); ! 217: } ! 218: /* ! 219: * If buffer is not valid, wait for it. ! 220: */ ! 221: while (bp->b_flag&BFNTP) { ! 222: v_sleep((char *)bp, CVBLKIO, IVBLKIO, SVBLKIO, "bpwait"); ! 223: /* If buffer is not valid, wait for it. */ ! 224: } ! 225: spl(s); ! 226: if (bp->b_flag&BFERR) { ! 227: SET_U_ERROR(bp->b_err ? bp->b_err : EIO, "bread()"); ! 228: brelease(bp); ! 229: return (NULL); ! 230: } ! 231: if (bp->b_resid == BSIZE) { ! 232: brelease(bp); ! 233: return (NULL); ! 234: } ! 235: } ! 236: if (!sync) { ! 237: brelease(bp); ! 238: return (NULL); ! 239: } ! 240: u.u_block++; ! 241: return (bp); ! 242: } ! 243: ! 244: /* ! 245: * Perform an LRU chain update by unlinking the specified buffer ! 246: * from it present location in the LRU chain and inserting it ! 247: * at the head of the chain, as pointed to by "firstbuf". Handle ! 248: * updating "lastbuf" if current buffer is the last buffer on the chain. ! 249: */ ! 250: static ! 251: LRUupdate(bp) ! 252: register BUF *bp; ! 253: { ! 254: if (bp != firstbuf) { ! 255: if (bp == lastbuf) ! 256: lastbuf = bp->b_LRUb; ! 257: if (bp->b_LRUb != BNULL) ! 258: bp->b_LRUb->b_LRUf = bp->b_LRUf; ! 259: if (bp->b_LRUf != BNULL) ! 260: bp->b_LRUf->b_LRUb = bp->b_LRUb; ! 261: bp->b_LRUb = BNULL; ! 262: bp->b_LRUf = firstbuf; ! 263: firstbuf->b_LRUb = bp; ! 264: firstbuf = bp; ! 265: } ! 266: } ! 267: ! 268: /* ! 269: * If the requested buffer header is in the hash chain, delete it. ! 270: */ ! 271: static ! 272: HASHdelete(bp) ! 273: register BUF *bp; ! 274: { ! 275: if (bp->b_hashb == BNULL) { /* we're first in the chain */ ! 276: hasharray[bp->b_hashval] = bp->b_hashf; ! 277: if (bp->b_hashf != BNULL) ! 278: bp->b_hashf->b_hashb = BNULL; ! 279: } else { ! 280: bp->b_hashb->b_hashf = bp->b_hashf; ! 281: if (bp->b_hashf != BNULL) ! 282: bp->b_hashf->b_hashb = bp->b_hashb; ! 283: } ! 284: bp->b_hashf = BNULL; ! 285: bp->b_hashb = BNULL; ! 286: } ! 287: ! 288: /* ! 289: * Insert the current buffer at the head of the appropriate hash chain. ! 290: */ ! 291: static ! 292: HASHinsert(bp) ! 293: register BUF *bp; ! 294: { ! 295: if (bp->b_hashf != BNULL || bp->b_hashb != BNULL) ! 296: panic("HASHinsert"); ! 297: bp->b_hashf = hasharray[bp->b_hashval]; ! 298: if (bp->b_hashf != BNULL) ! 299: bp->b_hashf->b_hashb = bp; ! 300: hasharray[bp->b_hashval] = bp; ! 301: } ! 302: ! 303: /* ! 304: * If the requested buffer is in the buffer cache, return a pointer to ! 305: * it. If not, pick an empty buffer, set it up and return it. ! 306: */ ! 307: BUF * ! 308: bclaim(dev, bno) ! 309: dev_t dev; ! 310: register daddr_t bno; ! 311: { ! 312: register BUF *bp; ! 313: register int s; ! 314: unsigned long hashval; ! 315: static GATE bufgate; /* better than sphi()/spl() */ ! 316: ! 317: #if BDEBUG ! 318: ++bufdebug.bclaim; ! 319: #endif ! 320: hashval = HASH(dev, bno) % NHASH; /* select a hash bucket */ ! 321: ! 322: again: ! 323: lock(bufgate); /* avoid pointer updates */ ! 324: ! 325: for (bp = hasharray[hashval]; bp != BNULL; bp = bp->b_hashf) { ! 326: #if BDEBUG ! 327: ++bufdebug.compares; ! 328: #endif ! 329: if (bp->b_bno == bno && bp->b_dev == dev) { ! 330: lock(bp->b_gate); ! 331: if (bp->b_bno != bno || bp->b_dev != dev) { ! 332: #if BDEBUG ! 333: ++bufdebug.fails; ! 334: #endif ! 335: unlock(bp->b_gate); ! 336: unlock(bufgate); ! 337: goto again; ! 338: } ! 339: #if BDEBUG ! 340: ++bufdebug.hits; ! 341: #endif ! 342: /* ! 343: * Now that we have located the buffer in the cache, ! 344: * unlink it from its current location in the ! 345: * LRU chain and move it to the front. ! 346: */ ! 347: LRUupdate(bp); ! 348: ! 349: /* ! 350: * If the buffer had an I/O error, mark it as ! 351: * invalid. Unlock the buffer gate and return ! 352: * the buffer to the requestor. ! 353: */ ! 354: if (bp->b_flag&BFERR) ! 355: bp->b_flag |= BFNTP; ! 356: unlock(bufgate); ! 357: bsmap(bp); ! 358: return (bp); ! 359: } ! 360: } ! 361: unlock(bufgate); ! 362: #if BDEBUG ! 363: ++bufdebug.misses; ! 364: #endif ! 365: ! 366: /* ! 367: * The requested buffer is not resident in our cache. Locate the ! 368: * oldest (least recently used) available buffer. If it's dirty, ! 369: * queue up an asynchronous write for it and continue searching ! 370: * for the next old candidate. Once a candidate is found, move it ! 371: * to the front of the LRU chain, update the hash pointers, mark ! 372: * the buffer as invalid, unlock our buffer gate and return the ! 373: * buffer to the requestor. ! 374: */ ! 375: for (;;) { /* loop until successful */ ! 376: lock(bufgate); ! 377: for (bp = lastbuf; bp != BNULL; bp = bp->b_LRUb) { ! 378: if (locked(bp->b_gate)) ! 379: continue; /* not available */ ! 380: s = sphi(); ! 381: if (locked(bp->b_gate)) { ! 382: spl(s); ! 383: continue; /* they snuck in ;-) */ ! 384: } ! 385: lock(bp->b_gate); ! 386: spl(s); ! 387: if (bp->b_flag&BFMOD) ! 388: bwrite(bp, 0); /* flush dirty buffer */ ! 389: else { ! 390: /* ! 391: * Update the hash chain for this old ! 392: * buffer. Unlink it from it's old location ! 393: * fixing up any references. Also, update ! 394: * the LRU chain to move the buffer to the head. ! 395: */ ! 396: HASHdelete(bp); ! 397: LRUupdate(bp); ! 398: ! 399: bp->b_flag = BFNTP; ! 400: bp->b_dev = dev; ! 401: bp->b_bno = bno; ! 402: bp->b_hashval = hashval; ! 403: ! 404: HASHinsert(bp); ! 405: unlock(bufgate); ! 406: bsmap(bp); ! 407: return (bp); ! 408: } ! 409: } ! 410: unlock(bufgate); ! 411: #if BDEBUG ! 412: ++bufdebug.needbuf; ! 413: #endif ! 414: s = sphi(); ! 415: bufneed = 1; ! 416: v_sleep((char *)&bufneed, CVBLKIO, IVBLKIO, SVBLKIO, "bufneed"); ! 417: /* There are no buffers available. */ ! 418: spl(s); ! 419: } /* forever */ ! 420: } ! 421: ! 422: /* ! 423: * Write the given buffer out. If `sync' is set, the write is synchronous, ! 424: * otherwise asynchronous. This routine must be called with the buffer ! 425: * gate locked. ! 426: */ ! 427: bwrite(bp, sync) ! 428: register BUF *bp; ! 429: { ! 430: register int s; ! 431: ! 432: #if BDEBUG ! 433: ++bufdebug.bwrite; ! 434: #endif ! 435: if (sync) ! 436: bp->b_flag &= ~BFASY; ! 437: else { ! 438: bp->b_flag |= BFASY; ! 439: bumap(bp); ! 440: } ! 441: bp->b_flag |= BFNTP; ! 442: bp->b_req = BWRITE; ! 443: bp->b_count = BSIZE; ! 444: s = sphi(); ! 445: dblock(bp->b_dev, bp); ! 446: if (!sync) { ! 447: spl(s); ! 448: return; ! 449: } ! 450: while (bp->b_flag&BFNTP) { ! 451: v_sleep((char *)bp, CVBLKIO, IVBLKIO, SVBLKIO, "bwrite"); ! 452: /* Waiting for a buffer write to finish. */ ! 453: } ! 454: spl(s); ! 455: } ! 456: ! 457: /* ! 458: * This is called by the driver when I/O has completed on a buffer. ! 459: */ ! 460: bdone(bp) ! 461: register BUF *bp; ! 462: { ! 463: #if BDEBUG ! 464: ++bufdebug.bdone; ! 465: #endif ! 466: if (bp->b_req == BWRITE) ! 467: bp->b_flag &= ~BFMOD; ! 468: if (bp->b_req == BREAD) { ! 469: if (bp->b_flag&BFERR) ! 470: bp->b_dev = NODEV; ! 471: } ! 472: if (bp->b_flag&BFASY) { ! 473: bp->b_flag &= ~BFASY; ! 474: brelease(bp); ! 475: } ! 476: bp->b_flag &= ~BFNTP; ! 477: dwakeup((char *)bp); ! 478: } ! 479: ! 480: /* ! 481: * Release the given buffer. ! 482: */ ! 483: brelease(bp) ! 484: register BUF *bp; ! 485: { ! 486: #if BDEBUG ! 487: ++bufdebug.brelease; ! 488: #endif ! 489: if (bp->b_flag&BFERR) { ! 490: bp->b_flag &= ~BFERR; ! 491: bp->b_dev = NODEV; ! 492: } ! 493: bp->b_flag &= ~BFNTP; ! 494: bumap(bp); ! 495: unlock(bp->b_gate); ! 496: if (bufneed) { ! 497: bufneed = 0; ! 498: wakeup((char *)&bufneed); ! 499: } ! 500: } ! 501: ! 502: /* ! 503: * Map the given buffer. ! 504: */ ! 505: bsmap(bp) ! 506: register BUF *bp; ! 507: { ! 508: bsave(bp->b_map); ! 509: bp->b_flag |= BFMAP; ! 510: bmapv(bconv(bp->b_paddr)); ! 511: } ! 512: ! 513: /* ! 514: * Unmap the given buffer. ! 515: */ ! 516: bumap(bp) ! 517: register BUF *bp; ! 518: { ! 519: if ((bp->b_flag&BFMAP) == 0) ! 520: return; ! 521: bp->b_flag &= ~BFMAP; ! 522: brest(bp->b_map); ! 523: } ! 524: ! 525: /* ! 526: * Read data from the I/O segment into kernel space. ! 527: */ ! 528: ioread(iop, v, n) ! 529: register IO *iop; ! 530: register char *v; ! 531: register unsigned n; ! 532: { ! 533: #if BDEBUG ! 534: ++bufdebug.ioread; ! 535: #endif ! 536: switch (iop->io_seg) { ! 537: case IOSYS: ! 538: #if BDEBUG ! 539: ++bufdebug.iosys; ! 540: #endif ! 541: iop->io.vbase += kkcopy(iop->io.vbase, v, n); ! 542: break; ! 543: case IOUSR: ! 544: #if BDEBUG ! 545: ++bufdebug.iousr; ! 546: #endif ! 547: iop->io.vbase += ukcopy(iop->io.vbase, v, n); ! 548: break; ! 549: case IOPHY: ! 550: #if BDEBUG ! 551: ++bufdebug.iophy; ! 552: #endif ! 553: dmain(n, iop->io.pbase, v); ! 554: iop->io.pbase += n; ! 555: break; ! 556: } ! 557: iop->io_ioc -= n; ! 558: } ! 559: ! 560: /* ! 561: * Write data from kernel space to the I/O segment. ! 562: */ ! 563: iowrite(iop, v, n) ! 564: register IO *iop; ! 565: register char *v; ! 566: register unsigned n; ! 567: { ! 568: #if BDEBUG ! 569: ++bufdebug.iowrite; ! 570: #endif ! 571: switch (iop->io_seg) { ! 572: case IOSYS: ! 573: #if BDEBUG ! 574: ++bufdebug.iosys; ! 575: #endif ! 576: iop->io.vbase += kkcopy(v, iop->io.vbase, n); ! 577: break; ! 578: case IOUSR: ! 579: #if BDEBUG ! 580: ++bufdebug.iousr; ! 581: #endif ! 582: iop->io.vbase += kucopy(v, iop->io.vbase, n); ! 583: break; ! 584: case IOPHY: ! 585: #if BDEBUG ! 586: ++bufdebug.iophy; ! 587: #endif ! 588: dmaout(n, iop->io.pbase, v); ! 589: iop->io.pbase += n; ! 590: break; ! 591: } ! 592: iop->io_ioc -= n; ! 593: } ! 594: ! 595: /* ! 596: * Get a character from the I/O segment. ! 597: */ ! 598: iogetc(iop) ! 599: register IO *iop; ! 600: { ! 601: register int c; ! 602: ! 603: #if BDEBUG ! 604: ++bufdebug.iogetc; ! 605: #endif ! 606: if (iop->io_ioc == 0) ! 607: return (-1); ! 608: --iop->io_ioc; ! 609: if (iop->io_seg == IOSYS) ! 610: c = *(char*) iop->io.vbase++ & 0377; ! 611: else { ! 612: c = getubd(iop->io.vbase++); ! 613: if (u.u_error) ! 614: return (-1); ! 615: } ! 616: return (c); ! 617: } ! 618: ! 619: /* ! 620: * Put a character using the I/O segment. ! 621: */ ! 622: ioputc(c, iop) ! 623: register IO *iop; ! 624: { ! 625: #if BDEBUG ! 626: ++bufdebug.ioputc; ! 627: #endif ! 628: if (iop->io_ioc == 0) ! 629: return (-1); ! 630: --iop->io_ioc; ! 631: if (iop->io_seg == IOSYS) ! 632: * (char *)iop->io.vbase++ = c; ! 633: else { ! 634: putubd(iop->io.vbase++, c); ! 635: if (u.u_error) ! 636: return (-1); ! 637: } ! 638: return (c); ! 639: } ! 640: ! 641: /* ! 642: * Given a buffer pointer, an I/O structure, a device, request type, and ! 643: * a flags word, check the I/O structure and perform the I/O request. ! 644: */ ! 645: ioreq(bp, iop, dev, req, f) ! 646: register BUF *bp; ! 647: register IO *iop; ! 648: dev_t dev; ! 649: { ! 650: register int n; ! 651: register int s; ! 652: register CON *cp; ! 653: dold_t dold; ! 654: ! 655: #if BDEBUG ! 656: ++bufdebug.ioreq; ! 657: #endif ! 658: if ((cp=drvmap(dev, &dold)) == NULL) ! 659: return; ! 660: lock(bp->b_gate); ! 661: n = cp->c_flag; /* n should do something with that flag */ ! 662: drest(dold); ! 663: if (iop) { ! 664: if (f&BFBLK) { ! 665: if (blocko(iop->io_seek)) { ! 666: SET_U_ERROR(EIO, "ioreq()"); ! 667: goto out; ! 668: } ! 669: } ! 670: if (f&BFIOC) { ! 671: if (!iomapvp(iop, bp)) { ! 672: SET_U_ERROR(EIO, "ioreq()"); ! 673: goto out; ! 674: } ! 675: } ! 676: } ! 677: bp->b_flag = f|BFNTP; ! 678: bp->b_req = req; ! 679: bp->b_dev = dev; ! 680: if (iop) { ! 681: bp->b_bno = blockn(iop->io_seek); ! 682: bp->b_count = iop->io_ioc; ! 683: } ! 684: s = sphi(); ! 685: dblock(dev, bp); ! 686: while (bp->b_flag&BFNTP) { ! 687: v_sleep((char *)bp, CVBLKIO, IVBLKIO, SVBLKIO, "ioreq"); ! 688: /* Ask norm what this sleep means. */ ! 689: } ! 690: spl(s); ! 691: if (stimer.t_last) ! 692: wakeup((char *)&stimer); ! 693: if (bp->b_flag&BFERR) { ! 694: SET_U_ERROR(bp->b_err ? bp->b_err : EIO, "ioreq()"); ! 695: goto out; ! 696: } ! 697: if (iop) { ! 698: n = iop->io_ioc - bp->b_resid; ! 699: iop->io_seek += n; ! 700: iop->io_ioc -= n; ! 701: } ! 702: out: ! 703: unlock(bp->b_gate); ! 704: } ! 705: ! 706: /* ! 707: * Given an I/O structure and a buffer header, see if the addresses ! 708: * in the I/O structure are valid and set up the buffer header. ! 709: * ! 710: * Search the u area segment table for a data segment containing ! 711: * iop->io.vbase. If one is found, put the corresponding system ! 712: * global address into bp->b_paddr and return the corresponding ! 713: * SEG pointer, else return NULL. ! 714: */ ! 715: SEG * ! 716: iomapvp(iop, bp) ! 717: register IO *iop; ! 718: register BUF *bp; ! 719: { ! 720: register SR *srp; ! 721: register SEG *sp; ! 722: register vaddr_t b, base; ! 723: ! 724: if (iop->io_seg != IOUSR) ! 725: panic("Raw I/O from non user"); ! 726: for (srp=u.u_segl; srp<&u.u_segl[NUSEG]; srp++) { ! 727: if ((sp=srp->sr_segp) == NULL) ! 728: continue; ! 729: if ((srp->sr_flag&SRFDATA) == 0) ! 730: continue; ! 731: /* ! 732: * The following calculation is because the system represents ! 733: * the 'base' of a stack as its upper limit (because it is the ! 734: * upper limit that is fixed). ! 735: */ ! 736: base = srp->sr_base; ! 737: if (srp==&u.u_segl[SISTACK]) ! 738: base -= srp->sr_size; ! 739: ! 740: if ((b=iop->io.vbase) < base) ! 741: continue; ! 742: if ((long)b+iop->io_ioc > base + sp->s_size) ! 743: continue; ! 744: bp->b_paddr = MAPIO(sp->s_vmem, b-base); ! 745: return (sp); ! 746: } ! 747: return 0; ! 748: } ! 749: ! 750: /* ! 751: * Initialise devices. ! 752: * Mark all initialized devices as loaded. ! 753: */ ! 754: devinit() ! 755: { ! 756: register DRV *dp; ! 757: register int mind; ! 758: ! 759: for ( dp = drvl, mind = 0; mind < drvn; mind++, dp++ ) { ! 760: if (dp->d_conp && dp->d_conp->c_load) { ! 761: (*dp->d_conp->c_load)(); ! 762: dev_loaded |= (1<<mind); ! 763: } ! 764: } ! 765: } ! 766: ! 767: /* ! 768: * Open a device. ! 769: */ ! 770: dopen(dev, m, f) ! 771: register dev_t dev; ! 772: { ! 773: register CON *cp; ! 774: dold_t dold; ! 775: ! 776: if ((cp=drvmap(dev, &dold)) == NULL) ! 777: return; ! 778: if ((cp->c_flag&f) == 0) { ! 779: SET_U_ERROR(ENXIO, "dopen()"); ! 780: return; ! 781: } ! 782: (*cp->c_open)(dev, m); ! 783: drest(dold); ! 784: } ! 785: ! 786: /* ! 787: * Close a device. ! 788: */ ! 789: dclose(dev) ! 790: register dev_t dev; ! 791: { ! 792: register CON *cp; ! 793: dold_t dold; ! 794: ! 795: if ((cp=drvmap(dev, &dold)) == NULL) ! 796: return; ! 797: (*cp->c_close)(dev); ! 798: drest(dold); ! 799: } ! 800: ! 801: /* ! 802: * Call the block entry point of a device. ! 803: */ ! 804: dblock(dev, bp) ! 805: dev_t dev; ! 806: BUF *bp; ! 807: { ! 808: register CON *cp; ! 809: dold_t dold; ! 810: ! 811: if ((cp=drvmap(dev, &dold)) == NULL) ! 812: return; ! 813: (*cp->c_block)(bp); ! 814: drest(dold); ! 815: } ! 816: ! 817: /* ! 818: * Read from a device. ! 819: */ ! 820: dread(dev, iop) ! 821: register dev_t dev; ! 822: register IO *iop; ! 823: { ! 824: register CON *cp; ! 825: dold_t dold; ! 826: ! 827: if ((cp=drvmap(dev, &dold)) == NULL) ! 828: return; ! 829: (*cp->c_read)(dev, iop); ! 830: drest(dold); ! 831: } ! 832: ! 833: /* ! 834: * Write to a device. ! 835: */ ! 836: dwrite(dev, iop) ! 837: register dev_t dev; ! 838: register IO *iop; ! 839: { ! 840: register CON *cp; ! 841: dold_t dold; ! 842: ! 843: if ((cp=drvmap(dev, &dold)) == NULL) ! 844: return; ! 845: (*cp->c_write)(dev, iop); ! 846: drest(dold); ! 847: } ! 848: ! 849: /* ! 850: * Call the ioctl function for a device. ! 851: */ ! 852: dioctl(dev, com, vec) ! 853: register dev_t dev; ! 854: union ioctl *vec; ! 855: { ! 856: register CON *cp; ! 857: dold_t dold; ! 858: ! 859: if ((cp=drvmap(dev, &dold)) == NULL) ! 860: return; ! 861: (*cp->c_ioctl)(dev, com, vec); ! 862: drest(dold); ! 863: } ! 864: ! 865: /* ! 866: * Call the powerfail entry point of a device. ! 867: */ ! 868: dpower(dev) ! 869: register dev_t dev; ! 870: { ! 871: register CON *cp; ! 872: dold_t dold; ! 873: ! 874: if ((cp=drvmap(dev, &dold)) == NULL) ! 875: return; ! 876: (*cp->c_power)(dev); ! 877: drest(dold); ! 878: } ! 879: ! 880: /* ! 881: * Call the timeout entry point of a device. ! 882: */ ! 883: dtime(dev) ! 884: register dev_t dev; ! 885: { ! 886: register CON *cp; ! 887: dold_t dold; ! 888: ! 889: if ((cp=drvmap(dev, &dold)) == NULL) ! 890: return; ! 891: (*cp->c_timer)(dev); ! 892: drest(dold); ! 893: } ! 894: ! 895: /* ! 896: * Poll a device. ! 897: */ ! 898: dpoll(dev, ev, msec) ! 899: register dev_t dev; ! 900: int ev; ! 901: int msec; ! 902: { ! 903: register CON *cp; ! 904: dold_t dold; ! 905: ! 906: if ((cp=drvmap(dev, &dold)) == NULL) ! 907: return POLLNVAL; ! 908: ! 909: if ( cp->c_flag & DFPOL ) ! 910: ev = (*cp->c_poll)(dev, ev, msec); ! 911: else ! 912: ev = POLLNVAL; ! 913: ! 914: drest(dold); ! 915: return ev; ! 916: } ! 917: ! 918: /* ! 919: * Given a device, return the flags word. ! 920: */ ! 921: dflag(dev) ! 922: dev_t dev; ! 923: { ! 924: register CON *cp; ! 925: register int f; ! 926: dold_t dold; ! 927: ! 928: if ((cp=drvmap(dev, &dold)) == NULL) ! 929: return (DFERR); ! 930: f = cp->c_flag; ! 931: drest(dold); ! 932: return (f); ! 933: } ! 934: ! 935: /* ! 936: * Given a device, and a pointer to a driver map save area, save the ! 937: * current map in the driver map save area and map in the new device, ! 938: * returning a pointer to the configuration entry for that device. ! 939: */ ! 940: CON * ! 941: drvmap(dev, doldp) ! 942: dev_t dev; ! 943: dold_t *doldp; ! 944: { ! 945: register DRV *dp; ! 946: register unsigned m; ! 947: ! 948: if ((m=major(dev)) >= drvn) { ! 949: SET_U_ERROR(ENXIO, "drvmap()"); ! 950: return (NULL); ! 951: } ! 952: dp = &drvl[m]; ! 953: if (locked(dp->d_gate)) { ! 954: SET_U_ERROR(ENXIO, "drvmap()"); ! 955: return (NULL); ! 956: } ! 957: if (dp->d_conp == NULL) { ! 958: SET_U_ERROR(ENXIO, "drvmap()"); ! 959: return (NULL); ! 960: } ! 961: dsave(*doldp); ! 962: if (dp->d_map) ! 963: dmapv(dp->d_map); ! 964: return (dp->d_conp); ! 965: } ! 966: ! 967: /* ! 968: * Non existant device. ! 969: */ ! 970: nonedev() ! 971: { ! 972: SET_U_ERROR(ENXIO, "nonedev()"); ! 973: } ! 974: ! 975: /* ! 976: * Null device. ! 977: */ ! 978: nulldev() ! 979: { ! 980: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.