![[BACK]](/icons/back.gif){kind=icon}
Return to ffs_balloc.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / ufs / ffs|
Return to ffs_balloc.c CVS log | Up to [local] / sys / ufs / ffs |
1.1 nbrk 1: /* $OpenBSD: ffs_balloc.c,v 1.34 2007/06/01 18:54:27 pedro Exp $ */
2: /* $NetBSD: ffs_balloc.c,v 1.3 1996/02/09 22:22:21 christos Exp $ */
3:
4: /*
5: * Copyright (c) 2002 Networks Associates Technology, Inc.
6: * All rights reserved.
7: *
8: * This software was developed for the FreeBSD Project by Marshall
9: * Kirk McKusick and Network Associates Laboratories, the Security
10: * Research Division of Network Associates, Inc. under DARPA/SPAWAR
11: * contract N66001-01-C-8035 ("CBOSS"), as part of the DARPA CHATS
12: * research program.
13: *
14: * Copyright (c) 1982, 1986, 1989, 1993
15: * The Regents of the University of California. All rights reserved.
16: *
17: * Redistribution and use in source and binary forms, with or without
18: * modification, are permitted provided that the following conditions
19: * are met:
20: * 1. Redistributions of source code must retain the above copyright
21: * notice, this list of conditions and the following disclaimer.
22: * 2. Redistributions in binary form must reproduce the above copyright
23: * notice, this list of conditions and the following disclaimer in the
24: * documentation and/or other materials provided with the distribution.
25: * 3. Neither the name of the University nor the names of its contributors
26: * may be used to endorse or promote products derived from this software
27: * without specific prior written permission.
28: *
29: * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
30: * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
31: * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
32: * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
33: * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
34: * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
35: * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
36: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
37: * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
38: * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
39: * SUCH DAMAGE.
40: *
41: * @(#)ffs_balloc.c 8.4 (Berkeley) 9/23/93
42: */
43:
44: #include <sys/param.h>
45: #include <sys/systm.h>
46: #include <sys/buf.h>
47: #include <sys/proc.h>
48: #include <sys/file.h>
49: #include <sys/mount.h>
50: #include <sys/vnode.h>
51:
52: #include <uvm/uvm_extern.h>
53:
54: #include <ufs/ufs/quota.h>
55: #include <ufs/ufs/inode.h>
56: #include <ufs/ufs/ufsmount.h>
57: #include <ufs/ufs/ufs_extern.h>
58:
59: #include <ufs/ffs/fs.h>
60: #include <ufs/ffs/ffs_extern.h>
61:
62: int ffs1_balloc(struct inode *, off_t, int, struct ucred *, int, struct buf **);
63: #ifdef FFS2
64: int ffs2_balloc(struct inode *, off_t, int, struct ucred *, int, struct buf **);
65: #endif
66:
67: /*
68: * Balloc defines the structure of file system storage
69: * by allocating the physical blocks on a device given
70: * the inode and the logical block number in a file.
71: */
72: int
73: ffs1_balloc(struct inode *ip, off_t startoffset, int size, struct ucred *cred,
74: int flags, struct buf **bpp)
75: {
76: daddr_t lbn;
77: struct fs *fs;
78: daddr_t nb;
79: struct buf *bp, *nbp;
80: struct vnode *vp;
81: struct proc *p;
82: struct indir indirs[NIADDR + 2];
83: int32_t newb, *bap, pref;
84: int deallocated, osize, nsize, num, i, error;
85: int32_t *allocib, *blkp, *allocblk, allociblk[NIADDR+1];
86: int unwindidx = -1;
87:
88: vp = ITOV(ip);
89: fs = ip->i_fs;
90: p = curproc;
91: lbn = lblkno(fs, startoffset);
92: size = blkoff(fs, startoffset) + size;
93: if (size > fs->fs_bsize)
94: panic("ffs1_balloc: blk too big");
95: if (bpp != NULL)
96: *bpp = NULL;
97: if (lbn < 0)
98: return (EFBIG);
99:
100: /*
101: * If the next write will extend the file into a new block,
102: * and the file is currently composed of a fragment
103: * this fragment has to be extended to be a full block.
104: */
105: nb = lblkno(fs, ip->i_ffs1_size);
106: if (nb < NDADDR && nb < lbn) {
107: osize = blksize(fs, ip, nb);
108: if (osize < fs->fs_bsize && osize > 0) {
109: error = ffs_realloccg(ip, nb,
110: ffs1_blkpref(ip, nb, (int)nb, &ip->i_ffs1_db[0]),
111: osize, (int)fs->fs_bsize, cred, bpp, &newb);
112: if (error)
113: return (error);
114: if (DOINGSOFTDEP(vp))
115: softdep_setup_allocdirect(ip, nb, newb,
116: ip->i_ffs1_db[nb], fs->fs_bsize, osize,
117: bpp ? *bpp : NULL);
118:
119: ip->i_ffs1_size = lblktosize(fs, nb + 1);
120: uvm_vnp_setsize(vp, ip->i_ffs1_size);
121: ip->i_ffs1_db[nb] = newb;
122: ip->i_flag |= IN_CHANGE | IN_UPDATE;
123: if (bpp != NULL) {
124: if (flags & B_SYNC)
125: bwrite(*bpp);
126: else
127: bawrite(*bpp);
128: }
129: }
130: }
131: /*
132: * The first NDADDR blocks are direct blocks
133: */
134: if (lbn < NDADDR) {
135: nb = ip->i_ffs1_db[lbn];
136: if (nb != 0 && ip->i_ffs1_size >= lblktosize(fs, lbn + 1)) {
137: /*
138: * The block is an already-allocated direct block
139: * and the file already extends past this block,
140: * thus this must be a whole block.
141: * Just read the block (if requested).
142: */
143:
144: if (bpp != NULL) {
145: error = bread(vp, lbn, fs->fs_bsize, NOCRED,
146: bpp);
147: if (error) {
148: brelse(*bpp);
149: return (error);
150: }
151: }
152: return (0);
153: }
154: if (nb != 0) {
155: /*
156: * Consider need to reallocate a fragment.
157: */
158: osize = fragroundup(fs, blkoff(fs, ip->i_ffs1_size));
159: nsize = fragroundup(fs, size);
160: if (nsize <= osize) {
161: /*
162: * The existing block is already
163: * at least as big as we want.
164: * Just read the block (if requested).
165: */
166: if (bpp != NULL) {
167: error = bread(vp, lbn, fs->fs_bsize,
168: NOCRED, bpp);
169: if (error) {
170: brelse(*bpp);
171: return (error);
172: }
173: (*bpp)->b_bcount = osize;
174: }
175: return (0);
176: } else {
177: /*
178: * The existing block is smaller than we
179: * want, grow it.
180: */
181: error = ffs_realloccg(ip, lbn,
182: ffs1_blkpref(ip, lbn, (int)lbn,
183: &ip->i_ffs1_db[0]),
184: osize, nsize, cred, bpp, &newb);
185: if (error)
186: return (error);
187: if (DOINGSOFTDEP(vp))
188: softdep_setup_allocdirect(ip, lbn,
189: newb, nb, nsize, osize,
190: bpp ? *bpp : NULL);
191: }
192: } else {
193: /*
194: * The block was not previously allocated,
195: * allocate a new block or fragment.
196: */
197:
198: if (ip->i_ffs1_size < lblktosize(fs, lbn + 1))
199: nsize = fragroundup(fs, size);
200: else
201: nsize = fs->fs_bsize;
202: error = ffs_alloc(ip, lbn,
203: ffs1_blkpref(ip, lbn, (int)lbn, &ip->i_ffs1_db[0]),
204: nsize, cred, &newb);
205: if (error)
206: return (error);
207: if (bpp != NULL) {
208: *bpp = getblk(vp, lbn, fs->fs_bsize, 0, 0);
209: if (nsize < fs->fs_bsize)
210: (*bpp)->b_bcount = nsize;
211: (*bpp)->b_blkno = fsbtodb(fs, newb);
212: if (flags & B_CLRBUF)
213: clrbuf(*bpp);
214: }
215: if (DOINGSOFTDEP(vp))
216: softdep_setup_allocdirect(ip, lbn, newb, 0,
217: nsize, 0, bpp ? *bpp : NULL);
218: }
219: ip->i_ffs1_db[lbn] = newb;
220: ip->i_flag |= IN_CHANGE | IN_UPDATE;
221: return (0);
222: }
223:
224: /*
225: * Determine the number of levels of indirection.
226: */
227: pref = 0;
228: if ((error = ufs_getlbns(vp, lbn, indirs, &num)) != 0)
229: return(error);
230: #ifdef DIAGNOSTIC
231: if (num < 1)
232: panic ("ffs1_balloc: ufs_bmaparray returned indirect block");
233: #endif
234: /*
235: * Fetch the first indirect block allocating if necessary.
236: */
237: --num;
238: nb = ip->i_ffs1_ib[indirs[0].in_off];
239:
240: allocib = NULL;
241: allocblk = allociblk;
242: if (nb == 0) {
243: pref = ffs1_blkpref(ip, lbn, 0, (daddr_t *)0);
244: error = ffs_alloc(ip, lbn, pref, (int)fs->fs_bsize,
245: cred, &newb);
246: if (error)
247: goto fail;
248: nb = newb;
249:
250: *allocblk++ = nb;
251: bp = getblk(vp, indirs[1].in_lbn, fs->fs_bsize, 0, 0);
252: bp->b_blkno = fsbtodb(fs, nb);
253: clrbuf(bp);
254:
255: if (DOINGSOFTDEP(vp)) {
256: softdep_setup_allocdirect(ip, NDADDR + indirs[0].in_off,
257: newb, 0, fs->fs_bsize, 0, bp);
258: bdwrite(bp);
259: } else {
260: /*
261: * Write synchronously so that indirect blocks
262: * never point at garbage.
263: */
264: if ((error = bwrite(bp)) != 0)
265: goto fail;
266: }
267: allocib = &ip->i_ffs1_ib[indirs[0].in_off];
268: *allocib = nb;
269: ip->i_flag |= IN_CHANGE | IN_UPDATE;
270: }
271:
272: /*
273: * Fetch through the indirect blocks, allocating as necessary.
274: */
275: for (i = 1;;) {
276: error = bread(vp,
277: indirs[i].in_lbn, (int)fs->fs_bsize, NOCRED, &bp);
278: if (error) {
279: brelse(bp);
280: goto fail;
281: }
282: bap = (daddr_t *)bp->b_data;
283: nb = bap[indirs[i].in_off];
284: if (i == num)
285: break;
286: i++;
287: if (nb != 0) {
288: brelse(bp);
289: continue;
290: }
291: if (pref == 0)
292: pref = ffs1_blkpref(ip, lbn, 0, (daddr_t *)0);
293: error = ffs_alloc(ip, lbn, pref, (int)fs->fs_bsize, cred,
294: &newb);
295: if (error) {
296: brelse(bp);
297: goto fail;
298: }
299: nb = newb;
300: *allocblk++ = nb;
301: nbp = getblk(vp, indirs[i].in_lbn, fs->fs_bsize, 0, 0);
302: nbp->b_blkno = fsbtodb(fs, nb);
303: clrbuf(nbp);
304:
305: if (DOINGSOFTDEP(vp)) {
306: softdep_setup_allocindir_meta(nbp, ip, bp,
307: indirs[i - 1].in_off, nb);
308: bdwrite(nbp);
309: } else {
310: /*
311: * Write synchronously so that indirect blocks
312: * never point at garbage.
313: */
314: if ((error = bwrite(nbp)) != 0) {
315: brelse(bp);
316: goto fail;
317: }
318: }
319: bap[indirs[i - 1].in_off] = nb;
320: if (allocib == NULL && unwindidx < 0)
321: unwindidx = i - 1;
322: /*
323: * If required, write synchronously, otherwise use
324: * delayed write.
325: */
326: if (flags & B_SYNC) {
327: bwrite(bp);
328: } else {
329: bdwrite(bp);
330: }
331: }
332: /*
333: * Get the data block, allocating if necessary.
334: */
335: if (nb == 0) {
336: pref = ffs1_blkpref(ip, lbn, indirs[i].in_off, &bap[0]);
337: error = ffs_alloc(ip, lbn, pref, (int)fs->fs_bsize, cred,
338: &newb);
339: if (error) {
340: brelse(bp);
341: goto fail;
342: }
343: nb = newb;
344: *allocblk++ = nb;
345: if (bpp != NULL) {
346: nbp = getblk(vp, lbn, fs->fs_bsize, 0, 0);
347: nbp->b_blkno = fsbtodb(fs, nb);
348: if (flags & B_CLRBUF)
349: clrbuf(nbp);
350: *bpp = nbp;
351: }
352: if (DOINGSOFTDEP(vp))
353: softdep_setup_allocindir_page(ip, lbn, bp,
354: indirs[i].in_off, nb, 0, bpp ? *bpp : NULL);
355: bap[indirs[i].in_off] = nb;
356: /*
357: * If required, write synchronously, otherwise use
358: * delayed write.
359: */
360: if (flags & B_SYNC) {
361: bwrite(bp);
362: } else {
363: bdwrite(bp);
364: }
365: return (0);
366: }
367: brelse(bp);
368: if (bpp != NULL) {
369: if (flags & B_CLRBUF) {
370: error = bread(vp, lbn, (int)fs->fs_bsize, NOCRED, &nbp);
371: if (error) {
372: brelse(nbp);
373: goto fail;
374: }
375: } else {
376: nbp = getblk(vp, lbn, fs->fs_bsize, 0, 0);
377: nbp->b_blkno = fsbtodb(fs, nb);
378: }
379: *bpp = nbp;
380: }
381: return (0);
382:
383: fail:
384: /*
385: * If we have failed to allocate any blocks, simply return the error.
386: * This is the usual case and avoids the need to fsync the file.
387: */
388: if (allocblk == allociblk && allocib == NULL && unwindidx == -1)
389: return (error);
390: /*
391: * If we have failed part way through block allocation, we have to
392: * deallocate any indirect blocks that we have allocated. We have to
393: * fsync the file before we start to get rid of all of its
394: * dependencies so that we do not leave them dangling. We have to sync
395: * it at the end so that the softdep code does not find any untracked
396: * changes. Although this is really slow, running out of disk space is
397: * not expected to be a common occurence. The error return from fsync
398: * is ignored as we already have an error to return to the user.
399: */
400: VOP_FSYNC(vp, p->p_ucred, MNT_WAIT, p);
401: for (deallocated = 0, blkp = allociblk; blkp < allocblk; blkp++) {
402: ffs_blkfree(ip, *blkp, fs->fs_bsize);
403: deallocated += fs->fs_bsize;
404: }
405: if (allocib != NULL) {
406: *allocib = 0;
407: } else if (unwindidx >= 0) {
408: int r;
409:
410: r = bread(vp, indirs[unwindidx].in_lbn,
411: (int)fs->fs_bsize, NOCRED, &bp);
412: if (r)
413: panic("Could not unwind indirect block, error %d", r);
414: bap = (daddr_t *)bp->b_data;
415: bap[indirs[unwindidx].in_off] = 0;
416: if (flags & B_SYNC) {
417: bwrite(bp);
418: } else {
419: bdwrite(bp);
420: }
421: }
422: if (deallocated) {
423: /*
424: * Restore user's disk quota because allocation failed.
425: */
426: (void)ufs_quota_free_blocks(ip, btodb(deallocated), cred);
427:
428: ip->i_ffs1_blocks -= btodb(deallocated);
429: ip->i_flag |= IN_CHANGE | IN_UPDATE;
430: }
431: VOP_FSYNC(vp, p->p_ucred, MNT_WAIT, p);
432: return (error);
433: }
434:
435: #ifdef FFS2
436: int
437: ffs2_balloc(struct inode *ip, off_t off, int size, struct ucred *cred,
438: int flags, struct buf **bpp)
439: {
440: daddr_t lbn, lastlbn, nb, newb, *blkp;
441: daddr_t pref, *allocblk, allociblk[NIADDR + 1];
442: daddr64_t *bap, *allocib;
443: int deallocated, osize, nsize, num, i, error, unwindidx, r;
444: struct buf *bp, *nbp;
445: struct indir indirs[NIADDR + 2];
446: struct fs *fs;
447: struct vnode *vp;
448: struct proc *p;
449:
450: vp = ITOV(ip);
451: fs = ip->i_fs;
452: p = curproc;
453: unwindidx = -1;
454:
455: lbn = lblkno(fs, off);
456: size = blkoff(fs, off) + size;
457:
458: if (size > fs->fs_bsize)
459: panic("ffs2_balloc: block too big");
460:
461: if (bpp != NULL)
462: *bpp = NULL;
463:
464: if (lbn < 0)
465: return (EFBIG);
466:
467: /*
468: * If the next write will extend the file into a new block, and the
469: * file is currently composed of a fragment, this fragment has to be
470: * extended to be a full block.
471: */
472: lastlbn = lblkno(fs, ip->i_ffs2_size);
473: if (lastlbn < NDADDR && lastlbn < lbn) {
474: nb = lastlbn;
475: osize = blksize(fs, ip, nb);
476: if (osize < fs->fs_bsize && osize > 0) {
477: error = ffs_realloccg(ip, nb, ffs2_blkpref(ip,
478: lastlbn, nb, &ip->i_ffs2_db[0]), osize,
479: (int) fs->fs_bsize, cred, bpp, &newb);
480: if (error)
481: return (error);
482:
483: if (DOINGSOFTDEP(vp))
484: softdep_setup_allocdirect(ip, nb, newb,
485: ip->i_ffs2_db[nb], fs->fs_bsize, osize,
486: bpp ? *bpp : NULL);
487:
488: ip->i_ffs2_size = lblktosize(fs, nb + 1);
489: uvm_vnp_setsize(vp, ip->i_ffs2_size);
490: ip->i_ffs2_db[nb] = newb;
491: ip->i_flag |= IN_CHANGE | IN_UPDATE;
492:
493: if (bpp) {
494: if (flags & B_SYNC)
495: bwrite(*bpp);
496: else
497: bawrite(*bpp);
498: }
499: }
500: }
501:
502: /*
503: * The first NDADDR blocks are direct.
504: */
505: if (lbn < NDADDR) {
506:
507: nb = ip->i_ffs2_db[lbn];
508:
509: if (nb != 0 && ip->i_ffs2_size >= lblktosize(fs, lbn + 1)) {
510: /*
511: * The direct block is already allocated and the file
512: * extends past this block, thus this must be a whole
513: * block. Just read it, if requested.
514: */
515: if (bpp != NULL) {
516: error = bread(vp, lbn, fs->fs_bsize, NOCRED,
517: bpp);
518: if (error) {
519: brelse(*bpp);
520: return (error);
521: }
522: }
523:
524: return (0);
525: }
526:
527: if (nb != 0) {
528: /*
529: * Consider the need to allocate a fragment.
530: */
531: osize = fragroundup(fs, blkoff(fs, ip->i_ffs2_size));
532: nsize = fragroundup(fs, size);
533:
534: if (nsize <= osize) {
535: /*
536: * The existing block is already at least as
537: * big as we want. Just read it, if requested.
538: */
539: if (bpp != NULL) {
540: error = bread(vp, lbn, fs->fs_bsize,
541: NOCRED, bpp);
542: if (error) {
543: brelse(*bpp);
544: return (error);
545: }
546: (*bpp)->b_bcount = osize;
547: }
548:
549: return (0);
550: } else {
551: /*
552: * The existing block is smaller than we want,
553: * grow it.
554: */
555: error = ffs_realloccg(ip, lbn,
556: ffs2_blkpref(ip, lbn, (int) lbn,
557: &ip->i_ffs2_db[0]), osize, nsize, cred,
558: bpp, &newb);
559: if (error)
560: return (error);
561:
562: if (DOINGSOFTDEP(vp))
563: softdep_setup_allocdirect(ip, lbn,
564: newb, nb, nsize, osize,
565: bpp ? *bpp : NULL);
566: }
567: } else {
568: /*
569: * The block was not previously allocated, allocate a
570: * new block or fragment.
571: */
572: if (ip->i_ffs2_size < lblktosize(fs, lbn + 1))
573: nsize = fragroundup(fs, size);
574: else
575: nsize = fs->fs_bsize;
576:
577: error = ffs_alloc(ip, lbn, ffs2_blkpref(ip, lbn,
578: (int) lbn, &ip->i_ffs2_db[0]), nsize, cred, &newb);
579: if (error)
580: return (error);
581:
582: if (bpp != NULL) {
583: bp = getblk(vp, lbn, fs->fs_bsize, 0, 0);
584: if (nsize < fs->fs_bsize)
585: bp->b_bcount = nsize;
586: bp->b_blkno = fsbtodb(fs, newb);
587: if (flags & B_CLRBUF)
588: clrbuf(bp);
589: *bpp = bp;
590: }
591:
592: if (DOINGSOFTDEP(vp))
593: softdep_setup_allocdirect(ip, lbn, newb, 0,
594: nsize, 0, bpp ? *bpp : NULL);
595: }
596:
597: ip->i_ffs2_db[lbn] = newb;
598: ip->i_flag |= IN_CHANGE | IN_UPDATE;
599:
600: return (0);
601: }
602:
603: /*
604: * Determine the number of levels of indirection.
605: */
606: pref = 0;
607: error = ufs_getlbns(vp, lbn, indirs, &num);
608: if (error)
609: return (error);
610:
611: #ifdef DIAGNOSTIC
612: if (num < 1)
613: panic("ffs2_balloc: ufs_bmaparray returned indirect block");
614: #endif
615:
616: /*
617: * Fetch the first indirect block allocating it necessary.
618: */
619: --num;
620: nb = ip->i_ffs2_ib[indirs[0].in_off];
621: allocib = NULL;
622: allocblk = allociblk;
623:
624: if (nb == 0) {
625: pref = ffs2_blkpref(ip, lbn, 0, NULL);
626: error = ffs_alloc(ip, lbn, pref, (int) fs->fs_bsize, cred,
627: &newb);
628: if (error)
629: goto fail;
630:
631: nb = newb;
632: *allocblk++ = nb;
633: bp = getblk(vp, indirs[1].in_lbn, fs->fs_bsize, 0, 0);
634: bp->b_blkno = fsbtodb(fs, nb);
635: clrbuf(bp);
636:
637: if (DOINGSOFTDEP(vp)) {
638: softdep_setup_allocdirect(ip, NDADDR + indirs[0].in_off,
639: newb, 0, fs->fs_bsize, 0, bp);
640: bdwrite(bp);
641: } else {
642: /*
643: * Write synchronously so that indirect blocks never
644: * point at garbage.
645: */
646: error = bwrite(bp);
647: if (error)
648: goto fail;
649: }
650:
651: unwindidx = 0;
652: allocib = &ip->i_ffs2_ib[indirs[0].in_off];
653: *allocib = nb;
654: ip->i_flag |= IN_CHANGE | IN_UPDATE;
655: }
656:
657: /*
658: * Fetch through the indirect blocks, allocating as necessary.
659: */
660: for (i = 1;;) {
661: error = bread(vp, indirs[i].in_lbn, (int) fs->fs_bsize,
662: NOCRED, &bp);
663: if (error) {
664: brelse(bp);
665: goto fail;
666: }
667:
668: bap = (int64_t *) bp->b_data;
669: nb = bap[indirs[i].in_off];
670:
671: if (i == num)
672: break;
673:
674: i++;
675:
676: if (nb != 0) {
677: brelse(bp);
678: continue;
679: }
680:
681: if (pref == 0)
682: pref = ffs2_blkpref(ip, lbn, 0, NULL);
683:
684: error = ffs_alloc(ip, lbn, pref, (int) fs->fs_bsize, cred,
685: &newb);
686: if (error) {
687: brelse(bp);
688: goto fail;
689: }
690:
691: nb = newb;
692: *allocblk++ = nb;
693: nbp = getblk(vp, indirs[i].in_lbn, fs->fs_bsize, 0, 0);
694: nbp->b_blkno = fsbtodb(fs, nb);
695: clrbuf(nbp);
696:
697: if (DOINGSOFTDEP(vp)) {
698: softdep_setup_allocindir_meta(nbp, ip, bp,
699: indirs[i - 1].in_off, nb);
700: bdwrite(nbp);
701: } else {
702: /*
703: * Write synchronously so that indirect blocks never
704: * point at garbage.
705: */
706: error = bwrite(nbp);
707: if (error) {
708: brelse(bp);
709: goto fail;
710: }
711: }
712:
713: if (unwindidx < 0)
714: unwindidx = i - 1;
715:
716: bap[indirs[i - 1].in_off] = nb;
717:
718: /*
719: * If required, write synchronously, otherwise use delayed
720: * write.
721: */
722: if (flags & B_SYNC)
723: bwrite(bp);
724: else
725: bdwrite(bp);
726: }
727:
728: /*
729: * Get the data block, allocating if necessary.
730: */
731: if (nb == 0) {
732: pref = ffs2_blkpref(ip, lbn, indirs[num].in_off, &bap[0]);
733:
734: error = ffs_alloc(ip, lbn, pref, (int)fs->fs_bsize, cred,
735: &newb);
736: if (error) {
737: brelse(bp);
738: goto fail;
739: }
740:
741: nb = newb;
742: *allocblk++ = nb;
743:
744: if (bpp != NULL) {
745: nbp = getblk(vp, lbn, fs->fs_bsize, 0, 0);
746: nbp->b_blkno = fsbtodb(fs, nb);
747: if (flags & B_CLRBUF)
748: clrbuf(nbp);
749: *bpp = nbp;
750: }
751:
752: if (DOINGSOFTDEP(vp))
753: softdep_setup_allocindir_page(ip, lbn, bp,
754: indirs[num].in_off, nb, 0, bpp ? *bpp : NULL);
755:
756: bap[indirs[num].in_off] = nb;
757:
758: if (allocib == NULL && unwindidx < 0)
759: unwindidx = i - 1;
760:
761: /*
762: * If required, write synchronously, otherwise use delayed
763: * write.
764: */
765: if (flags & B_SYNC)
766: bwrite(bp);
767: else
768: bdwrite(bp);
769:
770: return (0);
771: }
772:
773: brelse(bp);
774:
775: if (bpp != NULL) {
776: if (flags & B_CLRBUF) {
777: error = bread(vp, lbn, (int)fs->fs_bsize, NOCRED, &nbp);
778: if (error) {
779: brelse(nbp);
780: goto fail;
781: }
782: } else {
783: nbp = getblk(vp, lbn, fs->fs_bsize, 0, 0);
784: nbp->b_blkno = fsbtodb(fs, nb);
785: clrbuf(nbp);
786: }
787:
788: *bpp = nbp;
789: }
790:
791: return (0);
792:
793: fail:
794: /*
795: * If we have failed to allocate any blocks, simply return the error.
796: * This is the usual case and avoids the need to fsync the file.
797: */
798: if (allocblk == allociblk && allocib == NULL && unwindidx == -1)
799: return (error);
800: /*
801: * If we have failed part way through block allocation, we have to
802: * deallocate any indirect blocks that we have allocated. We have to
803: * fsync the file before we start to get rid of all of its
804: * dependencies so that we do not leave them dangling. We have to sync
805: * it at the end so that the softdep code does not find any untracked
806: * changes. Although this is really slow, running out of disk space is
807: * not expected to be a common occurence. The error return from fsync
808: * is ignored as we already have an error to return to the user.
809: */
810: VOP_FSYNC(vp, p->p_ucred, MNT_WAIT, p);
811: if (unwindidx >= 0) {
812: /*
813: * First write out any buffers we've created to resolve their
814: * softdeps. This must be done in reverse order of creation so
815: * that we resolve the dependencies in one pass.
816: * Write the cylinder group buffers for these buffers too.
817: */
818: for (i = num; i >= unwindidx; i--) {
819: if (i == 0)
820: break;
821:
822: bp = getblk(vp, indirs[i].in_lbn, (int) fs->fs_bsize,
823: 0, 0);
824: if (bp->b_flags & B_DELWRI) {
825: nb = fsbtodb(fs, cgtod(fs, dtog(fs,
826: dbtofsb(fs, bp->b_blkno))));
827: bwrite(bp);
828: bp = getblk(ip->i_devvp, nb,
829: (int) fs->fs_cgsize, 0, 0);
830: if (bp->b_flags & B_DELWRI)
831: bwrite(bp);
832: else {
833: bp->b_flags |= B_INVAL;
834: brelse(bp);
835: }
836: } else {
837: bp->b_flags |= B_INVAL;
838: brelse(bp);
839: }
840: }
841:
842: if (DOINGSOFTDEP(vp) && unwindidx == 0) {
843: ip->i_flag |= IN_CHANGE | IN_UPDATE;
844: ffs_update(ip, NULL, NULL, MNT_WAIT);
845: }
846:
847: /*
848: * Now that any dependencies that we created have been
849: * resolved, we can undo the partial allocation.
850: */
851: if (unwindidx == 0) {
852: *allocib = 0;
853: ip->i_flag |= IN_CHANGE | IN_UPDATE;
854: if (DOINGSOFTDEP(vp))
855: ffs_update(ip, NULL, NULL, MNT_WAIT);
856: } else {
857: r = bread(vp, indirs[unwindidx].in_lbn,
858: (int) fs->fs_bsize, NOCRED, &bp);
859: if (r)
860: panic("ffs2_balloc: unwind failed");
861:
862: bap = (int64_t *) bp->b_data;
863: bap[indirs[unwindidx].in_off] = 0;
864: bwrite(bp);
865: }
866:
867: for (i = unwindidx + 1; i <= num; i++) {
868: bp = getblk(vp, indirs[i].in_lbn, (int)fs->fs_bsize, 0,
869: 0);
870: bp->b_flags |= B_INVAL;
871: brelse(bp);
872: }
873: }
874:
875: for (deallocated = 0, blkp = allociblk; blkp < allocblk; blkp++) {
876: ffs_blkfree(ip, *blkp, fs->fs_bsize);
877: deallocated += fs->fs_bsize;
878: }
879:
880: if (deallocated) {
881: /*
882: * Restore user's disk quota because allocation failed.
883: */
884: (void) ufs_quota_free_blocks(ip, btodb(deallocated), cred);
885:
886: ip->i_ffs2_blocks -= btodb(deallocated);
887: ip->i_flag |= IN_CHANGE | IN_UPDATE;
888: }
889: VOP_FSYNC(vp, p->p_ucred, MNT_WAIT, p);
890: return (error);
891: }
892: #endif /* FFS2 */
893:
894: /*
895: * Balloc defines the structure of file system storage by allocating the
896: * physical blocks given the inode and the logical block number in a file.
897: */
898: int
899: ffs_balloc(struct inode *ip, off_t off, int size, struct ucred *cred,
900: int flags, struct buf **bpp)
901: {
902: #ifdef FFS2
903: if (ip->i_fs->fs_magic == FS_UFS2_MAGIC)
904: return (ffs2_balloc(ip, off, size, cred, flags, bpp));
905: else
906: #endif
907: return (ffs1_balloc(ip, off, size, cred, flags, bpp));
908: }