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