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/pagemap.h> 28 #include <linux/writeback.h> 29 #include <linux/aio.h> 30 #include "nilfs.h" 31 #include "btnode.h" 32 #include "segment.h" 33 #include "page.h" 34 #include "mdt.h" 35 #include "cpfile.h" 36 #include "ifile.h" 37 38 /** 39 * struct nilfs_iget_args - arguments used during comparison between inodes 40 * @ino: inode number 41 * @cno: checkpoint number 42 * @root: pointer on NILFS root object (mounted checkpoint) 43 * @for_gc: inode for GC flag 44 */ 45 struct nilfs_iget_args { 46 u64 ino; 47 __u64 cno; 48 struct nilfs_root *root; 49 int for_gc; 50 }; 51 52 void nilfs_inode_add_blocks(struct inode *inode, int n) 53 { 54 struct nilfs_root *root = NILFS_I(inode)->i_root; 55 56 inode_add_bytes(inode, (1 << inode->i_blkbits) * n); 57 if (root) 58 atomic64_add(n, &root->blocks_count); 59 } 60 61 void nilfs_inode_sub_blocks(struct inode *inode, int n) 62 { 63 struct nilfs_root *root = NILFS_I(inode)->i_root; 64 65 inode_sub_bytes(inode, (1 << inode->i_blkbits) * n); 66 if (root) 67 atomic64_sub(n, &root->blocks_count); 68 } 69 70 /** 71 * nilfs_get_block() - get a file block on the filesystem (callback function) 72 * @inode - inode struct of the target file 73 * @blkoff - file block number 74 * @bh_result - buffer head to be mapped on 75 * @create - indicate whether allocating the block or not when it has not 76 * been allocated yet. 77 * 78 * This function does not issue actual read request of the specified data 79 * block. It is done by VFS. 80 */ 81 int nilfs_get_block(struct inode *inode, sector_t blkoff, 82 struct buffer_head *bh_result, int create) 83 { 84 struct nilfs_inode_info *ii = NILFS_I(inode); 85 struct the_nilfs *nilfs = inode->i_sb->s_fs_info; 86 __u64 blknum = 0; 87 int err = 0, ret; 88 unsigned maxblocks = bh_result->b_size >> inode->i_blkbits; 89 90 down_read(&NILFS_MDT(nilfs->ns_dat)->mi_sem); 91 ret = nilfs_bmap_lookup_contig(ii->i_bmap, blkoff, &blknum, maxblocks); 92 up_read(&NILFS_MDT(nilfs->ns_dat)->mi_sem); 93 if (ret >= 0) { /* found */ 94 map_bh(bh_result, inode->i_sb, blknum); 95 if (ret > 0) 96 bh_result->b_size = (ret << inode->i_blkbits); 97 goto out; 98 } 99 /* data block was not found */ 100 if (ret == -ENOENT && create) { 101 struct nilfs_transaction_info ti; 102 103 bh_result->b_blocknr = 0; 104 err = nilfs_transaction_begin(inode->i_sb, &ti, 1); 105 if (unlikely(err)) 106 goto out; 107 err = nilfs_bmap_insert(ii->i_bmap, (unsigned long)blkoff, 108 (unsigned long)bh_result); 109 if (unlikely(err != 0)) { 110 if (err == -EEXIST) { 111 /* 112 * The get_block() function could be called 113 * from multiple callers for an inode. 114 * However, the page having this block must 115 * be locked in this case. 116 */ 117 printk(KERN_WARNING 118 "nilfs_get_block: a race condition " 119 "while inserting a data block. " 120 "(inode number=%lu, file block " 121 "offset=%llu)\n", 122 inode->i_ino, 123 (unsigned long long)blkoff); 124 err = 0; 125 } 126 nilfs_transaction_abort(inode->i_sb); 127 goto out; 128 } 129 nilfs_mark_inode_dirty(inode); 130 nilfs_transaction_commit(inode->i_sb); /* never fails */ 131 /* Error handling should be detailed */ 132 set_buffer_new(bh_result); 133 set_buffer_delay(bh_result); 134 map_bh(bh_result, inode->i_sb, 0); /* dbn must be changed 135 to proper value */ 136 } else if (ret == -ENOENT) { 137 /* not found is not error (e.g. hole); must return without 138 the mapped state flag. */ 139 ; 140 } else { 141 err = ret; 142 } 143 144 out: 145 return err; 146 } 147 148 /** 149 * nilfs_readpage() - implement readpage() method of nilfs_aops {} 150 * address_space_operations. 151 * @file - file struct of the file to be read 152 * @page - the page to be read 153 */ 154 static int nilfs_readpage(struct file *file, struct page *page) 155 { 156 return mpage_readpage(page, nilfs_get_block); 157 } 158 159 /** 160 * nilfs_readpages() - implement readpages() method of nilfs_aops {} 161 * address_space_operations. 162 * @file - file struct of the file to be read 163 * @mapping - address_space struct used for reading multiple pages 164 * @pages - the pages to be read 165 * @nr_pages - number of pages to be read 166 */ 167 static int nilfs_readpages(struct file *file, struct address_space *mapping, 168 struct list_head *pages, unsigned nr_pages) 169 { 170 return mpage_readpages(mapping, pages, nr_pages, nilfs_get_block); 171 } 172 173 static int nilfs_writepages(struct address_space *mapping, 174 struct writeback_control *wbc) 175 { 176 struct inode *inode = mapping->host; 177 int err = 0; 178 179 if (inode->i_sb->s_flags & MS_RDONLY) { 180 nilfs_clear_dirty_pages(mapping, false); 181 return -EROFS; 182 } 183 184 if (wbc->sync_mode == WB_SYNC_ALL) 185 err = nilfs_construct_dsync_segment(inode->i_sb, inode, 186 wbc->range_start, 187 wbc->range_end); 188 return err; 189 } 190 191 static int nilfs_writepage(struct page *page, struct writeback_control *wbc) 192 { 193 struct inode *inode = page->mapping->host; 194 int err; 195 196 if (inode->i_sb->s_flags & MS_RDONLY) { 197 /* 198 * It means that filesystem was remounted in read-only 199 * mode because of error or metadata corruption. But we 200 * have dirty pages that try to be flushed in background. 201 * So, here we simply discard this dirty page. 202 */ 203 nilfs_clear_dirty_page(page, false); 204 unlock_page(page); 205 return -EROFS; 206 } 207 208 redirty_page_for_writepage(wbc, page); 209 unlock_page(page); 210 211 if (wbc->sync_mode == WB_SYNC_ALL) { 212 err = nilfs_construct_segment(inode->i_sb); 213 if (unlikely(err)) 214 return err; 215 } else if (wbc->for_reclaim) 216 nilfs_flush_segment(inode->i_sb, inode->i_ino); 217 218 return 0; 219 } 220 221 static int nilfs_set_page_dirty(struct page *page) 222 { 223 struct inode *inode = page->mapping->host; 224 int ret = __set_page_dirty_nobuffers(page); 225 226 if (page_has_buffers(page)) { 227 unsigned nr_dirty = 0; 228 struct buffer_head *bh, *head; 229 230 /* 231 * This page is locked by callers, and no other thread 232 * concurrently marks its buffers dirty since they are 233 * only dirtied through routines in fs/buffer.c in 234 * which call sites of mark_buffer_dirty are protected 235 * by page lock. 236 */ 237 bh = head = page_buffers(page); 238 do { 239 /* Do not mark hole blocks dirty */ 240 if (buffer_dirty(bh) || !buffer_mapped(bh)) 241 continue; 242 243 set_buffer_dirty(bh); 244 nr_dirty++; 245 } while (bh = bh->b_this_page, bh != head); 246 247 if (nr_dirty) 248 nilfs_set_file_dirty(inode, nr_dirty); 249 } else if (ret) { 250 unsigned nr_dirty = 1 << (PAGE_CACHE_SHIFT - inode->i_blkbits); 251 252 nilfs_set_file_dirty(inode, nr_dirty); 253 } 254 return ret; 255 } 256 257 void nilfs_write_failed(struct address_space *mapping, loff_t to) 258 { 259 struct inode *inode = mapping->host; 260 261 if (to > inode->i_size) { 262 truncate_pagecache(inode, inode->i_size); 263 nilfs_truncate(inode); 264 } 265 } 266 267 static int nilfs_write_begin(struct file *file, struct address_space *mapping, 268 loff_t pos, unsigned len, unsigned flags, 269 struct page **pagep, void **fsdata) 270 271 { 272 struct inode *inode = mapping->host; 273 int err = nilfs_transaction_begin(inode->i_sb, NULL, 1); 274 275 if (unlikely(err)) 276 return err; 277 278 err = block_write_begin(mapping, pos, len, flags, pagep, 279 nilfs_get_block); 280 if (unlikely(err)) { 281 nilfs_write_failed(mapping, pos + len); 282 nilfs_transaction_abort(inode->i_sb); 283 } 284 return err; 285 } 286 287 static int nilfs_write_end(struct file *file, struct address_space *mapping, 288 loff_t pos, unsigned len, unsigned copied, 289 struct page *page, void *fsdata) 290 { 291 struct inode *inode = mapping->host; 292 unsigned start = pos & (PAGE_CACHE_SIZE - 1); 293 unsigned nr_dirty; 294 int err; 295 296 nr_dirty = nilfs_page_count_clean_buffers(page, start, 297 start + copied); 298 copied = generic_write_end(file, mapping, pos, len, copied, page, 299 fsdata); 300 nilfs_set_file_dirty(inode, nr_dirty); 301 err = nilfs_transaction_commit(inode->i_sb); 302 return err ? : copied; 303 } 304 305 static ssize_t 306 nilfs_direct_IO(int rw, struct kiocb *iocb, struct iov_iter *iter, 307 loff_t offset) 308 { 309 struct file *file = iocb->ki_filp; 310 struct address_space *mapping = file->f_mapping; 311 struct inode *inode = file->f_mapping->host; 312 size_t count = iov_iter_count(iter); 313 ssize_t size; 314 315 if (rw == WRITE) 316 return 0; 317 318 /* Needs synchronization with the cleaner */ 319 size = blockdev_direct_IO(rw, iocb, inode, iter, offset, 320 nilfs_get_block); 321 322 /* 323 * In case of error extending write may have instantiated a few 324 * blocks outside i_size. Trim these off again. 325 */ 326 if (unlikely((rw & WRITE) && size < 0)) { 327 loff_t isize = i_size_read(inode); 328 loff_t end = offset + count; 329 330 if (end > isize) 331 nilfs_write_failed(mapping, end); 332 } 333 334 return size; 335 } 336 337 const struct address_space_operations nilfs_aops = { 338 .writepage = nilfs_writepage, 339 .readpage = nilfs_readpage, 340 .writepages = nilfs_writepages, 341 .set_page_dirty = nilfs_set_page_dirty, 342 .readpages = nilfs_readpages, 343 .write_begin = nilfs_write_begin, 344 .write_end = nilfs_write_end, 345 /* .releasepage = nilfs_releasepage, */ 346 .invalidatepage = block_invalidatepage, 347 .direct_IO = nilfs_direct_IO, 348 .is_partially_uptodate = block_is_partially_uptodate, 349 }; 350 351 struct inode *nilfs_new_inode(struct inode *dir, umode_t mode) 352 { 353 struct super_block *sb = dir->i_sb; 354 struct the_nilfs *nilfs = sb->s_fs_info; 355 struct inode *inode; 356 struct nilfs_inode_info *ii; 357 struct nilfs_root *root; 358 int err = -ENOMEM; 359 ino_t ino; 360 361 inode = new_inode(sb); 362 if (unlikely(!inode)) 363 goto failed; 364 365 mapping_set_gfp_mask(inode->i_mapping, 366 mapping_gfp_mask(inode->i_mapping) & ~__GFP_FS); 367 368 root = NILFS_I(dir)->i_root; 369 ii = NILFS_I(inode); 370 ii->i_state = 1 << NILFS_I_NEW; 371 ii->i_root = root; 372 373 err = nilfs_ifile_create_inode(root->ifile, &ino, &ii->i_bh); 374 if (unlikely(err)) 375 goto failed_ifile_create_inode; 376 /* reference count of i_bh inherits from nilfs_mdt_read_block() */ 377 378 atomic64_inc(&root->inodes_count); 379 inode_init_owner(inode, dir, mode); 380 inode->i_ino = ino; 381 inode->i_mtime = inode->i_atime = inode->i_ctime = CURRENT_TIME; 382 383 if (S_ISREG(mode) || S_ISDIR(mode) || S_ISLNK(mode)) { 384 err = nilfs_bmap_read(ii->i_bmap, NULL); 385 if (err < 0) 386 goto failed_bmap; 387 388 set_bit(NILFS_I_BMAP, &ii->i_state); 389 /* No lock is needed; iget() ensures it. */ 390 } 391 392 ii->i_flags = nilfs_mask_flags( 393 mode, NILFS_I(dir)->i_flags & NILFS_FL_INHERITED); 394 395 /* ii->i_file_acl = 0; */ 396 /* ii->i_dir_acl = 0; */ 397 ii->i_dir_start_lookup = 0; 398 nilfs_set_inode_flags(inode); 399 spin_lock(&nilfs->ns_next_gen_lock); 400 inode->i_generation = nilfs->ns_next_generation++; 401 spin_unlock(&nilfs->ns_next_gen_lock); 402 insert_inode_hash(inode); 403 404 err = nilfs_init_acl(inode, dir); 405 if (unlikely(err)) 406 goto failed_acl; /* never occur. When supporting 407 nilfs_init_acl(), proper cancellation of 408 above jobs should be considered */ 409 410 return inode; 411 412 failed_acl: 413 failed_bmap: 414 clear_nlink(inode); 415 iput(inode); /* raw_inode will be deleted through 416 generic_delete_inode() */ 417 goto failed; 418 419 failed_ifile_create_inode: 420 make_bad_inode(inode); 421 iput(inode); /* if i_nlink == 1, generic_forget_inode() will be 422 called */ 423 failed: 424 return ERR_PTR(err); 425 } 426 427 void nilfs_set_inode_flags(struct inode *inode) 428 { 429 unsigned int flags = NILFS_I(inode)->i_flags; 430 431 inode->i_flags &= ~(S_SYNC | S_APPEND | S_IMMUTABLE | S_NOATIME | 432 S_DIRSYNC); 433 if (flags & FS_SYNC_FL) 434 inode->i_flags |= S_SYNC; 435 if (flags & FS_APPEND_FL) 436 inode->i_flags |= S_APPEND; 437 if (flags & FS_IMMUTABLE_FL) 438 inode->i_flags |= S_IMMUTABLE; 439 if (flags & FS_NOATIME_FL) 440 inode->i_flags |= S_NOATIME; 441 if (flags & FS_DIRSYNC_FL) 442 inode->i_flags |= S_DIRSYNC; 443 mapping_set_gfp_mask(inode->i_mapping, 444 mapping_gfp_mask(inode->i_mapping) & ~__GFP_FS); 445 } 446 447 int nilfs_read_inode_common(struct inode *inode, 448 struct nilfs_inode *raw_inode) 449 { 450 struct nilfs_inode_info *ii = NILFS_I(inode); 451 int err; 452 453 inode->i_mode = le16_to_cpu(raw_inode->i_mode); 454 i_uid_write(inode, le32_to_cpu(raw_inode->i_uid)); 455 i_gid_write(inode, le32_to_cpu(raw_inode->i_gid)); 456 set_nlink(inode, le16_to_cpu(raw_inode->i_links_count)); 457 inode->i_size = le64_to_cpu(raw_inode->i_size); 458 inode->i_atime.tv_sec = le64_to_cpu(raw_inode->i_mtime); 459 inode->i_ctime.tv_sec = le64_to_cpu(raw_inode->i_ctime); 460 inode->i_mtime.tv_sec = le64_to_cpu(raw_inode->i_mtime); 461 inode->i_atime.tv_nsec = le32_to_cpu(raw_inode->i_mtime_nsec); 462 inode->i_ctime.tv_nsec = le32_to_cpu(raw_inode->i_ctime_nsec); 463 inode->i_mtime.tv_nsec = le32_to_cpu(raw_inode->i_mtime_nsec); 464 if (inode->i_nlink == 0 && inode->i_mode == 0) 465 return -EINVAL; /* this inode is deleted */ 466 467 inode->i_blocks = le64_to_cpu(raw_inode->i_blocks); 468 ii->i_flags = le32_to_cpu(raw_inode->i_flags); 469 #if 0 470 ii->i_file_acl = le32_to_cpu(raw_inode->i_file_acl); 471 ii->i_dir_acl = S_ISREG(inode->i_mode) ? 472 0 : le32_to_cpu(raw_inode->i_dir_acl); 473 #endif 474 ii->i_dir_start_lookup = 0; 475 inode->i_generation = le32_to_cpu(raw_inode->i_generation); 476 477 if (S_ISREG(inode->i_mode) || S_ISDIR(inode->i_mode) || 478 S_ISLNK(inode->i_mode)) { 479 err = nilfs_bmap_read(ii->i_bmap, raw_inode); 480 if (err < 0) 481 return err; 482 set_bit(NILFS_I_BMAP, &ii->i_state); 483 /* No lock is needed; iget() ensures it. */ 484 } 485 return 0; 486 } 487 488 static int __nilfs_read_inode(struct super_block *sb, 489 struct nilfs_root *root, unsigned long ino, 490 struct inode *inode) 491 { 492 struct the_nilfs *nilfs = sb->s_fs_info; 493 struct buffer_head *bh; 494 struct nilfs_inode *raw_inode; 495 int err; 496 497 down_read(&NILFS_MDT(nilfs->ns_dat)->mi_sem); 498 err = nilfs_ifile_get_inode_block(root->ifile, ino, &bh); 499 if (unlikely(err)) 500 goto bad_inode; 501 502 raw_inode = nilfs_ifile_map_inode(root->ifile, ino, bh); 503 504 err = nilfs_read_inode_common(inode, raw_inode); 505 if (err) 506 goto failed_unmap; 507 508 if (S_ISREG(inode->i_mode)) { 509 inode->i_op = &nilfs_file_inode_operations; 510 inode->i_fop = &nilfs_file_operations; 511 inode->i_mapping->a_ops = &nilfs_aops; 512 } else if (S_ISDIR(inode->i_mode)) { 513 inode->i_op = &nilfs_dir_inode_operations; 514 inode->i_fop = &nilfs_dir_operations; 515 inode->i_mapping->a_ops = &nilfs_aops; 516 } else if (S_ISLNK(inode->i_mode)) { 517 inode->i_op = &nilfs_symlink_inode_operations; 518 inode->i_mapping->a_ops = &nilfs_aops; 519 } else { 520 inode->i_op = &nilfs_special_inode_operations; 521 init_special_inode( 522 inode, inode->i_mode, 523 huge_decode_dev(le64_to_cpu(raw_inode->i_device_code))); 524 } 525 nilfs_ifile_unmap_inode(root->ifile, ino, bh); 526 brelse(bh); 527 up_read(&NILFS_MDT(nilfs->ns_dat)->mi_sem); 528 nilfs_set_inode_flags(inode); 529 return 0; 530 531 failed_unmap: 532 nilfs_ifile_unmap_inode(root->ifile, ino, bh); 533 brelse(bh); 534 535 bad_inode: 536 up_read(&NILFS_MDT(nilfs->ns_dat)->mi_sem); 537 return err; 538 } 539 540 static int nilfs_iget_test(struct inode *inode, void *opaque) 541 { 542 struct nilfs_iget_args *args = opaque; 543 struct nilfs_inode_info *ii; 544 545 if (args->ino != inode->i_ino || args->root != NILFS_I(inode)->i_root) 546 return 0; 547 548 ii = NILFS_I(inode); 549 if (!test_bit(NILFS_I_GCINODE, &ii->i_state)) 550 return !args->for_gc; 551 552 return args->for_gc && args->cno == ii->i_cno; 553 } 554 555 static int nilfs_iget_set(struct inode *inode, void *opaque) 556 { 557 struct nilfs_iget_args *args = opaque; 558 559 inode->i_ino = args->ino; 560 if (args->for_gc) { 561 NILFS_I(inode)->i_state = 1 << NILFS_I_GCINODE; 562 NILFS_I(inode)->i_cno = args->cno; 563 NILFS_I(inode)->i_root = NULL; 564 } else { 565 if (args->root && args->ino == NILFS_ROOT_INO) 566 nilfs_get_root(args->root); 567 NILFS_I(inode)->i_root = args->root; 568 } 569 return 0; 570 } 571 572 struct inode *nilfs_ilookup(struct super_block *sb, struct nilfs_root *root, 573 unsigned long ino) 574 { 575 struct nilfs_iget_args args = { 576 .ino = ino, .root = root, .cno = 0, .for_gc = 0 577 }; 578 579 return ilookup5(sb, ino, nilfs_iget_test, &args); 580 } 581 582 struct inode *nilfs_iget_locked(struct super_block *sb, struct nilfs_root *root, 583 unsigned long ino) 584 { 585 struct nilfs_iget_args args = { 586 .ino = ino, .root = root, .cno = 0, .for_gc = 0 587 }; 588 589 return iget5_locked(sb, ino, nilfs_iget_test, nilfs_iget_set, &args); 590 } 591 592 struct inode *nilfs_iget(struct super_block *sb, struct nilfs_root *root, 593 unsigned long ino) 594 { 595 struct inode *inode; 596 int err; 597 598 inode = nilfs_iget_locked(sb, root, ino); 599 if (unlikely(!inode)) 600 return ERR_PTR(-ENOMEM); 601 if (!(inode->i_state & I_NEW)) 602 return inode; 603 604 err = __nilfs_read_inode(sb, root, ino, inode); 605 if (unlikely(err)) { 606 iget_failed(inode); 607 return ERR_PTR(err); 608 } 609 unlock_new_inode(inode); 610 return inode; 611 } 612 613 struct inode *nilfs_iget_for_gc(struct super_block *sb, unsigned long ino, 614 __u64 cno) 615 { 616 struct nilfs_iget_args args = { 617 .ino = ino, .root = NULL, .cno = cno, .for_gc = 1 618 }; 619 struct inode *inode; 620 int err; 621 622 inode = iget5_locked(sb, ino, nilfs_iget_test, nilfs_iget_set, &args); 623 if (unlikely(!inode)) 624 return ERR_PTR(-ENOMEM); 625 if (!(inode->i_state & I_NEW)) 626 return inode; 627 628 err = nilfs_init_gcinode(inode); 629 if (unlikely(err)) { 630 iget_failed(inode); 631 return ERR_PTR(err); 632 } 633 unlock_new_inode(inode); 634 return inode; 635 } 636 637 void nilfs_write_inode_common(struct inode *inode, 638 struct nilfs_inode *raw_inode, int has_bmap) 639 { 640 struct nilfs_inode_info *ii = NILFS_I(inode); 641 642 raw_inode->i_mode = cpu_to_le16(inode->i_mode); 643 raw_inode->i_uid = cpu_to_le32(i_uid_read(inode)); 644 raw_inode->i_gid = cpu_to_le32(i_gid_read(inode)); 645 raw_inode->i_links_count = cpu_to_le16(inode->i_nlink); 646 raw_inode->i_size = cpu_to_le64(inode->i_size); 647 raw_inode->i_ctime = cpu_to_le64(inode->i_ctime.tv_sec); 648 raw_inode->i_mtime = cpu_to_le64(inode->i_mtime.tv_sec); 649 raw_inode->i_ctime_nsec = cpu_to_le32(inode->i_ctime.tv_nsec); 650 raw_inode->i_mtime_nsec = cpu_to_le32(inode->i_mtime.tv_nsec); 651 raw_inode->i_blocks = cpu_to_le64(inode->i_blocks); 652 653 raw_inode->i_flags = cpu_to_le32(ii->i_flags); 654 raw_inode->i_generation = cpu_to_le32(inode->i_generation); 655 656 if (NILFS_ROOT_METADATA_FILE(inode->i_ino)) { 657 struct the_nilfs *nilfs = inode->i_sb->s_fs_info; 658 659 /* zero-fill unused portion in the case of super root block */ 660 raw_inode->i_xattr = 0; 661 raw_inode->i_pad = 0; 662 memset((void *)raw_inode + sizeof(*raw_inode), 0, 663 nilfs->ns_inode_size - sizeof(*raw_inode)); 664 } 665 666 if (has_bmap) 667 nilfs_bmap_write(ii->i_bmap, raw_inode); 668 else if (S_ISCHR(inode->i_mode) || S_ISBLK(inode->i_mode)) 669 raw_inode->i_device_code = 670 cpu_to_le64(huge_encode_dev(inode->i_rdev)); 671 /* When extending inode, nilfs->ns_inode_size should be checked 672 for substitutions of appended fields */ 673 } 674 675 void nilfs_update_inode(struct inode *inode, struct buffer_head *ibh) 676 { 677 ino_t ino = inode->i_ino; 678 struct nilfs_inode_info *ii = NILFS_I(inode); 679 struct inode *ifile = ii->i_root->ifile; 680 struct nilfs_inode *raw_inode; 681 682 raw_inode = nilfs_ifile_map_inode(ifile, ino, ibh); 683 684 if (test_and_clear_bit(NILFS_I_NEW, &ii->i_state)) 685 memset(raw_inode, 0, NILFS_MDT(ifile)->mi_entry_size); 686 set_bit(NILFS_I_INODE_DIRTY, &ii->i_state); 687 688 nilfs_write_inode_common(inode, raw_inode, 0); 689 /* XXX: call with has_bmap = 0 is a workaround to avoid 690 deadlock of bmap. This delays update of i_bmap to just 691 before writing */ 692 nilfs_ifile_unmap_inode(ifile, ino, ibh); 693 } 694 695 #define NILFS_MAX_TRUNCATE_BLOCKS 16384 /* 64MB for 4KB block */ 696 697 static void nilfs_truncate_bmap(struct nilfs_inode_info *ii, 698 unsigned long from) 699 { 700 unsigned long b; 701 int ret; 702 703 if (!test_bit(NILFS_I_BMAP, &ii->i_state)) 704 return; 705 repeat: 706 ret = nilfs_bmap_last_key(ii->i_bmap, &b); 707 if (ret == -ENOENT) 708 return; 709 else if (ret < 0) 710 goto failed; 711 712 if (b < from) 713 return; 714 715 b -= min_t(unsigned long, NILFS_MAX_TRUNCATE_BLOCKS, b - from); 716 ret = nilfs_bmap_truncate(ii->i_bmap, b); 717 nilfs_relax_pressure_in_lock(ii->vfs_inode.i_sb); 718 if (!ret || (ret == -ENOMEM && 719 nilfs_bmap_truncate(ii->i_bmap, b) == 0)) 720 goto repeat; 721 722 failed: 723 nilfs_warning(ii->vfs_inode.i_sb, __func__, 724 "failed to truncate bmap (ino=%lu, err=%d)", 725 ii->vfs_inode.i_ino, ret); 726 } 727 728 void nilfs_truncate(struct inode *inode) 729 { 730 unsigned long blkoff; 731 unsigned int blocksize; 732 struct nilfs_transaction_info ti; 733 struct super_block *sb = inode->i_sb; 734 struct nilfs_inode_info *ii = NILFS_I(inode); 735 736 if (!test_bit(NILFS_I_BMAP, &ii->i_state)) 737 return; 738 if (IS_APPEND(inode) || IS_IMMUTABLE(inode)) 739 return; 740 741 blocksize = sb->s_blocksize; 742 blkoff = (inode->i_size + blocksize - 1) >> sb->s_blocksize_bits; 743 nilfs_transaction_begin(sb, &ti, 0); /* never fails */ 744 745 block_truncate_page(inode->i_mapping, inode->i_size, nilfs_get_block); 746 747 nilfs_truncate_bmap(ii, blkoff); 748 749 inode->i_mtime = inode->i_ctime = CURRENT_TIME; 750 if (IS_SYNC(inode)) 751 nilfs_set_transaction_flag(NILFS_TI_SYNC); 752 753 nilfs_mark_inode_dirty(inode); 754 nilfs_set_file_dirty(inode, 0); 755 nilfs_transaction_commit(sb); 756 /* May construct a logical segment and may fail in sync mode. 757 But truncate has no return value. */ 758 } 759 760 static void nilfs_clear_inode(struct inode *inode) 761 { 762 struct nilfs_inode_info *ii = NILFS_I(inode); 763 struct nilfs_mdt_info *mdi = NILFS_MDT(inode); 764 765 /* 766 * Free resources allocated in nilfs_read_inode(), here. 767 */ 768 BUG_ON(!list_empty(&ii->i_dirty)); 769 brelse(ii->i_bh); 770 ii->i_bh = NULL; 771 772 if (mdi && mdi->mi_palloc_cache) 773 nilfs_palloc_destroy_cache(inode); 774 775 if (test_bit(NILFS_I_BMAP, &ii->i_state)) 776 nilfs_bmap_clear(ii->i_bmap); 777 778 nilfs_btnode_cache_clear(&ii->i_btnode_cache); 779 780 if (ii->i_root && inode->i_ino == NILFS_ROOT_INO) 781 nilfs_put_root(ii->i_root); 782 } 783 784 void nilfs_evict_inode(struct inode *inode) 785 { 786 struct nilfs_transaction_info ti; 787 struct super_block *sb = inode->i_sb; 788 struct nilfs_inode_info *ii = NILFS_I(inode); 789 int ret; 790 791 if (inode->i_nlink || !ii->i_root || unlikely(is_bad_inode(inode))) { 792 truncate_inode_pages_final(&inode->i_data); 793 clear_inode(inode); 794 nilfs_clear_inode(inode); 795 return; 796 } 797 nilfs_transaction_begin(sb, &ti, 0); /* never fails */ 798 799 truncate_inode_pages_final(&inode->i_data); 800 801 /* TODO: some of the following operations may fail. */ 802 nilfs_truncate_bmap(ii, 0); 803 nilfs_mark_inode_dirty(inode); 804 clear_inode(inode); 805 806 ret = nilfs_ifile_delete_inode(ii->i_root->ifile, inode->i_ino); 807 if (!ret) 808 atomic64_dec(&ii->i_root->inodes_count); 809 810 nilfs_clear_inode(inode); 811 812 if (IS_SYNC(inode)) 813 nilfs_set_transaction_flag(NILFS_TI_SYNC); 814 nilfs_transaction_commit(sb); 815 /* May construct a logical segment and may fail in sync mode. 816 But delete_inode has no return value. */ 817 } 818 819 int nilfs_setattr(struct dentry *dentry, struct iattr *iattr) 820 { 821 struct nilfs_transaction_info ti; 822 struct inode *inode = dentry->d_inode; 823 struct super_block *sb = inode->i_sb; 824 int err; 825 826 err = inode_change_ok(inode, iattr); 827 if (err) 828 return err; 829 830 err = nilfs_transaction_begin(sb, &ti, 0); 831 if (unlikely(err)) 832 return err; 833 834 if ((iattr->ia_valid & ATTR_SIZE) && 835 iattr->ia_size != i_size_read(inode)) { 836 inode_dio_wait(inode); 837 truncate_setsize(inode, iattr->ia_size); 838 nilfs_truncate(inode); 839 } 840 841 setattr_copy(inode, iattr); 842 mark_inode_dirty(inode); 843 844 if (iattr->ia_valid & ATTR_MODE) { 845 err = nilfs_acl_chmod(inode); 846 if (unlikely(err)) 847 goto out_err; 848 } 849 850 return nilfs_transaction_commit(sb); 851 852 out_err: 853 nilfs_transaction_abort(sb); 854 return err; 855 } 856 857 int nilfs_permission(struct inode *inode, int mask) 858 { 859 struct nilfs_root *root = NILFS_I(inode)->i_root; 860 if ((mask & MAY_WRITE) && root && 861 root->cno != NILFS_CPTREE_CURRENT_CNO) 862 return -EROFS; /* snapshot is not writable */ 863 864 return generic_permission(inode, mask); 865 } 866 867 int nilfs_load_inode_block(struct inode *inode, struct buffer_head **pbh) 868 { 869 struct the_nilfs *nilfs = inode->i_sb->s_fs_info; 870 struct nilfs_inode_info *ii = NILFS_I(inode); 871 int err; 872 873 spin_lock(&nilfs->ns_inode_lock); 874 if (ii->i_bh == NULL) { 875 spin_unlock(&nilfs->ns_inode_lock); 876 err = nilfs_ifile_get_inode_block(ii->i_root->ifile, 877 inode->i_ino, pbh); 878 if (unlikely(err)) 879 return err; 880 spin_lock(&nilfs->ns_inode_lock); 881 if (ii->i_bh == NULL) 882 ii->i_bh = *pbh; 883 else { 884 brelse(*pbh); 885 *pbh = ii->i_bh; 886 } 887 } else 888 *pbh = ii->i_bh; 889 890 get_bh(*pbh); 891 spin_unlock(&nilfs->ns_inode_lock); 892 return 0; 893 } 894 895 int nilfs_inode_dirty(struct inode *inode) 896 { 897 struct nilfs_inode_info *ii = NILFS_I(inode); 898 struct the_nilfs *nilfs = inode->i_sb->s_fs_info; 899 int ret = 0; 900 901 if (!list_empty(&ii->i_dirty)) { 902 spin_lock(&nilfs->ns_inode_lock); 903 ret = test_bit(NILFS_I_DIRTY, &ii->i_state) || 904 test_bit(NILFS_I_BUSY, &ii->i_state); 905 spin_unlock(&nilfs->ns_inode_lock); 906 } 907 return ret; 908 } 909 910 int nilfs_set_file_dirty(struct inode *inode, unsigned nr_dirty) 911 { 912 struct nilfs_inode_info *ii = NILFS_I(inode); 913 struct the_nilfs *nilfs = inode->i_sb->s_fs_info; 914 915 atomic_add(nr_dirty, &nilfs->ns_ndirtyblks); 916 917 if (test_and_set_bit(NILFS_I_DIRTY, &ii->i_state)) 918 return 0; 919 920 spin_lock(&nilfs->ns_inode_lock); 921 if (!test_bit(NILFS_I_QUEUED, &ii->i_state) && 922 !test_bit(NILFS_I_BUSY, &ii->i_state)) { 923 /* Because this routine may race with nilfs_dispose_list(), 924 we have to check NILFS_I_QUEUED here, too. */ 925 if (list_empty(&ii->i_dirty) && igrab(inode) == NULL) { 926 /* This will happen when somebody is freeing 927 this inode. */ 928 nilfs_warning(inode->i_sb, __func__, 929 "cannot get inode (ino=%lu)\n", 930 inode->i_ino); 931 spin_unlock(&nilfs->ns_inode_lock); 932 return -EINVAL; /* NILFS_I_DIRTY may remain for 933 freeing inode */ 934 } 935 list_move_tail(&ii->i_dirty, &nilfs->ns_dirty_files); 936 set_bit(NILFS_I_QUEUED, &ii->i_state); 937 } 938 spin_unlock(&nilfs->ns_inode_lock); 939 return 0; 940 } 941 942 int nilfs_mark_inode_dirty(struct inode *inode) 943 { 944 struct buffer_head *ibh; 945 int err; 946 947 err = nilfs_load_inode_block(inode, &ibh); 948 if (unlikely(err)) { 949 nilfs_warning(inode->i_sb, __func__, 950 "failed to reget inode block.\n"); 951 return err; 952 } 953 nilfs_update_inode(inode, ibh); 954 mark_buffer_dirty(ibh); 955 nilfs_mdt_mark_dirty(NILFS_I(inode)->i_root->ifile); 956 brelse(ibh); 957 return 0; 958 } 959 960 /** 961 * nilfs_dirty_inode - reflect changes on given inode to an inode block. 962 * @inode: inode of the file to be registered. 963 * 964 * nilfs_dirty_inode() loads a inode block containing the specified 965 * @inode and copies data from a nilfs_inode to a corresponding inode 966 * entry in the inode block. This operation is excluded from the segment 967 * construction. This function can be called both as a single operation 968 * and as a part of indivisible file operations. 969 */ 970 void nilfs_dirty_inode(struct inode *inode, int flags) 971 { 972 struct nilfs_transaction_info ti; 973 struct nilfs_mdt_info *mdi = NILFS_MDT(inode); 974 975 if (is_bad_inode(inode)) { 976 nilfs_warning(inode->i_sb, __func__, 977 "tried to mark bad_inode dirty. ignored.\n"); 978 dump_stack(); 979 return; 980 } 981 if (mdi) { 982 nilfs_mdt_mark_dirty(inode); 983 return; 984 } 985 nilfs_transaction_begin(inode->i_sb, &ti, 0); 986 nilfs_mark_inode_dirty(inode); 987 nilfs_transaction_commit(inode->i_sb); /* never fails */ 988 } 989 990 int nilfs_fiemap(struct inode *inode, struct fiemap_extent_info *fieinfo, 991 __u64 start, __u64 len) 992 { 993 struct the_nilfs *nilfs = inode->i_sb->s_fs_info; 994 __u64 logical = 0, phys = 0, size = 0; 995 __u32 flags = 0; 996 loff_t isize; 997 sector_t blkoff, end_blkoff; 998 sector_t delalloc_blkoff; 999 unsigned long delalloc_blklen; 1000 unsigned int blkbits = inode->i_blkbits; 1001 int ret, n; 1002 1003 ret = fiemap_check_flags(fieinfo, FIEMAP_FLAG_SYNC); 1004 if (ret) 1005 return ret; 1006 1007 mutex_lock(&inode->i_mutex); 1008 1009 isize = i_size_read(inode); 1010 1011 blkoff = start >> blkbits; 1012 end_blkoff = (start + len - 1) >> blkbits; 1013 1014 delalloc_blklen = nilfs_find_uncommitted_extent(inode, blkoff, 1015 &delalloc_blkoff); 1016 1017 do { 1018 __u64 blkphy; 1019 unsigned int maxblocks; 1020 1021 if (delalloc_blklen && blkoff == delalloc_blkoff) { 1022 if (size) { 1023 /* End of the current extent */ 1024 ret = fiemap_fill_next_extent( 1025 fieinfo, logical, phys, size, flags); 1026 if (ret) 1027 break; 1028 } 1029 if (blkoff > end_blkoff) 1030 break; 1031 1032 flags = FIEMAP_EXTENT_MERGED | FIEMAP_EXTENT_DELALLOC; 1033 logical = blkoff << blkbits; 1034 phys = 0; 1035 size = delalloc_blklen << blkbits; 1036 1037 blkoff = delalloc_blkoff + delalloc_blklen; 1038 delalloc_blklen = nilfs_find_uncommitted_extent( 1039 inode, blkoff, &delalloc_blkoff); 1040 continue; 1041 } 1042 1043 /* 1044 * Limit the number of blocks that we look up so as 1045 * not to get into the next delayed allocation extent. 1046 */ 1047 maxblocks = INT_MAX; 1048 if (delalloc_blklen) 1049 maxblocks = min_t(sector_t, delalloc_blkoff - blkoff, 1050 maxblocks); 1051 blkphy = 0; 1052 1053 down_read(&NILFS_MDT(nilfs->ns_dat)->mi_sem); 1054 n = nilfs_bmap_lookup_contig( 1055 NILFS_I(inode)->i_bmap, blkoff, &blkphy, maxblocks); 1056 up_read(&NILFS_MDT(nilfs->ns_dat)->mi_sem); 1057 1058 if (n < 0) { 1059 int past_eof; 1060 1061 if (unlikely(n != -ENOENT)) 1062 break; /* error */ 1063 1064 /* HOLE */ 1065 blkoff++; 1066 past_eof = ((blkoff << blkbits) >= isize); 1067 1068 if (size) { 1069 /* End of the current extent */ 1070 1071 if (past_eof) 1072 flags |= FIEMAP_EXTENT_LAST; 1073 1074 ret = fiemap_fill_next_extent( 1075 fieinfo, logical, phys, size, flags); 1076 if (ret) 1077 break; 1078 size = 0; 1079 } 1080 if (blkoff > end_blkoff || past_eof) 1081 break; 1082 } else { 1083 if (size) { 1084 if (phys && blkphy << blkbits == phys + size) { 1085 /* The current extent goes on */ 1086 size += n << blkbits; 1087 } else { 1088 /* Terminate the current extent */ 1089 ret = fiemap_fill_next_extent( 1090 fieinfo, logical, phys, size, 1091 flags); 1092 if (ret || blkoff > end_blkoff) 1093 break; 1094 1095 /* Start another extent */ 1096 flags = FIEMAP_EXTENT_MERGED; 1097 logical = blkoff << blkbits; 1098 phys = blkphy << blkbits; 1099 size = n << blkbits; 1100 } 1101 } else { 1102 /* Start a new extent */ 1103 flags = FIEMAP_EXTENT_MERGED; 1104 logical = blkoff << blkbits; 1105 phys = blkphy << blkbits; 1106 size = n << blkbits; 1107 } 1108 blkoff += n; 1109 } 1110 cond_resched(); 1111 } while (true); 1112 1113 /* If ret is 1 then we just hit the end of the extent array */ 1114 if (ret == 1) 1115 ret = 0; 1116 1117 mutex_unlock(&inode->i_mutex); 1118 return ret; 1119 } 1120