ext2_inode.c revision 311232
1/*- 2 * modified for Lites 1.1 3 * 4 * Aug 1995, Godmar Back (gback@cs.utah.edu) 5 * University of Utah, Department of Computer Science 6 */ 7/*- 8 * Copyright (c) 1982, 1986, 1989, 1993 9 * The Regents of the University of California. All rights reserved. 10 * 11 * Redistribution and use in source and binary forms, with or without 12 * modification, are permitted provided that the following conditions 13 * are met: 14 * 1. Redistributions of source code must retain the above copyright 15 * notice, this list of conditions and the following disclaimer. 16 * 2. Redistributions in binary form must reproduce the above copyright 17 * notice, this list of conditions and the following disclaimer in the 18 * documentation and/or other materials provided with the distribution. 19 * 4. Neither the name of the University nor the names of its contributors 20 * may be used to endorse or promote products derived from this software 21 * without specific prior written permission. 22 * 23 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND 24 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 25 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 26 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE 27 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 28 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 29 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 30 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 31 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 32 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 33 * SUCH DAMAGE. 34 * 35 * @(#)ffs_inode.c 8.5 (Berkeley) 12/30/93 36 * $FreeBSD: stable/10/sys/fs/ext2fs/ext2_inode.c 311232 2017-01-04 02:43:33Z pfg $ 37 */ 38 39#include <sys/param.h> 40#include <sys/systm.h> 41#include <sys/mount.h> 42#include <sys/bio.h> 43#include <sys/buf.h> 44#include <sys/vnode.h> 45#include <sys/malloc.h> 46#include <sys/rwlock.h> 47 48#include <vm/vm.h> 49#include <vm/vm_extern.h> 50 51#include <fs/ext2fs/inode.h> 52#include <fs/ext2fs/ext2_mount.h> 53#include <fs/ext2fs/ext2fs.h> 54#include <fs/ext2fs/fs.h> 55#include <fs/ext2fs/ext2_extern.h> 56 57static int ext2_indirtrunc(struct inode *, daddr_t, daddr_t, 58 daddr_t, int, e4fs_daddr_t *); 59 60/* 61 * Update the access, modified, and inode change times as specified by the 62 * IN_ACCESS, IN_UPDATE, and IN_CHANGE flags respectively. Write the inode 63 * to disk if the IN_MODIFIED flag is set (it may be set initially, or by 64 * the timestamp update). The IN_LAZYMOD flag is set to force a write 65 * later if not now. If we write now, then clear both IN_MODIFIED and 66 * IN_LAZYMOD to reflect the presumably successful write, and if waitfor is 67 * set, then wait for the write to complete. 68 */ 69int 70ext2_update(struct vnode *vp, int waitfor) 71{ 72 struct m_ext2fs *fs; 73 struct buf *bp; 74 struct inode *ip; 75 int error; 76 77 ASSERT_VOP_ELOCKED(vp, "ext2_update"); 78 ext2_itimes(vp); 79 ip = VTOI(vp); 80 if ((ip->i_flag & IN_MODIFIED) == 0 && waitfor == 0) 81 return (0); 82 ip->i_flag &= ~(IN_LAZYACCESS | IN_LAZYMOD | IN_MODIFIED); 83 fs = ip->i_e2fs; 84 if (fs->e2fs_ronly) 85 return (0); 86 if ((error = bread(ip->i_devvp, 87 fsbtodb(fs, ino_to_fsba(fs, ip->i_number)), 88 (int)fs->e2fs_bsize, NOCRED, &bp)) != 0) { 89 brelse(bp); 90 return (error); 91 } 92 ext2_i2ei(ip, (struct ext2fs_dinode *)((char *)bp->b_data + 93 EXT2_INODE_SIZE(fs) * ino_to_fsbo(fs, ip->i_number))); 94 if (waitfor && !DOINGASYNC(vp)) 95 return (bwrite(bp)); 96 else { 97 bdwrite(bp); 98 return (0); 99 } 100} 101 102#define SINGLE 0 /* index of single indirect block */ 103#define DOUBLE 1 /* index of double indirect block */ 104#define TRIPLE 2 /* index of triple indirect block */ 105/* 106 * Truncate the inode oip to at most length size, freeing the 107 * disk blocks. 108 */ 109int 110ext2_truncate(struct vnode *vp, off_t length, int flags, struct ucred *cred, 111 struct thread *td) 112{ 113 struct vnode *ovp = vp; 114 int32_t lastblock; 115 struct inode *oip; 116 int32_t bn, lbn, lastiblock[NIADDR], indir_lbn[NIADDR]; 117 uint32_t oldblks[NDADDR + NIADDR], newblks[NDADDR + NIADDR]; 118 struct m_ext2fs *fs; 119 struct buf *bp; 120 int offset, size, level; 121 e4fs_daddr_t count, nblocks, blocksreleased = 0; 122 int error, i, allerror; 123 off_t osize; 124#ifdef INVARIANTS 125 struct bufobj *bo; 126#endif 127 128 oip = VTOI(ovp); 129#ifdef INVARIANTS 130 bo = &ovp->v_bufobj; 131#endif 132 133 ASSERT_VOP_LOCKED(vp, "ext2_truncate"); 134 135 if (length < 0) 136 return (EINVAL); 137 138 if (ovp->v_type == VLNK && 139 oip->i_size < ovp->v_mount->mnt_maxsymlinklen) { 140#ifdef INVARIANTS 141 if (length != 0) 142 panic("ext2_truncate: partial truncate of symlink"); 143#endif 144 bzero((char *)&oip->i_shortlink, (u_int)oip->i_size); 145 oip->i_size = 0; 146 oip->i_flag |= IN_CHANGE | IN_UPDATE; 147 return (ext2_update(ovp, 1)); 148 } 149 if (oip->i_size == length) { 150 oip->i_flag |= IN_CHANGE | IN_UPDATE; 151 return (ext2_update(ovp, 0)); 152 } 153 fs = oip->i_e2fs; 154 osize = oip->i_size; 155 /* 156 * Lengthen the size of the file. We must ensure that the 157 * last byte of the file is allocated. Since the smallest 158 * value of osize is 0, length will be at least 1. 159 */ 160 if (osize < length) { 161 if (length > oip->i_e2fs->e2fs_maxfilesize) 162 return (EFBIG); 163 vnode_pager_setsize(ovp, length); 164 offset = blkoff(fs, length - 1); 165 lbn = lblkno(fs, length - 1); 166 flags |= BA_CLRBUF; 167 error = ext2_balloc(oip, lbn, offset + 1, cred, &bp, flags); 168 if (error) { 169 vnode_pager_setsize(vp, osize); 170 return (error); 171 } 172 oip->i_size = length; 173 if (bp->b_bufsize == fs->e2fs_bsize) 174 bp->b_flags |= B_CLUSTEROK; 175 if (flags & IO_SYNC) 176 bwrite(bp); 177 else if (DOINGASYNC(ovp)) 178 bdwrite(bp); 179 else 180 bawrite(bp); 181 oip->i_flag |= IN_CHANGE | IN_UPDATE; 182 return (ext2_update(ovp, !DOINGASYNC(ovp))); 183 } 184 /* 185 * Shorten the size of the file. If the file is not being 186 * truncated to a block boundry, the contents of the 187 * partial block following the end of the file must be 188 * zero'ed in case it ever become accessible again because 189 * of subsequent file growth. 190 */ 191 /* I don't understand the comment above */ 192 offset = blkoff(fs, length); 193 if (offset == 0) { 194 oip->i_size = length; 195 } else { 196 lbn = lblkno(fs, length); 197 flags |= BA_CLRBUF; 198 error = ext2_balloc(oip, lbn, offset, cred, &bp, flags); 199 if (error) 200 return (error); 201 oip->i_size = length; 202 size = blksize(fs, oip, lbn); 203 bzero((char *)bp->b_data + offset, (u_int)(size - offset)); 204 allocbuf(bp, size); 205 if (bp->b_bufsize == fs->e2fs_bsize) 206 bp->b_flags |= B_CLUSTEROK; 207 if (flags & IO_SYNC) 208 bwrite(bp); 209 else if (DOINGASYNC(ovp)) 210 bdwrite(bp); 211 else 212 bawrite(bp); 213 } 214 /* 215 * Calculate index into inode's block list of 216 * last direct and indirect blocks (if any) 217 * which we want to keep. Lastblock is -1 when 218 * the file is truncated to 0. 219 */ 220 lastblock = lblkno(fs, length + fs->e2fs_bsize - 1) - 1; 221 lastiblock[SINGLE] = lastblock - NDADDR; 222 lastiblock[DOUBLE] = lastiblock[SINGLE] - NINDIR(fs); 223 lastiblock[TRIPLE] = lastiblock[DOUBLE] - NINDIR(fs) * NINDIR(fs); 224 nblocks = btodb(fs->e2fs_bsize); 225 /* 226 * Update file and block pointers on disk before we start freeing 227 * blocks. If we crash before free'ing blocks below, the blocks 228 * will be returned to the free list. lastiblock values are also 229 * normalized to -1 for calls to ext2_indirtrunc below. 230 */ 231 for (level = TRIPLE; level >= SINGLE; level--) { 232 oldblks[NDADDR + level] = oip->i_ib[level]; 233 if (lastiblock[level] < 0) { 234 oip->i_ib[level] = 0; 235 lastiblock[level] = -1; 236 } 237 } 238 for (i = 0; i < NDADDR; i++) { 239 oldblks[i] = oip->i_db[i]; 240 if (i > lastblock) 241 oip->i_db[i] = 0; 242 } 243 oip->i_flag |= IN_CHANGE | IN_UPDATE; 244 allerror = ext2_update(ovp, !DOINGASYNC(ovp)); 245 246 /* 247 * Having written the new inode to disk, save its new configuration 248 * and put back the old block pointers long enough to process them. 249 * Note that we save the new block configuration so we can check it 250 * when we are done. 251 */ 252 for (i = 0; i < NDADDR; i++) { 253 newblks[i] = oip->i_db[i]; 254 oip->i_db[i] = oldblks[i]; 255 } 256 for (i = 0; i < NIADDR; i++) { 257 newblks[NDADDR + i] = oip->i_ib[i]; 258 oip->i_ib[i] = oldblks[NDADDR + i]; 259 } 260 oip->i_size = osize; 261 error = vtruncbuf(ovp, cred, length, (int)fs->e2fs_bsize); 262 if (error && (allerror == 0)) 263 allerror = error; 264 vnode_pager_setsize(ovp, length); 265 266 /* 267 * Indirect blocks first. 268 */ 269 indir_lbn[SINGLE] = -NDADDR; 270 indir_lbn[DOUBLE] = indir_lbn[SINGLE] - NINDIR(fs) - 1; 271 indir_lbn[TRIPLE] = indir_lbn[DOUBLE] - NINDIR(fs) * NINDIR(fs) - 1; 272 for (level = TRIPLE; level >= SINGLE; level--) { 273 bn = oip->i_ib[level]; 274 if (bn != 0) { 275 error = ext2_indirtrunc(oip, indir_lbn[level], 276 fsbtodb(fs, bn), lastiblock[level], level, &count); 277 if (error) 278 allerror = error; 279 blocksreleased += count; 280 if (lastiblock[level] < 0) { 281 oip->i_ib[level] = 0; 282 ext2_blkfree(oip, bn, fs->e2fs_fsize); 283 blocksreleased += nblocks; 284 } 285 } 286 if (lastiblock[level] >= 0) 287 goto done; 288 } 289 290 /* 291 * All whole direct blocks or frags. 292 */ 293 for (i = NDADDR - 1; i > lastblock; i--) { 294 long bsize; 295 296 bn = oip->i_db[i]; 297 if (bn == 0) 298 continue; 299 oip->i_db[i] = 0; 300 bsize = blksize(fs, oip, i); 301 ext2_blkfree(oip, bn, bsize); 302 blocksreleased += btodb(bsize); 303 } 304 if (lastblock < 0) 305 goto done; 306 307 /* 308 * Finally, look for a change in size of the 309 * last direct block; release any frags. 310 */ 311 bn = oip->i_db[lastblock]; 312 if (bn != 0) { 313 long oldspace, newspace; 314 315 /* 316 * Calculate amount of space we're giving 317 * back as old block size minus new block size. 318 */ 319 oldspace = blksize(fs, oip, lastblock); 320 oip->i_size = length; 321 newspace = blksize(fs, oip, lastblock); 322 if (newspace == 0) 323 panic("ext2_truncate: newspace"); 324 if (oldspace - newspace > 0) { 325 /* 326 * Block number of space to be free'd is 327 * the old block # plus the number of frags 328 * required for the storage we're keeping. 329 */ 330 bn += numfrags(fs, newspace); 331 ext2_blkfree(oip, bn, oldspace - newspace); 332 blocksreleased += btodb(oldspace - newspace); 333 } 334 } 335done: 336#ifdef INVARIANTS 337 for (level = SINGLE; level <= TRIPLE; level++) 338 if (newblks[NDADDR + level] != oip->i_ib[level]) 339 panic("itrunc1"); 340 for (i = 0; i < NDADDR; i++) 341 if (newblks[i] != oip->i_db[i]) 342 panic("itrunc2"); 343 BO_LOCK(bo); 344 if (length == 0 && (bo->bo_dirty.bv_cnt != 0 || 345 bo->bo_clean.bv_cnt != 0)) 346 panic("itrunc3"); 347 BO_UNLOCK(bo); 348#endif /* INVARIANTS */ 349 /* 350 * Put back the real size. 351 */ 352 oip->i_size = length; 353 if (oip->i_blocks >= blocksreleased) 354 oip->i_blocks -= blocksreleased; 355 else /* sanity */ 356 oip->i_blocks = 0; 357 oip->i_flag |= IN_CHANGE; 358 vnode_pager_setsize(ovp, length); 359 return (allerror); 360} 361 362/* 363 * Release blocks associated with the inode ip and stored in the indirect 364 * block bn. Blocks are free'd in LIFO order up to (but not including) 365 * lastbn. If level is greater than SINGLE, the block is an indirect block 366 * and recursive calls to indirtrunc must be used to cleanse other indirect 367 * blocks. 368 * 369 * NB: triple indirect blocks are untested. 370 */ 371 372static int 373ext2_indirtrunc(struct inode *ip, daddr_t lbn, daddr_t dbn, 374 daddr_t lastbn, int level, e4fs_daddr_t *countp) 375{ 376 struct buf *bp; 377 struct m_ext2fs *fs = ip->i_e2fs; 378 struct vnode *vp; 379 e2fs_daddr_t *bap, *copy; 380 int i, nblocks, error = 0, allerror = 0; 381 e2fs_lbn_t nb, nlbn, last; 382 e4fs_daddr_t blkcount, factor, blocksreleased = 0; 383 384 /* 385 * Calculate index in current block of last 386 * block to be kept. -1 indicates the entire 387 * block so we need not calculate the index. 388 */ 389 factor = 1; 390 for (i = SINGLE; i < level; i++) 391 factor *= NINDIR(fs); 392 last = lastbn; 393 if (lastbn > 0) 394 last /= factor; 395 nblocks = btodb(fs->e2fs_bsize); 396 /* 397 * Get buffer of block pointers, zero those entries corresponding 398 * to blocks to be free'd, and update on disk copy first. Since 399 * double(triple) indirect before single(double) indirect, calls 400 * to bmap on these blocks will fail. However, we already have 401 * the on disk address, so we have to set the b_blkno field 402 * explicitly instead of letting bread do everything for us. 403 */ 404 vp = ITOV(ip); 405 bp = getblk(vp, lbn, (int)fs->e2fs_bsize, 0, 0, 0); 406 if ((bp->b_flags & (B_DONE | B_DELWRI)) == 0) { 407 bp->b_iocmd = BIO_READ; 408 if (bp->b_bcount > bp->b_bufsize) 409 panic("ext2_indirtrunc: bad buffer size"); 410 bp->b_blkno = dbn; 411 vfs_busy_pages(bp, 0); 412 bp->b_iooffset = dbtob(bp->b_blkno); 413 bstrategy(bp); 414 error = bufwait(bp); 415 } 416 if (error) { 417 brelse(bp); 418 *countp = 0; 419 return (error); 420 } 421 bap = (e2fs_daddr_t *)bp->b_data; 422 copy = malloc(fs->e2fs_bsize, M_TEMP, M_WAITOK); 423 bcopy((caddr_t)bap, (caddr_t)copy, (u_int)fs->e2fs_bsize); 424 bzero((caddr_t)&bap[last + 1], 425 (NINDIR(fs) - (last + 1)) * sizeof(e2fs_daddr_t)); 426 if (last == -1) 427 bp->b_flags |= B_INVAL; 428 if (DOINGASYNC(vp)) { 429 bdwrite(bp); 430 } else { 431 error = bwrite(bp); 432 if (error) 433 allerror = error; 434 } 435 bap = copy; 436 437 /* 438 * Recursively free totally unused blocks. 439 */ 440 for (i = NINDIR(fs) - 1, nlbn = lbn + 1 - i * factor; i > last; 441 i--, nlbn += factor) { 442 nb = bap[i]; 443 if (nb == 0) 444 continue; 445 if (level > SINGLE) { 446 if ((error = ext2_indirtrunc(ip, nlbn, 447 fsbtodb(fs, nb), (int32_t)-1, level - 1, &blkcount)) != 0) 448 allerror = error; 449 blocksreleased += blkcount; 450 } 451 ext2_blkfree(ip, nb, fs->e2fs_bsize); 452 blocksreleased += nblocks; 453 } 454 455 /* 456 * Recursively free last partial block. 457 */ 458 if (level > SINGLE && lastbn >= 0) { 459 last = lastbn % factor; 460 nb = bap[i]; 461 if (nb != 0) { 462 if ((error = ext2_indirtrunc(ip, nlbn, fsbtodb(fs, nb), 463 last, level - 1, &blkcount)) != 0) 464 allerror = error; 465 blocksreleased += blkcount; 466 } 467 } 468 free(copy, M_TEMP); 469 *countp = blocksreleased; 470 return (allerror); 471} 472 473/* 474 * discard preallocated blocks 475 */ 476int 477ext2_inactive(struct vop_inactive_args *ap) 478{ 479 struct vnode *vp = ap->a_vp; 480 struct inode *ip = VTOI(vp); 481 struct thread *td = ap->a_td; 482 int mode, error = 0; 483 484 /* 485 * Ignore inodes related to stale file handles. 486 */ 487 if (ip->i_mode == 0) 488 goto out; 489 if (ip->i_nlink <= 0) { 490 error = ext2_truncate(vp, (off_t)0, 0, NOCRED, td); 491 ip->i_rdev = 0; 492 mode = ip->i_mode; 493 ip->i_mode = 0; 494 ip->i_flag |= IN_CHANGE | IN_UPDATE; 495 ext2_vfree(vp, ip->i_number, mode); 496 } 497 if (ip->i_flag & (IN_ACCESS | IN_CHANGE | IN_MODIFIED | IN_UPDATE)) 498 ext2_update(vp, 0); 499out: 500 /* 501 * If we are done with the inode, reclaim it 502 * so that it can be reused immediately. 503 */ 504 if (ip->i_mode == 0) 505 vrecycle(vp); 506 return (error); 507} 508 509/* 510 * Reclaim an inode so that it can be used for other purposes. 511 */ 512int 513ext2_reclaim(struct vop_reclaim_args *ap) 514{ 515 struct inode *ip; 516 struct vnode *vp = ap->a_vp; 517 518 ip = VTOI(vp); 519 if (ip->i_flag & IN_LAZYMOD) { 520 ip->i_flag |= IN_MODIFIED; 521 ext2_update(vp, 0); 522 } 523 vfs_hash_remove(vp); 524 free(vp->v_data, M_EXT2NODE); 525 vp->v_data = 0; 526 vnode_destroy_vobject(vp); 527 return (0); 528} 529