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