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