~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/fs/f2fs/inode.c

Version: ~ [ linux-5.15-rc7 ] ~ [ linux-5.14.14 ] ~ [ linux-5.13.19 ] ~ [ linux-5.12.19 ] ~ [ linux-5.11.22 ] ~ [ linux-5.10.75 ] ~ [ linux-5.9.16 ] ~ [ linux-5.8.18 ] ~ [ linux-5.7.19 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.155 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.213 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.252 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.287 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.289 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.18.140 ] ~ [ linux-3.16.85 ] ~ [ linux-3.14.79 ] ~ [ linux-3.12.74 ] ~ [ linux-3.10.108 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  1 /*
  2  * fs/f2fs/inode.c
  3  *
  4  * Copyright (c) 2012 Samsung Electronics Co., Ltd.
  5  *             http://www.samsung.com/
  6  *
  7  * This program is free software; you can redistribute it and/or modify
  8  * it under the terms of the GNU General Public License version 2 as
  9  * published by the Free Software Foundation.
 10  */
 11 #include <linux/fs.h>
 12 #include <linux/f2fs_fs.h>
 13 #include <linux/buffer_head.h>
 14 #include <linux/backing-dev.h>
 15 #include <linux/writeback.h>
 16 
 17 #include "f2fs.h"
 18 #include "node.h"
 19 #include "segment.h"
 20 
 21 #include <trace/events/f2fs.h>
 22 
 23 void f2fs_mark_inode_dirty_sync(struct inode *inode, bool sync)
 24 {
 25         if (f2fs_inode_dirtied(inode, sync))
 26                 return;
 27 
 28         mark_inode_dirty_sync(inode);
 29 }
 30 
 31 void f2fs_set_inode_flags(struct inode *inode)
 32 {
 33         unsigned int flags = F2FS_I(inode)->i_flags;
 34         unsigned int new_fl = 0;
 35 
 36         if (flags & FS_SYNC_FL)
 37                 new_fl |= S_SYNC;
 38         if (flags & FS_APPEND_FL)
 39                 new_fl |= S_APPEND;
 40         if (flags & FS_IMMUTABLE_FL)
 41                 new_fl |= S_IMMUTABLE;
 42         if (flags & FS_NOATIME_FL)
 43                 new_fl |= S_NOATIME;
 44         if (flags & FS_DIRSYNC_FL)
 45                 new_fl |= S_DIRSYNC;
 46         inode_set_flags(inode, new_fl,
 47                         S_SYNC|S_APPEND|S_IMMUTABLE|S_NOATIME|S_DIRSYNC);
 48 }
 49 
 50 static void __get_inode_rdev(struct inode *inode, struct f2fs_inode *ri)
 51 {
 52         if (S_ISCHR(inode->i_mode) || S_ISBLK(inode->i_mode) ||
 53                         S_ISFIFO(inode->i_mode) || S_ISSOCK(inode->i_mode)) {
 54                 if (ri->i_addr[0])
 55                         inode->i_rdev =
 56                                 old_decode_dev(le32_to_cpu(ri->i_addr[0]));
 57                 else
 58                         inode->i_rdev =
 59                                 new_decode_dev(le32_to_cpu(ri->i_addr[1]));
 60         }
 61 }
 62 
 63 static bool __written_first_block(struct f2fs_inode *ri)
 64 {
 65         block_t addr = le32_to_cpu(ri->i_addr[0]);
 66 
 67         if (addr != NEW_ADDR && addr != NULL_ADDR)
 68                 return true;
 69         return false;
 70 }
 71 
 72 static void __set_inode_rdev(struct inode *inode, struct f2fs_inode *ri)
 73 {
 74         if (S_ISCHR(inode->i_mode) || S_ISBLK(inode->i_mode)) {
 75                 if (old_valid_dev(inode->i_rdev)) {
 76                         ri->i_addr[0] =
 77                                 cpu_to_le32(old_encode_dev(inode->i_rdev));
 78                         ri->i_addr[1] = 0;
 79                 } else {
 80                         ri->i_addr[0] = 0;
 81                         ri->i_addr[1] =
 82                                 cpu_to_le32(new_encode_dev(inode->i_rdev));
 83                         ri->i_addr[2] = 0;
 84                 }
 85         }
 86 }
 87 
 88 static void __recover_inline_status(struct inode *inode, struct page *ipage)
 89 {
 90         void *inline_data = inline_data_addr(ipage);
 91         __le32 *start = inline_data;
 92         __le32 *end = start + MAX_INLINE_DATA / sizeof(__le32);
 93 
 94         while (start < end) {
 95                 if (*start++) {
 96                         f2fs_wait_on_page_writeback(ipage, NODE, true);
 97 
 98                         set_inode_flag(inode, FI_DATA_EXIST);
 99                         set_raw_inline(inode, F2FS_INODE(ipage));
100                         set_page_dirty(ipage);
101                         return;
102                 }
103         }
104         return;
105 }
106 
107 static int do_read_inode(struct inode *inode)
108 {
109         struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
110         struct f2fs_inode_info *fi = F2FS_I(inode);
111         struct page *node_page;
112         struct f2fs_inode *ri;
113 
114         /* Check if ino is within scope */
115         if (check_nid_range(sbi, inode->i_ino)) {
116                 f2fs_msg(inode->i_sb, KERN_ERR, "bad inode number: %lu",
117                          (unsigned long) inode->i_ino);
118                 WARN_ON(1);
119                 return -EINVAL;
120         }
121 
122         node_page = get_node_page(sbi, inode->i_ino);
123         if (IS_ERR(node_page))
124                 return PTR_ERR(node_page);
125 
126         ri = F2FS_INODE(node_page);
127 
128         inode->i_mode = le16_to_cpu(ri->i_mode);
129         i_uid_write(inode, le32_to_cpu(ri->i_uid));
130         i_gid_write(inode, le32_to_cpu(ri->i_gid));
131         set_nlink(inode, le32_to_cpu(ri->i_links));
132         inode->i_size = le64_to_cpu(ri->i_size);
133         inode->i_blocks = SECTOR_FROM_BLOCK(le64_to_cpu(ri->i_blocks) - 1);
134 
135         inode->i_atime.tv_sec = le64_to_cpu(ri->i_atime);
136         inode->i_ctime.tv_sec = le64_to_cpu(ri->i_ctime);
137         inode->i_mtime.tv_sec = le64_to_cpu(ri->i_mtime);
138         inode->i_atime.tv_nsec = le32_to_cpu(ri->i_atime_nsec);
139         inode->i_ctime.tv_nsec = le32_to_cpu(ri->i_ctime_nsec);
140         inode->i_mtime.tv_nsec = le32_to_cpu(ri->i_mtime_nsec);
141         inode->i_generation = le32_to_cpu(ri->i_generation);
142 
143         fi->i_current_depth = le32_to_cpu(ri->i_current_depth);
144         fi->i_xattr_nid = le32_to_cpu(ri->i_xattr_nid);
145         fi->i_flags = le32_to_cpu(ri->i_flags);
146         fi->flags = 0;
147         fi->i_advise = ri->i_advise;
148         fi->i_pino = le32_to_cpu(ri->i_pino);
149         fi->i_dir_level = ri->i_dir_level;
150 
151         if (f2fs_init_extent_tree(inode, &ri->i_ext))
152                 set_page_dirty(node_page);
153 
154         get_inline_info(inode, ri);
155 
156         /* check data exist */
157         if (f2fs_has_inline_data(inode) && !f2fs_exist_data(inode))
158                 __recover_inline_status(inode, node_page);
159 
160         /* get rdev by using inline_info */
161         __get_inode_rdev(inode, ri);
162 
163         if (__written_first_block(ri))
164                 set_inode_flag(inode, FI_FIRST_BLOCK_WRITTEN);
165 
166         if (!need_inode_block_update(sbi, inode->i_ino))
167                 fi->last_disk_size = inode->i_size;
168 
169         f2fs_put_page(node_page, 1);
170 
171         stat_inc_inline_xattr(inode);
172         stat_inc_inline_inode(inode);
173         stat_inc_inline_dir(inode);
174 
175         return 0;
176 }
177 
178 struct inode *f2fs_iget(struct super_block *sb, unsigned long ino)
179 {
180         struct f2fs_sb_info *sbi = F2FS_SB(sb);
181         struct inode *inode;
182         int ret = 0;
183 
184         inode = iget_locked(sb, ino);
185         if (!inode)
186                 return ERR_PTR(-ENOMEM);
187 
188         if (!(inode->i_state & I_NEW)) {
189                 trace_f2fs_iget(inode);
190                 return inode;
191         }
192         if (ino == F2FS_NODE_INO(sbi) || ino == F2FS_META_INO(sbi))
193                 goto make_now;
194 
195         ret = do_read_inode(inode);
196         if (ret)
197                 goto bad_inode;
198 make_now:
199         if (ino == F2FS_NODE_INO(sbi)) {
200                 inode->i_mapping->a_ops = &f2fs_node_aops;
201                 mapping_set_gfp_mask(inode->i_mapping, GFP_F2FS_ZERO);
202         } else if (ino == F2FS_META_INO(sbi)) {
203                 inode->i_mapping->a_ops = &f2fs_meta_aops;
204                 mapping_set_gfp_mask(inode->i_mapping, GFP_F2FS_ZERO);
205         } else if (S_ISREG(inode->i_mode)) {
206                 inode->i_op = &f2fs_file_inode_operations;
207                 inode->i_fop = &f2fs_file_operations;
208                 inode->i_mapping->a_ops = &f2fs_dblock_aops;
209         } else if (S_ISDIR(inode->i_mode)) {
210                 inode->i_op = &f2fs_dir_inode_operations;
211                 inode->i_fop = &f2fs_dir_operations;
212                 inode->i_mapping->a_ops = &f2fs_dblock_aops;
213                 mapping_set_gfp_mask(inode->i_mapping, GFP_F2FS_HIGH_ZERO);
214         } else if (S_ISLNK(inode->i_mode)) {
215                 if (f2fs_encrypted_inode(inode))
216                         inode->i_op = &f2fs_encrypted_symlink_inode_operations;
217                 else
218                         inode->i_op = &f2fs_symlink_inode_operations;
219                 inode_nohighmem(inode);
220                 inode->i_mapping->a_ops = &f2fs_dblock_aops;
221         } else if (S_ISCHR(inode->i_mode) || S_ISBLK(inode->i_mode) ||
222                         S_ISFIFO(inode->i_mode) || S_ISSOCK(inode->i_mode)) {
223                 inode->i_op = &f2fs_special_inode_operations;
224                 init_special_inode(inode, inode->i_mode, inode->i_rdev);
225         } else {
226                 ret = -EIO;
227                 goto bad_inode;
228         }
229         f2fs_set_inode_flags(inode);
230         unlock_new_inode(inode);
231         trace_f2fs_iget(inode);
232         return inode;
233 
234 bad_inode:
235         iget_failed(inode);
236         trace_f2fs_iget_exit(inode, ret);
237         return ERR_PTR(ret);
238 }
239 
240 struct inode *f2fs_iget_retry(struct super_block *sb, unsigned long ino)
241 {
242         struct inode *inode;
243 retry:
244         inode = f2fs_iget(sb, ino);
245         if (IS_ERR(inode)) {
246                 if (PTR_ERR(inode) == -ENOMEM) {
247                         congestion_wait(BLK_RW_ASYNC, HZ/50);
248                         goto retry;
249                 }
250         }
251         return inode;
252 }
253 
254 int update_inode(struct inode *inode, struct page *node_page)
255 {
256         struct f2fs_inode *ri;
257         struct extent_tree *et = F2FS_I(inode)->extent_tree;
258 
259         f2fs_inode_synced(inode);
260 
261         f2fs_wait_on_page_writeback(node_page, NODE, true);
262 
263         ri = F2FS_INODE(node_page);
264 
265         ri->i_mode = cpu_to_le16(inode->i_mode);
266         ri->i_advise = F2FS_I(inode)->i_advise;
267         ri->i_uid = cpu_to_le32(i_uid_read(inode));
268         ri->i_gid = cpu_to_le32(i_gid_read(inode));
269         ri->i_links = cpu_to_le32(inode->i_nlink);
270         ri->i_size = cpu_to_le64(i_size_read(inode));
271         ri->i_blocks = cpu_to_le64(SECTOR_TO_BLOCK(inode->i_blocks) + 1);
272 
273         if (et) {
274                 read_lock(&et->lock);
275                 set_raw_extent(&et->largest, &ri->i_ext);
276                 read_unlock(&et->lock);
277         } else {
278                 memset(&ri->i_ext, 0, sizeof(ri->i_ext));
279         }
280         set_raw_inline(inode, ri);
281 
282         ri->i_atime = cpu_to_le64(inode->i_atime.tv_sec);
283         ri->i_ctime = cpu_to_le64(inode->i_ctime.tv_sec);
284         ri->i_mtime = cpu_to_le64(inode->i_mtime.tv_sec);
285         ri->i_atime_nsec = cpu_to_le32(inode->i_atime.tv_nsec);
286         ri->i_ctime_nsec = cpu_to_le32(inode->i_ctime.tv_nsec);
287         ri->i_mtime_nsec = cpu_to_le32(inode->i_mtime.tv_nsec);
288         ri->i_current_depth = cpu_to_le32(F2FS_I(inode)->i_current_depth);
289         ri->i_xattr_nid = cpu_to_le32(F2FS_I(inode)->i_xattr_nid);
290         ri->i_flags = cpu_to_le32(F2FS_I(inode)->i_flags);
291         ri->i_pino = cpu_to_le32(F2FS_I(inode)->i_pino);
292         ri->i_generation = cpu_to_le32(inode->i_generation);
293         ri->i_dir_level = F2FS_I(inode)->i_dir_level;
294 
295         __set_inode_rdev(inode, ri);
296         set_cold_node(inode, node_page);
297 
298         /* deleted inode */
299         if (inode->i_nlink == 0)
300                 clear_inline_node(node_page);
301 
302         return set_page_dirty(node_page);
303 }
304 
305 int update_inode_page(struct inode *inode)
306 {
307         struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
308         struct page *node_page;
309         int ret = 0;
310 retry:
311         node_page = get_node_page(sbi, inode->i_ino);
312         if (IS_ERR(node_page)) {
313                 int err = PTR_ERR(node_page);
314                 if (err == -ENOMEM) {
315                         cond_resched();
316                         goto retry;
317                 } else if (err != -ENOENT) {
318                         f2fs_stop_checkpoint(sbi, false);
319                 }
320                 return 0;
321         }
322         ret = update_inode(inode, node_page);
323         f2fs_put_page(node_page, 1);
324         return ret;
325 }
326 
327 int f2fs_write_inode(struct inode *inode, struct writeback_control *wbc)
328 {
329         struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
330 
331         if (inode->i_ino == F2FS_NODE_INO(sbi) ||
332                         inode->i_ino == F2FS_META_INO(sbi))
333                 return 0;
334 
335         if (!is_inode_flag_set(inode, FI_DIRTY_INODE))
336                 return 0;
337 
338         /*
339          * We need to balance fs here to prevent from producing dirty node pages
340          * during the urgent cleaning time when runing out of free sections.
341          */
342         update_inode_page(inode);
343         if (wbc && wbc->nr_to_write)
344                 f2fs_balance_fs(sbi, true);
345         return 0;
346 }
347 
348 /*
349  * Called at the last iput() if i_nlink is zero
350  */
351 void f2fs_evict_inode(struct inode *inode)
352 {
353         struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
354         nid_t xnid = F2FS_I(inode)->i_xattr_nid;
355         int err = 0;
356 
357         /* some remained atomic pages should discarded */
358         if (f2fs_is_atomic_file(inode))
359                 drop_inmem_pages(inode);
360 
361         trace_f2fs_evict_inode(inode);
362         truncate_inode_pages_final(&inode->i_data);
363 
364         if (inode->i_ino == F2FS_NODE_INO(sbi) ||
365                         inode->i_ino == F2FS_META_INO(sbi))
366                 goto out_clear;
367 
368         f2fs_bug_on(sbi, get_dirty_pages(inode));
369         remove_dirty_inode(inode);
370 
371         f2fs_destroy_extent_tree(inode);
372 
373         if (inode->i_nlink || is_bad_inode(inode))
374                 goto no_delete;
375 
376         dquot_initialize(inode);
377 
378         remove_ino_entry(sbi, inode->i_ino, APPEND_INO);
379         remove_ino_entry(sbi, inode->i_ino, UPDATE_INO);
380 
381         sb_start_intwrite(inode->i_sb);
382         set_inode_flag(inode, FI_NO_ALLOC);
383         i_size_write(inode, 0);
384 retry:
385         if (F2FS_HAS_BLOCKS(inode))
386                 err = f2fs_truncate(inode);
387 
388 #ifdef CONFIG_F2FS_FAULT_INJECTION
389         if (time_to_inject(sbi, FAULT_EVICT_INODE)) {
390                 f2fs_show_injection_info(FAULT_EVICT_INODE);
391                 err = -EIO;
392         }
393 #endif
394         if (!err) {
395                 f2fs_lock_op(sbi);
396                 err = remove_inode_page(inode);
397                 f2fs_unlock_op(sbi);
398                 if (err == -ENOENT)
399                         err = 0;
400         }
401 
402         /* give more chances, if ENOMEM case */
403         if (err == -ENOMEM) {
404                 err = 0;
405                 goto retry;
406         }
407 
408         if (err)
409                 update_inode_page(inode);
410         dquot_free_inode(inode);
411         sb_end_intwrite(inode->i_sb);
412 no_delete:
413         dquot_drop(inode);
414 
415         stat_dec_inline_xattr(inode);
416         stat_dec_inline_dir(inode);
417         stat_dec_inline_inode(inode);
418 
419         /* ino == 0, if f2fs_new_inode() was failed t*/
420         if (inode->i_ino)
421                 invalidate_mapping_pages(NODE_MAPPING(sbi), inode->i_ino,
422                                                         inode->i_ino);
423         if (xnid)
424                 invalidate_mapping_pages(NODE_MAPPING(sbi), xnid, xnid);
425         if (inode->i_nlink) {
426                 if (is_inode_flag_set(inode, FI_APPEND_WRITE))
427                         add_ino_entry(sbi, inode->i_ino, APPEND_INO);
428                 if (is_inode_flag_set(inode, FI_UPDATE_WRITE))
429                         add_ino_entry(sbi, inode->i_ino, UPDATE_INO);
430         }
431         if (is_inode_flag_set(inode, FI_FREE_NID)) {
432                 alloc_nid_failed(sbi, inode->i_ino);
433                 clear_inode_flag(inode, FI_FREE_NID);
434         } else {
435                 f2fs_bug_on(sbi, err &&
436                         !exist_written_data(sbi, inode->i_ino, ORPHAN_INO));
437         }
438 out_clear:
439         fscrypt_put_encryption_info(inode, NULL);
440         clear_inode(inode);
441 }
442 
443 /* caller should call f2fs_lock_op() */
444 void handle_failed_inode(struct inode *inode)
445 {
446         struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
447         struct node_info ni;
448 
449         /*
450          * clear nlink of inode in order to release resource of inode
451          * immediately.
452          */
453         clear_nlink(inode);
454 
455         /*
456          * we must call this to avoid inode being remained as dirty, resulting
457          * in a panic when flushing dirty inodes in gdirty_list.
458          */
459         update_inode_page(inode);
460         f2fs_inode_synced(inode);
461 
462         /* don't make bad inode, since it becomes a regular file. */
463         unlock_new_inode(inode);
464 
465         /*
466          * Note: we should add inode to orphan list before f2fs_unlock_op()
467          * so we can prevent losing this orphan when encoutering checkpoint
468          * and following suddenly power-off.
469          */
470         get_node_info(sbi, inode->i_ino, &ni);
471 
472         if (ni.blk_addr != NULL_ADDR) {
473                 int err = acquire_orphan_inode(sbi);
474                 if (err) {
475                         set_sbi_flag(sbi, SBI_NEED_FSCK);
476                         f2fs_msg(sbi->sb, KERN_WARNING,
477                                 "Too many orphan inodes, run fsck to fix.");
478                 } else {
479                         add_orphan_inode(inode);
480                 }
481                 alloc_nid_done(sbi, inode->i_ino);
482         } else {
483                 set_inode_flag(inode, FI_FREE_NID);
484         }
485 
486         f2fs_unlock_op(sbi);
487 
488         /* iput will drop the inode object */
489         iput(inode);
490 }
491 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp