fs/ufs/truncate.c

   1 /*
   2  *  linux/fs/ufs/truncate.c
   3  *
   4  * Copyright (C) 1998
   5  * Daniel Pirkl <daniel.pirkl@email.cz>
   6  * Charles University, Faculty of Mathematics and Physics
   7  *
   8  *  from
   9  *
  10  *  linux/fs/ext2/truncate.c
  11  *
  12  * Copyright (C) 1992, 1993, 1994, 1995
  13  * Remy Card (card@masi.ibp.fr)
  14  * Laboratoire MASI - Institut Blaise Pascal
  15  * Universite Pierre et Marie Curie (Paris VI)
  16  *
  17  *  from
  18  *
  19  *  linux/fs/minix/truncate.c
  20  *
  21  *  Copyright (C) 1991, 1992  Linus Torvalds
  22  *
  23  *  Big-endian to little-endian byte-swapping/bitmaps by
  24  *        David S. Miller (davem@caip.rutgers.edu), 1995
  25  */
  26
  27 /*
  28  * Real random numbers for secure rm added 94/02/18
  29  * Idea from Pierre del Perugia <delperug@gla.ecoledoc.ibp.fr>
  30  */
  31
  32 /*
  33  * Adoptation to use page cache and UFS2 write support by
  34  * Evgeniy Dushistov <dushistov@mail.ru>, 2006-2007
  35  */
  36
  37 #include <linux/errno.h>
  38 #include <linux/fs.h>
  39 #include <linux/fcntl.h>
  40 #include <linux/time.h>
  41 #include <linux/stat.h>
  42 #include <linux/string.h>
  43 #include <linux/buffer_head.h>
  44 #include <linux/blkdev.h>
  45 #include <linux/sched.h>
  46
  47 #include "ufs_fs.h"
  48 #include "ufs.h"
  49 #include "swab.h"
  50 #include "util.h"
  51
  52 /*
  53  * Secure deletion currently doesn't work. It interacts very badly
  54  * with buffers shared with memory mappings, and for that reason
  55  * can't be done in the truncate() routines. It should instead be
  56  * done separately in "release()" before calling the truncate routines
  57  * that will release the actual file blocks.
  58  *
  59  *              Linus
  60  */
  61
  62 #define DIRECT_BLOCK ((inode->i_size + uspi->s_bsize - 1) >> uspi->s_bshift)
  63 #define DIRECT_FRAGMENT ((inode->i_size + uspi->s_fsize - 1) >> uspi->s_fshift)
  64
  65
  66 static void ufs_trunc_direct(struct inode *inode)
  67 {
  68         struct ufs_inode_info *ufsi = UFS_I(inode);
  69         struct super_block * sb;
  70         struct ufs_sb_private_info * uspi;
  71         void *p;
  72         u64 frag1, frag2, frag3, frag4, block1, block2;
  73         unsigned frag_to_free, free_count;
  74         unsigned i, tmp;
  75
  76         UFSD("ENTER: ino %lu\n", inode->i_ino);
  77
  78         sb = inode->i_sb;
  79         uspi = UFS_SB(sb)->s_uspi;
  80
  81         frag_to_free = 0;
  82         free_count = 0;
  83
  84         frag1 = DIRECT_FRAGMENT;
  85         frag4 = min_t(u64, UFS_NDIR_FRAGMENT, ufsi->i_lastfrag);
  86         frag2 = ((frag1 & uspi->s_fpbmask) ? ((frag1 | uspi->s_fpbmask) + 1) : frag1);
  87         frag3 = frag4 & ~uspi->s_fpbmask;
  88         block1 = block2 = 0;
  89         if (frag2 > frag3) {
  90                 frag2 = frag4;
  91                 frag3 = frag4 = 0;
  92         } else if (frag2 < frag3) {
  93                 block1 = ufs_fragstoblks (frag2);
  94                 block2 = ufs_fragstoblks (frag3);
  95         }
  96
  97         UFSD("ino %lu, frag1 %llu, frag2 %llu, block1 %llu, block2 %llu,"
  98              " frag3 %llu, frag4 %llu\n", inode->i_ino,
  99              (unsigned long long)frag1, (unsigned long long)frag2,
 100              (unsigned long long)block1, (unsigned long long)block2,
 101              (unsigned long long)frag3, (unsigned long long)frag4);
 102
 103         if (frag1 >= frag2)
 104                 goto next1;
 105
 106         /*
 107          * Free first free fragments
 108          */
 109         p = ufs_get_direct_data_ptr(uspi, ufsi, ufs_fragstoblks(frag1));
 110         tmp = ufs_data_ptr_to_cpu(sb, p);
 111         if (!tmp )
 112                 ufs_panic (sb, "ufs_trunc_direct", "internal error");
 113         frag2 -= frag1;
 114         frag1 = ufs_fragnum (frag1);
 115
 116         ufs_free_fragments(inode, tmp + frag1, frag2);
 117         mark_inode_dirty(inode);
 118         frag_to_free = tmp + frag1;
 119
 120 next1:
 121         /*
 122          * Free whole blocks
 123          */
 124         for (i = block1 ; i < block2; i++) {
 125                 p = ufs_get_direct_data_ptr(uspi, ufsi, i);
 126                 tmp = ufs_data_ptr_to_cpu(sb, p);
 127                 if (!tmp)
 128                         continue;
 129                 write_seqlock(&ufsi->meta_lock);
 130                 ufs_data_ptr_clear(uspi, p);
 131                 write_sequnlock(&ufsi->meta_lock);
 132
 133                 if (free_count == 0) {
 134                         frag_to_free = tmp;
 135                         free_count = uspi->s_fpb;
 136                 } else if (free_count > 0 && frag_to_free == tmp - free_count)
 137                         free_count += uspi->s_fpb;
 138                 else {
 139                         ufs_free_blocks (inode, frag_to_free, free_count);
 140                         frag_to_free = tmp;
 141                         free_count = uspi->s_fpb;
 142                 }
 143                 mark_inode_dirty(inode);
 144         }
 145
 146         if (free_count > 0)
 147                 ufs_free_blocks (inode, frag_to_free, free_count);
 148
 149         if (frag3 >= frag4)
 150                 goto next3;
 151
 152         /*
 153          * Free last free fragments
 154          */
 155         p = ufs_get_direct_data_ptr(uspi, ufsi, ufs_fragstoblks(frag3));
 156         tmp = ufs_data_ptr_to_cpu(sb, p);
 157         if (!tmp )
 158                 ufs_panic(sb, "ufs_truncate_direct", "internal error");
 159         frag4 = ufs_fragnum (frag4);
 160         write_seqlock(&ufsi->meta_lock);
 161         ufs_data_ptr_clear(uspi, p);
 162         write_sequnlock(&ufsi->meta_lock);
 163
 164         ufs_free_fragments (inode, tmp, frag4);
 165         mark_inode_dirty(inode);
 166  next3:
 167
 168         UFSD("EXIT: ino %lu\n", inode->i_ino);
 169 }
 170
 171
 172 static int ufs_trunc_indirect(struct inode *inode, u64 offset, void *p)
 173 {
 174         struct super_block * sb;
 175         struct ufs_sb_private_info * uspi;
 176         struct ufs_buffer_head * ind_ubh;
 177         void *ind;
 178         u64 tmp, indirect_block, i, frag_to_free;
 179         unsigned free_count;
 180         int retry;
 181
 182         UFSD("ENTER: ino %lu, offset %llu, p: %p\n",
 183              inode->i_ino, (unsigned long long)offset, p);
 184
 185         BUG_ON(!p);
 186
 187         sb = inode->i_sb;
 188         uspi = UFS_SB(sb)->s_uspi;
 189
 190         frag_to_free = 0;
 191         free_count = 0;
 192         retry = 0;
 193
 194         tmp = ufs_data_ptr_to_cpu(sb, p);
 195         if (!tmp)
 196                 return 0;
 197         ind_ubh = ubh_bread(sb, tmp, uspi->s_bsize);
 198         if (!ind_ubh) {
 199                 write_seqlock(&UFS_I(inode)->meta_lock);
 200                 ufs_data_ptr_clear(uspi, p);
 201                 write_sequnlock(&UFS_I(inode)->meta_lock);
 202                 return 0;
 203         }
 204
 205         indirect_block = (DIRECT_BLOCK > offset) ? (DIRECT_BLOCK - offset) : 0;
 206         for (i = indirect_block; i < uspi->s_apb; i++) {
 207                 ind = ubh_get_data_ptr(uspi, ind_ubh, i);
 208                 tmp = ufs_data_ptr_to_cpu(sb, ind);
 209                 if (!tmp)
 210                         continue;
 211
 212                 write_seqlock(&UFS_I(inode)->meta_lock);
 213                 ufs_data_ptr_clear(uspi, ind);
 214                 write_sequnlock(&UFS_I(inode)->meta_lock);
 215                 ubh_mark_buffer_dirty(ind_ubh);
 216                 if (free_count == 0) {
 217                         frag_to_free = tmp;
 218                         free_count = uspi->s_fpb;
 219                 } else if (free_count > 0 && frag_to_free == tmp - free_count)
 220                         free_count += uspi->s_fpb;
 221                 else {
 222                         ufs_free_blocks (inode, frag_to_free, free_count);
 223                         frag_to_free = tmp;
 224                         free_count = uspi->s_fpb;
 225                 }
 226
 227                 mark_inode_dirty(inode);
 228         }
 229
 230         if (free_count > 0) {
 231                 ufs_free_blocks (inode, frag_to_free, free_count);
 232         }
 233         for (i = 0; i < uspi->s_apb; i++)
 234                 if (!ufs_is_data_ptr_zero(uspi,
 235                                           ubh_get_data_ptr(uspi, ind_ubh, i)))
 236                         break;
 237         if (i >= uspi->s_apb) {
 238                 tmp = ufs_data_ptr_to_cpu(sb, p);
 239                 write_seqlock(&UFS_I(inode)->meta_lock);
 240                 ufs_data_ptr_clear(uspi, p);
 241                 write_sequnlock(&UFS_I(inode)->meta_lock);
 242
 243                 ubh_bforget(ind_ubh);
 244                 ufs_free_blocks (inode, tmp, uspi->s_fpb);
 245                 mark_inode_dirty(inode);
 246                 ind_ubh = NULL;
 247         }
 248         if (IS_SYNC(inode) && ind_ubh && ubh_buffer_dirty(ind_ubh))
 249                 ubh_sync_block(ind_ubh);
 250         ubh_brelse (ind_ubh);
 251
 252         UFSD("EXIT: ino %lu\n", inode->i_ino);
 253
 254         return retry;
 255 }
 256
 257 static int ufs_trunc_dindirect(struct inode *inode, u64 offset, void *p)
 258 {
 259         struct super_block * sb;
 260         struct ufs_sb_private_info * uspi;
 261         struct ufs_buffer_head *dind_bh;
 262         u64 i, tmp, dindirect_block;
 263         void *dind;
 264         int retry = 0;
 265
 266         UFSD("ENTER: ino %lu\n", inode->i_ino);
 267
 268         sb = inode->i_sb;
 269         uspi = UFS_SB(sb)->s_uspi;
 270
 271         dindirect_block = (DIRECT_BLOCK > offset)
 272                 ? ((DIRECT_BLOCK - offset) >> uspi->s_apbshift) : 0;
 273         retry = 0;
 274
 275         tmp = ufs_data_ptr_to_cpu(sb, p);
 276         if (!tmp)
 277                 return 0;
 278         dind_bh = ubh_bread(sb, tmp, uspi->s_bsize);
 279         if (!dind_bh) {
 280                 write_seqlock(&UFS_I(inode)->meta_lock);
 281                 ufs_data_ptr_clear(uspi, p);
 282                 write_sequnlock(&UFS_I(inode)->meta_lock);
 283                 return 0;
 284         }
 285
 286         for (i = dindirect_block ; i < uspi->s_apb ; i++) {
 287                 dind = ubh_get_data_ptr(uspi, dind_bh, i);
 288                 tmp = ufs_data_ptr_to_cpu(sb, dind);
 289                 if (!tmp)
 290                         continue;
 291                 retry |= ufs_trunc_indirect (inode, offset + (i << uspi->s_apbshift), dind);
 292                 ubh_mark_buffer_dirty(dind_bh);
 293         }
 294
 295         for (i = 0; i < uspi->s_apb; i++)
 296                 if (!ufs_is_data_ptr_zero(uspi,
 297                                           ubh_get_data_ptr(uspi, dind_bh, i)))
 298                         break;
 299         if (i >= uspi->s_apb) {
 300                 tmp = ufs_data_ptr_to_cpu(sb, p);
 301                 write_seqlock(&UFS_I(inode)->meta_lock);
 302                 ufs_data_ptr_clear(uspi, p);
 303                 write_sequnlock(&UFS_I(inode)->meta_lock);
 304
 305                 ubh_bforget(dind_bh);
 306                 ufs_free_blocks(inode, tmp, uspi->s_fpb);
 307                 mark_inode_dirty(inode);
 308                 dind_bh = NULL;
 309         }
 310         if (IS_SYNC(inode) && dind_bh && ubh_buffer_dirty(dind_bh))
 311                 ubh_sync_block(dind_bh);
 312         ubh_brelse (dind_bh);
 313
 314         UFSD("EXIT: ino %lu\n", inode->i_ino);
 315
 316         return retry;
 317 }
 318
 319 static int ufs_trunc_tindirect(struct inode *inode)
 320 {
 321         struct super_block *sb = inode->i_sb;
 322         struct ufs_sb_private_info *uspi = UFS_SB(sb)->s_uspi;
 323         struct ufs_inode_info *ufsi = UFS_I(inode);
 324         struct ufs_buffer_head * tind_bh;
 325         u64 tindirect_block, tmp, i;
 326         void *tind, *p;
 327         int retry;
 328
 329         UFSD("ENTER: ino %lu\n", inode->i_ino);
 330
 331         retry = 0;
 332
 333         tindirect_block = (DIRECT_BLOCK > (UFS_NDADDR + uspi->s_apb + uspi->s_2apb))
 334                 ? ((DIRECT_BLOCK - UFS_NDADDR - uspi->s_apb - uspi->s_2apb) >> uspi->s_2apbshift) : 0;
 335
 336         p = ufs_get_direct_data_ptr(uspi, ufsi, UFS_TIND_BLOCK);
 337         if (!(tmp = ufs_data_ptr_to_cpu(sb, p)))
 338                 return 0;
 339         tind_bh = ubh_bread (sb, tmp, uspi->s_bsize);
 340         if (!tind_bh) {
 341                 write_seqlock(&ufsi->meta_lock);
 342                 ufs_data_ptr_clear(uspi, p);
 343                 write_sequnlock(&ufsi->meta_lock);
 344                 return 0;
 345         }
 346
 347         for (i = tindirect_block ; i < uspi->s_apb ; i++) {
 348                 tind = ubh_get_data_ptr(uspi, tind_bh, i);
 349                 retry |= ufs_trunc_dindirect(inode, UFS_NDADDR +
 350                         uspi->s_apb + ((i + 1) << uspi->s_2apbshift), tind);
 351                 ubh_mark_buffer_dirty(tind_bh);
 352         }
 353         for (i = 0; i < uspi->s_apb; i++)
 354                 if (!ufs_is_data_ptr_zero(uspi,
 355                                           ubh_get_data_ptr(uspi, tind_bh, i)))
 356                         break;
 357         if (i >= uspi->s_apb) {
 358                 tmp = ufs_data_ptr_to_cpu(sb, p);
 359                 write_seqlock(&ufsi->meta_lock);
 360                 ufs_data_ptr_clear(uspi, p);
 361                 write_sequnlock(&ufsi->meta_lock);
 362
 363                 ubh_bforget(tind_bh);
 364                 ufs_free_blocks(inode, tmp, uspi->s_fpb);
 365                 mark_inode_dirty(inode);
 366                 tind_bh = NULL;
 367         }
 368         if (IS_SYNC(inode) && tind_bh && ubh_buffer_dirty(tind_bh))
 369                 ubh_sync_block(tind_bh);
 370         ubh_brelse (tind_bh);
 371
 372         UFSD("EXIT: ino %lu\n", inode->i_ino);
 373         return retry;
 374 }
 375
 376 static int ufs_alloc_lastblock(struct inode *inode, loff_t size)
 377 {
 378         int err = 0;
 379         struct super_block *sb = inode->i_sb;
 380         struct address_space *mapping = inode->i_mapping;
 381         struct ufs_sb_private_info *uspi = UFS_SB(sb)->s_uspi;
 382         unsigned i, end;
 383         sector_t lastfrag;
 384         struct page *lastpage;
 385         struct buffer_head *bh;
 386         u64 phys64;
 387
 388         lastfrag = (size + uspi->s_fsize - 1) >> uspi->s_fshift;
 389
 390         if (!lastfrag)
 391                 goto out;
 392
 393         lastfrag--;
 394
 395         lastpage = ufs_get_locked_page(mapping, lastfrag >>
 396                                        (PAGE_CACHE_SHIFT - inode->i_blkbits));
 397        if (IS_ERR(lastpage)) {
 398                err = -EIO;
 399                goto out;
 400        }
 401
 402        end = lastfrag & ((1 << (PAGE_CACHE_SHIFT - inode->i_blkbits)) - 1);
 403        bh = page_buffers(lastpage);
 404        for (i = 0; i < end; ++i)
 405                bh = bh->b_this_page;
 406
 407
 408        err = ufs_getfrag_block(inode, lastfrag, bh, 1);
 409
 410        if (unlikely(err))
 411                goto out_unlock;
 412
 413        if (buffer_new(bh)) {
 414                clear_buffer_new(bh);
 415                unmap_underlying_metadata(bh->b_bdev,
 416                                          bh->b_blocknr);
 417                /*
 418                 * we do not zeroize fragment, because of
 419                 * if it maped to hole, it already contains zeroes
 420                 */
 421                set_buffer_uptodate(bh);
 422                mark_buffer_dirty(bh);
 423                set_page_dirty(lastpage);
 424        }
 425
 426        if (lastfrag >= UFS_IND_FRAGMENT) {
 427                end = uspi->s_fpb - ufs_fragnum(lastfrag) - 1;
 428                phys64 = bh->b_blocknr + 1;
 429                for (i = 0; i < end; ++i) {
 430                        bh = sb_getblk(sb, i + phys64);
 431                        lock_buffer(bh);
 432                        memset(bh->b_data, 0, sb->s_blocksize);
 433                        set_buffer_uptodate(bh);
 434                        mark_buffer_dirty(bh);
 435                        unlock_buffer(bh);
 436                        sync_dirty_buffer(bh);
 437                        brelse(bh);
 438                }
 439        }
 440 out_unlock:
 441        ufs_put_locked_page(lastpage);
 442 out:
 443        return err;
 444 }
 445
 446 static void __ufs_truncate_blocks(struct inode *inode)
 447 {
 448         struct ufs_inode_info *ufsi = UFS_I(inode);
 449         struct super_block *sb = inode->i_sb;
 450         struct ufs_sb_private_info *uspi = UFS_SB(sb)->s_uspi;
 451         int retry;
 452
 453         mutex_lock(&ufsi->truncate_mutex);
 454         while (1) {
 455                 ufs_trunc_direct(inode);
 456                 retry = ufs_trunc_indirect(inode, UFS_IND_BLOCK,
 457                                             ufs_get_direct_data_ptr(uspi, ufsi,
 458                                                                     UFS_IND_BLOCK));
 459                 retry |= ufs_trunc_dindirect(inode, UFS_IND_BLOCK + uspi->s_apb,
 460                                              ufs_get_direct_data_ptr(uspi, ufsi,
 461                                                                      UFS_DIND_BLOCK));
 462                 retry |= ufs_trunc_tindirect (inode);
 463                 if (!retry)
 464                         break;
 465                 if (IS_SYNC(inode) && (inode->i_state & I_DIRTY))
 466                         ufs_sync_inode (inode);
 467                 yield();
 468         }
 469
 470         ufsi->i_lastfrag = DIRECT_FRAGMENT;
 471         mutex_unlock(&ufsi->truncate_mutex);
 472 }
 473
 474 int ufs_truncate(struct inode *inode, loff_t size)
 475 {
 476         int err = 0;
 477
 478         UFSD("ENTER: ino %lu, i_size: %llu, old_i_size: %llu\n",
 479              inode->i_ino, (unsigned long long)size,
 480              (unsigned long long)i_size_read(inode));
 481
 482         if (!(S_ISREG(inode->i_mode) || S_ISDIR(inode->i_mode) ||
 483               S_ISLNK(inode->i_mode)))
 484                 return -EINVAL;
 485         if (IS_APPEND(inode) || IS_IMMUTABLE(inode))
 486                 return -EPERM;
 487
 488         err = ufs_alloc_lastblock(inode, size);
 489
 490         if (err)
 491                 goto out;
 492
 493         block_truncate_page(inode->i_mapping, size, ufs_getfrag_block);
 494
 495         truncate_setsize(inode, size);
 496
 497         __ufs_truncate_blocks(inode);
 498         inode->i_mtime = inode->i_ctime = CURRENT_TIME_SEC;
 499         mark_inode_dirty(inode);
 500 out:
 501         UFSD("EXIT: err %d\n", err);
 502         return err;
 503 }
 504
 505 void ufs_truncate_blocks(struct inode *inode)
 506 {
 507         if (!(S_ISREG(inode->i_mode) || S_ISDIR(inode->i_mode) ||
 508               S_ISLNK(inode->i_mode)))
 509                 return;
 510         if (IS_APPEND(inode) || IS_IMMUTABLE(inode))
 511                 return;
 512         __ufs_truncate_blocks(inode);
 513 }
 514
 515 int ufs_setattr(struct dentry *dentry, struct iattr *attr)
 516 {
 517         struct inode *inode = d_inode(dentry);
 518         unsigned int ia_valid = attr->ia_valid;
 519         int error;
 520
 521         error = inode_change_ok(inode, attr);
 522         if (error)
 523                 return error;
 524
 525         if (ia_valid & ATTR_SIZE && attr->ia_size != inode->i_size) {
 526                 error = ufs_truncate(inode, attr->ia_size);
 527                 if (error)
 528                         return error;
 529         }
 530
 531         setattr_copy(inode, attr);
 532         mark_inode_dirty(inode);
 533         return 0;
 534 }
 535
 536 const struct inode_operations ufs_file_inode_operations = {
 537         .setattr = ufs_setattr,
 538 };