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