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