![[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 [Research Unix] / researchv8dc / sys / dev|
Return to bio.c CVS log | Up to [Research Unix] / researchv8dc / sys / dev |
1.1 root 1: /* bio.c 4.21 81/05/08 */
2:
3: #include "../h/param.h"
4: #include "../h/systm.h"
5: #include "../h/dir.h"
6: #include "../h/user.h"
7: #include "../h/buf.h"
8: #include "../h/conf.h"
9: #include "../h/proc.h"
10: #include "../h/seg.h"
11: #include "../h/pte.h"
12: #include "../h/vm.h"
13: #include "../h/trace.h"
14:
15: /*
16: * The following several routines allocate and free
17: * buffers with various side effects. In general the
18: * arguments to an allocate routine are a device and
19: * a block number, and the value is a pointer to
20: * to the buffer header; the buffer is marked "busy"
21: * so that no one else can touch it. If the block was
22: * already in core, no I/O need be done; if it is
23: * already busy, the process waits until it becomes free.
24: * The following routines allocate a buffer:
25: * getblk
26: * bread
27: * breada
28: * baddr (if it is incore)
29: * Eventually the buffer must be released, possibly with the
30: * side effect of writing it out, by using one of
31: * bwrite
32: * bdwrite
33: * bawrite
34: * brelse
35: */
36:
37: struct buf bfreelist[BQUEUES];
38: struct buf bswlist, *bclnlist;
39:
40: #define BUFHSZ 63
41: struct bufhd bufhash[BUFHSZ];
42: #define BUFHASH(dev, dblkno) \
43: ((struct buf *)&bufhash[((int)(dev)+(int)(dblkno)) % BUFHSZ])
44:
45: /*
46: * Initialize hash links for buffers.
47: */
48: bhinit()
49: {
50: register int i;
51: register struct bufhd *bp;
52:
53: for (bp = bufhash, i = 0; i < BUFHSZ; i++, bp++)
54: bp->b_forw = bp->b_back = (struct buf *)bp;
55: }
56:
57: /* #define DISKMON 1 */
58:
59: #ifdef DISKMON
60: struct {
61: int nbuf;
62: long nread;
63: long nreada;
64: long ncache;
65: long nwrite;
66: long bufcount[64];
67: } io_info;
68: #endif
69:
70: /*
71: * Swap IO headers -
72: * They contain the necessary information for the swap I/O.
73: * At any given time, a swap header can be in three
74: * different lists. When free it is in the free list,
75: * when allocated and the I/O queued, it is on the swap
76: * device list, and finally, if the operation was a dirty
77: * page push, when the I/O completes, it is inserted
78: * in a list of cleaned pages to be processed by the pageout daemon.
79: */
80: struct buf *swbuf;
81: short *swsize; /* CAN WE JUST USE B_BCOUNT? */
82: int *swpf;
83:
84:
85: #ifndef UNFAST
86: #define notavail(bp) \
87: { \
88: int s = spl6(); \
89: (bp)->av_back->av_forw = (bp)->av_forw; \
90: (bp)->av_forw->av_back = (bp)->av_back; \
91: (bp)->b_flags |= B_BUSY; \
92: splx(s); \
93: }
94: #endif
95:
96: /*
97: * Read in (if necessary) the block and return a buffer pointer.
98: */
99: struct buf *
100: bread(dev, blkno)
101: dev_t dev;
102: daddr_t blkno;
103: {
104: register struct buf *bp;
105:
106: bp = getblk(dev, blkno);
107: if (bp->b_flags&B_DONE) {
108: #ifdef DISKMON
109: io_info.ncache++;
110: #endif
111: return(bp);
112: }
113: bp->b_flags |= B_READ;
114: bp->b_bcount = BSIZE(dev);
115: (*bdevsw[major(dev)].d_strategy)(bp);
116: #ifdef DISKMON
117: io_info.nread++;
118: #endif
119: u.u_vm.vm_inblk++; /* pay for read */
120: iowait(bp);
121: return(bp);
122: }
123:
124: /*
125: * Read in the block, like bread, but also start I/O on the
126: * read-ahead block (which is not allocated to the caller)
127: */
128: struct buf *
129: breada(dev, blkno, rablkno)
130: dev_t dev;
131: daddr_t blkno, rablkno;
132: {
133: register struct buf *bp, *rabp;
134:
135: bp = NULL;
136: if (!incore(dev, blkno)) {
137: bp = getblk(dev, blkno);
138: if ((bp->b_flags&B_DONE) == 0) {
139: bp->b_flags |= B_READ;
140: bp->b_bcount = BSIZE(dev);
141: (*bdevsw[major(dev)].d_strategy)(bp);
142: #ifdef DISKMON
143: io_info.nread++;
144: #endif
145: u.u_vm.vm_inblk++; /* pay for read */
146: }
147: }
148: if (rablkno && !incore(dev, rablkno)) {
149: rabp = getblk(dev, rablkno);
150: if (rabp->b_flags & B_DONE) {
151: brelse(rabp);
152: } else {
153: rabp->b_flags |= B_READ|B_ASYNC;
154: rabp->b_bcount = BSIZE(dev);
155: (*bdevsw[major(dev)].d_strategy)(rabp);
156: #ifdef DISKMON
157: io_info.nreada++;
158: #endif
159: u.u_vm.vm_inblk++; /* pay in advance */
160: }
161: }
162: if(bp == NULL)
163: return(bread(dev, blkno));
164: iowait(bp);
165: return(bp);
166: }
167:
168: /*
169: * Write the buffer, waiting for completion.
170: * Then release the buffer.
171: */
172: bwrite(bp)
173: register struct buf *bp;
174: {
175: register flag;
176:
177: flag = bp->b_flags;
178: bp->b_flags &= ~(B_READ | B_DONE | B_ERROR | B_DELWRI | B_AGE);
179: bp->b_bcount = BSIZE(bp->b_dev);
180: #ifdef DISKMON
181: io_info.nwrite++;
182: #endif
183: if ((flag&B_DELWRI) == 0)
184: u.u_vm.vm_oublk++; /* noone paid yet */
185: (*bdevsw[major(bp->b_dev)].d_strategy)(bp);
186: if ((flag&B_ASYNC) == 0) {
187: iowait(bp);
188: brelse(bp);
189: } else if (flag & B_DELWRI)
190: bp->b_flags |= B_AGE;
191: else
192: geterror(bp);
193: }
194:
195: /*
196: * Release the buffer, marking it so that if it is grabbed
197: * for another purpose it will be written out before being
198: * given up (e.g. when writing a partial block where it is
199: * assumed that another write for the same block will soon follow).
200: * This can't be done for magtape, since writes must be done
201: * in the same order as requested.
202: */
203: bdwrite(bp)
204: register struct buf *bp;
205: {
206: register int flags;
207:
208: if ((bp->b_flags&B_DELWRI) == 0)
209: u.u_vm.vm_oublk++; /* noone paid yet */
210: flags = bdevsw[major(bp->b_dev)].d_flags;
211: if(flags & B_TAPE)
212: bawrite(bp);
213: else {
214: bp->b_flags |= B_DELWRI | B_DONE;
215: brelse(bp);
216: }
217: }
218:
219: /*
220: * Release the buffer, start I/O on it, but don't wait for completion.
221: */
222: bawrite(bp)
223: register struct buf *bp;
224: {
225:
226: bp->b_flags |= B_ASYNC;
227: bwrite(bp);
228: }
229:
230: /*
231: * release the buffer, with no I/O implied.
232: */
233: brelse(bp)
234: register struct buf *bp;
235: {
236: register struct buf *flist;
237: register s;
238:
239: if (bp->b_flags&B_WANTED)
240: wakeup((caddr_t)bp);
241: if (bfreelist[0].b_flags&B_WANTED) {
242: bfreelist[0].b_flags &= ~B_WANTED;
243: wakeup((caddr_t)bfreelist);
244: }
245: if (bp->b_flags&B_ERROR)
246: if (bp->b_flags & B_LOCKED)
247: bp->b_flags &= ~B_ERROR; /* try again later */
248: else
249: bp->b_dev = NODEV; /* no assoc */
250: s = spl6();
251: if (bp->b_flags & (B_ERROR|B_INVAL)) {
252: /* block has no info ... put at front of most free list */
253: flist = &bfreelist[BQUEUES-1];
254: flist->av_forw->av_back = bp;
255: bp->av_forw = flist->av_forw;
256: flist->av_forw = bp;
257: bp->av_back = flist;
258: } else {
259: if (bp->b_flags & B_LOCKED)
260: flist = &bfreelist[BQ_LOCKED];
261: else if (bp->b_flags & B_AGE)
262: flist = &bfreelist[BQ_AGE];
263: else
264: flist = &bfreelist[BQ_LRU];
265: flist->av_back->av_forw = bp;
266: bp->av_back = flist->av_back;
267: flist->av_back = bp;
268: bp->av_forw = flist;
269: }
270: bp->b_flags &= ~(B_WANTED|B_BUSY|B_ASYNC|B_AGE);
271: splx(s);
272: }
273:
274: /*
275: * See if the block is associated with some buffer
276: * (mainly to avoid getting hung up on a wait in breada)
277: */
278: incore(dev, blkno)
279: dev_t dev;
280: daddr_t blkno;
281: {
282: register struct buf *bp;
283: register struct buf *dp;
284: register int dblkno = fsbtodb(dev, blkno);
285:
286: dp = BUFHASH(dev, dblkno);
287: for (bp = dp->b_forw; bp != dp; bp = bp->b_forw)
288: if (bp->b_blkno == dblkno && bp->b_dev == dev &&
289: !(bp->b_flags & B_INVAL))
290: return (1);
291: return (0);
292: }
293:
294: struct buf *
295: baddr(dev, blkno)
296: dev_t dev;
297: daddr_t blkno;
298: {
299:
300: if (incore(dev, blkno))
301: return (bread(dev, blkno));
302: return (0);
303: }
304:
305: /*
306: * Assign a buffer for the given block. If the appropriate
307: * block is already associated, return it; otherwise search
308: * for the oldest non-busy buffer and reassign it.
309: */
310: struct buf *
311: getblk(dev, blkno)
312: dev_t dev;
313: daddr_t blkno;
314: {
315: register struct buf *bp, *dp, *ep;
316: register int dblkno = fsbtodb(dev, blkno);
317: #ifdef DISKMON
318: register int i;
319: #endif
320:
321: if ((unsigned)blkno >= 1 << (sizeof(int)*NBBY-PGSHIFT))
322: blkno = 1 << ((sizeof(int)*NBBY-PGSHIFT) + 1);
323: dblkno = fsbtodb(dev, blkno);
324: dp = BUFHASH(dev, dblkno);
325: loop:
326: (void) spl0();
327: for (bp = dp->b_forw; bp != dp; bp = bp->b_forw) {
328: if (bp->b_blkno != dblkno || bp->b_dev != dev ||
329: bp->b_flags&B_INVAL)
330: continue;
331: (void) spl6();
332: if (bp->b_flags&B_BUSY) {
333: bp->b_flags |= B_WANTED;
334: sleep((caddr_t)bp, PRIBIO+1);
335: goto loop;
336: }
337: (void) spl0();
338: #ifdef DISKMON
339: i = 0;
340: dp = bp->av_forw;
341: while ((dp->b_flags & B_HEAD) == 0) {
342: i++;
343: dp = dp->av_forw;
344: }
345: if (i<64)
346: io_info.bufcount[i]++;
347: #endif
348: notavail(bp);
349: bp->b_flags |= B_CACHE;
350: return(bp);
351: }
352: if (major(dev) >= nblkdev)
353: panic("blkdev");
354: (void) spl6();
355: for (ep = &bfreelist[BQUEUES-1]; ep > bfreelist; ep--)
356: if (ep->av_forw != ep)
357: break;
358: if (ep == bfreelist) { /* no free blocks at all */
359: ep->b_flags |= B_WANTED;
360: sleep((caddr_t)ep, PRIBIO+1);
361: goto loop;
362: }
363: (void) spl0();
364: bp = ep->av_forw;
365: notavail(bp);
366: if (bp->b_flags & B_DELWRI) {
367: bp->b_flags |= B_ASYNC;
368: bwrite(bp);
369: goto loop;
370: }
371: bp->b_flags = B_BUSY;
372: bp->b_back->b_forw = bp->b_forw;
373: bp->b_forw->b_back = bp->b_back;
374: bp->b_forw = dp->b_forw;
375: bp->b_back = dp;
376: dp->b_forw->b_back = bp;
377: dp->b_forw = bp;
378: bp->b_dev = dev;
379: bp->b_blkno = dblkno;
380: return(bp);
381: }
382:
383: /*
384: * get an empty block,
385: * not assigned to any particular device
386: */
387: struct buf *
388: geteblk()
389: {
390: register struct buf *bp, *dp;
391: register int s;
392:
393: loop:
394: s = spl6();
395: for (dp = &bfreelist[BQUEUES-1]; dp > bfreelist; dp--)
396: if (dp->av_forw != dp)
397: break;
398: if (dp == bfreelist) { /* no free blocks */
399: dp->b_flags |= B_WANTED;
400: sleep((caddr_t)dp, PRIBIO+1);
401: goto loop;
402: }
403: (void) splx(s);
404: bp = dp->av_forw;
405: notavail(bp);
406: if (bp->b_flags & B_DELWRI) {
407: bp->b_flags |= B_ASYNC;
408: bwrite(bp);
409: goto loop;
410: }
411: bp->b_flags = B_BUSY|B_INVAL;
412: bp->b_back->b_forw = bp->b_forw;
413: bp->b_forw->b_back = bp->b_back;
414: bp->b_forw = dp->b_forw;
415: bp->b_back = dp;
416: dp->b_forw->b_back = bp;
417: dp->b_forw = bp;
418: bp->b_dev = (dev_t)NODEV;
419: return(bp);
420: }
421:
422: /*
423: * Wait for I/O completion on the buffer; return errors
424: * to the user.
425: */
426: iowait(bp)
427: register struct buf *bp;
428: {
429:
430: (void) spl6();
431: while ((bp->b_flags&B_DONE)==0)
432: sleep((caddr_t)bp, PRIBIO);
433: (void) spl0();
434: geterror(bp);
435: }
436:
437: #ifdef UNFAST
438: /*
439: * Unlink a buffer from the available list and mark it busy.
440: * (internal interface)
441: */
442: notavail(bp)
443: register struct buf *bp;
444: {
445: register s;
446:
447: s = spl6();
448: bp->av_back->av_forw = bp->av_forw;
449: bp->av_forw->av_back = bp->av_back;
450: bp->b_flags |= B_BUSY;
451: splx(s);
452: }
453: #endif
454:
455: /*
456: * Mark I/O complete on a buffer. If the header
457: * indicates a dirty page push completion, the
458: * header is inserted into the ``cleaned'' list
459: * to be processed by the pageout daemon. Otherwise
460: * release it if I/O is asynchronous, and wake
461: * up anyone waiting for it.
462: */
463: iodone(bp)
464: register struct buf *bp;
465: {
466: register int s;
467:
468: if (bp->b_flags & B_DONE)
469: panic("dup iodone");
470: bp->b_flags |= B_DONE;
471: if (bp->b_flags & B_DIRTY) {
472: if (bp->b_flags & B_ERROR)
473: panic("IO err in push");
474: s = spl6();
475: bp->av_forw = bclnlist;
476: bp->b_bcount = swsize[bp - swbuf];
477: bp->b_pfcent = swpf[bp - swbuf];
478: cnt.v_pgout++;
479: cnt.v_pgpgout += bp->b_bcount / NBPG;
480: bclnlist = bp;
481: if (bswlist.b_flags & B_WANTED)
482: wakeup((caddr_t)&proc[2]);
483: splx(s);
484: return;
485: }
486: if (bp->b_flags&B_ASYNC)
487: brelse(bp);
488: else {
489: bp->b_flags &= ~B_WANTED;
490: wakeup((caddr_t)bp);
491: }
492: }
493:
494: /*
495: * Zero the core associated with a buffer.
496: */
497: clrbuf(bp)
498: struct buf *bp;
499: {
500: register *p;
501: register c;
502:
503: p = bp->b_un.b_words;
504: c = BUFSIZE/sizeof(int);
505: do
506: *p++ = 0;
507: while (--c);
508: bp->b_resid = 0;
509: }
510:
511: /*
512: * swap I/O -
513: *
514: * If the flag indicates a dirty page push initiated
515: * by the pageout daemon, we map the page into the i th
516: * virtual page of process 2 (the daemon itself) where i is
517: * the index of the swap header that has been allocated.
518: * We simply initialize the header and queue the I/O but
519: * do not wait for completion. When the I/O completes,
520: * iodone() will link the header to a list of cleaned
521: * pages to be processed by the pageout daemon.
522: */
523: swap(p, dblkno, addr, nbytes, rdflg, flag, dev, pfcent)
524: struct proc *p;
525: swblk_t dblkno;
526: caddr_t addr;
527: int flag, nbytes;
528: dev_t dev;
529: unsigned pfcent;
530: {
531: register struct buf *bp;
532: register int c;
533: int p2dp;
534: register struct pte *dpte, *vpte;
535:
536: (void) spl6();
537: while (bswlist.av_forw == NULL) {
538: bswlist.b_flags |= B_WANTED;
539: sleep((caddr_t)&bswlist, PSWP+1);
540: }
541: bp = bswlist.av_forw;
542: bswlist.av_forw = bp->av_forw;
543: (void) spl0();
544:
545: bp->b_flags = B_BUSY | B_PHYS | rdflg | flag;
546: if ((bp->b_flags & (B_DIRTY|B_PGIN)) == 0)
547: if (rdflg == B_READ)
548: sum.v_pswpin += btoc(nbytes);
549: else
550: sum.v_pswpout += btoc(nbytes);
551: bp->b_proc = p;
552: if (flag & B_DIRTY) {
553: p2dp = ((bp - swbuf) * CLSIZE) * KLMAX;
554: dpte = dptopte(&proc[2], p2dp);
555: vpte = vtopte(p, btop(addr));
556: for (c = 0; c < nbytes; c += NBPG) {
557: if (vpte->pg_pfnum == 0 || vpte->pg_fod)
558: panic("swap bad pte");
559: *dpte++ = *vpte++;
560: }
561: bp->b_un.b_addr = (caddr_t)ctob(p2dp);
562: } else
563: bp->b_un.b_addr = addr;
564: while (nbytes > 0) {
565: c = imin(ctob(120), nbytes);
566: bp->b_bcount = c;
567: bp->b_blkno = dblkno;
568: bp->b_dev = dev;
569: if (flag & B_DIRTY) {
570: swpf[bp - swbuf] = pfcent;
571: swsize[bp - swbuf] = nbytes;
572: }
573: (*bdevsw[major(dev)].d_strategy)(bp);
574: if (flag & B_DIRTY) {
575: if (c < nbytes)
576: panic("big push");
577: return;
578: }
579: (void) spl6();
580: while((bp->b_flags&B_DONE)==0)
581: sleep((caddr_t)bp, PSWP);
582: (void) spl0();
583: bp->b_un.b_addr += c;
584: bp->b_flags &= ~B_DONE;
585: if (bp->b_flags & B_ERROR) {
586: if ((flag & (B_UAREA|B_PAGET)) || rdflg == B_WRITE)
587: panic("hard IO err in swap");
588: swkill(p, (char *)0);
589: }
590: nbytes -= c;
591: dblkno += btoc(c);
592: }
593: (void) spl6();
594: bp->b_flags &= ~(B_BUSY|B_WANTED|B_PHYS|B_PAGET|B_UAREA|B_DIRTY);
595: bp->av_forw = bswlist.av_forw;
596: bswlist.av_forw = bp;
597: if (bswlist.b_flags & B_WANTED) {
598: bswlist.b_flags &= ~B_WANTED;
599: wakeup((caddr_t)&bswlist);
600: wakeup((caddr_t)&proc[2]);
601: }
602: (void) spl0();
603: }
604:
605: /*
606: * If rout == 0 then killed on swap error, else
607: * rout is the name of the routine where we ran out of
608: * swap space.
609: */
610: swkill(p, rout)
611: struct proc *p;
612: char *rout;
613: {
614: char *mesg;
615:
616: printf("pid %d: ", p->p_pid);
617: if (rout)
618: printf(mesg = "killed due to no swap space\n");
619: else
620: printf(mesg = "killed on swap error\n");
621: uprintf("sorry, pid %d was %s", p->p_pid, mesg);
622: /*
623: * To be sure no looping (e.g. in vmsched trying to
624: * swap out) mark process locked in core (as though
625: * done by user) after killing it so noone will try
626: * to swap it out.
627: */
628: psignal(p, SIGKILL);
629: p->p_flag |= SULOCK;
630: }
631:
632: /*
633: * make sure all write-behind blocks
634: * on dev (or NODEV for all)
635: * are flushed out.
636: * (from umount and update)
637: */
638: bflush(dev)
639: dev_t dev;
640: {
641: register struct buf *bp;
642: register struct buf *flist;
643: register int s;
644:
645: loop:
646: s = spl6();
647: trace(TR_BFIN, dev, 1);
648: for (flist = bfreelist; flist < &bfreelist[BQUEUES]; flist++)
649: for (bp = flist->av_forw; bp != flist; bp = bp->av_forw) {
650: if (bp->b_flags&B_DELWRI && (dev == NODEV||dev==bp->b_dev)) {
651: bp->b_flags |= B_ASYNC;
652: notavail(bp);
653: bwrite(bp);
654: goto loop;
655: }
656: }
657: trace(TR_BFOUT, s, 1);
658: (void) spl0();
659: }
660:
661: /*
662: * Raw I/O. The arguments are
663: * The strategy routine for the device
664: * A buffer, which will always be a special buffer
665: * header owned exclusively by the device for this purpose
666: * The device number
667: * Read/write flag
668: * Essentially all the work is computing physical addresses and
669: * validating them.
670: * If the user has the proper access privilidges, the process is
671: * marked 'delayed unlock' and the pages involved in the I/O are
672: * faulted and locked. After the completion of the I/O, the above pages
673: * are unlocked.
674: */
675: physio(strat, bp, dev, rw, mincnt)
676: int (*strat)();
677: register struct buf *bp;
678: unsigned (*mincnt)();
679: {
680: register int c;
681: char *a;
682: register int s;
683:
684: if (useracc(u.u_base,u.u_count,rw==B_READ?B_WRITE:B_READ) == NULL) {
685: u.u_error = EFAULT;
686: return;
687: }
688: s = spl6();
689: while (bp->b_flags&B_BUSY) {
690: bp->b_flags |= B_WANTED;
691: /*sleep((caddr_t)bp, PRIBIO+1);*/
692: switch(tsleep((caddr_t)bp, PRIBIO+1, 20)) {
693: case TS_OK:
694: continue;
695: case TS_SIG: /* can't happen at PRIBIO+1*/
696: continue;
697: case TS_TIME:
698: u.u_error = EIO;
699: (void) splx(s);
700: return;
701: }
702: }
703: (void) splx(s);
704: bp->b_error = 0;
705: bp->b_proc = u.u_procp;
706: bp->b_un.b_addr = u.u_base;
707: while (u.u_count != 0) {
708: bp->b_flags = B_BUSY | B_PHYS | rw;
709: bp->b_dev = dev;
710: bp->b_blkno = u.u_offset >> PGSHIFT;
711: bp->b_bcount = u.u_count;
712: (*mincnt)(bp);
713: c = bp->b_bcount;
714: u.u_procp->p_flag |= SPHYSIO;
715: vslock(a = bp->b_un.b_addr, c);
716: (*strat)(bp);
717: s = spl6();
718: while ((bp->b_flags&B_DONE) == 0)
719: sleep((caddr_t)bp, PRIBIO);
720: vsunlock(a, c, rw);
721: u.u_procp->p_flag &= ~SPHYSIO;
722: if (bp->b_flags&B_WANTED)
723: wakeup((caddr_t)bp);
724: (void) splx(s);
725: bp->b_un.b_addr += c;
726: u.u_count -= c;
727: u.u_offset += c;
728: if (bp->b_flags&B_ERROR)
729: break;
730: }
731: bp->b_flags &= ~(B_BUSY|B_WANTED|B_PHYS);
732: u.u_count = bp->b_resid;
733: geterror(bp);
734: }
735:
736: /*ARGSUSED*/
737: unsigned
738: minphys(bp)
739: struct buf *bp;
740: {
741:
742: if (bp->b_bcount > 60 * 1024)
743: bp->b_bcount = 60 * 1024;
744: }
745:
746: /*
747: * Pick up the device's error number and pass it to the user;
748: * if there is an error but the number is 0 set a generalized
749: * code. Actually the latter is always true because devices
750: * don't yet return specific errors.
751: */
752: geterror(bp)
753: register struct buf *bp;
754: {
755:
756: if (bp->b_flags&B_ERROR)
757: if ((u.u_error = bp->b_error)==0)
758: u.u_error = EIO;
759: }
760:
761: /*
762: * Invalidate in core blocks belonging to closed or umounted filesystem
763: *
764: * This is not nicely done at all - the buffer ought to be removed from the
765: * hash chains & have its dev/blkno fields clobbered, but unfortunately we
766: * can't do that here, as it is quite possible that the block is still
767: * being used for i/o. Eventually, all disc drivers should be forced to
768: * have a close routine, which ought ensure that the queue is empty, then
769: * properly flush the queues. Until that happy day, this suffices for
770: * correctness. ... kre
771: */
772: binval(dev)
773: dev_t dev;
774: {
775: register struct buf *bp;
776: register struct bufhd *hp;
777: #define dp ((struct buf *)hp)
778:
779: for (hp = bufhash; hp < &bufhash[BUFHSZ]; hp++)
780: for (bp = dp->b_forw; bp != dp; bp = bp->b_forw)
781: if (bp->b_dev == dev)
782: bp->b_flags |= B_INVAL;
783: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.