![[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 / 286_KERNEL / USRSRC / coh|
Return to bio.c CVS log | Up to [MW Coherent from dump] / coherent / d / 286_KERNEL / USRSRC / coh |
1.1 root 1: /* $Header: /x/usr/src/sys/coh/RCS/bio.c,v 1.1 91/11/08 12:46:39 hal Exp $ */
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.1 91/11/08 12:46:39 hal
21: * Used in COH 3.2.0
22: *
23: * Revision 1.1 88/03/24 16:13:29 src
24: * Initial revision
25: *
26: * 87/11/25 Allan Cornish /usr/src/sys/coh/bio.c
27: * vaddr_t bp->b_vaddr --> faddr_t bp->b_faddr.
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: #include <sys/uproc.h>
54:
55: /*
56: * Initialise buffer headers.
57: */
58: bufinit()
59: {
60: register BUF *bp;
61: faddr_t f;
62: paddr_t p;
63:
64: FP_SEL(f) = sds;
65: FP_OFF(f) = 0;
66: p = blockp;
67: FP_OFF(f) = blockp - vtop(f);
68:
69: bufl = kalloc(NBUF * sizeof(BUF));
70: if (bufl == NULL)
71: panic("bufinit: no space for BUF's");
72:
73: for (bp=&bufl[NBUF-1]; bp >= bufl; --bp) {
74: bp->b_dev = NODEV;
75: bp->b_faddr = f;
76: bp->b_paddr = p;
77: FP_OFF(f) += BSIZE;
78: p += BSIZE;
79: }
80: }
81:
82: /*
83: * Synchronise the buffer cache.
84: */
85: bsync()
86: {
87: register BUF *bp;
88:
89: for (bp=&bufl[NBUF-1]; bp >= bufl; --bp) {
90: if ((bp->b_flag&BFMOD) == 0)
91: continue;
92: lock(bp->b_gate);
93: if ((bp->b_flag&BFMOD) != 0)
94: bwrite(bp, 1);
95: unlock(bp->b_gate);
96: }
97: }
98:
99: /*
100: * Synchronise all block for a particular device in the buffer cache
101: * and invalidate all references.
102: */
103: bflush(dev)
104: register dev_t dev;
105: {
106: register BUF *bp;
107:
108: for (bp=&bufl[NBUF-1]; bp >= bufl; --bp) {
109: if (bp->b_dev != dev)
110: continue;
111: lock(bp->b_gate);
112: if (bp->b_dev == dev) {
113: if ((bp->b_flag&BFMOD) != 0)
114: bwrite(bp, 1);
115: bp->b_dev = NODEV;
116: }
117: unlock(bp->b_gate);
118: }
119: }
120:
121: /*
122: * Return a buffer containing the given block from the given device.
123: * If `f' is not set, the read is asynchronous and no buffer is returned.
124: */
125: BUF *
126: bread(dev, bno, f)
127: dev_t dev;
128: daddr_t bno;
129: register int f;
130: {
131: register BUF *bp;
132: register int s;
133:
134: bp = bclaim(dev, bno);
135: if ((bp->b_flag&BFNTP) != 0) {
136: if (f != 0)
137: bp->b_flag &= ~BFASY;
138: else {
139: bp->b_flag |= BFASY;
140: bumap(bp);
141: }
142: bp->b_req = BREAD;
143: bp->b_count = BSIZE;
144: s = sphi();
145: dblock(dev, bp);
146: if (f == 0) {
147: spl(s);
148: return (NULL);
149: }
150: while ((bp->b_flag&BFNTP) != 0)
151: sleep((char *)bp, CVBLKIO, IVBLKIO, SVBLKIO);
152: spl(s);
153: if ((bp->b_flag&BFERR) != 0) {
154: u.u_error = bp->b_err ? bp->b_err : EIO;
155: brelease(bp);
156: return (NULL);
157: }
158: if (bp->b_resid == BSIZE) {
159: brelease(bp);
160: return (NULL);
161: }
162: }
163: if (f == 0) {
164: brelease(bp);
165: return (NULL);
166: }
167: u.u_block++;
168: return (bp);
169: }
170:
171: /*
172: * If the requested buffer is in the buffer cache, return a pointer to
173: * it. If not, pick an empty buffer, set it up and return it.
174: */
175: BUF *
176: bclaim(dev, bno)
177: dev_t dev;
178: daddr_t bno;
179: {
180: register BUF *bp;
181: register BUF *bp1;
182: register unsigned seqn;
183: register int s;
184:
185: again:
186: bp1 = NULL;
187: seqn = 0;
188: for (bp=&bufl[NBUF-1]; bp >= bufl; --bp) {
189: if (bp->b_bno == bno && bp->b_dev == dev) {
190: lock(bp->b_gate);
191: if (bp->b_bno != bno || bp->b_dev != dev) {
192: unlock(bp->b_gate);
193: goto again;
194: }
195: if ((bp->b_flag&BFERR) != 0)
196: bp->b_flag |= BFNTP;
197: bsmap(bp);
198: return (bp);
199: }
200: if (locked(bp->b_gate) == 0) {
201: if (bufseqn-bp->b_seqn >= seqn) {
202: bp1 = bp;
203: seqn = bufseqn - bp->b_seqn;
204: }
205: }
206: }
207: if (bp1 == NULL) {
208: s = sphi();
209: for (bp=&bufl[NBUF-1]; bp >= bufl; --bp) {
210: if (locked(bp->b_gate) == 0) {
211: if (bufseqn-bp->b_seqn >= seqn) {
212: bp1 = bp;
213: seqn = bufseqn - bp->b_seqn;
214: }
215: }
216: }
217: if (bp1 == NULL) {
218: bufneed = 1;
219: sleep((char *)&bufneed, CVBLKIO, IVBLKIO, SVBLKIO);
220: spl(s);
221: goto again;
222: }
223: spl(s);
224: }
225: bp = bp1;
226: lock(bp->b_gate);
227: if ((bp->b_flag&BFMOD) != 0) {
228: bwrite(bp, 0);
229: goto again;
230: }
231: bp->b_flag = BFNTP;
232: bp->b_dev = dev;
233: bp->b_bno = bno;
234: bsmap(bp);
235: return (bp);
236: }
237:
238: /*
239: * Write the given buffer out. If `f' is set, the write is synchronous,
240: * otherwise asynchronous. This routine must be called with the buffer
241: * gate locked.
242: */
243: bwrite(bp, f)
244: register BUF *bp;
245: {
246: register int s;
247:
248: if (f != 0)
249: bp->b_flag &= ~BFASY;
250: else {
251: bp->b_flag |= BFASY;
252: bumap(bp);
253: }
254: bp->b_flag |= BFNTP;
255: bp->b_req = BWRITE;
256: bp->b_count = BSIZE;
257: s = sphi();
258: dblock(bp->b_dev, bp);
259: if (f == 0) {
260: spl(s);
261: return;
262: }
263: while ((bp->b_flag&BFNTP) != 0)
264: sleep((char *)bp, CVBLKIO, IVBLKIO, SVBLKIO);
265: spl(s);
266: }
267:
268: /*
269: * This is called by the driver when I/O has completed on a buffer.
270: */
271: bdone(bp)
272: register BUF *bp;
273: {
274: if (bp->b_req == BWRITE)
275: bp->b_flag &= ~BFMOD;
276: if (bp->b_req == BREAD) {
277: if ((bp->b_flag&BFERR) != 0)
278: bp->b_dev = NODEV;
279: }
280: if ((bp->b_flag&BFASY) != 0) {
281: bp->b_flag &= ~BFASY;
282: brelease(bp);
283: }
284: bp->b_flag &= ~BFNTP;
285: wakeup((char *)bp);
286: }
287:
288: /*
289: * Release the given buffer.
290: */
291: brelease(bp)
292: register BUF *bp;
293: {
294: if ((bp->b_flag&BFERR) == 0)
295: bp->b_seqn = bufseqn++;
296: else {
297: bp->b_flag &= ~BFERR;
298: bp->b_dev = NODEV;
299: }
300: bp->b_flag &= ~BFNTP;
301: bumap(bp);
302: unlock(bp->b_gate);
303: if (bufneed != 0) {
304: bufneed = 0;
305: wakeup((char *)&bufneed);
306: }
307: }
308:
309: /*
310: * Map the given buffer.
311: */
312: bsmap(bp)
313: register BUF *bp;
314: {
315: bsave(bp->b_map);
316: bp->b_flag |= BFMAP;
317: bmapv(bconv(bp->b_paddr));
318: }
319:
320: /*
321: * Unmap the given buffer.
322: */
323: bumap(bp)
324: register BUF *bp;
325: {
326: if ((bp->b_flag&BFMAP) == 0)
327: return;
328: bp->b_flag &= ~BFMAP;
329: brest(bp->b_map);
330: }
331:
332: /*
333: * Read data from the I/O segment into kernel space.
334: */
335: ioread(iop, v, n)
336: register IO *iop;
337: register char *v;
338: register unsigned n;
339: {
340: switch (iop->io_seg) {
341: case IOSYS:
342: iop->io_base += kkcopy(iop->io_base, v, n);
343: break;
344: case IOUSR:
345: iop->io_base += ukcopy(iop->io_base, v, n);
346: break;
347: case IOPHY:
348: iop->io_phys += pkcopy(iop->io_phys, v, n);
349: break;
350: }
351: iop->io_ioc -= n;
352: }
353:
354: /*
355: * Write data from kernel space to the I/O segment.
356: */
357: iowrite(iop, v, n)
358: register IO *iop;
359: register char *v;
360: register unsigned n;
361: {
362: switch (iop->io_seg) {
363: case IOSYS:
364: iop->io_base += kkcopy(v, iop->io_base, n);
365: break;
366: case IOUSR:
367: iop->io_base += kucopy(v, iop->io_base, n);
368: break;
369: case IOPHY:
370: iop->io_phys += kpcopy(v, iop->io_phys, n);
371: break;
372: }
373: iop->io_ioc -= n;
374: }
375:
376: /*
377: * Get a character from the I/O segment.
378: */
379: iogetc(iop)
380: register IO *iop;
381: {
382: register int c;
383:
384: if (iop->io_ioc == 0)
385: return (-1);
386: --iop->io_ioc;
387: if (iop->io_seg == IOSYS)
388: c = *iop->io_base++ & 0377;
389: else {
390: c = getubd(iop->io_base++);
391: if (u.u_error)
392: return (-1);
393: }
394: return (c);
395: }
396:
397: /*
398: * Put a character using the I/O segment.
399: */
400: ioputc(c, iop)
401: register IO *iop;
402: {
403: if (iop->io_ioc == 0)
404: return (-1);
405: --iop->io_ioc;
406: if (iop->io_seg == IOSYS)
407: *iop->io_base++ = c;
408: else {
409: putubd(iop->io_base++, c);
410: if (u.u_error)
411: return (-1);
412: }
413: return (c);
414: }
415:
416: /*
417: * Given a buffer pointer, an I/O structure, a device, request type, and
418: * a flags word, check the I/O structure and perform the I/O request.
419: */
420: ioreq(bp, iop, dev, req, f)
421: register BUF *bp;
422: register IO *iop;
423: dev_t dev;
424: {
425: register SEG *sp;
426: register int n;
427: register int s;
428: register CON *cp;
429: dold_t dold;
430:
431: if ((cp=drvmap(dev, &dold)) == NULL)
432: return;
433: lock(bp->b_gate);
434: n = cp->c_flag; /* n should do something with that flag */
435: drest(dold);
436: sp = NULL;
437: if (iop != NULL) {
438: if ((f&BFBLK) != 0) {
439: if (blocko(iop->io_seek) != 0) {
440: u.u_error = EIO;
441: goto out;
442: }
443: }
444: if ((f&BFIOC) != 0) {
445: if ((sp=iomapvp(iop, bp)) == NULL) {
446: u.u_error = EIO;
447: goto out;
448: }
449: }
450: }
451: bp->b_flag = f|BFNTP;
452: bp->b_req = req;
453: bp->b_dev = dev;
454: if (iop != NULL) {
455: bp->b_bno = blockn(iop->io_seek);
456: bp->b_count = iop->io_ioc;
457: }
458: if (sp != NULL) {
459: bp->b_faddr = ptov( bp->b_paddr, (fsize_t) bp->b_count );
460: sp->s_lrefc++;
461: }
462: s = sphi();
463: dblock(dev, bp);
464: while ((bp->b_flag&BFNTP) != 0)
465: sleep((char *)bp, CVBLKIO, IVBLKIO, SVBLKIO);
466: spl(s);
467: if (sp != NULL) {
468: vrelse( bp->b_faddr );
469: sp->s_lrefc--;
470: }
471: if (stimer.t_last != 0)
472: wakeup((char *)&stimer);
473: if ((bp->b_flag&BFERR) != 0) {
474: u.u_error = bp->b_err ? bp->b_err : EIO;
475: goto out;
476: }
477: if (iop != NULL) {
478: n = iop->io_ioc - bp->b_resid;
479: iop->io_seek += n;
480: iop->io_ioc -= n;
481: }
482: out:
483: unlock(bp->b_gate);
484: }
485:
486: /*
487: * Given an I/O structure and a buffer header, see if the addresses
488: * in the I/O structure are valid and set up the buffer header.
489: */
490: SEG *
491: iomapvp(iop, bp)
492: register IO *iop;
493: register BUF *bp;
494: {
495: register SR *srp;
496: register SEG *sp;
497: register vaddr_t b;
498:
499: if (iop->io_seg != IOUSR)
500: panic("Raw I/O from non user");
501: for (srp=u.u_segl; srp<&u.u_segl[NUSEG]; srp++) {
502: if ((sp=srp->sr_segp) == NULL)
503: continue;
504: if ((srp->sr_flag&SRFDATA) == 0)
505: continue;
506: /* Yet another bug in the 8000 C compiler
507: if ((long)(b=iop->io_base) < (long)srp->sr_base)
508: */
509: if ((b=iop->io_base) < srp->sr_base)
510: continue;
511: if ((long)b+iop->io_ioc > (long)srp->sr_base + sp->s_size)
512: continue;
513: bp->b_paddr = sp->s_paddr + (vaddr_t) (b - srp->sr_base);
514: return (sp);
515: }
516: return (NULL);
517: }
518:
519: /*
520: * Initialise devices.
521: */
522: devinit()
523: {
524: register DRV *dp;
525: register int mind;
526:
527: for ( dp = drvl, mind = 0; mind < drvn; mind++, dp++ ) {
528: if ((dp->d_conp != NULL) && (dp->d_conp->c_load != NULL)) {
529: (*dp->d_conp->c_load)();
530: }
531: }
532: }
533:
534: /*
535: * Open a device.
536: */
537: dopen(dev, m, f)
538: register dev_t dev;
539: {
540: register CON *cp;
541: dold_t dold;
542:
543: if ((cp=drvmap(dev, &dold)) == NULL)
544: return;
545: if ((cp->c_flag&f) == 0) {
546: u.u_error = ENXIO;
547: return;
548: }
549: (*cp->c_open)(dev, m);
550: drest(dold);
551: }
552:
553: /*
554: * Close a device.
555: */
556: dclose(dev)
557: register dev_t dev;
558: {
559: register CON *cp;
560: dold_t dold;
561:
562: if ((cp=drvmap(dev, &dold)) == NULL)
563: return;
564: (*cp->c_close)(dev);
565: drest(dold);
566: }
567:
568: /*
569: * Call the block entry point of a device.
570: */
571: dblock(dev, bp)
572: dev_t dev;
573: BUF *bp;
574: {
575: register CON *cp;
576: dold_t dold;
577:
578: if ((cp=drvmap(dev, &dold)) == NULL)
579: return;
580: (*cp->c_block)(bp);
581: drest(dold);
582: }
583:
584: /*
585: * Read from a device.
586: */
587: dread(dev, iop)
588: register dev_t dev;
589: register IO *iop;
590: {
591: register CON *cp;
592: dold_t dold;
593:
594: if ((cp=drvmap(dev, &dold)) == NULL)
595: return;
596: (*cp->c_read)(dev, iop);
597: drest(dold);
598: }
599:
600: /*
601: * Write to a device.
602: */
603: dwrite(dev, iop)
604: register dev_t dev;
605: register IO *iop;
606: {
607: register CON *cp;
608: dold_t dold;
609:
610: if ((cp=drvmap(dev, &dold)) == NULL)
611: return;
612: (*cp->c_write)(dev, iop);
613: drest(dold);
614: }
615:
616: /*
617: * Call the ioctl function for a device.
618: */
619: dioctl(dev, com, vec)
620: register dev_t dev;
621: union ioctl *vec;
622: {
623: register CON *cp;
624: dold_t dold;
625:
626: if ((cp=drvmap(dev, &dold)) == NULL)
627: return;
628: (*cp->c_ioctl)(dev, com, vec);
629: drest(dold);
630: }
631:
632: /*
633: * Call the powerfail entry point of a device.
634: */
635: dpower(dev)
636: register dev_t dev;
637: {
638: register CON *cp;
639: dold_t dold;
640:
641: if ((cp=drvmap(dev, &dold)) == NULL)
642: return;
643: (*cp->c_power)(dev);
644: drest(dold);
645: }
646:
647: /*
648: * Call the timeout entry point of a device.
649: */
650: dtime(dev)
651: register dev_t dev;
652: {
653: register CON *cp;
654: dold_t dold;
655:
656: if ((cp=drvmap(dev, &dold)) == NULL)
657: return;
658: (*cp->c_timer)(dev);
659: drest(dold);
660: }
661:
662: /*
663: * Poll a device.
664: */
665: dpoll(dev, ev, msec)
666: register dev_t dev;
667: int ev;
668: int msec;
669: {
670: register CON *cp;
671: dold_t dold;
672:
673: if ((cp=drvmap(dev, &dold)) == NULL)
674: return POLLNVAL;
675:
676: if ( cp->c_flag & DFPOL )
677: ev = (*cp->c_poll)(dev, ev, msec);
678: else
679: ev = POLLNVAL;
680:
681: drest(dold);
682: return ev;
683: }
684:
685: /*
686: * Given a device, return the flags word.
687: */
688: dflag(dev)
689: dev_t dev;
690: {
691: register CON *cp;
692: register int f;
693: dold_t dold;
694:
695: if ((cp=drvmap(dev, &dold)) == NULL)
696: return (DFERR);
697: f = cp->c_flag;
698: drest(dold);
699: return (f);
700: }
701:
702: /*
703: * Given a device, and a pointer to a driver map save area, save the
704: * current map in the driver map save area and map in the new device,
705: * returning a pointer to the configuration entry for that device.
706: */
707: CON *
708: drvmap(dev, doldp)
709: dev_t dev;
710: dold_t *doldp;
711: {
712: register DRV *dp;
713: register unsigned m;
714:
715: if ((m=major(dev)) >= drvn) {
716: u.u_error = ENXIO;
717: return (NULL);
718: }
719: dp = &drvl[m];
720: if (locked(dp->d_gate)) {
721: u.u_error = ENXIO;
722: return (NULL);
723: }
724: if (dp->d_conp == NULL) {
725: u.u_error = ENXIO;
726: return (NULL);
727: }
728: dsave(*doldp);
729: if (dp->d_map != 0)
730: dmapv(dp->d_map);
731: return (dp->d_conp);
732: }
733:
734: /*
735: * Non existant device.
736: */
737: nonedev()
738: {
739: u.u_error = ENXIO;
740: }
741:
742: /*
743: * Null device.
744: */
745: nulldev()
746: {
747: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.