inode.c (355a47ae7ebcf9d605aa809b259d380422e81b8d) inode.c (dcbb4c10e6d9693cc9d6fa493b4d130b66a60c7d)
1// SPDX-License-Identifier: GPL-2.0
2/*
3 * fs/f2fs/inode.c
4 *
5 * Copyright (c) 2012 Samsung Electronics Co., Ltd.
6 * http://www.samsung.com/
7 */
8#include <linux/fs.h>

--- 162 unchanged lines hidden (view full) ---

171#endif
172 return true;
173
174 ri = &F2FS_NODE(page)->i;
175 provided = le32_to_cpu(ri->i_inode_checksum);
176 calculated = f2fs_inode_chksum(sbi, page);
177
178 if (provided != calculated)
1// SPDX-License-Identifier: GPL-2.0
2/*
3 * fs/f2fs/inode.c
4 *
5 * Copyright (c) 2012 Samsung Electronics Co., Ltd.
6 * http://www.samsung.com/
7 */
8#include <linux/fs.h>

--- 162 unchanged lines hidden (view full) ---

171#endif
172 return true;
173
174 ri = &F2FS_NODE(page)->i;
175 provided = le32_to_cpu(ri->i_inode_checksum);
176 calculated = f2fs_inode_chksum(sbi, page);
177
178 if (provided != calculated)
179 f2fs_msg(sbi->sb, KERN_WARNING,
180 "checksum invalid, nid = %lu, ino_of_node = %x, %x vs. %x",
181 page->index, ino_of_node(page), provided, calculated);
179 f2fs_warn(sbi, "checksum invalid, nid = %lu, ino_of_node = %x, %x vs. %x",
180 page->index, ino_of_node(page), provided, calculated);
182
183 return provided == calculated;
184}
185
186void f2fs_inode_chksum_set(struct f2fs_sb_info *sbi, struct page *page)
187{
188 struct f2fs_inode *ri = &F2FS_NODE(page)->i;
189

--- 7 unchanged lines hidden (view full) ---

197{
198 struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
199 struct f2fs_inode_info *fi = F2FS_I(inode);
200 unsigned long long iblocks;
201
202 iblocks = le64_to_cpu(F2FS_INODE(node_page)->i_blocks);
203 if (!iblocks) {
204 set_sbi_flag(sbi, SBI_NEED_FSCK);
181
182 return provided == calculated;
183}
184
185void f2fs_inode_chksum_set(struct f2fs_sb_info *sbi, struct page *page)
186{
187 struct f2fs_inode *ri = &F2FS_NODE(page)->i;
188

--- 7 unchanged lines hidden (view full) ---

196{
197 struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
198 struct f2fs_inode_info *fi = F2FS_I(inode);
199 unsigned long long iblocks;
200
201 iblocks = le64_to_cpu(F2FS_INODE(node_page)->i_blocks);
202 if (!iblocks) {
203 set_sbi_flag(sbi, SBI_NEED_FSCK);
205 f2fs_msg(sbi->sb, KERN_WARNING,
206 "%s: corrupted inode i_blocks i_ino=%lx iblocks=%llu, "
207 "run fsck to fix.",
208 __func__, inode->i_ino, iblocks);
204 f2fs_warn(sbi, "%s: corrupted inode i_blocks i_ino=%lx iblocks=%llu, run fsck to fix.",
205 __func__, inode->i_ino, iblocks);
209 return false;
210 }
211
212 if (ino_of_node(node_page) != nid_of_node(node_page)) {
213 set_sbi_flag(sbi, SBI_NEED_FSCK);
206 return false;
207 }
208
209 if (ino_of_node(node_page) != nid_of_node(node_page)) {
210 set_sbi_flag(sbi, SBI_NEED_FSCK);
214 f2fs_msg(sbi->sb, KERN_WARNING,
215 "%s: corrupted inode footer i_ino=%lx, ino,nid: "
216 "[%u, %u] run fsck to fix.",
217 __func__, inode->i_ino,
218 ino_of_node(node_page), nid_of_node(node_page));
211 f2fs_warn(sbi, "%s: corrupted inode footer i_ino=%lx, ino,nid: [%u, %u] run fsck to fix.",
212 __func__, inode->i_ino,
213 ino_of_node(node_page), nid_of_node(node_page));
219 return false;
220 }
221
222 if (f2fs_sb_has_flexible_inline_xattr(sbi)
223 && !f2fs_has_extra_attr(inode)) {
224 set_sbi_flag(sbi, SBI_NEED_FSCK);
214 return false;
215 }
216
217 if (f2fs_sb_has_flexible_inline_xattr(sbi)
218 && !f2fs_has_extra_attr(inode)) {
219 set_sbi_flag(sbi, SBI_NEED_FSCK);
225 f2fs_msg(sbi->sb, KERN_WARNING,
226 "%s: corrupted inode ino=%lx, run fsck to fix.",
227 __func__, inode->i_ino);
220 f2fs_warn(sbi, "%s: corrupted inode ino=%lx, run fsck to fix.",
221 __func__, inode->i_ino);
228 return false;
229 }
230
231 if (f2fs_has_extra_attr(inode) &&
232 !f2fs_sb_has_extra_attr(sbi)) {
233 set_sbi_flag(sbi, SBI_NEED_FSCK);
222 return false;
223 }
224
225 if (f2fs_has_extra_attr(inode) &&
226 !f2fs_sb_has_extra_attr(sbi)) {
227 set_sbi_flag(sbi, SBI_NEED_FSCK);
234 f2fs_msg(sbi->sb, KERN_WARNING,
235 "%s: inode (ino=%lx) is with extra_attr, "
236 "but extra_attr feature is off",
237 __func__, inode->i_ino);
228 f2fs_warn(sbi, "%s: inode (ino=%lx) is with extra_attr, but extra_attr feature is off",
229 __func__, inode->i_ino);
238 return false;
239 }
240
241 if (fi->i_extra_isize > F2FS_TOTAL_EXTRA_ATTR_SIZE ||
242 fi->i_extra_isize % sizeof(__le32)) {
243 set_sbi_flag(sbi, SBI_NEED_FSCK);
230 return false;
231 }
232
233 if (fi->i_extra_isize > F2FS_TOTAL_EXTRA_ATTR_SIZE ||
234 fi->i_extra_isize % sizeof(__le32)) {
235 set_sbi_flag(sbi, SBI_NEED_FSCK);
244 f2fs_msg(sbi->sb, KERN_WARNING,
245 "%s: inode (ino=%lx) has corrupted i_extra_isize: %d, "
246 "max: %zu",
247 __func__, inode->i_ino, fi->i_extra_isize,
248 F2FS_TOTAL_EXTRA_ATTR_SIZE);
236 f2fs_warn(sbi, "%s: inode (ino=%lx) has corrupted i_extra_isize: %d, max: %zu",
237 __func__, inode->i_ino, fi->i_extra_isize,
238 F2FS_TOTAL_EXTRA_ATTR_SIZE);
249 return false;
250 }
251
252 if (f2fs_has_extra_attr(inode) &&
253 f2fs_sb_has_flexible_inline_xattr(sbi) &&
254 f2fs_has_inline_xattr(inode) &&
255 (!fi->i_inline_xattr_size ||
256 fi->i_inline_xattr_size > MAX_INLINE_XATTR_SIZE)) {
257 set_sbi_flag(sbi, SBI_NEED_FSCK);
239 return false;
240 }
241
242 if (f2fs_has_extra_attr(inode) &&
243 f2fs_sb_has_flexible_inline_xattr(sbi) &&
244 f2fs_has_inline_xattr(inode) &&
245 (!fi->i_inline_xattr_size ||
246 fi->i_inline_xattr_size > MAX_INLINE_XATTR_SIZE)) {
247 set_sbi_flag(sbi, SBI_NEED_FSCK);
258 f2fs_msg(sbi->sb, KERN_WARNING,
259 "%s: inode (ino=%lx) has corrupted "
260 "i_inline_xattr_size: %d, max: %zu",
261 __func__, inode->i_ino, fi->i_inline_xattr_size,
262 MAX_INLINE_XATTR_SIZE);
248 f2fs_warn(sbi, "%s: inode (ino=%lx) has corrupted i_inline_xattr_size: %d, max: %zu",
249 __func__, inode->i_ino, fi->i_inline_xattr_size,
250 MAX_INLINE_XATTR_SIZE);
263 return false;
264 }
265
266 if (F2FS_I(inode)->extent_tree) {
267 struct extent_info *ei = &F2FS_I(inode)->extent_tree->largest;
268
269 if (ei->len &&
270 (!f2fs_is_valid_blkaddr(sbi, ei->blk,
271 DATA_GENERIC_ENHANCE) ||
272 !f2fs_is_valid_blkaddr(sbi, ei->blk + ei->len - 1,
273 DATA_GENERIC_ENHANCE))) {
274 set_sbi_flag(sbi, SBI_NEED_FSCK);
251 return false;
252 }
253
254 if (F2FS_I(inode)->extent_tree) {
255 struct extent_info *ei = &F2FS_I(inode)->extent_tree->largest;
256
257 if (ei->len &&
258 (!f2fs_is_valid_blkaddr(sbi, ei->blk,
259 DATA_GENERIC_ENHANCE) ||
260 !f2fs_is_valid_blkaddr(sbi, ei->blk + ei->len - 1,
261 DATA_GENERIC_ENHANCE))) {
262 set_sbi_flag(sbi, SBI_NEED_FSCK);
275 f2fs_msg(sbi->sb, KERN_WARNING,
276 "%s: inode (ino=%lx) extent info [%u, %u, %u] "
277 "is incorrect, run fsck to fix",
278 __func__, inode->i_ino,
279 ei->blk, ei->fofs, ei->len);
263 f2fs_warn(sbi, "%s: inode (ino=%lx) extent info [%u, %u, %u] is incorrect, run fsck to fix",
264 __func__, inode->i_ino,
265 ei->blk, ei->fofs, ei->len);
280 return false;
281 }
282 }
283
284 if (f2fs_has_inline_data(inode) &&
285 (!S_ISREG(inode->i_mode) && !S_ISLNK(inode->i_mode))) {
286 set_sbi_flag(sbi, SBI_NEED_FSCK);
266 return false;
267 }
268 }
269
270 if (f2fs_has_inline_data(inode) &&
271 (!S_ISREG(inode->i_mode) && !S_ISLNK(inode->i_mode))) {
272 set_sbi_flag(sbi, SBI_NEED_FSCK);
287 f2fs_msg(sbi->sb, KERN_WARNING,
288 "%s: inode (ino=%lx, mode=%u) should not have "
289 "inline_data, run fsck to fix",
290 __func__, inode->i_ino, inode->i_mode);
273 f2fs_warn(sbi, "%s: inode (ino=%lx, mode=%u) should not have inline_data, run fsck to fix",
274 __func__, inode->i_ino, inode->i_mode);
291 return false;
292 }
293
294 if (f2fs_has_inline_dentry(inode) && !S_ISDIR(inode->i_mode)) {
295 set_sbi_flag(sbi, SBI_NEED_FSCK);
275 return false;
276 }
277
278 if (f2fs_has_inline_dentry(inode) && !S_ISDIR(inode->i_mode)) {
279 set_sbi_flag(sbi, SBI_NEED_FSCK);
296 f2fs_msg(sbi->sb, KERN_WARNING,
297 "%s: inode (ino=%lx, mode=%u) should not have "
298 "inline_dentry, run fsck to fix",
299 __func__, inode->i_ino, inode->i_mode);
280 f2fs_warn(sbi, "%s: inode (ino=%lx, mode=%u) should not have inline_dentry, run fsck to fix",
281 __func__, inode->i_ino, inode->i_mode);
300 return false;
301 }
302
303 return true;
304}
305
306static int do_read_inode(struct inode *inode)
307{

--- 30 unchanged lines hidden (view full) ---

338 inode->i_generation = le32_to_cpu(ri->i_generation);
339 if (S_ISDIR(inode->i_mode))
340 fi->i_current_depth = le32_to_cpu(ri->i_current_depth);
341 else if (S_ISREG(inode->i_mode))
342 fi->i_gc_failures[GC_FAILURE_PIN] =
343 le16_to_cpu(ri->i_gc_failures);
344 fi->i_xattr_nid = le32_to_cpu(ri->i_xattr_nid);
345 fi->i_flags = le32_to_cpu(ri->i_flags);
282 return false;
283 }
284
285 return true;
286}
287
288static int do_read_inode(struct inode *inode)
289{

--- 30 unchanged lines hidden (view full) ---

320 inode->i_generation = le32_to_cpu(ri->i_generation);
321 if (S_ISDIR(inode->i_mode))
322 fi->i_current_depth = le32_to_cpu(ri->i_current_depth);
323 else if (S_ISREG(inode->i_mode))
324 fi->i_gc_failures[GC_FAILURE_PIN] =
325 le16_to_cpu(ri->i_gc_failures);
326 fi->i_xattr_nid = le32_to_cpu(ri->i_xattr_nid);
327 fi->i_flags = le32_to_cpu(ri->i_flags);
328 if (S_ISREG(inode->i_mode))
329 fi->i_flags &= ~F2FS_PROJINHERIT_FL;
346 fi->flags = 0;
347 fi->i_advise = ri->i_advise;
348 fi->i_pino = le32_to_cpu(ri->i_pino);
349 fi->i_dir_level = ri->i_dir_level;
350
351 if (f2fs_init_extent_tree(inode, &ri->i_ext))
352 set_page_dirty(node_page);
353

--- 424 unchanged lines hidden (view full) ---

778 /*
779 * Note: we should add inode to orphan list before f2fs_unlock_op()
780 * so we can prevent losing this orphan when encoutering checkpoint
781 * and following suddenly power-off.
782 */
783 err = f2fs_get_node_info(sbi, inode->i_ino, &ni);
784 if (err) {
785 set_sbi_flag(sbi, SBI_NEED_FSCK);
330 fi->flags = 0;
331 fi->i_advise = ri->i_advise;
332 fi->i_pino = le32_to_cpu(ri->i_pino);
333 fi->i_dir_level = ri->i_dir_level;
334
335 if (f2fs_init_extent_tree(inode, &ri->i_ext))
336 set_page_dirty(node_page);
337

--- 424 unchanged lines hidden (view full) ---

762 /*
763 * Note: we should add inode to orphan list before f2fs_unlock_op()
764 * so we can prevent losing this orphan when encoutering checkpoint
765 * and following suddenly power-off.
766 */
767 err = f2fs_get_node_info(sbi, inode->i_ino, &ni);
768 if (err) {
769 set_sbi_flag(sbi, SBI_NEED_FSCK);
786 f2fs_msg(sbi->sb, KERN_WARNING,
787 "May loss orphan inode, run fsck to fix.");
770 f2fs_warn(sbi, "May loss orphan inode, run fsck to fix.");
788 goto out;
789 }
790
791 if (ni.blk_addr != NULL_ADDR) {
792 err = f2fs_acquire_orphan_inode(sbi);
793 if (err) {
794 set_sbi_flag(sbi, SBI_NEED_FSCK);
771 goto out;
772 }
773
774 if (ni.blk_addr != NULL_ADDR) {
775 err = f2fs_acquire_orphan_inode(sbi);
776 if (err) {
777 set_sbi_flag(sbi, SBI_NEED_FSCK);
795 f2fs_msg(sbi->sb, KERN_WARNING,
796 "Too many orphan inodes, run fsck to fix.");
778 f2fs_warn(sbi, "Too many orphan inodes, run fsck to fix.");
797 } else {
798 f2fs_add_orphan_inode(inode);
799 }
800 f2fs_alloc_nid_done(sbi, inode->i_ino);
801 } else {
802 set_inode_flag(inode, FI_FREE_NID);
803 }
804
805out:
806 f2fs_unlock_op(sbi);
807
808 /* iput will drop the inode object */
809 iput(inode);
810}
779 } else {
780 f2fs_add_orphan_inode(inode);
781 }
782 f2fs_alloc_nid_done(sbi, inode->i_ino);
783 } else {
784 set_inode_flag(inode, FI_FREE_NID);
785 }
786
787out:
788 f2fs_unlock_op(sbi);
789
790 /* iput will drop the inode object */
791 iput(inode);
792}