2 * inode.c - NILFS inode operations.
4 * Copyright (C) 2005-2008 Nippon Telegraph and Telephone Corporation.
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.
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.
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
20 * Written by Ryusuke Konishi <ryusuke@osrg.net>
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>
37 struct nilfs_iget_args
{
40 struct nilfs_root
*root
;
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
52 * This function does not issue actual read request of the specified data
53 * block. It is done by VFS.
55 int nilfs_get_block(struct inode
*inode
, sector_t blkoff
,
56 struct buffer_head
*bh_result
, int create
)
58 struct nilfs_inode_info
*ii
= NILFS_I(inode
);
61 struct inode
*dat
= nilfs_dat_inode(NILFS_I_NILFS(inode
));
62 unsigned maxblocks
= bh_result
->b_size
>> inode
->i_blkbits
;
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
);
70 bh_result
->b_size
= (ret
<< inode
->i_blkbits
);
73 /* data block was not found */
74 if (ret
== -ENOENT
&& create
) {
75 struct nilfs_transaction_info ti
;
77 bh_result
->b_blocknr
= 0;
78 err
= nilfs_transaction_begin(inode
->i_sb
, &ti
, 1);
81 err
= nilfs_bmap_insert(ii
->i_bmap
, (unsigned long)blkoff
,
82 (unsigned long)bh_result
);
83 if (unlikely(err
!= 0)) {
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.
92 "nilfs_get_block: a race condition "
93 "while inserting a data block. "
94 "(inode number=%lu, file block "
97 (unsigned long long)blkoff
);
99 } else if (err
== -EINVAL
) {
100 nilfs_error(inode
->i_sb
, __func__
,
101 "broken bmap (inode=%lu)\n",
105 nilfs_transaction_abort(inode
->i_sb
);
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
114 } else if (ret
== -ENOENT
) {
115 /* not found is not error (e.g. hole); must return without
116 the mapped state flag. */
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
132 static int nilfs_readpage(struct file
*file
, struct page
*page
)
134 return mpage_readpage(page
, nilfs_get_block
);
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
145 static int nilfs_readpages(struct file
*file
, struct address_space
*mapping
,
146 struct list_head
*pages
, unsigned nr_pages
)
148 return mpage_readpages(mapping
, pages
, nr_pages
, nilfs_get_block
);
151 static int nilfs_writepages(struct address_space
*mapping
,
152 struct writeback_control
*wbc
)
154 struct inode
*inode
= mapping
->host
;
157 if (wbc
->sync_mode
== WB_SYNC_ALL
)
158 err
= nilfs_construct_dsync_segment(inode
->i_sb
, inode
,
164 static int nilfs_writepage(struct page
*page
, struct writeback_control
*wbc
)
166 struct inode
*inode
= page
->mapping
->host
;
169 redirty_page_for_writepage(wbc
, page
);
172 if (wbc
->sync_mode
== WB_SYNC_ALL
) {
173 err
= nilfs_construct_segment(inode
->i_sb
);
176 } else if (wbc
->for_reclaim
)
177 nilfs_flush_segment(inode
->i_sb
, inode
->i_ino
);
182 static int nilfs_set_page_dirty(struct page
*page
)
184 int ret
= __set_page_dirty_buffers(page
);
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
);
191 nilfs_set_file_dirty(sbi
, inode
, nr_dirty
);
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
)
201 struct inode
*inode
= mapping
->host
;
202 int err
= nilfs_transaction_begin(inode
->i_sb
, NULL
, 1);
207 err
= block_write_begin(mapping
, pos
, len
, flags
, pagep
,
210 loff_t isize
= mapping
->host
->i_size
;
211 if (pos
+ len
> isize
)
212 vmtruncate(mapping
->host
, isize
);
214 nilfs_transaction_abort(inode
->i_sb
);
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
)
223 struct inode
*inode
= mapping
->host
;
224 unsigned start
= pos
& (PAGE_CACHE_SIZE
- 1);
228 nr_dirty
= nilfs_page_count_clean_buffers(page
, start
,
230 copied
= generic_write_end(file
, mapping
, pos
, len
, copied
, page
,
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
;
238 nilfs_direct_IO(int rw
, struct kiocb
*iocb
, const struct iovec
*iov
,
239 loff_t offset
, unsigned long nr_segs
)
241 struct file
*file
= iocb
->ki_filp
;
242 struct inode
*inode
= file
->f_mapping
->host
;
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
);
253 * In case of error extending write may have instantiated a few
254 * blocks outside i_size. Trim these off again.
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
);
261 vmtruncate(inode
, isize
);
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
,
282 struct inode
*nilfs_new_inode(struct inode
*dir
, int mode
)
284 struct super_block
*sb
= dir
->i_sb
;
285 struct nilfs_sb_info
*sbi
= NILFS_SB(sb
);
287 struct nilfs_inode_info
*ii
;
288 struct nilfs_root
*root
;
292 inode
= new_inode(sb
);
293 if (unlikely(!inode
))
296 mapping_set_gfp_mask(inode
->i_mapping
,
297 mapping_gfp_mask(inode
->i_mapping
) & ~__GFP_FS
);
299 root
= NILFS_I(dir
)->i_root
;
301 ii
->i_state
= 1 << NILFS_I_NEW
;
304 err
= nilfs_ifile_create_inode(root
->ifile
, &ino
, &ii
->i_bh
);
306 goto failed_ifile_create_inode
;
307 /* reference count of i_bh inherits from nilfs_mdt_read_block() */
309 atomic_inc(&root
->inodes_count
);
310 inode_init_owner(inode
, dir
, mode
);
312 inode
->i_mtime
= inode
->i_atime
= inode
->i_ctime
= CURRENT_TIME
;
314 if (S_ISREG(mode
) || S_ISDIR(mode
) || S_ISLNK(mode
)) {
315 err
= nilfs_bmap_read(ii
->i_bmap
, NULL
);
319 set_bit(NILFS_I_BMAP
, &ii
->i_state
);
320 /* No lock is needed; iget() ensures it. */
323 ii
->i_flags
= NILFS_I(dir
)->i_flags
;
325 ii
->i_flags
&= ~(NILFS_IMMUTABLE_FL
| NILFS_APPEND_FL
);
327 ii
->i_flags
&= ~NILFS_DIRSYNC_FL
;
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
);
338 err
= nilfs_init_acl(inode
, dir
);
340 goto failed_acl
; /* never occur. When supporting
341 nilfs_init_acl(), proper cancellation of
342 above jobs should be considered */
349 iput(inode
); /* raw_inode will be deleted through
350 generic_delete_inode() */
353 failed_ifile_create_inode
:
354 make_bad_inode(inode
);
355 iput(inode
); /* if i_nlink == 1, generic_forget_inode() will be
361 void nilfs_set_inode_flags(struct inode
*inode
)
363 unsigned int flags
= NILFS_I(inode
)->i_flags
;
365 inode
->i_flags
&= ~(S_SYNC
| S_APPEND
| S_IMMUTABLE
| S_NOATIME
|
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
)
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
);
383 int nilfs_read_inode_common(struct inode
*inode
,
384 struct nilfs_inode
*raw_inode
)
386 struct nilfs_inode_info
*ii
= NILFS_I(inode
);
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 */
403 inode
->i_blocks
= le64_to_cpu(raw_inode
->i_blocks
);
404 ii
->i_flags
= le32_to_cpu(raw_inode
->i_flags
);
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
);
410 ii
->i_dir_start_lookup
= 0;
411 inode
->i_generation
= le32_to_cpu(raw_inode
->i_generation
);
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
);
418 set_bit(NILFS_I_BMAP
, &ii
->i_state
);
419 /* No lock is needed; iget() ensures it. */
424 static int __nilfs_read_inode(struct super_block
*sb
,
425 struct nilfs_root
*root
, unsigned long ino
,
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
;
434 down_read(&NILFS_MDT(dat
)->mi_sem
); /* XXX */
435 err
= nilfs_ifile_get_inode_block(root
->ifile
, ino
, &bh
);
439 raw_inode
= nilfs_ifile_map_inode(root
->ifile
, ino
, bh
);
441 err
= nilfs_read_inode_common(inode
, raw_inode
);
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
;
457 inode
->i_op
= &nilfs_special_inode_operations
;
459 inode
, inode
->i_mode
,
460 huge_decode_dev(le64_to_cpu(raw_inode
->i_device_code
)));
462 nilfs_ifile_unmap_inode(root
->ifile
, ino
, bh
);
464 up_read(&NILFS_MDT(dat
)->mi_sem
); /* XXX */
465 nilfs_set_inode_flags(inode
);
469 nilfs_ifile_unmap_inode(root
->ifile
, ino
, bh
);
473 up_read(&NILFS_MDT(dat
)->mi_sem
); /* XXX */
477 static int nilfs_iget_test(struct inode
*inode
, void *opaque
)
479 struct nilfs_iget_args
*args
= opaque
;
480 struct nilfs_inode_info
*ii
;
482 if (args
->ino
!= inode
->i_ino
|| args
->root
!= NILFS_I(inode
)->i_root
)
486 if (!test_bit(NILFS_I_GCINODE
, &ii
->i_state
))
487 return !args
->for_gc
;
489 return args
->for_gc
&& args
->cno
== ii
->i_cno
;
492 static int nilfs_iget_set(struct inode
*inode
, void *opaque
)
494 struct nilfs_iget_args
*args
= opaque
;
496 inode
->i_ino
= args
->ino
;
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
;
502 if (args
->root
&& args
->ino
== NILFS_ROOT_INO
)
503 nilfs_get_root(args
->root
);
504 NILFS_I(inode
)->i_root
= args
->root
;
509 struct inode
*nilfs_ilookup(struct super_block
*sb
, struct nilfs_root
*root
,
512 struct nilfs_iget_args args
= {
513 .ino
= ino
, .root
= root
, .cno
= 0, .for_gc
= 0
516 return ilookup5(sb
, ino
, nilfs_iget_test
, &args
);
519 struct inode
*nilfs_iget_locked(struct super_block
*sb
, struct nilfs_root
*root
,
522 struct nilfs_iget_args args
= {
523 .ino
= ino
, .root
= root
, .cno
= 0, .for_gc
= 0
526 return iget5_locked(sb
, ino
, nilfs_iget_test
, nilfs_iget_set
, &args
);
529 struct inode
*nilfs_iget(struct super_block
*sb
, struct nilfs_root
*root
,
535 inode
= nilfs_iget_locked(sb
, root
, ino
);
536 if (unlikely(!inode
))
537 return ERR_PTR(-ENOMEM
);
538 if (!(inode
->i_state
& I_NEW
))
541 err
= __nilfs_read_inode(sb
, root
, ino
, inode
);
546 unlock_new_inode(inode
);
550 struct inode
*nilfs_iget_for_gc(struct super_block
*sb
, unsigned long ino
,
553 struct nilfs_iget_args args
= {
554 .ino
= ino
, .root
= NULL
, .cno
= cno
, .for_gc
= 1
559 inode
= iget5_locked(sb
, ino
, nilfs_iget_test
, nilfs_iget_set
, &args
);
560 if (unlikely(!inode
))
561 return ERR_PTR(-ENOMEM
);
562 if (!(inode
->i_state
& I_NEW
))
565 err
= nilfs_init_gcinode(inode
);
570 unlock_new_inode(inode
);
574 void nilfs_write_inode_common(struct inode
*inode
,
575 struct nilfs_inode
*raw_inode
, int has_bmap
)
577 struct nilfs_inode_info
*ii
= NILFS_I(inode
);
579 raw_inode
->i_mode
= cpu_to_le16(inode
->i_mode
);
580 raw_inode
->i_uid
= cpu_to_le32(inode
->i_uid
);
581 raw_inode
->i_gid
= cpu_to_le32(inode
->i_gid
);
582 raw_inode
->i_links_count
= cpu_to_le16(inode
->i_nlink
);
583 raw_inode
->i_size
= cpu_to_le64(inode
->i_size
);
584 raw_inode
->i_ctime
= cpu_to_le64(inode
->i_ctime
.tv_sec
);
585 raw_inode
->i_mtime
= cpu_to_le64(inode
->i_mtime
.tv_sec
);
586 raw_inode
->i_ctime_nsec
= cpu_to_le32(inode
->i_ctime
.tv_nsec
);
587 raw_inode
->i_mtime_nsec
= cpu_to_le32(inode
->i_mtime
.tv_nsec
);
588 raw_inode
->i_blocks
= cpu_to_le64(inode
->i_blocks
);
590 raw_inode
->i_flags
= cpu_to_le32(ii
->i_flags
);
591 raw_inode
->i_generation
= cpu_to_le32(inode
->i_generation
);
594 nilfs_bmap_write(ii
->i_bmap
, raw_inode
);
595 else if (S_ISCHR(inode
->i_mode
) || S_ISBLK(inode
->i_mode
))
596 raw_inode
->i_device_code
=
597 cpu_to_le64(huge_encode_dev(inode
->i_rdev
));
598 /* When extending inode, nilfs->ns_inode_size should be checked
599 for substitutions of appended fields */
602 void nilfs_update_inode(struct inode
*inode
, struct buffer_head
*ibh
)
604 ino_t ino
= inode
->i_ino
;
605 struct nilfs_inode_info
*ii
= NILFS_I(inode
);
606 struct inode
*ifile
= ii
->i_root
->ifile
;
607 struct nilfs_inode
*raw_inode
;
609 raw_inode
= nilfs_ifile_map_inode(ifile
, ino
, ibh
);
611 if (test_and_clear_bit(NILFS_I_NEW
, &ii
->i_state
))
612 memset(raw_inode
, 0, NILFS_MDT(ifile
)->mi_entry_size
);
613 set_bit(NILFS_I_INODE_DIRTY
, &ii
->i_state
);
615 nilfs_write_inode_common(inode
, raw_inode
, 0);
616 /* XXX: call with has_bmap = 0 is a workaround to avoid
617 deadlock of bmap. This delays update of i_bmap to just
619 nilfs_ifile_unmap_inode(ifile
, ino
, ibh
);
622 #define NILFS_MAX_TRUNCATE_BLOCKS 16384 /* 64MB for 4KB block */
624 static void nilfs_truncate_bmap(struct nilfs_inode_info
*ii
,
630 if (!test_bit(NILFS_I_BMAP
, &ii
->i_state
))
633 ret
= nilfs_bmap_last_key(ii
->i_bmap
, &b
);
642 b
-= min_t(unsigned long, NILFS_MAX_TRUNCATE_BLOCKS
, b
- from
);
643 ret
= nilfs_bmap_truncate(ii
->i_bmap
, b
);
644 nilfs_relax_pressure_in_lock(ii
->vfs_inode
.i_sb
);
645 if (!ret
|| (ret
== -ENOMEM
&&
646 nilfs_bmap_truncate(ii
->i_bmap
, b
) == 0))
651 nilfs_error(ii
->vfs_inode
.i_sb
, __func__
,
652 "bmap is broken (ino=%lu)", ii
->vfs_inode
.i_ino
);
654 nilfs_warning(ii
->vfs_inode
.i_sb
, __func__
,
655 "failed to truncate bmap (ino=%lu, err=%d)",
656 ii
->vfs_inode
.i_ino
, ret
);
659 void nilfs_truncate(struct inode
*inode
)
661 unsigned long blkoff
;
662 unsigned int blocksize
;
663 struct nilfs_transaction_info ti
;
664 struct super_block
*sb
= inode
->i_sb
;
665 struct nilfs_inode_info
*ii
= NILFS_I(inode
);
667 if (!test_bit(NILFS_I_BMAP
, &ii
->i_state
))
669 if (IS_APPEND(inode
) || IS_IMMUTABLE(inode
))
672 blocksize
= sb
->s_blocksize
;
673 blkoff
= (inode
->i_size
+ blocksize
- 1) >> sb
->s_blocksize_bits
;
674 nilfs_transaction_begin(sb
, &ti
, 0); /* never fails */
676 block_truncate_page(inode
->i_mapping
, inode
->i_size
, nilfs_get_block
);
678 nilfs_truncate_bmap(ii
, blkoff
);
680 inode
->i_mtime
= inode
->i_ctime
= CURRENT_TIME
;
682 nilfs_set_transaction_flag(NILFS_TI_SYNC
);
684 nilfs_mark_inode_dirty(inode
);
685 nilfs_set_file_dirty(NILFS_SB(sb
), inode
, 0);
686 nilfs_transaction_commit(sb
);
687 /* May construct a logical segment and may fail in sync mode.
688 But truncate has no return value. */
691 static void nilfs_clear_inode(struct inode
*inode
)
693 struct nilfs_inode_info
*ii
= NILFS_I(inode
);
694 struct nilfs_mdt_info
*mdi
= NILFS_MDT(inode
);
697 * Free resources allocated in nilfs_read_inode(), here.
699 BUG_ON(!list_empty(&ii
->i_dirty
));
703 if (mdi
&& mdi
->mi_palloc_cache
)
704 nilfs_palloc_destroy_cache(inode
);
706 if (test_bit(NILFS_I_BMAP
, &ii
->i_state
))
707 nilfs_bmap_clear(ii
->i_bmap
);
709 nilfs_btnode_cache_clear(&ii
->i_btnode_cache
);
711 if (ii
->i_root
&& inode
->i_ino
== NILFS_ROOT_INO
)
712 nilfs_put_root(ii
->i_root
);
715 void nilfs_evict_inode(struct inode
*inode
)
717 struct nilfs_transaction_info ti
;
718 struct super_block
*sb
= inode
->i_sb
;
719 struct nilfs_inode_info
*ii
= NILFS_I(inode
);
721 if (inode
->i_nlink
|| !ii
->i_root
|| unlikely(is_bad_inode(inode
))) {
722 if (inode
->i_data
.nrpages
)
723 truncate_inode_pages(&inode
->i_data
, 0);
724 end_writeback(inode
);
725 nilfs_clear_inode(inode
);
728 nilfs_transaction_begin(sb
, &ti
, 0); /* never fails */
730 if (inode
->i_data
.nrpages
)
731 truncate_inode_pages(&inode
->i_data
, 0);
733 /* TODO: some of the following operations may fail. */
734 nilfs_truncate_bmap(ii
, 0);
735 nilfs_mark_inode_dirty(inode
);
736 end_writeback(inode
);
738 nilfs_ifile_delete_inode(ii
->i_root
->ifile
, inode
->i_ino
);
739 atomic_dec(&ii
->i_root
->inodes_count
);
741 nilfs_clear_inode(inode
);
744 nilfs_set_transaction_flag(NILFS_TI_SYNC
);
745 nilfs_transaction_commit(sb
);
746 /* May construct a logical segment and may fail in sync mode.
747 But delete_inode has no return value. */
750 int nilfs_setattr(struct dentry
*dentry
, struct iattr
*iattr
)
752 struct nilfs_transaction_info ti
;
753 struct inode
*inode
= dentry
->d_inode
;
754 struct super_block
*sb
= inode
->i_sb
;
757 err
= inode_change_ok(inode
, iattr
);
761 err
= nilfs_transaction_begin(sb
, &ti
, 0);
765 if ((iattr
->ia_valid
& ATTR_SIZE
) &&
766 iattr
->ia_size
!= i_size_read(inode
)) {
767 err
= vmtruncate(inode
, iattr
->ia_size
);
772 setattr_copy(inode
, iattr
);
773 mark_inode_dirty(inode
);
775 if (iattr
->ia_valid
& ATTR_MODE
) {
776 err
= nilfs_acl_chmod(inode
);
781 return nilfs_transaction_commit(sb
);
784 nilfs_transaction_abort(sb
);
788 int nilfs_permission(struct inode
*inode
, int mask
, unsigned int flags
)
790 struct nilfs_root
*root
;
792 if (flags
& IPERM_FLAG_RCU
)
795 root
= NILFS_I(inode
)->i_root
;
796 if ((mask
& MAY_WRITE
) && root
&&
797 root
->cno
!= NILFS_CPTREE_CURRENT_CNO
)
798 return -EROFS
; /* snapshot is not writable */
800 return generic_permission(inode
, mask
, flags
, NULL
);
803 int nilfs_load_inode_block(struct nilfs_sb_info
*sbi
, struct inode
*inode
,
804 struct buffer_head
**pbh
)
806 struct nilfs_inode_info
*ii
= NILFS_I(inode
);
809 spin_lock(&sbi
->s_inode_lock
);
810 if (ii
->i_bh
== NULL
) {
811 spin_unlock(&sbi
->s_inode_lock
);
812 err
= nilfs_ifile_get_inode_block(ii
->i_root
->ifile
,
816 spin_lock(&sbi
->s_inode_lock
);
817 if (ii
->i_bh
== NULL
)
827 spin_unlock(&sbi
->s_inode_lock
);
831 int nilfs_inode_dirty(struct inode
*inode
)
833 struct nilfs_inode_info
*ii
= NILFS_I(inode
);
834 struct nilfs_sb_info
*sbi
= NILFS_SB(inode
->i_sb
);
837 if (!list_empty(&ii
->i_dirty
)) {
838 spin_lock(&sbi
->s_inode_lock
);
839 ret
= test_bit(NILFS_I_DIRTY
, &ii
->i_state
) ||
840 test_bit(NILFS_I_BUSY
, &ii
->i_state
);
841 spin_unlock(&sbi
->s_inode_lock
);
846 int nilfs_set_file_dirty(struct nilfs_sb_info
*sbi
, struct inode
*inode
,
849 struct nilfs_inode_info
*ii
= NILFS_I(inode
);
851 atomic_add(nr_dirty
, &sbi
->s_nilfs
->ns_ndirtyblks
);
853 if (test_and_set_bit(NILFS_I_DIRTY
, &ii
->i_state
))
856 spin_lock(&sbi
->s_inode_lock
);
857 if (!test_bit(NILFS_I_QUEUED
, &ii
->i_state
) &&
858 !test_bit(NILFS_I_BUSY
, &ii
->i_state
)) {
859 /* Because this routine may race with nilfs_dispose_list(),
860 we have to check NILFS_I_QUEUED here, too. */
861 if (list_empty(&ii
->i_dirty
) && igrab(inode
) == NULL
) {
862 /* This will happen when somebody is freeing
864 nilfs_warning(sbi
->s_super
, __func__
,
865 "cannot get inode (ino=%lu)\n",
867 spin_unlock(&sbi
->s_inode_lock
);
868 return -EINVAL
; /* NILFS_I_DIRTY may remain for
871 list_del(&ii
->i_dirty
);
872 list_add_tail(&ii
->i_dirty
, &sbi
->s_dirty_files
);
873 set_bit(NILFS_I_QUEUED
, &ii
->i_state
);
875 spin_unlock(&sbi
->s_inode_lock
);
879 int nilfs_mark_inode_dirty(struct inode
*inode
)
881 struct nilfs_sb_info
*sbi
= NILFS_SB(inode
->i_sb
);
882 struct buffer_head
*ibh
;
885 err
= nilfs_load_inode_block(sbi
, inode
, &ibh
);
887 nilfs_warning(inode
->i_sb
, __func__
,
888 "failed to reget inode block.\n");
891 nilfs_update_inode(inode
, ibh
);
892 nilfs_mdt_mark_buffer_dirty(ibh
);
893 nilfs_mdt_mark_dirty(NILFS_I(inode
)->i_root
->ifile
);
899 * nilfs_dirty_inode - reflect changes on given inode to an inode block.
900 * @inode: inode of the file to be registered.
902 * nilfs_dirty_inode() loads a inode block containing the specified
903 * @inode and copies data from a nilfs_inode to a corresponding inode
904 * entry in the inode block. This operation is excluded from the segment
905 * construction. This function can be called both as a single operation
906 * and as a part of indivisible file operations.
908 void nilfs_dirty_inode(struct inode
*inode
)
910 struct nilfs_transaction_info ti
;
911 struct nilfs_mdt_info
*mdi
= NILFS_MDT(inode
);
913 if (is_bad_inode(inode
)) {
914 nilfs_warning(inode
->i_sb
, __func__
,
915 "tried to mark bad_inode dirty. ignored.\n");
920 nilfs_mdt_mark_dirty(inode
);
923 nilfs_transaction_begin(inode
->i_sb
, &ti
, 0);
924 nilfs_mark_inode_dirty(inode
);
925 nilfs_transaction_commit(inode
->i_sb
); /* never fails */