![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to vfs_cluster.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Apple Darwin 0.x] / kernel / bsd / vfs|
Return to vfs_cluster.c CVS log | Up to [Apple Darwin 0.x] / kernel / bsd / vfs |
1.1 root 1: /*
2: * Copyright (c) 1999 Apple Computer, Inc. All rights reserved.
3: *
4: * @APPLE_LICENSE_HEADER_START@
5: *
6: * Portions Copyright (c) 1999 Apple Computer, Inc. All Rights
7: * Reserved. This file contains Original Code and/or Modifications of
8: * Original Code as defined in and that are subject to the Apple Public
9: * Source License Version 1.1 (the "License"). You may not use this file
10: * except in compliance with the License. Please obtain a copy of the
11: * License at http://www.apple.com/publicsource and read it before using
12: * this file.
13: *
14: * The Original Code and all software distributed under the License are
15: * distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER
16: * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
17: * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
18: * FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT. Please see the
19: * License for the specific language governing rights and limitations
20: * under the License.
21: *
22: * @APPLE_LICENSE_HEADER_END@
23: */
24:
25: /* Copyright (c) 1995 NeXT Computer, Inc. All Rights Reserved */
26: /*
27: * Copyright (c) 1993
28: * The Regents of the University of California. All rights reserved.
29: *
30: * Redistribution and use in source and binary forms, with or without
31: * modification, are permitted provided that the following conditions
32: * are met:
33: * 1. Redistributions of source code must retain the above copyright
34: * notice, this list of conditions and the following disclaimer.
35: * 2. Redistributions in binary form must reproduce the above copyright
36: * notice, this list of conditions and the following disclaimer in the
37: * documentation and/or other materials provided with the distribution.
38: * 3. All advertising materials mentioning features or use of this software
39: * must display the following acknowledgement:
40: * This product includes software developed by the University of
41: * California, Berkeley and its contributors.
42: * 4. Neither the name of the University nor the names of its contributors
43: * may be used to endorse or promote products derived from this software
44: * without specific prior written permission.
45: *
46: * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
47: * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
48: * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
49: * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
50: * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
51: * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
52: * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
53: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
54: * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
55: * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
56: * SUCH DAMAGE.
57: *
58: * @(#)vfs_cluster.c 8.10 (Berkeley) 3/28/95
59: */
60:
61: #include <sys/param.h>
62: #include <sys/proc.h>
63: #include <sys/buf.h>
64: #include <sys/vnode.h>
65: #include <sys/mount.h>
66: #include <sys/trace.h>
67: #include <sys/malloc.h>
68: #include <sys/resourcevar.h>
69: #include <libkern/libkern.h>
70: #include <kern/mapfs.h>
71:
72: #include <kern/kdebug.h>
73:
74: /*
75: * Local declarations
76: */
77: struct buf *cluster_rbuild __P((struct vnode *, u_quad_t, struct buf *,
78: daddr_t, daddr_t, long, int, long, long));
79: struct buf *cluster_create __P((struct vnode *, struct buf *, daddr_t, daddr_t, long,
80: int, long, daddr_t *));
81: int cluster_block __P((struct vnode *, u_quad_t, struct buf *, long, long));
82: void cluster_wbuild __P((struct vnode *, struct buf *, long,
83: daddr_t, int, daddr_t, long, int));
84: struct cluster_save *cluster_collectbufs __P((struct vnode *, struct buf *));
85:
86: #if DIAGNOSTIC
87: /*
88: * Set to 1 if reads of block zero should cause readahead to be done.
89: * Set to 0 treats a read of block zero as a non-sequential read.
90: *
91: * Setting to one assumes that most reads of block zero of files are due to
92: * sequential passes over the files (e.g. cat, sum) where additional blocks
93: * will soon be needed. Setting to zero assumes that the majority are
94: * surgical strikes to get particular info (e.g. size, file) where readahead
95: * blocks will not be used and, in fact, push out other potentially useful
96: * blocks from the cache. The former seems intuitive, but some quick tests
97: * showed that the latter performed better from a system-wide point of view.
98: */
99: int doclusterraz = 0;
100: #define ISSEQREAD(vp, blk) \
101: (((blk) != 0 || doclusterraz) && \
102: ((blk) == (vp)->v_lastr + 1 || (blk) == (vp)->v_lastr))
103: #else
104: #define ISSEQREAD(vp, blk) \
105: ((blk) != 0 && ((blk) == (vp)->v_lastr + 1 || (blk) == (vp)->v_lastr))
106: #endif
107:
108: /*
109: * This replaces bread. If this is a bread at the beginning of a file and
110: * lastr is 0, we assume this is the first read and we'll read up to two
111: * blocks if they are sequential. After that, we'll do regular read ahead
112: * in clustered chunks.
113: *
114: * There are 4 or 5 cases depending on how you count:
115: * Desired block is in the cache:
116: * 1 Not sequential access (0 I/Os).
117: * 2 Access is sequential, do read-ahead (1 ASYNC).
118: * Desired block is not in cache:
119: * 3 Not sequential access (1 SYNC).
120: * 4 Sequential access, next block is contiguous (1 SYNC).
121: * 5 Sequential access, next block is not contiguous (1 SYNC, 1 ASYNC)
122: *
123: * There are potentially two buffers that require I/O.
124: * bp is the block requested.
125: * rbp is the read-ahead block.
126: * If either is NULL, then you don't have to do the I/O.
127: */
128:
129: cluster_read(vp, filesize, lblkno, size, cred, bpp, secsize,
130: firstpass, resid, fp_sequential)
131: struct vnode *vp;
132: u_quad_t filesize;
133: daddr_t lblkno;
134: long size;
135: struct ucred *cred;
136: struct buf **bpp;
137: long secsize;
138: int firstpass;
139: long resid;
140: int *fp_sequential;
141: {
142: struct buf *bp, *rbp, *cbp;
143: daddr_t blkno, ioblkno;
144: long flags;
145: int error, num_ra, alreadyincore;
146: long num;
147: int sequential, case4;
148:
149: #if DIAGNOSTIC
150: if (size == 0)
151: panic("cluster_read: size = 0");
152: #endif
153:
154: KERNEL_DEBUG((FSDBG_CODE(DBG_FSRW, 11)) | DBG_FUNC_START,
155: lblkno,
156: resid,
157: firstpass,
158: vp,
159: 0);
160: error = 0;
161: flags = B_READ;
162: *bpp = bp = getblk(vp, lblkno, size, 0, 0);
163:
164: if (resid == PAGE_SIZE && lblkno && !ISSEQREAD(vp, lblkno) &&
165: (vp->v_mount->mnt_stat.f_iosize & (PAGE_SIZE - 1)) == 0) {
166: if (bp->b_flags & B_CACHE) {
167:
168: KERNEL_DEBUG((FSDBG_CODE(DBG_FSRW, 11)) | DBG_FUNC_END,
169: lblkno,
170: size,
171: -1,
172: 0,
173: 0);
174:
175: vp->v_consumed += (bp->b_bcount/size);
176: return (0);
177: }
178: bp->b_flags |= B_READ;
179:
180: if (cluster_block(vp, filesize, bp, size, secsize)) {
181:
182: error = biowait(bp);
183:
184: KERNEL_DEBUG((FSDBG_CODE(DBG_FSRW, 11)) | DBG_FUNC_END,
185: bp,
186: 0,
187: 0,
188: 0,
189: 0);
190:
191: return(error);
192: }
193: }
194: /* round up resid count to nearest block size */
195: if ( resid > size )
196: resid += size - 1;
197:
198: if (bp->b_flags & B_CACHE) {
199: /*
200: * Desired block is in cache; do any readahead ASYNC.
201: * Case 1, 2.
202: */
203: trace(TR_BREADHIT, pack(vp, size), lblkno);
204: flags |= B_ASYNC;
205: if (resid > size)
206: resid -= size;
207:
208: if (!fp_sequential)
209: {
210: ioblkno = lblkno + 1;
211: alreadyincore = incore(vp, ioblkno) != NULL;
212: }
213: else
214: {
215: ioblkno = lblkno + (vp->v_ralen ? vp->v_ralen : 1);
216: alreadyincore = incore(vp, ioblkno) != NULL;
217: }
218: /*
219: * treat this as a hit for purposes of speculative I/O around paging activity
220: */
221: vp->v_consumed += (bp->b_bcount/size);
222:
223: bp = NULL;
224: } else {
225: /* Block wasn't in cache, case 3, 4, 5. */
226: trace(TR_BREADMISS, pack(vp, size), lblkno);
227: bp->b_flags |= B_READ;
228: ioblkno = lblkno;
229: alreadyincore = 0;
230: current_proc()->p_stats->p_ru.ru_inblock++; /* XXX */
231: }
232: /*
233: * XXX
234: * Replace 1 with a window size based on some permutation of
235: * maxcontig and rot_delay. This will let you figure out how
236: * many blocks you should read-ahead (case 2, 4, 5).
237: *
238: * If the access isn't sequential, reset the window to 1.
239: * Note that a read to the same block is considered sequential.
240: * This catches the case where the file is being read sequentially,
241: * but at smaller than the filesystem block size.
242: */
243: rbp = NULL;
244: cbp = NULL;
245: case4 = 0;
246:
247: if (!ISSEQREAD(vp, lblkno)) {
248: vp->v_ralen = 0;
249: vp->v_maxra = lblkno;
250: sequential = 0;
251: }
252: else
253: sequential = 1;
254:
255: /* On first pass set the sequential state.
256: * Otherwise, just use the value passed in.
257: */
258: if (firstpass)
259: *fp_sequential = sequential;
260:
261: if (resid > size || *fp_sequential) {
262: if (((u_quad_t)(ioblkno + 1)) * (u_quad_t)size <= filesize && !alreadyincore &&
263: !(error = VOP_BMAP(vp, ioblkno, NULL, &blkno, &num_ra)) &&
264: blkno != -1) {
265: /*
266: * Reading sequentially, and the next block is not in the
267: * cache. We are going to try reading ahead.
268: */
269: if (num_ra) {
270: /*
271: * If our desired readahead block had been read
272: * in a previous readahead but is no longer in
273: * core, then we may be reading ahead too far
274: * or are not using our readahead very rapidly.
275: * In this case we scale back the window.
276: */
277: if (*fp_sequential) {
278: if (!alreadyincore && ioblkno <= vp->v_maxra)
279: vp->v_ralen = max(vp->v_ralen >> 1, 1);
280: /*
281: * There are more sequential blocks than our current
282: * window allows, scale up. Ideally we want to get
283: * in sync with the filesystem maxcontig value.
284: */
285: else if (num_ra > vp->v_ralen && lblkno != vp->v_lastr)
286: vp->v_ralen = vp->v_ralen ?
287: min(num_ra, vp->v_ralen << 1) : 1;
288: }
289: num = max((resid/size)-1, vp->v_ralen);
290: num_ra = min(num, num_ra);
291: }
292:
293: if (num_ra) { /* case 2, 4 */
294: cbp = cluster_rbuild(vp, filesize,
295: bp, ioblkno, blkno, size, num_ra, flags, secsize);
296:
297: if ( !(cbp->b_flags & B_CALL)) {
298: if ((rbp = cbp) == bp)
299: rbp = NULL;
300: cbp = NULL;
301: } else
302: case4 = 1;
303: } else if (ioblkno == lblkno) {
304: bp->b_blkno = blkno;
305: /* Case 5: check how many blocks to read ahead */
306: ++ioblkno;
307: if (((u_quad_t)(ioblkno + 1)) * (u_quad_t)size > filesize ||
308: incore(vp, ioblkno) || (error = VOP_BMAP(vp,
309: ioblkno, NULL, &blkno, &num_ra)) || blkno == -1)
310: goto skip_readahead;
311: /*
312: * Adjust readahead as above.
313: * Don't check alreadyincore, we know it is 0 from
314: * the previous conditional.
315: */
316: if (num_ra) {
317: if (*fp_sequential) {
318: if (ioblkno <= vp->v_maxra)
319: vp->v_ralen = max(vp->v_ralen >> 1, 1);
320: else if (num_ra > vp->v_ralen &&
321: lblkno != vp->v_lastr)
322: vp->v_ralen = vp->v_ralen ?
323: min(num_ra,vp->v_ralen<<1) : 1;
324: }
325: num = max((resid/size)-1, vp->v_ralen);
326: num_ra = min(num, num_ra);
327: }
328: flags |= B_ASYNC;
329:
330: if (num_ra) {
331: cbp = cluster_rbuild(vp, filesize,
332: NULL, ioblkno, blkno, size, num_ra, flags,
333: secsize);
334: if ( !(cbp->b_flags & B_CALL)) {
335: rbp = cbp;
336: cbp = NULL;
337: }
338: } else {
339: rbp = getblk(vp, ioblkno, size, 0, 0);
340: rbp->b_flags |= flags;
341: rbp->b_blkno = blkno;
342: }
343: } else {
344: /* case 2; read ahead single block */
345: rbp = getblk(vp, ioblkno, size, 0, 0);
346: rbp->b_flags |= flags;
347: rbp->b_blkno = blkno;
348: }
349: if (cbp || rbp) { /* case 2, 5 */
350: trace(TR_BREADMISSRA,
351: pack(vp, (num_ra + 1) * size), ioblkno);
352: current_proc()->p_stats->p_ru.ru_inblock++; /* XXX */
353: }
354: }
355: }
356:
357: skip_readahead:
358: if (bp && !case4) {
359: if (bp->b_flags & (B_DONE | B_DELWRI))
360: panic("cluster_read: DONE bp");
361: else {
362: /*
363: * issue the BMAP here if needed due to the block device's
364: * lack of a BMAP call in the strategy routine.... when being
365: * used by the filesystem/mount code, the blockno's being worked
366: * with are always physical so the strategy routine doesn't bother.
367: * Now that we are calling cluster read/write from spec_read/spec_write
368: * we have to use real logical blockno's in order to properly trigger
369: * the read-ahead and write-coalescing.
370: */
371: if (bp->b_lblkno == bp->b_blkno) {
372: VOP_BMAP(vp, bp->b_lblkno, NULL, &bp->b_blkno, NULL);
373:
374: if ((long)bp->b_blkno == -1)
375: clrbuf(bp);
376: }
377: error = VOP_STRATEGY(bp);
378:
379: KERNEL_DEBUG((FSDBG_CODE(DBG_FSRW, 11)) | DBG_FUNC_NONE,
380: bp->b_lblkno,
381: bp->b_bufsize,
382: bp->b_bcount,
383: 1, 0 );
384: }
385: }
386: if (rbp) {
387: if (error || rbp->b_flags & (B_DONE | B_DELWRI)) {
388: rbp->b_flags &= ~(B_ASYNC | B_READ);
389: brelse(rbp);
390: } else {
391: /*
392: * issue the BMAP here if needed due to the block device's
393: * lack of a BMAP call in the strategy routine.... when being
394: * used by the filesystem/mount code, the blockno's being worked
395: * with are always physical so the strategy routine doesn't bother.
396: * Now that we are calling cluster read/write from spec_read/spec_write
397: * we have to use real logical blockno's in order to properly trigger
398: * the read-ahead and write-coalescing.
399: */
400: if (rbp->b_lblkno == rbp->b_blkno) {
401: VOP_BMAP(vp, rbp->b_lblkno, NULL, &rbp->b_blkno, NULL);
402:
403: if ((long)rbp->b_blkno == -1)
404: clrbuf(rbp);
405: }
406: (void) VOP_STRATEGY(rbp);
407:
408: KERNEL_DEBUG((FSDBG_CODE(DBG_FSRW, 11)) | DBG_FUNC_NONE,
409: rbp->b_lblkno,
410: rbp->b_bufsize,
411: rbp->b_bcount,
412: 2, 0 );
413: }
414: }
415: if (cbp) {
416: (void) VOP_STRATEGY(cbp);
417:
418: KERNEL_DEBUG((FSDBG_CODE(DBG_FSRW, 11)) | DBG_FUNC_NONE,
419: cbp->b_lblkno,
420: cbp->b_bufsize,
421: cbp->b_bcount,
422: 3, 0 );
423: }
424: /*
425: * Recalculate our maximum readahead
426: */
427: if (rbp == NULL) {
428: if (cbp)
429: rbp = cbp;
430: else
431: rbp = bp;
432: }
433: if (rbp)
434: vp->v_maxra = rbp->b_lblkno + (rbp->b_bcount / size) - 1;
435:
436: if (bp)
437: error = biowait(bp);
438:
439: KERNEL_DEBUG((FSDBG_CODE(DBG_FSRW, 11)) | DBG_FUNC_END,
440: bp,
441: rbp,
442: cbp,
443: vp->v_maxra,
444: 0);
445: return(error);
446: }
447:
448: struct pent {
449: int mask;
450: int num;
451: } pent[7] = {
452: {0,0},
453: {0,0},
454: {~0,1},
455: {~1,2},
456: {~3,4},
457: {~7,8},
458: {~15,16}};
459:
460:
461: int cluster_block(vp, filesize, bp, size, secsize)
462: struct vnode *vp;
463: u_quad_t filesize;
464: struct buf *bp;
465: long size;
466: long secsize;
467: {
468: struct buf *cbp;
469: daddr_t lblkno, blkno, ioblkno, lbn;
470: int num_io, num;
471: unsigned ratio;
472:
473: #if 0 /* FIXED READS */
474: /* calculate maximum number of blocks to read in */
475:
476: lblkno = bp->b_lblkno & ~0x07; /* put us on a 32k (8 page boundary) boundary */
477: num = 8;
478: num_io = 0;
479: #else /* ADAPTIVE READS */
480: if (vp->v_bread > vp->v_trigger) {
481: ratio = (vp->v_consumed*100) / vp->v_bread;
482:
483: if (ratio < 50 && vp->v_power > 2) {
484: vp->v_power--;
485: vp->v_trigger = vp->v_bread + (16 * pent[vp->v_power].num);
486: } else if (ratio > 75 && vp->v_power < 6) {
487: vp->v_power++;
488: vp->v_trigger = vp->v_bread + (16 * pent[vp->v_power].num);
489: }
490: }
491: if ((num = pent[vp->v_power].num) == 1)
492: return (0);
493: lblkno = bp->b_lblkno & pent[vp->v_power].mask;
494: num_io = 0;
495: #endif
496:
497: KERNEL_DEBUG((FSDBG_CODE(DBG_FSRW, 14)) | DBG_FUNC_START,
498: lblkno,
499: num,
500: vp->v_flag,
501: vp,
502: 0 );
503:
504: for (lbn = bp->b_lblkno; lbn > lblkno; lbn--) {
505: if (incore(vp, lbn - 1))
506: break;
507: }
508: num -= (lbn - lblkno);
509:
510: for (;;) {
511: if (VOP_BMAP(vp, lbn, NULL, &blkno, &num_io) || blkno == -1 || num_io == 0) {
512: if (lbn == bp->b_lblkno) {
513: KERNEL_DEBUG((FSDBG_CODE(DBG_FSRW, 14)) | DBG_FUNC_END,
514: -1,
515: lbn,
516: blkno,
517: num_io,
518: 0);
519: return (0);
520: }
521: }
522: if ((lbn + num_io) >= bp->b_lblkno)
523: break;
524: lbn++;
525: num--;
526: }
527: if ((num_io = min(num, num_io + 1)) == 1)
528: return (0);
529:
530: if ((u_quad_t)size * ((u_quad_t)(lbn + num_io)) > filesize)
531: num_io = (filesize - ((u_quad_t)size * (u_quad_t)lbn)) / size;
532:
533: cbp = cluster_create(vp, bp, lbn, blkno, size, num_io, secsize, &ioblkno);
534:
535: if (cbp) {
536: (void) VOP_STRATEGY(cbp);
537: vp->v_bread += (cbp->b_bcount / size);
538: KERNEL_DEBUG((FSDBG_CODE(DBG_FSRW, 14)) | DBG_FUNC_END,
539: cbp->b_lblkno,
540: cbp->b_blkno,
541: cbp->b_bcount,
542: 0,
543: 0 );
544:
545: return (1);
546: }
547: KERNEL_DEBUG((FSDBG_CODE(DBG_FSRW, 14)) | DBG_FUNC_END,
548: 0,
549: 0,
550: 0,
551: 0,
552: 0);
553: return (0);
554: }
555:
556:
557: /*
558: * generate advisory I/O in as big of chunks as possible
559: * and then parcel them up into logical blocks in the buffer hash table.
560: */
561: advisory_read(vp, filesize, lblkno, size, runt_size, io_size, secsize)
562: struct vnode *vp;
563: u_quad_t filesize;
564: daddr_t lblkno;
565: long size;
566: long runt_size;
567: long io_size;
568: long secsize;
569: {
570: struct buf *bp, *cbp;
571: daddr_t blkno, ioblkno;
572: int error, num_io;
573: long num;
574:
575: error = 0;
576:
577: /* calculate maximum number of blocks to read in */
578:
579: num = (io_size + (size - 1)) / size;
580:
581: if ((u_quad_t)size * ((u_quad_t)(lblkno + num)) > filesize) {
582: if (((u_quad_t)size * (u_quad_t)lblkno) >= filesize)
583: return(EFBIG);
584: io_size = filesize - ((u_quad_t)size * (u_quad_t)lblkno);
585:
586: num = io_size / size;
587: } else
588: io_size = num * size;
589:
590: KERNEL_DEBUG((FSDBG_CODE(DBG_FSRW, 13)) | DBG_FUNC_START,
591: lblkno,
592: io_size,
593: num,
594: vp,
595: 0 );
596:
597: while (num) {
598: if (error = VOP_BMAP(vp, lblkno, NULL, &blkno, &num_io))
599: break;
600:
601: if (blkno == -1) {
602: lblkno++;
603: num--;
604: io_size -= size;
605: continue;
606: }
607: num_io = min(num, num_io + 1);
608:
609: cbp = cluster_create(vp, NULL, lblkno, blkno, size, num_io, secsize, &ioblkno);
610:
611: if (cbp) {
612: KERNEL_DEBUG((FSDBG_CODE(DBG_FSRW, 13)) | DBG_FUNC_NONE,
613: cbp->b_lblkno,
614: cbp->b_blkno,
615: cbp->b_bcount,
616: 3,
617: 0 );
618:
619: (void) VOP_STRATEGY(cbp);
620: } else {
621: if (ioblkno == lblkno) {
622: error = ENOMEM;
623: break;
624: }
625: }
626: io_size -= ((ioblkno - lblkno) * size);
627: num -= ioblkno - lblkno;
628: lblkno = ioblkno;
629: }
630: if (io_size && !error) {
631: bp = getblk(vp, lblkno, runt_size, 0, 0);
632:
633: if (bp->b_flags & (B_DONE | B_DELWRI))
634: brelse(bp);
635: else {
636: bp->b_flags |= (B_READ | B_ASYNC);
637:
638: (void) VOP_STRATEGY(bp);
639:
640: KERNEL_DEBUG((FSDBG_CODE(DBG_FSRW, 13)) | DBG_FUNC_NONE,
641: bp->b_lblkno,
642: bp->b_blkno,
643: bp->b_bcount,
644: 4,
645: 0 );
646: }
647: io_size -= runt_size;
648: }
649:
650: KERNEL_DEBUG((FSDBG_CODE(DBG_FSRW, 13)) | DBG_FUNC_END,
651: lblkno,
652: io_size,
653: num,
654: error,
655: 0);
656: return(error);
657: }
658:
659:
660: /*
661: * If blocks are contiguous on disk, use this to provide clustered
662: * read ahead. We will read as many blocks as possible sequentially
663: * and then parcel them up into logical blocks in the buffer hash table.
664: */
665: struct buf *
666: cluster_rbuild(vp, filesize, bp, lbn, blkno, size, run, flags, secsize)
667: struct vnode *vp;
668: u_quad_t filesize;
669: struct buf *bp;
670: daddr_t lbn;
671: daddr_t blkno;
672: long size;
673: int run;
674: long flags;
675: long secsize;
676: {
677: struct cluster_save *b_save;
678: struct buf *tbp, *cbp;
679: caddr_t cp;
680: daddr_t bn;
681: int i, inc;
682:
683: #if DIAGNOSTIC
684: if (size != vp->v_mount->mnt_stat.f_iosize)
685: panic("cluster_rbuild: size %d != filesize %d\n",
686: size, vp->v_mount->mnt_stat.f_iosize);
687: #endif
688: if ((u_quad_t)size * ((u_quad_t)(lbn + run + 1)) > filesize)
689: --run;
690: if (run == 0) {
691: if (!bp) {
692: bp = getblk(vp, lbn, size, 0, 0);
693: bp->b_blkno = blkno;
694: bp->b_flags |= flags;
695: }
696: return(bp);
697: }
698: b_save = _MALLOC(sizeof(struct buf *) * (run + 1) + sizeof(struct cluster_save),
699: M_SEGMENT, M_NOWAIT);
700:
701: if (b_save)
702: cbp = alloc_io_buf(vp);
703: else
704: cbp = NULL;
705:
706: if (b_save == NULL || cbp == NULL) {
707: if (b_save)
708: _FREE(b_save, M_SEGMENT);
709: if (cbp)
710: free_io_buf(cbp);
711: return (bp);
712: }
713: b_save->bs_bufsize = size;
714: b_save->bs_nchildren = 0;
715: b_save->bs_children = (struct buf **)(b_save + 1);
716:
717: cbp->b_saveaddr = (caddr_t)b_save;
718: cbp->b_iodone = cluster_callback;
719: cbp->b_blkno = blkno;
720: cbp->b_lblkno = lbn;
721: cbp->b_flags |= flags | B_CALL;
722:
723: inc = btodb(size, secsize);
724: cp = (char *)cbp->b_data;
725: tbp = bp;
726:
727: for (bn = blkno, i = 0; i <= run; ++i, bn += inc) {
728: if (tbp == NULL) {
729: if (incore(vp, lbn + i))
730: /*
731: * A component of the cluster is already in core,
732: * terminate the cluster early.
733: */
734: break;
735: tbp = getblk(vp, lbn + i, size, 0, 0);
736: }
737: pagemove(tbp->b_data, cp, size);
738: cbp->b_bcount += size;
739: cbp->b_bufsize += size;
740: cp += size;
741:
742: if (bp != tbp)
743: tbp->b_flags |= flags | B_READ | B_ASYNC;
744: tbp->b_bufsize -= size;
745: tbp->b_blkno = bn;
746:
747: b_save->bs_children[i] = tbp;
748: b_save->bs_nchildren++;
749:
750: tbp = NULL;
751: }
752: /*
753: * The cluster may have been terminated early
754: * If no cluster could be formed, deallocate the cluster save info.
755: */
756: if (i == 0) {
757: _FREE(b_save, M_SEGMENT);
758: free_io_buf(cbp);
759: return(bp);
760: }
761: return(cbp);
762: }
763:
764:
765:
766: struct buf *
767: cluster_create(vp, bp, lbn, blkno, size, run, secsize, ioblkno)
768: struct vnode *vp;
769: struct buf *bp;
770: daddr_t lbn;
771: daddr_t blkno;
772: long size;
773: int run;
774: long secsize;
775: daddr_t *ioblkno;
776: {
777: struct cluster_save *b_save;
778: struct buf *tbp, *cbp;
779: caddr_t cp;
780: daddr_t bn;
781: int i, inc;
782:
783: inc = btodb(size, secsize);
784:
785: if (bp == NULL) {
786: while (run && (tbp = incore(vp, lbn))) {
787: /*
788: * if a block is already in core
789: * and is not busy
790: * then get and release to freshen it in the LRU
791: */
792: if ( !(tbp->b_flags & B_BUSY)) {
793: tbp = getblk(vp, lbn, size, 0, 0);
794: brelse(tbp);
795: }
796: lbn++;
797: run--;
798: blkno += inc;
799: }
800: if (run == 0) {
801: *ioblkno = lbn;
802: return (NULL);
803: }
804: }
805: b_save = _MALLOC((sizeof(struct buf *) * run) + sizeof(struct cluster_save), M_SEGMENT, M_NOWAIT);
806:
807: if (b_save)
808: cbp = alloc_io_buf(vp);
809: else
810: cbp = NULL;
811:
812: if (b_save == NULL || cbp == NULL) {
813: if (b_save)
814: _FREE(b_save, M_SEGMENT);
815: if (cbp)
816: free_io_buf(cbp);
817: *ioblkno = lbn;
818:
819: return (NULL);
820: }
821: b_save->bs_bufsize = size;
822: b_save->bs_nchildren = 0;
823: b_save->bs_children = (struct buf **)(b_save + 1);
824:
825: cbp->b_saveaddr = (caddr_t)b_save;
826: cbp->b_iodone = cluster_callback;
827: cbp->b_blkno = blkno;
828: cbp->b_lblkno = lbn;
829: cbp->b_flags |= (B_READ | B_ASYNC | B_CALL);
830:
831: cp = (char *)cbp->b_data;
832:
833: for (bn = blkno, i = 0; i < run; ++i, bn += inc, ++lbn) {
834: if (bp && bp->b_lblkno == lbn)
835: tbp = bp;
836: else {
837: if (tbp = incore(vp, lbn)) {
838: /*
839: * A component of the cluster is already in core,
840: * terminate the cluster early.
841: * if its not busy then also
842: * get and release to freshen it in the LRU
843: */
844: if ( !(tbp->b_flags & B_BUSY)) {
845: tbp = getblk(vp, lbn, size, 0, 0);
846: brelse(tbp);
847: }
848: break;
849: }
850: tbp = getblk(vp, lbn, size, 0, 0);
851: }
852: pagemove(tbp->b_data, cp, size);
853:
854: tbp->b_bufsize -= size;
855: tbp->b_blkno = bn;
856: cbp->b_bcount += size;
857: cbp->b_bufsize += size;
858: cp += size;
859:
860: if (tbp != bp)
861: tbp->b_flags |= (B_READ | B_ASYNC);
862: b_save->bs_children[i] = tbp;
863: b_save->bs_nchildren++;
864: }
865: *ioblkno = lbn;
866: /*
867: * The cluster may have been terminated early
868: * If no cluster could be formed, deallocate the cluster save info.
869: */
870: if (cbp->b_bcount == 0) {
871: _FREE(b_save, M_SEGMENT);
872: free_io_buf(cbp);
873: return(NULL);
874: }
875: return(cbp);
876: }
877:
878:
879: /*
880: * Cleanup after a clustered read or write.
881: * This is complicated by the fact that any of the buffers might have
882: * extra memory (if there were no empty buffer headers at allocbuf time)
883: * that we will need to shift around.
884: */
885: void
886: cluster_callback(bp)
887: struct buf *bp;
888: {
889: struct cluster_save *b_save;
890: struct buf **bpp, *tbp;
891: long bsize;
892: int xsize;
893: int n;
894: caddr_t cp;
895: int error = 0;
896:
897: /*
898: * Must propogate errors to all the components.
899: */
900: if (bp->b_flags & B_ERROR)
901: error = bp->b_error;
902: b_save = (struct cluster_save *)(bp->b_saveaddr);
903:
904: bsize = b_save->bs_bufsize;
905: xsize = bp->b_bcount - bp->b_resid;
906: cp = (char *)bp->b_data;
907: /*
908: * Move memory from the large cluster buffer into the component
909: * buffers and mark IO as done on these.
910: */
911: for (bpp = b_save->bs_children; b_save->bs_nchildren--; ++bpp) {
912: tbp = *bpp;
913: pagemove(cp, tbp->b_data, bsize);
914: tbp->b_bufsize += bsize;
915:
916: n = min(bsize, xsize);
917: xsize -= n;
918:
919: if ((tbp->b_bcount = n) == 0)
920: tbp->b_flags |= B_INVAL;
921: tbp->b_resid = bsize - n;
922:
923: if (error) {
924: tbp->b_flags |= B_ERROR;
925: tbp->b_error = error;
926: }
927: biodone(tbp);
928: bp->b_bufsize -= bsize;
929: cp += bsize;
930: }
931: _FREE(b_save, M_SEGMENT);
932:
933: free_io_buf(bp);
934: }
935:
936:
937: /*
938: * on close, flush out any remaining cluster
939: *
940: */
941: cluster_close(vp, bsize, secsize)
942: struct vnode *vp;
943: int bsize;
944: long secsize;
945: {
946: int cursize;
947:
948: if (vp->v_clen) {
949: cursize = vp->v_lastw - vp->v_cstart + 1;
950:
951: cluster_wbuild(vp, NULL, bsize, vp->v_cstart, cursize, -1, secsize, 0);
952:
953: vp->v_lasta = vp->v_clen = vp->v_cstart = vp->v_lastw = 0;
954: }
955: }
956:
957:
958: /*
959: * Do clustered write for FFS.
960: *
961: * Three cases:
962: * 1. Write is not sequential (write asynchronously)
963: * Write is sequential:
964: * 2. beginning of cluster - begin cluster
965: * 3. middle of a cluster - add to cluster
966: * 4. end of a cluster - asynchronously write cluster
967: */
968:
969: cluster_write(bp, filesize, secsize)
970: struct buf *bp;
971: u_quad_t filesize;
972: long secsize;
973: {
974: struct vnode *vp;
975: daddr_t lbn;
976: daddr_t bn;
977: int maxclen, cursize;
978: int need_commit;
979: int need_sync;
980: int bsize;
981: int error = 0;
982:
983: need_commit = (bp->b_flags & B_CLUST_COMMIT);
984: need_sync = (bp->b_flags & B_CLUST_SYNC);
985: bp->b_flags &= ~(B_CLUST_COMMIT | B_CLUST_SYNC);
986:
987: vp = bp->b_vp;
988: bn = bp->b_blkno;
989: lbn = bp->b_lblkno;
990: bsize = bp->b_bcount;
991:
992: if ((bsize & (PAGE_SIZE - 1)) || bsize > MAXBSIZE) {
993: bp->b_flags |= B_AGE;
994: bawrite(bp);
995:
996: return (error);
997: }
998: /* Initialize vnode to beginning of file. */
999: if (lbn == 0)
1000: vp->v_lasta = vp->v_clen = vp->v_cstart = vp->v_lastw = 0;
1001:
1002:
1003: KERNEL_DEBUG((FSDBG_CODE(DBG_FSRW, 12)) | DBG_FUNC_START,
1004: bp->b_lblkno,
1005: bp->b_bcount,
1006: vp->v_lasta,
1007: vp->v_clen,
1008: 0);
1009:
1010: if (vp->v_clen == 0 || lbn != vp->v_lastw + 1 ||
1011: (bn != vp->v_lasta + btodb(bsize, secsize)))
1012: {
1013: maxclen = (MAXPHYSIO / bsize) - 1;
1014:
1015: if (vp->v_clen != 0) {
1016: /*
1017: * Next block is not sequential.
1018: *
1019: * If we are not writing at end of file, the process
1020: * seeked to another point in the file since its
1021: * last write, or we have reached our maximum
1022: * cluster size, then push the previous cluster.
1023: * Otherwise try reallocating to make it sequential.
1024: */
1025: cursize = vp->v_lastw - vp->v_cstart + 1;
1026: if (((u_quad_t)(lbn + 1)) * (u_quad_t)bsize != filesize ||
1027: lbn != vp->v_lastw + 1 || vp->v_clen <= cursize) {
1028: cluster_wbuild(vp, NULL, bsize,
1029: vp->v_cstart, cursize, lbn, secsize, need_sync);
1030: } else {
1031: struct buf **bpp, **endbp;
1032: struct cluster_save *buflist;
1033:
1034: buflist = cluster_collectbufs(vp, bp);
1035:
1036: if (buflist == NULL) {
1037: cluster_wbuild(vp, NULL, bp->b_bcount,
1038: vp->v_cstart, cursize, lbn, secsize, need_sync);
1039: } else {
1040:
1041: endbp = &buflist->bs_children
1042: [buflist->bs_nchildren - 1];
1043: if (VOP_REALLOCBLKS(vp, buflist)) {
1044: /*
1045: * Failed, push the previous cluster.
1046: */
1047: for (bpp = buflist->bs_children;
1048: bpp < endbp; bpp++)
1049: brelse(*bpp);
1050: _FREE(buflist, M_SEGMENT);
1051:
1052: cluster_wbuild(vp, NULL, bsize,
1053: vp->v_cstart, cursize, lbn, secsize, need_sync);
1054: } else {
1055: /*
1056: * Succeeded, keep building cluster.
1057: * don't bdwrite the last bp, we'll
1058: * first check to see if we now have a full
1059: * cluster, or the caller has requested a SYNC write
1060: */
1061: for (bpp = buflist->bs_children;
1062: bpp < endbp; bpp++)
1063: bdwrite(*bpp);
1064: _FREE(buflist, M_SEGMENT);
1065: /*
1066: * update the physical block number because,
1067: * VOP_REALLOCBLKS will have changed it
1068: */
1069: bn = bp->b_blkno;
1070: goto chk_cluster_full;
1071: }
1072: }
1073: }
1074: }
1075: /*
1076: * Consider beginning a cluster.
1077: * If at end of file, make cluster as large as possible,
1078: * otherwise find size of existing cluster.
1079: */
1080: if (((u_quad_t)(lbn + 1)) * (u_quad_t)bsize != filesize &&
1081: (VOP_BMAP(vp, lbn, NULL, &bp->b_blkno, &maxclen) ||
1082: bp->b_blkno == -1)) {
1083: bn = bp->b_blkno;
1084: vp->v_clen = 0;
1085: vp->v_cstart = lbn + 1;
1086:
1087: if (need_sync)
1088: bwrite(bp);
1089: else
1090: bawrite(bp);
1091:
1092: KERNEL_DEBUG((FSDBG_CODE(DBG_FSRW, 12)) | DBG_FUNC_END,
1093: bp->b_lblkno,
1094: bp->b_blkno,
1095: bp->b_bcount,
1096: vp->v_cstart,
1097: 1 );
1098: goto check_for_commit;
1099: }
1100: bn = bp->b_blkno;
1101:
1102: if ((vp->v_clen = maxclen) == 0 || need_commit) { /* I/O not contiguous or we're being asked to do IO_SYNC and this is the last */
1103: vp->v_cstart = lbn + 1; /* chunk of the I/O request */
1104:
1105: if (need_sync)
1106: bwrite(bp);
1107: else
1108: bawrite(bp);
1109:
1110: KERNEL_DEBUG((FSDBG_CODE(DBG_FSRW, 12)) | DBG_FUNC_END,
1111: bp->b_lblkno,
1112: bp->b_blkno,
1113: bp->b_bcount,
1114: vp->v_cstart,
1115: 2 );
1116: } else { /* Wait for rest of cluster */
1117: vp->v_cstart = lbn;
1118:
1119: bdwrite(bp);
1120:
1121: KERNEL_DEBUG((FSDBG_CODE(DBG_FSRW, 12)) | DBG_FUNC_END,
1122: bp->b_lblkno,
1123: bp->b_blkno,
1124: bp->b_bcount,
1125: vp->v_cstart,
1126: 3 );
1127: }
1128: goto check_for_commit;
1129: }
1130: chk_cluster_full:
1131: if ((lbn == vp->v_cstart + vp->v_clen) || need_commit) {
1132: /*
1133: * At end of cluster, write it out.
1134: */
1135: cluster_wbuild(vp, bp, bsize, vp->v_cstart,
1136: (lbn - vp->v_cstart) + 1, lbn, secsize, need_sync);
1137:
1138: KERNEL_DEBUG((FSDBG_CODE(DBG_FSRW, 12)) | DBG_FUNC_END,
1139: vp->v_cstart,
1140: vp->v_clen + 1,
1141: lbn,
1142: 0,
1143: 4 );
1144: vp->v_clen = 0;
1145: vp->v_cstart = lbn + 1;
1146: } else {
1147: /*
1148: * In the middle of a cluster, so just delay the
1149: * I/O for now.
1150: */
1151: bdwrite(bp);
1152:
1153: KERNEL_DEBUG((FSDBG_CODE(DBG_FSRW, 12)) | DBG_FUNC_END,
1154: bp->b_lblkno,
1155: bp->b_blkno,
1156: bp->b_bcount,
1157: vp->v_cstart,
1158: 5 );
1159: }
1160: check_for_commit:
1161: vp->v_lastw = lbn;
1162: vp->v_lasta = bn;
1163:
1164: if (need_commit) {
1165: bp = getblk(vp, lbn, bsize, 0, 0);
1166:
1167: if (bp->b_flags & B_ERROR)
1168: error = (bp->b_error ? bp->b_error : EIO);
1169: brelse(bp);
1170: }
1171: return (error);
1172: }
1173:
1174:
1175: /*
1176: * This is an awful lot like cluster_rbuild...wish they could be combined.
1177: * The last lbn argument is the current block on which I/O is being
1178: * performed. Check to see that it doesn't fall in the middle of
1179: * the current block (if last_bp == NULL).
1180: */
1181: void
1182: cluster_wbuild(vp, last_bp, size, start_lbn, len, lbn, secsize, need_sync)
1183: struct vnode *vp;
1184: struct buf *last_bp;
1185: long size;
1186: daddr_t start_lbn;
1187: int len;
1188: daddr_t lbn;
1189: long secsize;
1190: int need_sync;
1191: {
1192: struct cluster_save *b_save;
1193: struct buf *bp, *tbp;
1194: caddr_t cp;
1195: int i, s;
1196:
1197: #if DIAGNOSTIC
1198: if (size != vp->v_mount->mnt_stat.f_iosize)
1199: panic("cluster_wbuild: size %d != filesize %d\n",
1200: size, vp->v_mount->mnt_stat.f_iosize);
1201: #endif
1202: redo:
1203: while ((!incore(vp, start_lbn) || start_lbn == lbn) && len) {
1204: ++start_lbn;
1205: --len;
1206: }
1207: /* Get more memory for current buffer */
1208: if (len <= 1) {
1209: if (last_bp) {
1210: KERNEL_DEBUG((FSDBG_CODE(DBG_FSRW, 12)) | DBG_FUNC_NONE,
1211: last_bp->b_lblkno,
1212: last_bp->b_blkno,
1213: last_bp->b_bcount,
1214: 1,
1215: 0 );
1216: if (need_sync)
1217: bwrite(last_bp);
1218: else
1219: bawrite(last_bp);
1220: } else if (len) {
1221: bp = getblk(vp, start_lbn, size, 0, 0);
1222:
1223: KERNEL_DEBUG((FSDBG_CODE(DBG_FSRW, 12)) | DBG_FUNC_NONE,
1224: bp->b_lblkno,
1225: bp->b_blkno,
1226: bp->b_bcount,
1227: 2,
1228: 0 );
1229: if (bp->b_flags & B_DELWRI) {
1230: if (need_sync)
1231: bwrite(bp);
1232: else
1233: bawrite(bp);
1234: } else
1235: brelse(bp);
1236: }
1237: return;
1238: }
1239: b_save = _MALLOC(sizeof(struct buf *) * len + sizeof(struct cluster_save),
1240: M_SEGMENT, M_NOWAIT);
1241: if (b_save)
1242: bp = alloc_io_buf(vp);
1243: else
1244: bp = NULL;
1245:
1246: if (b_save == NULL || bp == NULL) {
1247: KERNEL_DEBUG((FSDBG_CODE(DBG_FSRW, 12)) | DBG_FUNC_NONE,
1248: bp,
1249: b_save,
1250: 0,
1251: 4,
1252: 0 );
1253: if (bp)
1254: free_io_buf(bp);
1255: if (b_save)
1256: _FREE(b_save, M_SEGMENT);
1257:
1258: for (i = 0; i < len; ++i, ++start_lbn) {
1259: if (!incore(vp, start_lbn))
1260: continue;
1261: if (last_bp == NULL || start_lbn != lbn) {
1262: tbp = getblk(vp, start_lbn, size, 0, 0);
1263:
1264: if (tbp->b_flags & B_DELWRI) {
1265: KERNEL_DEBUG((FSDBG_CODE(DBG_FSRW, 12)) | DBG_FUNC_NONE,
1266: tbp->b_lblkno,
1267: tbp->b_blkno,
1268: tbp->b_bcount,
1269: 5,
1270: 0 );
1271:
1272: if (need_sync)
1273: bwrite(tbp);
1274: else
1275: bawrite(tbp);
1276: } else
1277: brelse(tbp);
1278: }
1279: }
1280: if (last_bp) {
1281: KERNEL_DEBUG((FSDBG_CODE(DBG_FSRW, 12)) | DBG_FUNC_NONE,
1282: last_bp->b_lblkno,
1283: last_bp->b_blkno,
1284: last_bp->b_bcount,
1285: 6,
1286: 0 );
1287: if (need_sync)
1288: bwrite(last_bp);
1289: else
1290: bawrite(last_bp);
1291: }
1292: return;
1293: }
1294: b_save->bs_bufsize = size;
1295: b_save->bs_nchildren = 0;
1296: b_save->bs_children = (struct buf **)(b_save + 1);
1297:
1298: bp->b_saveaddr = (caddr_t)b_save;
1299: bp->b_iodone = cluster_callback;
1300: bp->b_flags |= (B_WRITEINPROG | B_CALL | B_ASYNC);
1301:
1302: cp = (char *)bp->b_data;
1303:
1304: for (start_lbn, i = 0; i < len; ++i, ++start_lbn) {
1305: /*
1306: * Block is not in core or the non-sequential block
1307: * ending our cluster was part of the cluster (in which
1308: * case we don't want to write it twice).
1309: */
1310: if (!incore(vp, start_lbn) ||
1311: (last_bp == NULL && start_lbn == lbn))
1312: break;
1313:
1314: /*
1315: * Get the desired block buffer (unless it is the final
1316: * sequential block whose buffer was passed in explictly
1317: * as last_bp).
1318: */
1319: if (last_bp == NULL || start_lbn != lbn) {
1320: tbp = getblk(vp, start_lbn, size, 0, 0);
1321: if (!(tbp->b_flags & B_DELWRI)) {
1322: brelse(tbp);
1323: break;
1324: }
1325: } else
1326: tbp = last_bp;
1327:
1328: if (i == 0) {
1329: bp->b_blkno = tbp->b_blkno;
1330: bp->b_lblkno= tbp->b_lblkno;
1331: } else {
1332: if (tbp->b_blkno != (bp->b_blkno + btodb(bp->b_bufsize, secsize))) {
1333: brelse(tbp);
1334: break;
1335: }
1336: }
1337: /* Move memory from children to parent */
1338: pagemove(tbp->b_data, cp, size);
1339: bp->b_bcount += size;
1340: bp->b_bufsize += size;
1341: cp += size;
1342:
1343: tbp->b_bufsize -= size;
1344: tbp->b_flags &= ~(B_READ | B_DONE | B_ERROR | B_DELWRI);
1345: tbp->b_flags |= (B_ASYNC | B_AGE);
1346:
1347: s = splbio();
1348: reassignbuf(tbp, tbp->b_vp); /* put on clean list */
1349: ++tbp->b_vp->v_numoutput;
1350: splx(s);
1351:
1352: b_save->bs_children[i] = tbp;
1353: b_save->bs_nchildren++;
1354: }
1355:
1356: KERNEL_DEBUG((FSDBG_CODE(DBG_FSRW, 12)) | DBG_FUNC_NONE,
1357: bp->b_lblkno,
1358: bp->b_blkno,
1359: bp->b_bcount,
1360: 7,
1361: 0 );
1362: if (i == 0) {
1363: /* None to cluster */
1364: free_io_buf(bp);
1365: _FREE(b_save, M_SEGMENT);
1366: } else {
1367: if (bp->b_bcount > MAXPHYSIO)
1368: panic("cluster_wbuild: bp->b_bcount = %x\n", bp->b_bcount);
1369:
1370: VOP_STRATEGY(bp);
1371: }
1372: if (i < len) {
1373: len -= i + 1;
1374: start_lbn += 1;
1375: goto redo;
1376: }
1377: }
1378:
1379: /*
1380: * Collect together all the buffers in a cluster.
1381: * Plus add one additional buffer.
1382: */
1383: struct cluster_save *
1384: cluster_collectbufs(vp, last_bp)
1385: struct vnode *vp;
1386: struct buf *last_bp;
1387: {
1388: struct cluster_save *buflist;
1389: daddr_t lbn;
1390: int i, j, len;
1391:
1392: len = vp->v_lastw - vp->v_cstart + 1;
1393: buflist = _MALLOC(sizeof(struct buf *) * (len + 1) + sizeof(*buflist),
1394: M_SEGMENT, M_NOWAIT);
1395:
1396: if (buflist == NULL)
1397: return (NULL);
1398:
1399: buflist->bs_nchildren = 0;
1400: buflist->bs_children = (struct buf **)(buflist + 1);
1401: for (lbn = vp->v_cstart, i = 0; i < len; lbn++, i++) {
1402: (void)bread(vp, lbn, last_bp->b_bcount, NOCRED,
1403: &buflist->bs_children[i]);
1404: if(!(buflist->bs_children[i]->b_flags & B_DELWRI)) {
1405: for (j=0; j<=i; j++)
1406: brelse(buflist->bs_children[j]);
1407: _FREE(buflist, M_SEGMENT);
1408: return(NULL);
1409: }
1410: }
1411: buflist->bs_children[i] = last_bp;
1412: buflist->bs_nchildren = i + 1;
1413: return (buflist);
1414: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.