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