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