![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to ffs_inode.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 / ufs / ffs|
Return to ffs_inode.c CVS log | Up to [Apple Darwin 0.x] / kernel / bsd / ufs / ffs |
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) 1982, 1986, 1989, 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: * @(#)ffs_inode.c 8.13 (Berkeley) 4/21/95
59: */
60:
61: #include <rev_endian_fs.h>
62: #include <mach_nbc.h>
63: #include <vm/vm_pager.h>
64: #include <vm/vnode_pager.h>
65:
66: #include <sys/param.h>
67: #include <sys/systm.h>
68: #include <sys/mount.h>
69: #include <sys/proc.h>
70: #include <sys/file.h>
71: #include <sys/buf.h>
72: #include <sys/vnode.h>
73: #include <sys/kernel.h>
74: #include <sys/malloc.h>
75: #include <sys/trace.h>
76: #include <sys/resourcevar.h>
77:
78: #include <sys/vm.h>
79:
80: #include <ufs/ufs/quota.h>
81: #include <ufs/ufs/inode.h>
82: #include <ufs/ufs/ufsmount.h>
83: #include <ufs/ufs/ufs_extern.h>
84:
85: #include <ufs/ffs/fs.h>
86: #include <ufs/ffs/ffs_extern.h>
87:
88: #if REV_ENDIAN_FS
89: #include <ufs/ufs/ufs_byte_order.h>
90: #include <architecture/byte_order.h>
91: #endif /* REV_ENDIAN_FS */
92:
93: #if MACH_NBC
94: #include <kern/mapfs.h>
95: #endif /* MACH_NBC */
96:
97:
98:
99: static int ffs_indirtrunc __P((struct inode *, ufs_daddr_t, ufs_daddr_t,
100: ufs_daddr_t, int, long *));
101:
102: /*
103: * Update the access, modified, and inode change times as specified by the
104: * IACCESS, IUPDATE, and ICHANGE flags respectively. The IMODIFIED flag is
105: * used to specify that the inode needs to be updated but that the times have
106: * already been set. The access and modified times are taken from the second
107: * and third parameters; the inode change time is always taken from the current
108: * time. If waitfor is set, then wait for the disk write of the inode to
109: * complete.
110: */
111: int
112: ffs_update(ap)
113: struct vop_update_args /* {
114: struct vnode *a_vp;
115: struct timeval *a_access;
116: struct timeval *a_modify;
117: int a_waitfor;
118: } */ *ap;
119: {
120: register struct fs *fs;
121: struct buf *bp;
122: struct inode *ip;
123: int error;
124: #if REV_ENDIAN_FS
125: struct mount *mp=(ap->a_vp)->v_mount;
126: int rev_endian=(mp->mnt_flag & MNT_REVEND);
127: #endif /* REV_ENDIAN_FS */
128:
129: ip = VTOI(ap->a_vp);
130: if (ap->a_vp->v_mount->mnt_flag & MNT_RDONLY) {
131: ip->i_flag &=
132: ~(IN_ACCESS | IN_CHANGE | IN_MODIFIED | IN_UPDATE);
133: return (0);
134: }
135: if ((ip->i_flag &
136: (IN_ACCESS | IN_CHANGE | IN_MODIFIED | IN_UPDATE)) == 0)
137: return (0);
138: if (ip->i_flag & IN_ACCESS)
139: ip->i_atime = ap->a_access->tv_sec;
140: if (ip->i_flag & IN_UPDATE) {
141: ip->i_mtime = ap->a_modify->tv_sec;
142: ip->i_modrev++;
143: }
144: if (ip->i_flag & IN_CHANGE)
145: ip->i_ctime = time.tv_sec;
146: ip->i_flag &= ~(IN_ACCESS | IN_CHANGE | IN_MODIFIED | IN_UPDATE);
147: fs = ip->i_fs;
148: /*
149: * Ensure that uid and gid are correct. This is a temporary
150: * fix until fsck has been changed to do the update.
151: */
152: if (fs->fs_inodefmt < FS_44INODEFMT) { /* XXX */
153: ip->i_din.di_ouid = ip->i_uid; /* XXX */
154: ip->i_din.di_ogid = ip->i_gid; /* XXX */
155: } /* XXX */
156: if (error = bread(ip->i_devvp,
157: fsbtodb(fs, ino_to_fsba(fs, ip->i_number)),
158: (int)fs->fs_bsize, NOCRED, &bp)) {
159: brelse(bp);
160: return (error);
161: }
162: #if REV_ENDIAN_FS
163: if (rev_endian)
164: byte_swap_inode_out(ip, ((struct dinode *)bp->b_data + ino_to_fsbo(fs, ip->i_number)));
165: else {
166: #endif /* REV_ENDIAN_FS */
167: *((struct dinode *)bp->b_data +
168: ino_to_fsbo(fs, ip->i_number)) = ip->i_din;
169: #if REV_ENDIAN_FS
170: }
171: #endif /* REV_ENDIAN_FS */
172:
173: if (ap->a_waitfor && (ap->a_vp->v_mount->mnt_flag & MNT_ASYNC) == 0)
174: return (bwrite(bp));
175: else {
176: bdwrite(bp);
177: return (0);
178: }
179: }
180:
181: #define SINGLE 0 /* index of single indirect block */
182: #define DOUBLE 1 /* index of double indirect block */
183: #define TRIPLE 2 /* index of triple indirect block */
184: /*
185: * Truncate the inode oip to at most length size, freeing the
186: * disk blocks.
187: */
188: ffs_truncate(ap)
189: struct vop_truncate_args /* {
190: struct vnode *a_vp;
191: off_t a_length;
192: int a_flags;
193: struct ucred *a_cred;
194: struct proc *a_p;
195: } */ *ap;
196: {
197: register struct vnode *ovp = ap->a_vp;
198: ufs_daddr_t lastblock;
199: register struct inode *oip;
200: ufs_daddr_t bn, lbn, lastiblock[NIADDR], indir_lbn[NIADDR];
201: ufs_daddr_t oldblks[NDADDR + NIADDR], newblks[NDADDR + NIADDR];
202: off_t length = ap->a_length;
203: register struct fs *fs;
204: struct buf *bp;
205: int offset, size, level;
206: long count, nblocks, vflags, blocksreleased = 0;
207: struct timeval tv;
208: register int i;
209: int aflags, error, allerror;
210: off_t osize;
211: #if NeXT
212: int devBlockSize=0;
213: #endif
214:
215: if (length < 0)
216: return (EINVAL);
217:
218: oip = VTOI(ovp);
219: fs = oip->i_fs;
220:
221: if (length > fs->fs_maxfilesize)
222: return (EFBIG);
223:
224: tv = time;
225: if (ovp->v_type == VLNK &&
226: oip->i_size < ovp->v_mount->mnt_maxsymlinklen) {
227: #if DIAGNOSTIC
228: if (length != 0)
229: panic("ffs_truncate: partial truncate of symlink");
230: #endif
231: bzero((char *)&oip->i_shortlink, (u_int)oip->i_size);
232: oip->i_size = 0;
233: oip->i_flag |= IN_CHANGE | IN_UPDATE;
234: #if MACH_NBC
235: error = mapfs_trunc(ovp, (vm_offset_t)0);
236: if (error)
237: return (error);
238: #endif /* MACH_NBC */
239: return (VOP_UPDATE(ovp, &tv, &tv, 1));
240: }
241:
242: #if MACH_NBC
243: error = mapfs_trunc(ovp, (vm_offset_t)length);
244: if (error)
245: return (error);
246: #endif /* MACH_NBC */
247:
248: if (oip->i_size == length) {
249: oip->i_flag |= IN_CHANGE | IN_UPDATE;
250: return (VOP_UPDATE(ovp, &tv, &tv, 0));
251: }
252: #if QUOTA
253: if (error = getinoquota(oip))
254: return (error);
255: #endif
256: osize = oip->i_size;
257:
258: /*
259: * Lengthen the size of the file. We must ensure that the
260: * last byte of the file is allocated. Since the smallest
261: * value of osize is 0, length will be at least 1.
262: */
263: if (osize < length) {
264: offset = blkoff(fs, length - 1);
265: lbn = lblkno(fs, length - 1);
266: aflags = B_CLRBUF;
267: if (ap->a_flags & IO_SYNC)
268: aflags |= B_SYNC;
269: if (error = ffs_balloc(oip, lbn, offset + 1, ap->a_cred, &bp,
270: aflags))
271: return (error);
272: oip->i_size = length;
273: #if MACH_NBC
274: if ((ovp->v_type == VREG) && (ovp->v_vm_info && !(ovp->v_vm_info->mapped))) {
275: #endif /* MACH_NBC */
276: vnode_pager_setsize(ovp, (u_long)length);
277: vnode_uncache(ovp);
278: #if MACH_NBC
279: }
280: #endif /* !MACH_NBC */
281: if (aflags & B_SYNC)
282: bwrite(bp);
283: else
284: bawrite(bp);
285: oip->i_flag |= IN_CHANGE | IN_UPDATE;
286: return (VOP_UPDATE(ovp, &tv, &tv, 1));
287: }
288: /*
289: * Shorten the size of the file. If the file is not being
290: * truncated to a block boundry, the contents of the
291: * partial block following the end of the file must be
292: * zero'ed in case it ever become accessable again because
293: * of subsequent file growth.
294: */
295: offset = blkoff(fs, length);
296: if (offset == 0) {
297: oip->i_size = length;
298: } else {
299: lbn = lblkno(fs, length);
300: aflags = B_CLRBUF;
301: if (ap->a_flags & IO_SYNC)
302: aflags |= B_SYNC;
303: if (error = ffs_balloc(oip, lbn, offset, ap->a_cred, &bp,
304: aflags))
305: return (error);
306: oip->i_size = length;
307: size = blksize(fs, oip, lbn);
308: (void) vnode_uncache(ovp); /* Ignore errors! */
309: bzero((char *)bp->b_data + offset, (u_int)(size - offset));
310: allocbuf(bp, size);
311: if (aflags & B_SYNC)
312: bwrite(bp);
313: else
314: bawrite(bp);
315: }
316: #if MACH_NBC
317: if ((ovp->v_type == VREG) && (ovp->v_vm_info && !(ovp->v_vm_info->mapped))) {
318: #endif /* MACH_NBC */
319: vnode_pager_setsize(ovp, (u_long)length);
320: #if MACH_NBC
321: }
322: #endif /* MACH_NBC */
323:
324: /*
325: * Calculate index into inode's block list of
326: * last direct and indirect blocks (if any)
327: * which we want to keep. Lastblock is -1 when
328: * the file is truncated to 0.
329: */
330: lastblock = lblkno(fs, length + fs->fs_bsize - 1) - 1;
331: lastiblock[SINGLE] = lastblock - NDADDR;
332: lastiblock[DOUBLE] = lastiblock[SINGLE] - NINDIR(fs);
333: lastiblock[TRIPLE] = lastiblock[DOUBLE] - NINDIR(fs) * NINDIR(fs);
334: #ifdef NeXT
335: VOP_DEVBLOCKSIZE(oip->i_devvp,&devBlockSize);
336: nblocks = btodb(fs->fs_bsize, devBlockSize);
337: #else
338: nblocks = btodb(fs->fs_bsize);
339: #endif /* NeXT */
340: /*
341: * Update file and block pointers on disk before we start freeing
342: * blocks. If we crash before free'ing blocks below, the blocks
343: * will be returned to the free list. lastiblock values are also
344: * normalized to -1 for calls to ffs_indirtrunc below.
345: */
346: bcopy((caddr_t)&oip->i_db[0], (caddr_t)oldblks, sizeof oldblks);
347: for (level = TRIPLE; level >= SINGLE; level--)
348: if (lastiblock[level] < 0) {
349: oip->i_ib[level] = 0;
350: lastiblock[level] = -1;
351: }
352: for (i = NDADDR - 1; i > lastblock; i--)
353: oip->i_db[i] = 0;
354: oip->i_flag |= IN_CHANGE | IN_UPDATE;
355: if (error = VOP_UPDATE(ovp, &tv, &tv, MNT_WAIT))
356: allerror = error;
357: /*
358: * Having written the new inode to disk, save its new configuration
359: * and put back the old block pointers long enough to process them.
360: * Note that we save the new block configuration so we can check it
361: * when we are done.
362: */
363: bcopy((caddr_t)&oip->i_db[0], (caddr_t)newblks, sizeof newblks);
364: bcopy((caddr_t)oldblks, (caddr_t)&oip->i_db[0], sizeof oldblks);
365: oip->i_size = osize;
366: vflags = ((length > 0) ? V_SAVE : 0) | V_SAVEMETA;
367: allerror = vinvalbuf(ovp, vflags, ap->a_cred, ap->a_p, 0, 0);
368:
369: /*
370: * Indirect blocks first.
371: */
372: indir_lbn[SINGLE] = -NDADDR;
373: indir_lbn[DOUBLE] = indir_lbn[SINGLE] - NINDIR(fs) - 1;
374: indir_lbn[TRIPLE] = indir_lbn[DOUBLE] - NINDIR(fs) * NINDIR(fs) - 1;
375: for (level = TRIPLE; level >= SINGLE; level--) {
376: bn = oip->i_ib[level];
377: if (bn != 0) {
378: error = ffs_indirtrunc(oip, indir_lbn[level],
379: fsbtodb(fs, bn), lastiblock[level], level, &count);
380: if (error)
381: allerror = error;
382: blocksreleased += count;
383: if (lastiblock[level] < 0) {
384: oip->i_ib[level] = 0;
385: ffs_blkfree(oip, bn, fs->fs_bsize);
386: blocksreleased += nblocks;
387: }
388: }
389: if (lastiblock[level] >= 0)
390: goto done;
391: }
392:
393: /*
394: * All whole direct blocks or frags.
395: */
396: for (i = NDADDR - 1; i > lastblock; i--) {
397: register long bsize;
398:
399: bn = oip->i_db[i];
400: if (bn == 0)
401: continue;
402: oip->i_db[i] = 0;
403: bsize = blksize(fs, oip, i);
404: ffs_blkfree(oip, bn, bsize);
405: #ifdef NeXT
406: blocksreleased += btodb(bsize, devBlockSize);
407: #else
408: blocksreleased += btodb(bsize);
409: #endif /* NeXT */
410: }
411: if (lastblock < 0)
412: goto done;
413:
414: /*
415: * Finally, look for a change in size of the
416: * last direct block; release any frags.
417: */
418: bn = oip->i_db[lastblock];
419: if (bn != 0) {
420: long oldspace, newspace;
421:
422: /*
423: * Calculate amount of space we're giving
424: * back as old block size minus new block size.
425: */
426: oldspace = blksize(fs, oip, lastblock);
427: oip->i_size = length;
428: newspace = blksize(fs, oip, lastblock);
429: if (newspace == 0)
430: panic("itrunc: newspace");
431: if (oldspace - newspace > 0) {
432: /*
433: * Block number of space to be free'd is
434: * the old block # plus the number of frags
435: * required for the storage we're keeping.
436: */
437: bn += numfrags(fs, newspace);
438: ffs_blkfree(oip, bn, oldspace - newspace);
439: #ifdef NeXT
440: blocksreleased += btodb(oldspace - newspace, devBlockSize);
441: #else
442: blocksreleased += btodb(oldspace - newspace);
443: #endif /* NeXT */
444: }
445: }
446: done:
447: #if DIAGNOSTIC
448: for (level = SINGLE; level <= TRIPLE; level++)
449: if (newblks[NDADDR + level] != oip->i_ib[level])
450: panic("itrunc1");
451: for (i = 0; i < NDADDR; i++)
452: if (newblks[i] != oip->i_db[i])
453: panic("itrunc2");
454: if (length == 0 &&
455: (ovp->v_dirtyblkhd.lh_first || ovp->v_cleanblkhd.lh_first))
456: panic("itrunc3");
457: #endif /* DIAGNOSTIC */
458: /*
459: * Put back the real size.
460: */
461: oip->i_size = length;
462: oip->i_blocks -= blocksreleased;
463: if (oip->i_blocks < 0) /* sanity */
464: oip->i_blocks = 0;
465: oip->i_flag |= IN_CHANGE;
466: #if QUOTA
467: (void) chkdq(oip, -blocksreleased, NOCRED, 0);
468: #endif
469: return (allerror);
470: }
471:
472: /*
473: * Release blocks associated with the inode ip and stored in the indirect
474: * block bn. Blocks are free'd in LIFO order up to (but not including)
475: * lastbn. If level is greater than SINGLE, the block is an indirect block
476: * and recursive calls to indirtrunc must be used to cleanse other indirect
477: * blocks.
478: *
479: * NB: triple indirect blocks are untested.
480: */
481: static int
482: ffs_indirtrunc(ip, lbn, dbn, lastbn, level, countp)
483: register struct inode *ip;
484: ufs_daddr_t lbn, lastbn;
485: ufs_daddr_t dbn;
486: int level;
487: long *countp;
488: {
489: register int i;
490: struct buf *bp;
491: struct buf *tbp;
492: register struct fs *fs = ip->i_fs;
493: register ufs_daddr_t *bap;
494: struct vnode *vp=ITOV(ip);
495: ufs_daddr_t *copy, nb, nlbn, last;
496: long blkcount, factor;
497: int nblocks, blocksreleased = 0;
498: int error = 0, allerror = 0;
499: #if NeXT
500: int devBlockSize=0;
501: #endif /* NeXT */
502: #if REV_ENDIAN_FS
503: struct mount *mp=vp->v_mount;
504: int rev_endian=(mp->mnt_flag & MNT_REVEND);
505: #endif /* REV_ENDIAN_FS */
506:
507: /*
508: * Calculate index in current block of last
509: * block to be kept. -1 indicates the entire
510: * block so we need not calculate the index.
511: */
512: factor = 1;
513: for (i = SINGLE; i < level; i++)
514: factor *= NINDIR(fs);
515: last = lastbn;
516: if (lastbn > 0)
517: last /= factor;
518: #if NeXT
519: VOP_DEVBLOCKSIZE(ip->i_devvp,&devBlockSize);
520: nblocks = btodb(fs->fs_bsize, devBlockSize);
521: #else
522: nblocks = btodb(fs->fs_bsize);
523: #endif /* NeXT */
524:
525: /* Doing a MALLOC here is asking for trouble. We can still
526: * deadlock on pagerfile lock, in case we are running
527: * low on memory and block in MALLOC
528: */
529:
530: tbp = geteblk(fs->fs_bsize);
531: copy = (ufs_daddr_t *)tbp->b_data;
532:
533: /*
534: * Get buffer of block pointers, zero those entries corresponding
535: * to blocks to be free'd, and update on disk copy first. Since
536: * double(triple) indirect before single(double) indirect, calls
537: * to bmap on these blocks will fail. However, we already have
538: * the on disk address, so we have to set the b_blkno field
539: * explicitly instead of letting bread do everything for us.
540: */
541:
542: vp = ITOV(ip);
543: bp = getblk(vp, lbn, (int)fs->fs_bsize, 0, 0);
544: if (bp->b_flags & (B_DONE | B_DELWRI)) {
545: /* Braces must be here in case trace evaluates to nothing. */
546: trace(TR_BREADHIT, pack(vp, fs->fs_bsize), lbn);
547: } else {
548: trace(TR_BREADMISS, pack(vp, fs->fs_bsize), lbn);
549: current_proc()->p_stats->p_ru.ru_inblock++; /* pay for read */
550: bp->b_flags |= B_READ;
551: if (bp->b_bcount > bp->b_bufsize)
552: panic("ffs_indirtrunc: bad buffer size");
553: bp->b_blkno = dbn;
554: VOP_STRATEGY(bp);
555: error = biowait(bp);
556: }
557: if (error) {
558: brelse(bp);
559: *countp = 0;
560: brelse(tbp);
561: return (error);
562: }
563:
564: bap = (ufs_daddr_t *)bp->b_data;
565: bcopy((caddr_t)bap, (caddr_t)copy, (u_int)fs->fs_bsize);
566: bzero((caddr_t)&bap[last + 1],
567: (u_int)(NINDIR(fs) - (last + 1)) * sizeof (ufs_daddr_t));
568: if (last == -1)
569: bp->b_flags |= B_INVAL;
570: error = bwrite(bp);
571: if (error)
572: allerror = error;
573: bap = copy;
574:
575: /*
576: * Recursively free totally unused blocks.
577: */
578: for (i = NINDIR(fs) - 1, nlbn = lbn + 1 - i * factor; i > last;
579: i--, nlbn += factor) {
580: #if REV_ENDIAN_FS
581: if (rev_endian)
582: nb = NXSwapLong(bap[i]);
583: else {
584: #endif /* REV_ENDIAN_FS */
585: nb = bap[i];
586: #if REV_ENDIAN_FS
587: }
588: #endif /* REV_ENDIAN_FS */
589: if (nb == 0)
590: continue;
591: if (level > SINGLE) {
592: if (error = ffs_indirtrunc(ip, nlbn, fsbtodb(fs, nb),
593: (ufs_daddr_t)-1, level - 1, &blkcount))
594: allerror = error;
595: blocksreleased += blkcount;
596: }
597: ffs_blkfree(ip, nb, fs->fs_bsize);
598: blocksreleased += nblocks;
599: }
600:
601: /*
602: * Recursively free last partial block.
603: */
604: if (level > SINGLE && lastbn >= 0) {
605: last = lastbn % factor;
606: #if REV_ENDIAN_FS
607: if (rev_endian)
608: nb = NXSwapLong(bap[i]);
609: else {
610: #endif /* REV_ENDIAN_FS */
611: nb = bap[i];
612: #if REV_ENDIAN_FS
613: }
614: #endif /* REV_ENDIAN_FS */
615: if (nb != 0) {
616: if (error = ffs_indirtrunc(ip, nlbn, fsbtodb(fs, nb),
617: last, level - 1, &blkcount))
618: allerror = error;
619: blocksreleased += blkcount;
620: }
621: }
622: brelse(tbp);
623: *countp = blocksreleased;
624: return (allerror);
625: }
626:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.