1 // SPDX-License-Identifier: GPL-2.0
5 * Copyright (c) 2012 Samsung Electronics Co., Ltd.
6 * http://www.samsung.com/
9 #include <linux/f2fs_fs.h>
10 #include <linux/buffer_head.h>
11 #include <linux/backing-dev.h>
12 #include <linux/writeback.h>
19 #include <trace/events/f2fs.h>
21 void f2fs_mark_inode_dirty_sync(struct inode
*inode
, bool sync
)
23 if (is_inode_flag_set(inode
, FI_NEW_INODE
))
26 if (f2fs_inode_dirtied(inode
, sync
))
29 mark_inode_dirty_sync(inode
);
32 void f2fs_set_inode_flags(struct inode
*inode
)
34 unsigned int flags
= F2FS_I(inode
)->i_flags
;
35 unsigned int new_fl
= 0;
37 if (flags
& F2FS_SYNC_FL
)
39 if (flags
& F2FS_APPEND_FL
)
41 if (flags
& F2FS_IMMUTABLE_FL
)
42 new_fl
|= S_IMMUTABLE
;
43 if (flags
& F2FS_NOATIME_FL
)
45 if (flags
& F2FS_DIRSYNC_FL
)
47 if (file_is_encrypt(inode
))
48 new_fl
|= S_ENCRYPTED
;
49 if (file_is_verity(inode
))
51 if (flags
& F2FS_CASEFOLD_FL
)
53 inode_set_flags(inode
, new_fl
,
54 S_SYNC
|S_APPEND
|S_IMMUTABLE
|S_NOATIME
|S_DIRSYNC
|
55 S_ENCRYPTED
|S_VERITY
|S_CASEFOLD
);
58 static void __get_inode_rdev(struct inode
*inode
, struct f2fs_inode
*ri
)
60 int extra_size
= get_extra_isize(inode
);
62 if (S_ISCHR(inode
->i_mode
) || S_ISBLK(inode
->i_mode
) ||
63 S_ISFIFO(inode
->i_mode
) || S_ISSOCK(inode
->i_mode
)) {
64 if (ri
->i_addr
[extra_size
])
65 inode
->i_rdev
= old_decode_dev(
66 le32_to_cpu(ri
->i_addr
[extra_size
]));
68 inode
->i_rdev
= new_decode_dev(
69 le32_to_cpu(ri
->i_addr
[extra_size
+ 1]));
73 static int __written_first_block(struct f2fs_sb_info
*sbi
,
74 struct f2fs_inode
*ri
)
76 block_t addr
= le32_to_cpu(ri
->i_addr
[offset_in_addr(ri
)]);
78 if (!__is_valid_data_blkaddr(addr
))
80 if (!f2fs_is_valid_blkaddr(sbi
, addr
, DATA_GENERIC_ENHANCE
))
85 static void __set_inode_rdev(struct inode
*inode
, struct f2fs_inode
*ri
)
87 int extra_size
= get_extra_isize(inode
);
89 if (S_ISCHR(inode
->i_mode
) || S_ISBLK(inode
->i_mode
)) {
90 if (old_valid_dev(inode
->i_rdev
)) {
91 ri
->i_addr
[extra_size
] =
92 cpu_to_le32(old_encode_dev(inode
->i_rdev
));
93 ri
->i_addr
[extra_size
+ 1] = 0;
95 ri
->i_addr
[extra_size
] = 0;
96 ri
->i_addr
[extra_size
+ 1] =
97 cpu_to_le32(new_encode_dev(inode
->i_rdev
));
98 ri
->i_addr
[extra_size
+ 2] = 0;
103 static void __recover_inline_status(struct inode
*inode
, struct page
*ipage
)
105 void *inline_data
= inline_data_addr(inode
, ipage
);
106 __le32
*start
= inline_data
;
107 __le32
*end
= start
+ MAX_INLINE_DATA(inode
) / sizeof(__le32
);
109 while (start
< end
) {
111 f2fs_wait_on_page_writeback(ipage
, NODE
, true, true);
113 set_inode_flag(inode
, FI_DATA_EXIST
);
114 set_raw_inline(inode
, F2FS_INODE(ipage
));
115 set_page_dirty(ipage
);
122 static bool f2fs_enable_inode_chksum(struct f2fs_sb_info
*sbi
, struct page
*page
)
124 struct f2fs_inode
*ri
= &F2FS_NODE(page
)->i
;
126 if (!f2fs_sb_has_inode_chksum(sbi
))
129 if (!IS_INODE(page
) || !(ri
->i_inline
& F2FS_EXTRA_ATTR
))
132 if (!F2FS_FITS_IN_INODE(ri
, le16_to_cpu(ri
->i_extra_isize
),
139 static __u32
f2fs_inode_chksum(struct f2fs_sb_info
*sbi
, struct page
*page
)
141 struct f2fs_node
*node
= F2FS_NODE(page
);
142 struct f2fs_inode
*ri
= &node
->i
;
143 __le32 ino
= node
->footer
.ino
;
144 __le32 gen
= ri
->i_generation
;
145 __u32 chksum
, chksum_seed
;
147 unsigned int offset
= offsetof(struct f2fs_inode
, i_inode_checksum
);
148 unsigned int cs_size
= sizeof(dummy_cs
);
150 chksum
= f2fs_chksum(sbi
, sbi
->s_chksum_seed
, (__u8
*)&ino
,
152 chksum_seed
= f2fs_chksum(sbi
, chksum
, (__u8
*)&gen
, sizeof(gen
));
154 chksum
= f2fs_chksum(sbi
, chksum_seed
, (__u8
*)ri
, offset
);
155 chksum
= f2fs_chksum(sbi
, chksum
, (__u8
*)&dummy_cs
, cs_size
);
157 chksum
= f2fs_chksum(sbi
, chksum
, (__u8
*)ri
+ offset
,
158 F2FS_BLKSIZE
- offset
);
162 bool f2fs_inode_chksum_verify(struct f2fs_sb_info
*sbi
, struct page
*page
)
164 struct f2fs_inode
*ri
;
165 __u32 provided
, calculated
;
167 if (unlikely(is_sbi_flag_set(sbi
, SBI_IS_SHUTDOWN
)))
170 #ifdef CONFIG_F2FS_CHECK_FS
171 if (!f2fs_enable_inode_chksum(sbi
, page
))
173 if (!f2fs_enable_inode_chksum(sbi
, page
) ||
174 PageDirty(page
) || PageWriteback(page
))
178 ri
= &F2FS_NODE(page
)->i
;
179 provided
= le32_to_cpu(ri
->i_inode_checksum
);
180 calculated
= f2fs_inode_chksum(sbi
, page
);
182 if (provided
!= calculated
)
183 f2fs_warn(sbi
, "checksum invalid, nid = %lu, ino_of_node = %x, %x vs. %x",
184 page
->index
, ino_of_node(page
), provided
, calculated
);
186 return provided
== calculated
;
189 void f2fs_inode_chksum_set(struct f2fs_sb_info
*sbi
, struct page
*page
)
191 struct f2fs_inode
*ri
= &F2FS_NODE(page
)->i
;
193 if (!f2fs_enable_inode_chksum(sbi
, page
))
196 ri
->i_inode_checksum
= cpu_to_le32(f2fs_inode_chksum(sbi
, page
));
199 static bool sanity_check_inode(struct inode
*inode
, struct page
*node_page
)
201 struct f2fs_sb_info
*sbi
= F2FS_I_SB(inode
);
202 struct f2fs_inode_info
*fi
= F2FS_I(inode
);
203 struct f2fs_inode
*ri
= F2FS_INODE(node_page
);
204 unsigned long long iblocks
;
206 iblocks
= le64_to_cpu(F2FS_INODE(node_page
)->i_blocks
);
208 set_sbi_flag(sbi
, SBI_NEED_FSCK
);
209 f2fs_warn(sbi
, "%s: corrupted inode i_blocks i_ino=%lx iblocks=%llu, run fsck to fix.",
210 __func__
, inode
->i_ino
, iblocks
);
214 if (ino_of_node(node_page
) != nid_of_node(node_page
)) {
215 set_sbi_flag(sbi
, SBI_NEED_FSCK
);
216 f2fs_warn(sbi
, "%s: corrupted inode footer i_ino=%lx, ino,nid: [%u, %u] run fsck to fix.",
217 __func__
, inode
->i_ino
,
218 ino_of_node(node_page
), nid_of_node(node_page
));
222 if (f2fs_sb_has_flexible_inline_xattr(sbi
)
223 && !f2fs_has_extra_attr(inode
)) {
224 set_sbi_flag(sbi
, SBI_NEED_FSCK
);
225 f2fs_warn(sbi
, "%s: corrupted inode ino=%lx, run fsck to fix.",
226 __func__
, inode
->i_ino
);
230 if (f2fs_has_extra_attr(inode
) &&
231 !f2fs_sb_has_extra_attr(sbi
)) {
232 set_sbi_flag(sbi
, SBI_NEED_FSCK
);
233 f2fs_warn(sbi
, "%s: inode (ino=%lx) is with extra_attr, but extra_attr feature is off",
234 __func__
, inode
->i_ino
);
238 if (fi
->i_extra_isize
> F2FS_TOTAL_EXTRA_ATTR_SIZE
||
239 fi
->i_extra_isize
% sizeof(__le32
)) {
240 set_sbi_flag(sbi
, SBI_NEED_FSCK
);
241 f2fs_warn(sbi
, "%s: inode (ino=%lx) has corrupted i_extra_isize: %d, max: %zu",
242 __func__
, inode
->i_ino
, fi
->i_extra_isize
,
243 F2FS_TOTAL_EXTRA_ATTR_SIZE
);
247 if (f2fs_has_extra_attr(inode
) &&
248 f2fs_sb_has_flexible_inline_xattr(sbi
) &&
249 f2fs_has_inline_xattr(inode
) &&
250 (!fi
->i_inline_xattr_size
||
251 fi
->i_inline_xattr_size
> MAX_INLINE_XATTR_SIZE
)) {
252 set_sbi_flag(sbi
, SBI_NEED_FSCK
);
253 f2fs_warn(sbi
, "%s: inode (ino=%lx) has corrupted i_inline_xattr_size: %d, max: %zu",
254 __func__
, inode
->i_ino
, fi
->i_inline_xattr_size
,
255 MAX_INLINE_XATTR_SIZE
);
259 if (F2FS_I(inode
)->extent_tree
) {
260 struct extent_info
*ei
= &F2FS_I(inode
)->extent_tree
->largest
;
263 (!f2fs_is_valid_blkaddr(sbi
, ei
->blk
,
264 DATA_GENERIC_ENHANCE
) ||
265 !f2fs_is_valid_blkaddr(sbi
, ei
->blk
+ ei
->len
- 1,
266 DATA_GENERIC_ENHANCE
))) {
267 set_sbi_flag(sbi
, SBI_NEED_FSCK
);
268 f2fs_warn(sbi
, "%s: inode (ino=%lx) extent info [%u, %u, %u] is incorrect, run fsck to fix",
269 __func__
, inode
->i_ino
,
270 ei
->blk
, ei
->fofs
, ei
->len
);
275 if (f2fs_has_inline_data(inode
) &&
276 (!S_ISREG(inode
->i_mode
) && !S_ISLNK(inode
->i_mode
))) {
277 set_sbi_flag(sbi
, SBI_NEED_FSCK
);
278 f2fs_warn(sbi
, "%s: inode (ino=%lx, mode=%u) should not have inline_data, run fsck to fix",
279 __func__
, inode
->i_ino
, inode
->i_mode
);
283 if (f2fs_has_inline_dentry(inode
) && !S_ISDIR(inode
->i_mode
)) {
284 set_sbi_flag(sbi
, SBI_NEED_FSCK
);
285 f2fs_warn(sbi
, "%s: inode (ino=%lx, mode=%u) should not have inline_dentry, run fsck to fix",
286 __func__
, inode
->i_ino
, inode
->i_mode
);
290 if ((fi
->i_flags
& F2FS_CASEFOLD_FL
) && !f2fs_sb_has_casefold(sbi
)) {
291 set_sbi_flag(sbi
, SBI_NEED_FSCK
);
292 f2fs_warn(sbi
, "%s: inode (ino=%lx) has casefold flag, but casefold feature is off",
293 __func__
, inode
->i_ino
);
297 if (f2fs_has_extra_attr(inode
) && f2fs_sb_has_compression(sbi
) &&
298 fi
->i_flags
& F2FS_COMPR_FL
&&
299 F2FS_FITS_IN_INODE(ri
, fi
->i_extra_isize
,
300 i_log_cluster_size
)) {
301 if (ri
->i_compress_algorithm
>= COMPRESS_MAX
) {
302 set_sbi_flag(sbi
, SBI_NEED_FSCK
);
303 f2fs_warn(sbi
, "%s: inode (ino=%lx) has unsupported "
304 "compress algorithm: %u, run fsck to fix",
305 __func__
, inode
->i_ino
,
306 ri
->i_compress_algorithm
);
309 if (le64_to_cpu(ri
->i_compr_blocks
) >
310 SECTOR_TO_BLOCK(inode
->i_blocks
)) {
311 set_sbi_flag(sbi
, SBI_NEED_FSCK
);
312 f2fs_warn(sbi
, "%s: inode (ino=%lx) has inconsistent "
313 "i_compr_blocks:%llu, i_blocks:%llu, run fsck to fix",
314 __func__
, inode
->i_ino
,
315 le64_to_cpu(ri
->i_compr_blocks
),
316 SECTOR_TO_BLOCK(inode
->i_blocks
));
319 if (ri
->i_log_cluster_size
< MIN_COMPRESS_LOG_SIZE
||
320 ri
->i_log_cluster_size
> MAX_COMPRESS_LOG_SIZE
) {
321 set_sbi_flag(sbi
, SBI_NEED_FSCK
);
322 f2fs_warn(sbi
, "%s: inode (ino=%lx) has unsupported "
323 "log cluster size: %u, run fsck to fix",
324 __func__
, inode
->i_ino
,
325 ri
->i_log_cluster_size
);
333 static int do_read_inode(struct inode
*inode
)
335 struct f2fs_sb_info
*sbi
= F2FS_I_SB(inode
);
336 struct f2fs_inode_info
*fi
= F2FS_I(inode
);
337 struct page
*node_page
;
338 struct f2fs_inode
*ri
;
342 /* Check if ino is within scope */
343 if (f2fs_check_nid_range(sbi
, inode
->i_ino
))
346 node_page
= f2fs_get_node_page(sbi
, inode
->i_ino
);
347 if (IS_ERR(node_page
))
348 return PTR_ERR(node_page
);
350 ri
= F2FS_INODE(node_page
);
352 inode
->i_mode
= le16_to_cpu(ri
->i_mode
);
353 i_uid_write(inode
, le32_to_cpu(ri
->i_uid
));
354 i_gid_write(inode
, le32_to_cpu(ri
->i_gid
));
355 set_nlink(inode
, le32_to_cpu(ri
->i_links
));
356 inode
->i_size
= le64_to_cpu(ri
->i_size
);
357 inode
->i_blocks
= SECTOR_FROM_BLOCK(le64_to_cpu(ri
->i_blocks
) - 1);
359 inode
->i_atime
.tv_sec
= le64_to_cpu(ri
->i_atime
);
360 inode
->i_ctime
.tv_sec
= le64_to_cpu(ri
->i_ctime
);
361 inode
->i_mtime
.tv_sec
= le64_to_cpu(ri
->i_mtime
);
362 inode
->i_atime
.tv_nsec
= le32_to_cpu(ri
->i_atime_nsec
);
363 inode
->i_ctime
.tv_nsec
= le32_to_cpu(ri
->i_ctime_nsec
);
364 inode
->i_mtime
.tv_nsec
= le32_to_cpu(ri
->i_mtime_nsec
);
365 inode
->i_generation
= le32_to_cpu(ri
->i_generation
);
366 if (S_ISDIR(inode
->i_mode
))
367 fi
->i_current_depth
= le32_to_cpu(ri
->i_current_depth
);
368 else if (S_ISREG(inode
->i_mode
))
369 fi
->i_gc_failures
[GC_FAILURE_PIN
] =
370 le16_to_cpu(ri
->i_gc_failures
);
371 fi
->i_xattr_nid
= le32_to_cpu(ri
->i_xattr_nid
);
372 fi
->i_flags
= le32_to_cpu(ri
->i_flags
);
373 if (S_ISREG(inode
->i_mode
))
374 fi
->i_flags
&= ~F2FS_PROJINHERIT_FL
;
375 bitmap_zero(fi
->flags
, FI_MAX
);
376 fi
->i_advise
= ri
->i_advise
;
377 fi
->i_pino
= le32_to_cpu(ri
->i_pino
);
378 fi
->i_dir_level
= ri
->i_dir_level
;
380 f2fs_init_extent_tree(inode
, node_page
);
382 get_inline_info(inode
, ri
);
384 fi
->i_extra_isize
= f2fs_has_extra_attr(inode
) ?
385 le16_to_cpu(ri
->i_extra_isize
) : 0;
387 if (f2fs_sb_has_flexible_inline_xattr(sbi
)) {
388 fi
->i_inline_xattr_size
= le16_to_cpu(ri
->i_inline_xattr_size
);
389 } else if (f2fs_has_inline_xattr(inode
) ||
390 f2fs_has_inline_dentry(inode
)) {
391 fi
->i_inline_xattr_size
= DEFAULT_INLINE_XATTR_ADDRS
;
395 * Previous inline data or directory always reserved 200 bytes
396 * in inode layout, even if inline_xattr is disabled. In order
397 * to keep inline_dentry's structure for backward compatibility,
398 * we get the space back only from inline_data.
400 fi
->i_inline_xattr_size
= 0;
403 if (!sanity_check_inode(inode
, node_page
)) {
404 f2fs_put_page(node_page
, 1);
405 return -EFSCORRUPTED
;
408 /* check data exist */
409 if (f2fs_has_inline_data(inode
) && !f2fs_exist_data(inode
))
410 __recover_inline_status(inode
, node_page
);
412 /* try to recover cold bit for non-dir inode */
413 if (!S_ISDIR(inode
->i_mode
) && !is_cold_node(node_page
)) {
414 f2fs_wait_on_page_writeback(node_page
, NODE
, true, true);
415 set_cold_node(node_page
, false);
416 set_page_dirty(node_page
);
419 /* get rdev by using inline_info */
420 __get_inode_rdev(inode
, ri
);
422 if (S_ISREG(inode
->i_mode
)) {
423 err
= __written_first_block(sbi
, ri
);
425 f2fs_put_page(node_page
, 1);
429 set_inode_flag(inode
, FI_FIRST_BLOCK_WRITTEN
);
432 if (!f2fs_need_inode_block_update(sbi
, inode
->i_ino
))
433 fi
->last_disk_size
= inode
->i_size
;
435 if (fi
->i_flags
& F2FS_PROJINHERIT_FL
)
436 set_inode_flag(inode
, FI_PROJ_INHERIT
);
438 if (f2fs_has_extra_attr(inode
) && f2fs_sb_has_project_quota(sbi
) &&
439 F2FS_FITS_IN_INODE(ri
, fi
->i_extra_isize
, i_projid
))
440 i_projid
= (projid_t
)le32_to_cpu(ri
->i_projid
);
442 i_projid
= F2FS_DEF_PROJID
;
443 fi
->i_projid
= make_kprojid(&init_user_ns
, i_projid
);
445 if (f2fs_has_extra_attr(inode
) && f2fs_sb_has_inode_crtime(sbi
) &&
446 F2FS_FITS_IN_INODE(ri
, fi
->i_extra_isize
, i_crtime
)) {
447 fi
->i_crtime
.tv_sec
= le64_to_cpu(ri
->i_crtime
);
448 fi
->i_crtime
.tv_nsec
= le32_to_cpu(ri
->i_crtime_nsec
);
451 if (f2fs_has_extra_attr(inode
) && f2fs_sb_has_compression(sbi
) &&
452 (fi
->i_flags
& F2FS_COMPR_FL
)) {
453 if (F2FS_FITS_IN_INODE(ri
, fi
->i_extra_isize
,
454 i_log_cluster_size
)) {
455 atomic_set(&fi
->i_compr_blocks
,
456 le64_to_cpu(ri
->i_compr_blocks
));
457 fi
->i_compress_algorithm
= ri
->i_compress_algorithm
;
458 fi
->i_log_cluster_size
= ri
->i_log_cluster_size
;
459 fi
->i_compress_flag
= le16_to_cpu(ri
->i_compress_flag
);
460 fi
->i_cluster_size
= 1 << fi
->i_log_cluster_size
;
461 set_inode_flag(inode
, FI_COMPRESSED_FILE
);
465 F2FS_I(inode
)->i_disk_time
[0] = inode
->i_atime
;
466 F2FS_I(inode
)->i_disk_time
[1] = inode
->i_ctime
;
467 F2FS_I(inode
)->i_disk_time
[2] = inode
->i_mtime
;
468 F2FS_I(inode
)->i_disk_time
[3] = F2FS_I(inode
)->i_crtime
;
469 f2fs_put_page(node_page
, 1);
471 stat_inc_inline_xattr(inode
);
472 stat_inc_inline_inode(inode
);
473 stat_inc_inline_dir(inode
);
474 stat_inc_compr_inode(inode
);
475 stat_add_compr_blocks(inode
, atomic_read(&fi
->i_compr_blocks
));
480 struct inode
*f2fs_iget(struct super_block
*sb
, unsigned long ino
)
482 struct f2fs_sb_info
*sbi
= F2FS_SB(sb
);
486 inode
= iget_locked(sb
, ino
);
488 return ERR_PTR(-ENOMEM
);
490 if (!(inode
->i_state
& I_NEW
)) {
491 trace_f2fs_iget(inode
);
494 if (ino
== F2FS_NODE_INO(sbi
) || ino
== F2FS_META_INO(sbi
))
497 ret
= do_read_inode(inode
);
501 if (ino
== F2FS_NODE_INO(sbi
)) {
502 inode
->i_mapping
->a_ops
= &f2fs_node_aops
;
503 mapping_set_gfp_mask(inode
->i_mapping
, GFP_NOFS
);
504 } else if (ino
== F2FS_META_INO(sbi
)) {
505 inode
->i_mapping
->a_ops
= &f2fs_meta_aops
;
506 mapping_set_gfp_mask(inode
->i_mapping
, GFP_NOFS
);
507 } else if (S_ISREG(inode
->i_mode
)) {
508 inode
->i_op
= &f2fs_file_inode_operations
;
509 inode
->i_fop
= &f2fs_file_operations
;
510 inode
->i_mapping
->a_ops
= &f2fs_dblock_aops
;
511 } else if (S_ISDIR(inode
->i_mode
)) {
512 inode
->i_op
= &f2fs_dir_inode_operations
;
513 inode
->i_fop
= &f2fs_dir_operations
;
514 inode
->i_mapping
->a_ops
= &f2fs_dblock_aops
;
515 inode_nohighmem(inode
);
516 } else if (S_ISLNK(inode
->i_mode
)) {
517 if (file_is_encrypt(inode
))
518 inode
->i_op
= &f2fs_encrypted_symlink_inode_operations
;
520 inode
->i_op
= &f2fs_symlink_inode_operations
;
521 inode_nohighmem(inode
);
522 inode
->i_mapping
->a_ops
= &f2fs_dblock_aops
;
523 } else if (S_ISCHR(inode
->i_mode
) || S_ISBLK(inode
->i_mode
) ||
524 S_ISFIFO(inode
->i_mode
) || S_ISSOCK(inode
->i_mode
)) {
525 inode
->i_op
= &f2fs_special_inode_operations
;
526 init_special_inode(inode
, inode
->i_mode
, inode
->i_rdev
);
531 f2fs_set_inode_flags(inode
);
532 unlock_new_inode(inode
);
533 trace_f2fs_iget(inode
);
537 f2fs_inode_synced(inode
);
539 trace_f2fs_iget_exit(inode
, ret
);
543 struct inode
*f2fs_iget_retry(struct super_block
*sb
, unsigned long ino
)
547 inode
= f2fs_iget(sb
, ino
);
549 if (PTR_ERR(inode
) == -ENOMEM
) {
550 congestion_wait(BLK_RW_ASYNC
, DEFAULT_IO_TIMEOUT
);
557 void f2fs_update_inode(struct inode
*inode
, struct page
*node_page
)
559 struct f2fs_inode
*ri
;
560 struct extent_tree
*et
= F2FS_I(inode
)->extent_tree
;
562 f2fs_wait_on_page_writeback(node_page
, NODE
, true, true);
563 set_page_dirty(node_page
);
565 f2fs_inode_synced(inode
);
567 ri
= F2FS_INODE(node_page
);
569 ri
->i_mode
= cpu_to_le16(inode
->i_mode
);
570 ri
->i_advise
= F2FS_I(inode
)->i_advise
;
571 ri
->i_uid
= cpu_to_le32(i_uid_read(inode
));
572 ri
->i_gid
= cpu_to_le32(i_gid_read(inode
));
573 ri
->i_links
= cpu_to_le32(inode
->i_nlink
);
574 ri
->i_size
= cpu_to_le64(i_size_read(inode
));
575 ri
->i_blocks
= cpu_to_le64(SECTOR_TO_BLOCK(inode
->i_blocks
) + 1);
578 read_lock(&et
->lock
);
579 set_raw_extent(&et
->largest
, &ri
->i_ext
);
580 read_unlock(&et
->lock
);
582 memset(&ri
->i_ext
, 0, sizeof(ri
->i_ext
));
584 set_raw_inline(inode
, ri
);
586 ri
->i_atime
= cpu_to_le64(inode
->i_atime
.tv_sec
);
587 ri
->i_ctime
= cpu_to_le64(inode
->i_ctime
.tv_sec
);
588 ri
->i_mtime
= cpu_to_le64(inode
->i_mtime
.tv_sec
);
589 ri
->i_atime_nsec
= cpu_to_le32(inode
->i_atime
.tv_nsec
);
590 ri
->i_ctime_nsec
= cpu_to_le32(inode
->i_ctime
.tv_nsec
);
591 ri
->i_mtime_nsec
= cpu_to_le32(inode
->i_mtime
.tv_nsec
);
592 if (S_ISDIR(inode
->i_mode
))
593 ri
->i_current_depth
=
594 cpu_to_le32(F2FS_I(inode
)->i_current_depth
);
595 else if (S_ISREG(inode
->i_mode
))
597 cpu_to_le16(F2FS_I(inode
)->i_gc_failures
[GC_FAILURE_PIN
]);
598 ri
->i_xattr_nid
= cpu_to_le32(F2FS_I(inode
)->i_xattr_nid
);
599 ri
->i_flags
= cpu_to_le32(F2FS_I(inode
)->i_flags
);
600 ri
->i_pino
= cpu_to_le32(F2FS_I(inode
)->i_pino
);
601 ri
->i_generation
= cpu_to_le32(inode
->i_generation
);
602 ri
->i_dir_level
= F2FS_I(inode
)->i_dir_level
;
604 if (f2fs_has_extra_attr(inode
)) {
605 ri
->i_extra_isize
= cpu_to_le16(F2FS_I(inode
)->i_extra_isize
);
607 if (f2fs_sb_has_flexible_inline_xattr(F2FS_I_SB(inode
)))
608 ri
->i_inline_xattr_size
=
609 cpu_to_le16(F2FS_I(inode
)->i_inline_xattr_size
);
611 if (f2fs_sb_has_project_quota(F2FS_I_SB(inode
)) &&
612 F2FS_FITS_IN_INODE(ri
, F2FS_I(inode
)->i_extra_isize
,
616 i_projid
= from_kprojid(&init_user_ns
,
617 F2FS_I(inode
)->i_projid
);
618 ri
->i_projid
= cpu_to_le32(i_projid
);
621 if (f2fs_sb_has_inode_crtime(F2FS_I_SB(inode
)) &&
622 F2FS_FITS_IN_INODE(ri
, F2FS_I(inode
)->i_extra_isize
,
625 cpu_to_le64(F2FS_I(inode
)->i_crtime
.tv_sec
);
627 cpu_to_le32(F2FS_I(inode
)->i_crtime
.tv_nsec
);
630 if (f2fs_sb_has_compression(F2FS_I_SB(inode
)) &&
631 F2FS_FITS_IN_INODE(ri
, F2FS_I(inode
)->i_extra_isize
,
632 i_log_cluster_size
)) {
634 cpu_to_le64(atomic_read(
635 &F2FS_I(inode
)->i_compr_blocks
));
636 ri
->i_compress_algorithm
=
637 F2FS_I(inode
)->i_compress_algorithm
;
638 ri
->i_compress_flag
=
639 cpu_to_le16(F2FS_I(inode
)->i_compress_flag
);
640 ri
->i_log_cluster_size
=
641 F2FS_I(inode
)->i_log_cluster_size
;
645 __set_inode_rdev(inode
, ri
);
648 if (inode
->i_nlink
== 0)
649 clear_inline_node(node_page
);
651 F2FS_I(inode
)->i_disk_time
[0] = inode
->i_atime
;
652 F2FS_I(inode
)->i_disk_time
[1] = inode
->i_ctime
;
653 F2FS_I(inode
)->i_disk_time
[2] = inode
->i_mtime
;
654 F2FS_I(inode
)->i_disk_time
[3] = F2FS_I(inode
)->i_crtime
;
656 #ifdef CONFIG_F2FS_CHECK_FS
657 f2fs_inode_chksum_set(F2FS_I_SB(inode
), node_page
);
661 void f2fs_update_inode_page(struct inode
*inode
)
663 struct f2fs_sb_info
*sbi
= F2FS_I_SB(inode
);
664 struct page
*node_page
;
666 node_page
= f2fs_get_node_page(sbi
, inode
->i_ino
);
667 if (IS_ERR(node_page
)) {
668 int err
= PTR_ERR(node_page
);
669 if (err
== -ENOMEM
) {
672 } else if (err
!= -ENOENT
) {
673 f2fs_stop_checkpoint(sbi
, false);
677 f2fs_update_inode(inode
, node_page
);
678 f2fs_put_page(node_page
, 1);
681 int f2fs_write_inode(struct inode
*inode
, struct writeback_control
*wbc
)
683 struct f2fs_sb_info
*sbi
= F2FS_I_SB(inode
);
685 if (inode
->i_ino
== F2FS_NODE_INO(sbi
) ||
686 inode
->i_ino
== F2FS_META_INO(sbi
))
690 * atime could be updated without dirtying f2fs inode in lazytime mode
692 if (f2fs_is_time_consistent(inode
) &&
693 !is_inode_flag_set(inode
, FI_DIRTY_INODE
))
696 if (!f2fs_is_checkpoint_ready(sbi
))
700 * We need to balance fs here to prevent from producing dirty node pages
701 * during the urgent cleaning time when runing out of free sections.
703 f2fs_update_inode_page(inode
);
704 if (wbc
&& wbc
->nr_to_write
)
705 f2fs_balance_fs(sbi
, true);
710 * Called at the last iput() if i_nlink is zero
712 void f2fs_evict_inode(struct inode
*inode
)
714 struct f2fs_sb_info
*sbi
= F2FS_I_SB(inode
);
715 nid_t xnid
= F2FS_I(inode
)->i_xattr_nid
;
718 /* some remained atomic pages should discarded */
719 if (f2fs_is_atomic_file(inode
))
720 f2fs_drop_inmem_pages(inode
);
722 trace_f2fs_evict_inode(inode
);
723 truncate_inode_pages_final(&inode
->i_data
);
725 if (inode
->i_ino
== F2FS_NODE_INO(sbi
) ||
726 inode
->i_ino
== F2FS_META_INO(sbi
))
729 f2fs_bug_on(sbi
, get_dirty_pages(inode
));
730 f2fs_remove_dirty_inode(inode
);
732 f2fs_destroy_extent_tree(inode
);
734 if (inode
->i_nlink
|| is_bad_inode(inode
))
737 err
= dquot_initialize(inode
);
740 set_sbi_flag(sbi
, SBI_QUOTA_NEED_REPAIR
);
743 f2fs_remove_ino_entry(sbi
, inode
->i_ino
, APPEND_INO
);
744 f2fs_remove_ino_entry(sbi
, inode
->i_ino
, UPDATE_INO
);
745 f2fs_remove_ino_entry(sbi
, inode
->i_ino
, FLUSH_INO
);
747 sb_start_intwrite(inode
->i_sb
);
748 set_inode_flag(inode
, FI_NO_ALLOC
);
749 i_size_write(inode
, 0);
751 if (F2FS_HAS_BLOCKS(inode
))
752 err
= f2fs_truncate(inode
);
754 if (time_to_inject(sbi
, FAULT_EVICT_INODE
)) {
755 f2fs_show_injection_info(sbi
, FAULT_EVICT_INODE
);
761 err
= f2fs_remove_inode_page(inode
);
767 /* give more chances, if ENOMEM case */
768 if (err
== -ENOMEM
) {
774 f2fs_update_inode_page(inode
);
775 if (dquot_initialize_needed(inode
))
776 set_sbi_flag(sbi
, SBI_QUOTA_NEED_REPAIR
);
778 sb_end_intwrite(inode
->i_sb
);
782 stat_dec_inline_xattr(inode
);
783 stat_dec_inline_dir(inode
);
784 stat_dec_inline_inode(inode
);
785 stat_dec_compr_inode(inode
);
786 stat_sub_compr_blocks(inode
,
787 atomic_read(&F2FS_I(inode
)->i_compr_blocks
));
789 if (likely(!f2fs_cp_error(sbi
) &&
790 !is_sbi_flag_set(sbi
, SBI_CP_DISABLED
)))
791 f2fs_bug_on(sbi
, is_inode_flag_set(inode
, FI_DIRTY_INODE
));
793 f2fs_inode_synced(inode
);
795 /* for the case f2fs_new_inode() was failed, .i_ino is zero, skip it */
797 invalidate_mapping_pages(NODE_MAPPING(sbi
), inode
->i_ino
,
800 invalidate_mapping_pages(NODE_MAPPING(sbi
), xnid
, xnid
);
801 if (inode
->i_nlink
) {
802 if (is_inode_flag_set(inode
, FI_APPEND_WRITE
))
803 f2fs_add_ino_entry(sbi
, inode
->i_ino
, APPEND_INO
);
804 if (is_inode_flag_set(inode
, FI_UPDATE_WRITE
))
805 f2fs_add_ino_entry(sbi
, inode
->i_ino
, UPDATE_INO
);
807 if (is_inode_flag_set(inode
, FI_FREE_NID
)) {
808 f2fs_alloc_nid_failed(sbi
, inode
->i_ino
);
809 clear_inode_flag(inode
, FI_FREE_NID
);
812 * If xattr nid is corrupted, we can reach out error condition,
813 * err & !f2fs_exist_written_data(sbi, inode->i_ino, ORPHAN_INO)).
814 * In that case, f2fs_check_nid_range() is enough to give a clue.
818 fscrypt_put_encryption_info(inode
);
819 fsverity_cleanup_inode(inode
);
823 /* caller should call f2fs_lock_op() */
824 void f2fs_handle_failed_inode(struct inode
*inode
)
826 struct f2fs_sb_info
*sbi
= F2FS_I_SB(inode
);
831 * clear nlink of inode in order to release resource of inode
837 * we must call this to avoid inode being remained as dirty, resulting
838 * in a panic when flushing dirty inodes in gdirty_list.
840 f2fs_update_inode_page(inode
);
841 f2fs_inode_synced(inode
);
843 /* don't make bad inode, since it becomes a regular file. */
844 unlock_new_inode(inode
);
847 * Note: we should add inode to orphan list before f2fs_unlock_op()
848 * so we can prevent losing this orphan when encoutering checkpoint
849 * and following suddenly power-off.
851 err
= f2fs_get_node_info(sbi
, inode
->i_ino
, &ni
);
853 set_sbi_flag(sbi
, SBI_NEED_FSCK
);
854 f2fs_warn(sbi
, "May loss orphan inode, run fsck to fix.");
858 if (ni
.blk_addr
!= NULL_ADDR
) {
859 err
= f2fs_acquire_orphan_inode(sbi
);
861 set_sbi_flag(sbi
, SBI_NEED_FSCK
);
862 f2fs_warn(sbi
, "Too many orphan inodes, run fsck to fix.");
864 f2fs_add_orphan_inode(inode
);
866 f2fs_alloc_nid_done(sbi
, inode
->i_ino
);
868 set_inode_flag(inode
, FI_FREE_NID
);
874 /* iput will drop the inode object */