1 /* 2 * inode.c - NILFS inode operations. 3 * 4 * Copyright (C) 2005-2008 Nippon Telegraph and Telephone Corporation. 5 * 6 * This program is free software; you can redistribute it and/or modify 7 * it under the terms of the GNU General Public License as published by 8 * the Free Software Foundation; either version 2 of the License, or 9 * (at your option) any later version. 10 * 11 * This program is distributed in the hope that it will be useful, 12 * but WITHOUT ANY WARRANTY; without even the implied warranty of 13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 14 * GNU General Public License for more details. 15 * 16 * You should have received a copy of the GNU General Public License 17 * along with this program; if not, write to the Free Software 18 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA 19 * 20 * Written by Ryusuke Konishi <ryusuke@osrg.net> 21 * 22 */ 23 24 #include <linux/buffer_head.h> 25 #include <linux/gfp.h> 26 #include <linux/mpage.h> 27 #include <linux/writeback.h> 28 #include <linux/uio.h> 29 #include "nilfs.h" 30 #include "btnode.h" 31 #include "segment.h" 32 #include "page.h" 33 #include "mdt.h" 34 #include "cpfile.h" 35 #include "ifile.h" 36 37 struct nilfs_iget_args { 38 u64 ino; 39 __u64 cno; 40 struct nilfs_root *root; 41 int for_gc; 42 }; 43 44 /** 45 * nilfs_get_block() - get a file block on the filesystem (callback function) 46 * @inode - inode struct of the target file 47 * @blkoff - file block number 48 * @bh_result - buffer head to be mapped on 49 * @create - indicate whether allocating the block or not when it has not 50 * been allocated yet. 51 * 52 * This function does not issue actual read request of the specified data 53 * block. It is done by VFS. 54 */ 55 int nilfs_get_block(struct inode *inode, sector_t blkoff, 56 struct buffer_head *bh_result, int create) 57 { 58 struct nilfs_inode_info *ii = NILFS_I(inode); 59 __u64 blknum = 0; 60 int err = 0, ret; 61 struct inode *dat = nilfs_dat_inode(NILFS_I_NILFS(inode)); 62 unsigned maxblocks = bh_result->b_size >> inode->i_blkbits; 63 64 down_read(&NILFS_MDT(dat)->mi_sem); 65 ret = nilfs_bmap_lookup_contig(ii->i_bmap, blkoff, &blknum, maxblocks); 66 up_read(&NILFS_MDT(dat)->mi_sem); 67 if (ret >= 0) { /* found */ 68 map_bh(bh_result, inode->i_sb, blknum); 69 if (ret > 0) 70 bh_result->b_size = (ret << inode->i_blkbits); 71 goto out; 72 } 73 /* data block was not found */ 74 if (ret == -ENOENT && create) { 75 struct nilfs_transaction_info ti; 76 77 bh_result->b_blocknr = 0; 78 err = nilfs_transaction_begin(inode->i_sb, &ti, 1); 79 if (unlikely(err)) 80 goto out; 81 err = nilfs_bmap_insert(ii->i_bmap, (unsigned long)blkoff, 82 (unsigned long)bh_result); 83 if (unlikely(err != 0)) { 84 if (err == -EEXIST) { 85 /* 86 * The get_block() function could be called 87 * from multiple callers for an inode. 88 * However, the page having this block must 89 * be locked in this case. 90 */ 91 printk(KERN_WARNING 92 "nilfs_get_block: a race condition " 93 "while inserting a data block. " 94 "(inode number=%lu, file block " 95 "offset=%llu)\n", 96 inode->i_ino, 97 (unsigned long long)blkoff); 98 err = 0; 99 } else if (err == -EINVAL) { 100 nilfs_error(inode->i_sb, __func__, 101 "broken bmap (inode=%lu)\n", 102 inode->i_ino); 103 err = -EIO; 104 } 105 nilfs_transaction_abort(inode->i_sb); 106 goto out; 107 } 108 nilfs_mark_inode_dirty(inode); 109 nilfs_transaction_commit(inode->i_sb); /* never fails */ 110 /* Error handling should be detailed */ 111 set_buffer_new(bh_result); 112 map_bh(bh_result, inode->i_sb, 0); /* dbn must be changed 113 to proper value */ 114 } else if (ret == -ENOENT) { 115 /* not found is not error (e.g. hole); must return without 116 the mapped state flag. */ 117 ; 118 } else { 119 err = ret; 120 } 121 122 out: 123 return err; 124 } 125 126 /** 127 * nilfs_readpage() - implement readpage() method of nilfs_aops {} 128 * address_space_operations. 129 * @file - file struct of the file to be read 130 * @page - the page to be read 131 */ 132 static int nilfs_readpage(struct file *file, struct page *page) 133 { 134 return mpage_readpage(page, nilfs_get_block); 135 } 136 137 /** 138 * nilfs_readpages() - implement readpages() method of nilfs_aops {} 139 * address_space_operations. 140 * @file - file struct of the file to be read 141 * @mapping - address_space struct used for reading multiple pages 142 * @pages - the pages to be read 143 * @nr_pages - number of pages to be read 144 */ 145 static int nilfs_readpages(struct file *file, struct address_space *mapping, 146 struct list_head *pages, unsigned nr_pages) 147 { 148 return mpage_readpages(mapping, pages, nr_pages, nilfs_get_block); 149 } 150 151 static int nilfs_writepages(struct address_space *mapping, 152 struct writeback_control *wbc) 153 { 154 struct inode *inode = mapping->host; 155 int err = 0; 156 157 if (wbc->sync_mode == WB_SYNC_ALL) 158 err = nilfs_construct_dsync_segment(inode->i_sb, inode, 159 wbc->range_start, 160 wbc->range_end); 161 return err; 162 } 163 164 static int nilfs_writepage(struct page *page, struct writeback_control *wbc) 165 { 166 struct inode *inode = page->mapping->host; 167 int err; 168 169 redirty_page_for_writepage(wbc, page); 170 unlock_page(page); 171 172 if (wbc->sync_mode == WB_SYNC_ALL) { 173 err = nilfs_construct_segment(inode->i_sb); 174 if (unlikely(err)) 175 return err; 176 } else if (wbc->for_reclaim) 177 nilfs_flush_segment(inode->i_sb, inode->i_ino); 178 179 return 0; 180 } 181 182 static int nilfs_set_page_dirty(struct page *page) 183 { 184 int ret = __set_page_dirty_buffers(page); 185 186 if (ret) { 187 struct inode *inode = page->mapping->host; 188 struct nilfs_sb_info *sbi = NILFS_SB(inode->i_sb); 189 unsigned nr_dirty = 1 << (PAGE_SHIFT - inode->i_blkbits); 190 191 nilfs_set_file_dirty(sbi, inode, nr_dirty); 192 } 193 return ret; 194 } 195 196 static int nilfs_write_begin(struct file *file, struct address_space *mapping, 197 loff_t pos, unsigned len, unsigned flags, 198 struct page **pagep, void **fsdata) 199 200 { 201 struct inode *inode = mapping->host; 202 int err = nilfs_transaction_begin(inode->i_sb, NULL, 1); 203 204 if (unlikely(err)) 205 return err; 206 207 err = block_write_begin(mapping, pos, len, flags, pagep, 208 nilfs_get_block); 209 if (unlikely(err)) { 210 loff_t isize = mapping->host->i_size; 211 if (pos + len > isize) 212 vmtruncate(mapping->host, isize); 213 214 nilfs_transaction_abort(inode->i_sb); 215 } 216 return err; 217 } 218 219 static int nilfs_write_end(struct file *file, struct address_space *mapping, 220 loff_t pos, unsigned len, unsigned copied, 221 struct page *page, void *fsdata) 222 { 223 struct inode *inode = mapping->host; 224 unsigned start = pos & (PAGE_CACHE_SIZE - 1); 225 unsigned nr_dirty; 226 int err; 227 228 nr_dirty = nilfs_page_count_clean_buffers(page, start, 229 start + copied); 230 copied = generic_write_end(file, mapping, pos, len, copied, page, 231 fsdata); 232 nilfs_set_file_dirty(NILFS_SB(inode->i_sb), inode, nr_dirty); 233 err = nilfs_transaction_commit(inode->i_sb); 234 return err ? : copied; 235 } 236 237 static ssize_t 238 nilfs_direct_IO(int rw, struct kiocb *iocb, const struct iovec *iov, 239 loff_t offset, unsigned long nr_segs) 240 { 241 struct file *file = iocb->ki_filp; 242 struct inode *inode = file->f_mapping->host; 243 ssize_t size; 244 245 if (rw == WRITE) 246 return 0; 247 248 /* Needs synchronization with the cleaner */ 249 size = blockdev_direct_IO(rw, iocb, inode, inode->i_sb->s_bdev, iov, 250 offset, nr_segs, nilfs_get_block, NULL); 251 252 /* 253 * In case of error extending write may have instantiated a few 254 * blocks outside i_size. Trim these off again. 255 */ 256 if (unlikely((rw & WRITE) && size < 0)) { 257 loff_t isize = i_size_read(inode); 258 loff_t end = offset + iov_length(iov, nr_segs); 259 260 if (end > isize) 261 vmtruncate(inode, isize); 262 } 263 264 return size; 265 } 266 267 const struct address_space_operations nilfs_aops = { 268 .writepage = nilfs_writepage, 269 .readpage = nilfs_readpage, 270 .sync_page = block_sync_page, 271 .writepages = nilfs_writepages, 272 .set_page_dirty = nilfs_set_page_dirty, 273 .readpages = nilfs_readpages, 274 .write_begin = nilfs_write_begin, 275 .write_end = nilfs_write_end, 276 /* .releasepage = nilfs_releasepage, */ 277 .invalidatepage = block_invalidatepage, 278 .direct_IO = nilfs_direct_IO, 279 .is_partially_uptodate = block_is_partially_uptodate, 280 }; 281 282 struct inode *nilfs_new_inode(struct inode *dir, int mode) 283 { 284 struct super_block *sb = dir->i_sb; 285 struct nilfs_sb_info *sbi = NILFS_SB(sb); 286 struct inode *inode; 287 struct nilfs_inode_info *ii; 288 struct nilfs_root *root; 289 int err = -ENOMEM; 290 ino_t ino; 291 292 inode = new_inode(sb); 293 if (unlikely(!inode)) 294 goto failed; 295 296 mapping_set_gfp_mask(inode->i_mapping, 297 mapping_gfp_mask(inode->i_mapping) & ~__GFP_FS); 298 299 root = NILFS_I(dir)->i_root; 300 ii = NILFS_I(inode); 301 ii->i_state = 1 << NILFS_I_NEW; 302 ii->i_root = root; 303 304 err = nilfs_ifile_create_inode(root->ifile, &ino, &ii->i_bh); 305 if (unlikely(err)) 306 goto failed_ifile_create_inode; 307 /* reference count of i_bh inherits from nilfs_mdt_read_block() */ 308 309 atomic_inc(&sbi->s_inodes_count); 310 inode_init_owner(inode, dir, mode); 311 inode->i_ino = ino; 312 inode->i_mtime = inode->i_atime = inode->i_ctime = CURRENT_TIME; 313 314 if (S_ISREG(mode) || S_ISDIR(mode) || S_ISLNK(mode)) { 315 err = nilfs_bmap_read(ii->i_bmap, NULL); 316 if (err < 0) 317 goto failed_bmap; 318 319 set_bit(NILFS_I_BMAP, &ii->i_state); 320 /* No lock is needed; iget() ensures it. */ 321 } 322 323 ii->i_flags = NILFS_I(dir)->i_flags; 324 if (S_ISLNK(mode)) 325 ii->i_flags &= ~(NILFS_IMMUTABLE_FL | NILFS_APPEND_FL); 326 if (!S_ISDIR(mode)) 327 ii->i_flags &= ~NILFS_DIRSYNC_FL; 328 329 /* ii->i_file_acl = 0; */ 330 /* ii->i_dir_acl = 0; */ 331 ii->i_dir_start_lookup = 0; 332 nilfs_set_inode_flags(inode); 333 spin_lock(&sbi->s_next_gen_lock); 334 inode->i_generation = sbi->s_next_generation++; 335 spin_unlock(&sbi->s_next_gen_lock); 336 insert_inode_hash(inode); 337 338 err = nilfs_init_acl(inode, dir); 339 if (unlikely(err)) 340 goto failed_acl; /* never occur. When supporting 341 nilfs_init_acl(), proper cancellation of 342 above jobs should be considered */ 343 344 return inode; 345 346 failed_acl: 347 failed_bmap: 348 inode->i_nlink = 0; 349 iput(inode); /* raw_inode will be deleted through 350 generic_delete_inode() */ 351 goto failed; 352 353 failed_ifile_create_inode: 354 make_bad_inode(inode); 355 iput(inode); /* if i_nlink == 1, generic_forget_inode() will be 356 called */ 357 failed: 358 return ERR_PTR(err); 359 } 360 361 void nilfs_set_inode_flags(struct inode *inode) 362 { 363 unsigned int flags = NILFS_I(inode)->i_flags; 364 365 inode->i_flags &= ~(S_SYNC | S_APPEND | S_IMMUTABLE | S_NOATIME | 366 S_DIRSYNC); 367 if (flags & NILFS_SYNC_FL) 368 inode->i_flags |= S_SYNC; 369 if (flags & NILFS_APPEND_FL) 370 inode->i_flags |= S_APPEND; 371 if (flags & NILFS_IMMUTABLE_FL) 372 inode->i_flags |= S_IMMUTABLE; 373 #ifndef NILFS_ATIME_DISABLE 374 if (flags & NILFS_NOATIME_FL) 375 #endif 376 inode->i_flags |= S_NOATIME; 377 if (flags & NILFS_DIRSYNC_FL) 378 inode->i_flags |= S_DIRSYNC; 379 mapping_set_gfp_mask(inode->i_mapping, 380 mapping_gfp_mask(inode->i_mapping) & ~__GFP_FS); 381 } 382 383 int nilfs_read_inode_common(struct inode *inode, 384 struct nilfs_inode *raw_inode) 385 { 386 struct nilfs_inode_info *ii = NILFS_I(inode); 387 int err; 388 389 inode->i_mode = le16_to_cpu(raw_inode->i_mode); 390 inode->i_uid = (uid_t)le32_to_cpu(raw_inode->i_uid); 391 inode->i_gid = (gid_t)le32_to_cpu(raw_inode->i_gid); 392 inode->i_nlink = le16_to_cpu(raw_inode->i_links_count); 393 inode->i_size = le64_to_cpu(raw_inode->i_size); 394 inode->i_atime.tv_sec = le64_to_cpu(raw_inode->i_mtime); 395 inode->i_ctime.tv_sec = le64_to_cpu(raw_inode->i_ctime); 396 inode->i_mtime.tv_sec = le64_to_cpu(raw_inode->i_mtime); 397 inode->i_atime.tv_nsec = le32_to_cpu(raw_inode->i_mtime_nsec); 398 inode->i_ctime.tv_nsec = le32_to_cpu(raw_inode->i_ctime_nsec); 399 inode->i_mtime.tv_nsec = le32_to_cpu(raw_inode->i_mtime_nsec); 400 if (inode->i_nlink == 0 && inode->i_mode == 0) 401 return -EINVAL; /* this inode is deleted */ 402 403 inode->i_blocks = le64_to_cpu(raw_inode->i_blocks); 404 ii->i_flags = le32_to_cpu(raw_inode->i_flags); 405 #if 0 406 ii->i_file_acl = le32_to_cpu(raw_inode->i_file_acl); 407 ii->i_dir_acl = S_ISREG(inode->i_mode) ? 408 0 : le32_to_cpu(raw_inode->i_dir_acl); 409 #endif 410 ii->i_dir_start_lookup = 0; 411 inode->i_generation = le32_to_cpu(raw_inode->i_generation); 412 413 if (S_ISREG(inode->i_mode) || S_ISDIR(inode->i_mode) || 414 S_ISLNK(inode->i_mode)) { 415 err = nilfs_bmap_read(ii->i_bmap, raw_inode); 416 if (err < 0) 417 return err; 418 set_bit(NILFS_I_BMAP, &ii->i_state); 419 /* No lock is needed; iget() ensures it. */ 420 } 421 return 0; 422 } 423 424 static int __nilfs_read_inode(struct super_block *sb, 425 struct nilfs_root *root, unsigned long ino, 426 struct inode *inode) 427 { 428 struct nilfs_sb_info *sbi = NILFS_SB(sb); 429 struct inode *dat = nilfs_dat_inode(sbi->s_nilfs); 430 struct buffer_head *bh; 431 struct nilfs_inode *raw_inode; 432 int err; 433 434 down_read(&NILFS_MDT(dat)->mi_sem); /* XXX */ 435 err = nilfs_ifile_get_inode_block(root->ifile, ino, &bh); 436 if (unlikely(err)) 437 goto bad_inode; 438 439 raw_inode = nilfs_ifile_map_inode(root->ifile, ino, bh); 440 441 err = nilfs_read_inode_common(inode, raw_inode); 442 if (err) 443 goto failed_unmap; 444 445 if (S_ISREG(inode->i_mode)) { 446 inode->i_op = &nilfs_file_inode_operations; 447 inode->i_fop = &nilfs_file_operations; 448 inode->i_mapping->a_ops = &nilfs_aops; 449 } else if (S_ISDIR(inode->i_mode)) { 450 inode->i_op = &nilfs_dir_inode_operations; 451 inode->i_fop = &nilfs_dir_operations; 452 inode->i_mapping->a_ops = &nilfs_aops; 453 } else if (S_ISLNK(inode->i_mode)) { 454 inode->i_op = &nilfs_symlink_inode_operations; 455 inode->i_mapping->a_ops = &nilfs_aops; 456 } else { 457 inode->i_op = &nilfs_special_inode_operations; 458 init_special_inode( 459 inode, inode->i_mode, 460 huge_decode_dev(le64_to_cpu(raw_inode->i_device_code))); 461 } 462 nilfs_ifile_unmap_inode(root->ifile, ino, bh); 463 brelse(bh); 464 up_read(&NILFS_MDT(dat)->mi_sem); /* XXX */ 465 nilfs_set_inode_flags(inode); 466 return 0; 467 468 failed_unmap: 469 nilfs_ifile_unmap_inode(root->ifile, ino, bh); 470 brelse(bh); 471 472 bad_inode: 473 up_read(&NILFS_MDT(dat)->mi_sem); /* XXX */ 474 return err; 475 } 476 477 static int nilfs_iget_test(struct inode *inode, void *opaque) 478 { 479 struct nilfs_iget_args *args = opaque; 480 struct nilfs_inode_info *ii; 481 482 if (args->ino != inode->i_ino || args->root != NILFS_I(inode)->i_root) 483 return 0; 484 485 ii = NILFS_I(inode); 486 if (!test_bit(NILFS_I_GCINODE, &ii->i_state)) 487 return !args->for_gc; 488 489 return args->for_gc && args->cno == ii->i_cno; 490 } 491 492 static int nilfs_iget_set(struct inode *inode, void *opaque) 493 { 494 struct nilfs_iget_args *args = opaque; 495 496 inode->i_ino = args->ino; 497 if (args->for_gc) { 498 NILFS_I(inode)->i_state = 1 << NILFS_I_GCINODE; 499 NILFS_I(inode)->i_cno = args->cno; 500 NILFS_I(inode)->i_root = NULL; 501 } else { 502 if (args->root && args->ino == NILFS_ROOT_INO) 503 nilfs_get_root(args->root); 504 NILFS_I(inode)->i_root = args->root; 505 } 506 return 0; 507 } 508 509 struct inode *nilfs_iget(struct super_block *sb, struct nilfs_root *root, 510 unsigned long ino) 511 { 512 struct nilfs_iget_args args = { 513 .ino = ino, .root = root, .cno = 0, .for_gc = 0 514 }; 515 struct inode *inode; 516 int err; 517 518 inode = iget5_locked(sb, ino, nilfs_iget_test, nilfs_iget_set, &args); 519 if (unlikely(!inode)) 520 return ERR_PTR(-ENOMEM); 521 if (!(inode->i_state & I_NEW)) 522 return inode; 523 524 err = __nilfs_read_inode(sb, root, ino, inode); 525 if (unlikely(err)) { 526 iget_failed(inode); 527 return ERR_PTR(err); 528 } 529 unlock_new_inode(inode); 530 return inode; 531 } 532 533 struct inode *nilfs_iget_for_gc(struct super_block *sb, unsigned long ino, 534 __u64 cno) 535 { 536 struct nilfs_iget_args args = { 537 .ino = ino, .root = NULL, .cno = cno, .for_gc = 1 538 }; 539 struct inode *inode; 540 int err; 541 542 inode = iget5_locked(sb, ino, nilfs_iget_test, nilfs_iget_set, &args); 543 if (unlikely(!inode)) 544 return ERR_PTR(-ENOMEM); 545 if (!(inode->i_state & I_NEW)) 546 return inode; 547 548 err = nilfs_init_gcinode(inode); 549 if (unlikely(err)) { 550 iget_failed(inode); 551 return ERR_PTR(err); 552 } 553 unlock_new_inode(inode); 554 return inode; 555 } 556 557 void nilfs_write_inode_common(struct inode *inode, 558 struct nilfs_inode *raw_inode, int has_bmap) 559 { 560 struct nilfs_inode_info *ii = NILFS_I(inode); 561 562 raw_inode->i_mode = cpu_to_le16(inode->i_mode); 563 raw_inode->i_uid = cpu_to_le32(inode->i_uid); 564 raw_inode->i_gid = cpu_to_le32(inode->i_gid); 565 raw_inode->i_links_count = cpu_to_le16(inode->i_nlink); 566 raw_inode->i_size = cpu_to_le64(inode->i_size); 567 raw_inode->i_ctime = cpu_to_le64(inode->i_ctime.tv_sec); 568 raw_inode->i_mtime = cpu_to_le64(inode->i_mtime.tv_sec); 569 raw_inode->i_ctime_nsec = cpu_to_le32(inode->i_ctime.tv_nsec); 570 raw_inode->i_mtime_nsec = cpu_to_le32(inode->i_mtime.tv_nsec); 571 raw_inode->i_blocks = cpu_to_le64(inode->i_blocks); 572 573 raw_inode->i_flags = cpu_to_le32(ii->i_flags); 574 raw_inode->i_generation = cpu_to_le32(inode->i_generation); 575 576 if (has_bmap) 577 nilfs_bmap_write(ii->i_bmap, raw_inode); 578 else if (S_ISCHR(inode->i_mode) || S_ISBLK(inode->i_mode)) 579 raw_inode->i_device_code = 580 cpu_to_le64(huge_encode_dev(inode->i_rdev)); 581 /* When extending inode, nilfs->ns_inode_size should be checked 582 for substitutions of appended fields */ 583 } 584 585 void nilfs_update_inode(struct inode *inode, struct buffer_head *ibh) 586 { 587 ino_t ino = inode->i_ino; 588 struct nilfs_inode_info *ii = NILFS_I(inode); 589 struct inode *ifile = ii->i_root->ifile; 590 struct nilfs_inode *raw_inode; 591 592 raw_inode = nilfs_ifile_map_inode(ifile, ino, ibh); 593 594 if (test_and_clear_bit(NILFS_I_NEW, &ii->i_state)) 595 memset(raw_inode, 0, NILFS_MDT(ifile)->mi_entry_size); 596 set_bit(NILFS_I_INODE_DIRTY, &ii->i_state); 597 598 nilfs_write_inode_common(inode, raw_inode, 0); 599 /* XXX: call with has_bmap = 0 is a workaround to avoid 600 deadlock of bmap. This delays update of i_bmap to just 601 before writing */ 602 nilfs_ifile_unmap_inode(ifile, ino, ibh); 603 } 604 605 #define NILFS_MAX_TRUNCATE_BLOCKS 16384 /* 64MB for 4KB block */ 606 607 static void nilfs_truncate_bmap(struct nilfs_inode_info *ii, 608 unsigned long from) 609 { 610 unsigned long b; 611 int ret; 612 613 if (!test_bit(NILFS_I_BMAP, &ii->i_state)) 614 return; 615 repeat: 616 ret = nilfs_bmap_last_key(ii->i_bmap, &b); 617 if (ret == -ENOENT) 618 return; 619 else if (ret < 0) 620 goto failed; 621 622 if (b < from) 623 return; 624 625 b -= min_t(unsigned long, NILFS_MAX_TRUNCATE_BLOCKS, b - from); 626 ret = nilfs_bmap_truncate(ii->i_bmap, b); 627 nilfs_relax_pressure_in_lock(ii->vfs_inode.i_sb); 628 if (!ret || (ret == -ENOMEM && 629 nilfs_bmap_truncate(ii->i_bmap, b) == 0)) 630 goto repeat; 631 632 failed: 633 if (ret == -EINVAL) 634 nilfs_error(ii->vfs_inode.i_sb, __func__, 635 "bmap is broken (ino=%lu)", ii->vfs_inode.i_ino); 636 else 637 nilfs_warning(ii->vfs_inode.i_sb, __func__, 638 "failed to truncate bmap (ino=%lu, err=%d)", 639 ii->vfs_inode.i_ino, ret); 640 } 641 642 void nilfs_truncate(struct inode *inode) 643 { 644 unsigned long blkoff; 645 unsigned int blocksize; 646 struct nilfs_transaction_info ti; 647 struct super_block *sb = inode->i_sb; 648 struct nilfs_inode_info *ii = NILFS_I(inode); 649 650 if (!test_bit(NILFS_I_BMAP, &ii->i_state)) 651 return; 652 if (IS_APPEND(inode) || IS_IMMUTABLE(inode)) 653 return; 654 655 blocksize = sb->s_blocksize; 656 blkoff = (inode->i_size + blocksize - 1) >> sb->s_blocksize_bits; 657 nilfs_transaction_begin(sb, &ti, 0); /* never fails */ 658 659 block_truncate_page(inode->i_mapping, inode->i_size, nilfs_get_block); 660 661 nilfs_truncate_bmap(ii, blkoff); 662 663 inode->i_mtime = inode->i_ctime = CURRENT_TIME; 664 if (IS_SYNC(inode)) 665 nilfs_set_transaction_flag(NILFS_TI_SYNC); 666 667 nilfs_mark_inode_dirty(inode); 668 nilfs_set_file_dirty(NILFS_SB(sb), inode, 0); 669 nilfs_transaction_commit(sb); 670 /* May construct a logical segment and may fail in sync mode. 671 But truncate has no return value. */ 672 } 673 674 static void nilfs_clear_inode(struct inode *inode) 675 { 676 struct nilfs_inode_info *ii = NILFS_I(inode); 677 678 /* 679 * Free resources allocated in nilfs_read_inode(), here. 680 */ 681 BUG_ON(!list_empty(&ii->i_dirty)); 682 brelse(ii->i_bh); 683 ii->i_bh = NULL; 684 685 if (test_bit(NILFS_I_BMAP, &ii->i_state)) 686 nilfs_bmap_clear(ii->i_bmap); 687 688 nilfs_btnode_cache_clear(&ii->i_btnode_cache); 689 690 if (ii->i_root && inode->i_ino == NILFS_ROOT_INO) 691 nilfs_put_root(ii->i_root); 692 } 693 694 void nilfs_evict_inode(struct inode *inode) 695 { 696 struct nilfs_transaction_info ti; 697 struct super_block *sb = inode->i_sb; 698 struct nilfs_inode_info *ii = NILFS_I(inode); 699 700 if (inode->i_nlink || !ii->i_root || unlikely(is_bad_inode(inode))) { 701 if (inode->i_data.nrpages) 702 truncate_inode_pages(&inode->i_data, 0); 703 end_writeback(inode); 704 nilfs_clear_inode(inode); 705 return; 706 } 707 nilfs_transaction_begin(sb, &ti, 0); /* never fails */ 708 709 if (inode->i_data.nrpages) 710 truncate_inode_pages(&inode->i_data, 0); 711 712 /* TODO: some of the following operations may fail. */ 713 nilfs_truncate_bmap(ii, 0); 714 nilfs_mark_inode_dirty(inode); 715 end_writeback(inode); 716 717 nilfs_ifile_delete_inode(ii->i_root->ifile, inode->i_ino); 718 atomic_dec(&NILFS_SB(sb)->s_inodes_count); 719 720 nilfs_clear_inode(inode); 721 722 if (IS_SYNC(inode)) 723 nilfs_set_transaction_flag(NILFS_TI_SYNC); 724 nilfs_transaction_commit(sb); 725 /* May construct a logical segment and may fail in sync mode. 726 But delete_inode has no return value. */ 727 } 728 729 int nilfs_setattr(struct dentry *dentry, struct iattr *iattr) 730 { 731 struct nilfs_transaction_info ti; 732 struct inode *inode = dentry->d_inode; 733 struct super_block *sb = inode->i_sb; 734 int err; 735 736 err = inode_change_ok(inode, iattr); 737 if (err) 738 return err; 739 740 err = nilfs_transaction_begin(sb, &ti, 0); 741 if (unlikely(err)) 742 return err; 743 744 if ((iattr->ia_valid & ATTR_SIZE) && 745 iattr->ia_size != i_size_read(inode)) { 746 err = vmtruncate(inode, iattr->ia_size); 747 if (unlikely(err)) 748 goto out_err; 749 } 750 751 setattr_copy(inode, iattr); 752 mark_inode_dirty(inode); 753 754 if (iattr->ia_valid & ATTR_MODE) { 755 err = nilfs_acl_chmod(inode); 756 if (unlikely(err)) 757 goto out_err; 758 } 759 760 return nilfs_transaction_commit(sb); 761 762 out_err: 763 nilfs_transaction_abort(sb); 764 return err; 765 } 766 767 int nilfs_load_inode_block(struct nilfs_sb_info *sbi, struct inode *inode, 768 struct buffer_head **pbh) 769 { 770 struct nilfs_inode_info *ii = NILFS_I(inode); 771 int err; 772 773 spin_lock(&sbi->s_inode_lock); 774 if (ii->i_bh == NULL) { 775 spin_unlock(&sbi->s_inode_lock); 776 err = nilfs_ifile_get_inode_block(ii->i_root->ifile, 777 inode->i_ino, pbh); 778 if (unlikely(err)) 779 return err; 780 spin_lock(&sbi->s_inode_lock); 781 if (ii->i_bh == NULL) 782 ii->i_bh = *pbh; 783 else { 784 brelse(*pbh); 785 *pbh = ii->i_bh; 786 } 787 } else 788 *pbh = ii->i_bh; 789 790 get_bh(*pbh); 791 spin_unlock(&sbi->s_inode_lock); 792 return 0; 793 } 794 795 int nilfs_inode_dirty(struct inode *inode) 796 { 797 struct nilfs_inode_info *ii = NILFS_I(inode); 798 struct nilfs_sb_info *sbi = NILFS_SB(inode->i_sb); 799 int ret = 0; 800 801 if (!list_empty(&ii->i_dirty)) { 802 spin_lock(&sbi->s_inode_lock); 803 ret = test_bit(NILFS_I_DIRTY, &ii->i_state) || 804 test_bit(NILFS_I_BUSY, &ii->i_state); 805 spin_unlock(&sbi->s_inode_lock); 806 } 807 return ret; 808 } 809 810 int nilfs_set_file_dirty(struct nilfs_sb_info *sbi, struct inode *inode, 811 unsigned nr_dirty) 812 { 813 struct nilfs_inode_info *ii = NILFS_I(inode); 814 815 atomic_add(nr_dirty, &sbi->s_nilfs->ns_ndirtyblks); 816 817 if (test_and_set_bit(NILFS_I_DIRTY, &ii->i_state)) 818 return 0; 819 820 spin_lock(&sbi->s_inode_lock); 821 if (!test_bit(NILFS_I_QUEUED, &ii->i_state) && 822 !test_bit(NILFS_I_BUSY, &ii->i_state)) { 823 /* Because this routine may race with nilfs_dispose_list(), 824 we have to check NILFS_I_QUEUED here, too. */ 825 if (list_empty(&ii->i_dirty) && igrab(inode) == NULL) { 826 /* This will happen when somebody is freeing 827 this inode. */ 828 nilfs_warning(sbi->s_super, __func__, 829 "cannot get inode (ino=%lu)\n", 830 inode->i_ino); 831 spin_unlock(&sbi->s_inode_lock); 832 return -EINVAL; /* NILFS_I_DIRTY may remain for 833 freeing inode */ 834 } 835 list_del(&ii->i_dirty); 836 list_add_tail(&ii->i_dirty, &sbi->s_dirty_files); 837 set_bit(NILFS_I_QUEUED, &ii->i_state); 838 } 839 spin_unlock(&sbi->s_inode_lock); 840 return 0; 841 } 842 843 int nilfs_mark_inode_dirty(struct inode *inode) 844 { 845 struct nilfs_sb_info *sbi = NILFS_SB(inode->i_sb); 846 struct buffer_head *ibh; 847 int err; 848 849 err = nilfs_load_inode_block(sbi, inode, &ibh); 850 if (unlikely(err)) { 851 nilfs_warning(inode->i_sb, __func__, 852 "failed to reget inode block.\n"); 853 return err; 854 } 855 nilfs_update_inode(inode, ibh); 856 nilfs_mdt_mark_buffer_dirty(ibh); 857 nilfs_mdt_mark_dirty(NILFS_I(inode)->i_root->ifile); 858 brelse(ibh); 859 return 0; 860 } 861 862 /** 863 * nilfs_dirty_inode - reflect changes on given inode to an inode block. 864 * @inode: inode of the file to be registered. 865 * 866 * nilfs_dirty_inode() loads a inode block containing the specified 867 * @inode and copies data from a nilfs_inode to a corresponding inode 868 * entry in the inode block. This operation is excluded from the segment 869 * construction. This function can be called both as a single operation 870 * and as a part of indivisible file operations. 871 */ 872 void nilfs_dirty_inode(struct inode *inode) 873 { 874 struct nilfs_transaction_info ti; 875 struct nilfs_mdt_info *mdi = NILFS_MDT(inode); 876 877 if (is_bad_inode(inode)) { 878 nilfs_warning(inode->i_sb, __func__, 879 "tried to mark bad_inode dirty. ignored.\n"); 880 dump_stack(); 881 return; 882 } 883 if (mdi) { 884 nilfs_mdt_mark_dirty(inode); 885 return; 886 } 887 nilfs_transaction_begin(inode->i_sb, &ti, 0); 888 nilfs_mark_inode_dirty(inode); 889 nilfs_transaction_commit(inode->i_sb); /* never fails */ 890 } 891