blob: 97e20decacb4e17677fc3c43cfb5d45a6ab290bc [file] [log] [blame]
Jaegeuk Kim0a8165d2012-11-29 13:28:09 +09001/*
Jaegeuk Kim19f99ce2012-11-02 17:10:40 +09002 * 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/writeback.h>
15
16#include "f2fs.h"
17#include "node.h"
18
Namjae Jeona2a4a7e2013-04-20 01:28:40 +090019#include <trace/events/f2fs.h>
20
Jaegeuk Kim19f99ce2012-11-02 17:10:40 +090021void f2fs_set_inode_flags(struct inode *inode)
22{
23 unsigned int flags = F2FS_I(inode)->i_flags;
Zhang Zhen8abfb362014-04-15 14:19:38 +080024 unsigned int new_fl = 0;
Jaegeuk Kim19f99ce2012-11-02 17:10:40 +090025
26 if (flags & FS_SYNC_FL)
Zhang Zhen8abfb362014-04-15 14:19:38 +080027 new_fl |= S_SYNC;
Jaegeuk Kim19f99ce2012-11-02 17:10:40 +090028 if (flags & FS_APPEND_FL)
Zhang Zhen8abfb362014-04-15 14:19:38 +080029 new_fl |= S_APPEND;
Jaegeuk Kim19f99ce2012-11-02 17:10:40 +090030 if (flags & FS_IMMUTABLE_FL)
Zhang Zhen8abfb362014-04-15 14:19:38 +080031 new_fl |= S_IMMUTABLE;
Jaegeuk Kim19f99ce2012-11-02 17:10:40 +090032 if (flags & FS_NOATIME_FL)
Zhang Zhen8abfb362014-04-15 14:19:38 +080033 new_fl |= S_NOATIME;
Jaegeuk Kim19f99ce2012-11-02 17:10:40 +090034 if (flags & FS_DIRSYNC_FL)
Zhang Zhen8abfb362014-04-15 14:19:38 +080035 new_fl |= S_DIRSYNC;
Zhang Zhen6a678852015-08-24 10:41:32 +080036 inode_set_flags(inode, new_fl,
37 S_SYNC|S_APPEND|S_IMMUTABLE|S_NOATIME|S_DIRSYNC);
Jaegeuk Kim19f99ce2012-11-02 17:10:40 +090038}
39
Jaegeuk Kim3d1e3802013-10-08 18:01:51 +090040static void __get_inode_rdev(struct inode *inode, struct f2fs_inode *ri)
41{
42 if (S_ISCHR(inode->i_mode) || S_ISBLK(inode->i_mode) ||
43 S_ISFIFO(inode->i_mode) || S_ISSOCK(inode->i_mode)) {
44 if (ri->i_addr[0])
Chris Fries6c311ec2014-01-17 14:44:39 -060045 inode->i_rdev =
46 old_decode_dev(le32_to_cpu(ri->i_addr[0]));
Jaegeuk Kim3d1e3802013-10-08 18:01:51 +090047 else
Chris Fries6c311ec2014-01-17 14:44:39 -060048 inode->i_rdev =
49 new_decode_dev(le32_to_cpu(ri->i_addr[1]));
Jaegeuk Kim3d1e3802013-10-08 18:01:51 +090050 }
51}
52
Jaegeuk Kim3c6c2be2015-03-17 17:16:35 -070053static bool __written_first_block(struct f2fs_inode *ri)
54{
Jaegeuk Kimadad81e2015-03-24 12:04:20 -070055 block_t addr = le32_to_cpu(ri->i_addr[0]);
56
57 if (addr != NEW_ADDR && addr != NULL_ADDR)
Jaegeuk Kim3c6c2be2015-03-17 17:16:35 -070058 return true;
59 return false;
60}
61
Jaegeuk Kim3d1e3802013-10-08 18:01:51 +090062static void __set_inode_rdev(struct inode *inode, struct f2fs_inode *ri)
63{
64 if (S_ISCHR(inode->i_mode) || S_ISBLK(inode->i_mode)) {
65 if (old_valid_dev(inode->i_rdev)) {
Chris Fries6c311ec2014-01-17 14:44:39 -060066 ri->i_addr[0] =
67 cpu_to_le32(old_encode_dev(inode->i_rdev));
Jaegeuk Kim3d1e3802013-10-08 18:01:51 +090068 ri->i_addr[1] = 0;
69 } else {
70 ri->i_addr[0] = 0;
Chris Fries6c311ec2014-01-17 14:44:39 -060071 ri->i_addr[1] =
72 cpu_to_le32(new_encode_dev(inode->i_rdev));
Jaegeuk Kim3d1e3802013-10-08 18:01:51 +090073 ri->i_addr[2] = 0;
74 }
75 }
76}
77
Chao Yu9e5ba772015-01-06 14:28:43 +080078static void __recover_inline_status(struct inode *inode, struct page *ipage)
Jaegeuk Kimb3d208f2014-10-23 19:48:09 -070079{
80 void *inline_data = inline_data_addr(ipage);
Chao Yu9e5ba772015-01-06 14:28:43 +080081 __le32 *start = inline_data;
82 __le32 *end = start + MAX_INLINE_DATA / sizeof(__le32);
Jaegeuk Kimb3d208f2014-10-23 19:48:09 -070083
Chao Yu9e5ba772015-01-06 14:28:43 +080084 while (start < end) {
85 if (*start++) {
86 f2fs_wait_on_page_writeback(ipage, NODE);
Jaegeuk Kimb3d208f2014-10-23 19:48:09 -070087
Chao Yu9e5ba772015-01-06 14:28:43 +080088 set_inode_flag(F2FS_I(inode), FI_DATA_EXIST);
89 set_raw_inline(F2FS_I(inode), F2FS_INODE(ipage));
90 set_page_dirty(ipage);
91 return;
92 }
Jaegeuk Kimb3d208f2014-10-23 19:48:09 -070093 }
Chao Yu9e5ba772015-01-06 14:28:43 +080094 return;
Jaegeuk Kimb3d208f2014-10-23 19:48:09 -070095}
96
Jaegeuk Kim19f99ce2012-11-02 17:10:40 +090097static int do_read_inode(struct inode *inode)
98{
Jaegeuk Kim40813632014-09-02 15:31:18 -070099 struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
Jaegeuk Kim19f99ce2012-11-02 17:10:40 +0900100 struct f2fs_inode_info *fi = F2FS_I(inode);
101 struct page *node_page;
Jaegeuk Kim19f99ce2012-11-02 17:10:40 +0900102 struct f2fs_inode *ri;
103
104 /* Check if ino is within scope */
Namjae Jeon064e0822013-03-17 17:27:20 +0900105 if (check_nid_range(sbi, inode->i_ino)) {
106 f2fs_msg(inode->i_sb, KERN_ERR, "bad inode number: %lu",
107 (unsigned long) inode->i_ino);
Chao Yud6b7d4b2014-06-12 13:23:41 +0800108 WARN_ON(1);
Namjae Jeon064e0822013-03-17 17:27:20 +0900109 return -EINVAL;
110 }
Jaegeuk Kim19f99ce2012-11-02 17:10:40 +0900111
112 node_page = get_node_page(sbi, inode->i_ino);
113 if (IS_ERR(node_page))
114 return PTR_ERR(node_page);
115
Jaegeuk Kim58bfaf42013-12-26 16:30:41 +0900116 ri = F2FS_INODE(node_page);
Jaegeuk Kim19f99ce2012-11-02 17:10:40 +0900117
118 inode->i_mode = le16_to_cpu(ri->i_mode);
119 i_uid_write(inode, le32_to_cpu(ri->i_uid));
120 i_gid_write(inode, le32_to_cpu(ri->i_gid));
121 set_nlink(inode, le32_to_cpu(ri->i_links));
122 inode->i_size = le64_to_cpu(ri->i_size);
123 inode->i_blocks = le64_to_cpu(ri->i_blocks);
124
125 inode->i_atime.tv_sec = le64_to_cpu(ri->i_atime);
126 inode->i_ctime.tv_sec = le64_to_cpu(ri->i_ctime);
127 inode->i_mtime.tv_sec = le64_to_cpu(ri->i_mtime);
128 inode->i_atime.tv_nsec = le32_to_cpu(ri->i_atime_nsec);
129 inode->i_ctime.tv_nsec = le32_to_cpu(ri->i_ctime_nsec);
130 inode->i_mtime.tv_nsec = le32_to_cpu(ri->i_mtime_nsec);
131 inode->i_generation = le32_to_cpu(ri->i_generation);
132
133 fi->i_current_depth = le32_to_cpu(ri->i_current_depth);
134 fi->i_xattr_nid = le32_to_cpu(ri->i_xattr_nid);
135 fi->i_flags = le32_to_cpu(ri->i_flags);
136 fi->flags = 0;
Jaegeuk Kim19f99ce2012-11-02 17:10:40 +0900137 fi->i_advise = ri->i_advise;
Jaegeuk Kim6666e6a2012-12-10 17:52:48 +0900138 fi->i_pino = le32_to_cpu(ri->i_pino);
Jaegeuk Kim38431542014-02-27 18:20:00 +0900139 fi->i_dir_level = ri->i_dir_level;
Jaegeuk Kim3d1e3802013-10-08 18:01:51 +0900140
Jaegeuk Kim3e72f722015-06-19 17:53:26 -0700141 f2fs_init_extent_tree(inode, &ri->i_ext);
Chao Yu0c872e22015-02-05 17:46:29 +0800142
Jaegeuk Kim444c5802013-08-08 15:16:22 +0900143 get_inline_info(fi, ri);
Jaegeuk Kim3d1e3802013-10-08 18:01:51 +0900144
Jaegeuk Kimb3d208f2014-10-23 19:48:09 -0700145 /* check data exist */
146 if (f2fs_has_inline_data(inode) && !f2fs_exist_data(inode))
Chao Yu9e5ba772015-01-06 14:28:43 +0800147 __recover_inline_status(inode, node_page);
Jaegeuk Kimb3d208f2014-10-23 19:48:09 -0700148
Jaegeuk Kim3d1e3802013-10-08 18:01:51 +0900149 /* get rdev by using inline_info */
150 __get_inode_rdev(inode, ri);
151
Jaegeuk Kim3c6c2be2015-03-17 17:16:35 -0700152 if (__written_first_block(ri))
153 set_inode_flag(F2FS_I(inode), FI_FIRST_BLOCK_WRITTEN);
154
Jaegeuk Kim19f99ce2012-11-02 17:10:40 +0900155 f2fs_put_page(node_page, 1);
Jaegeuk Kim9d1015d2014-12-05 10:51:50 -0800156
Chao Yud5e8f6c2015-07-15 17:28:53 +0800157 stat_inc_inline_xattr(inode);
Jaegeuk Kim9d1015d2014-12-05 10:51:50 -0800158 stat_inc_inline_inode(inode);
159 stat_inc_inline_dir(inode);
160
Chao Yu9e5ba772015-01-06 14:28:43 +0800161 return 0;
Jaegeuk Kim19f99ce2012-11-02 17:10:40 +0900162}
163
164struct inode *f2fs_iget(struct super_block *sb, unsigned long ino)
165{
166 struct f2fs_sb_info *sbi = F2FS_SB(sb);
167 struct inode *inode;
Namjae Jeona2a4a7e2013-04-20 01:28:40 +0900168 int ret = 0;
Jaegeuk Kim19f99ce2012-11-02 17:10:40 +0900169
170 inode = iget_locked(sb, ino);
171 if (!inode)
172 return ERR_PTR(-ENOMEM);
Namjae Jeona2a4a7e2013-04-20 01:28:40 +0900173
174 if (!(inode->i_state & I_NEW)) {
175 trace_f2fs_iget(inode);
Jaegeuk Kim19f99ce2012-11-02 17:10:40 +0900176 return inode;
Namjae Jeona2a4a7e2013-04-20 01:28:40 +0900177 }
Jaegeuk Kim19f99ce2012-11-02 17:10:40 +0900178 if (ino == F2FS_NODE_INO(sbi) || ino == F2FS_META_INO(sbi))
179 goto make_now;
180
181 ret = do_read_inode(inode);
182 if (ret)
183 goto bad_inode;
Jaegeuk Kim19f99ce2012-11-02 17:10:40 +0900184make_now:
185 if (ino == F2FS_NODE_INO(sbi)) {
186 inode->i_mapping->a_ops = &f2fs_node_aops;
187 mapping_set_gfp_mask(inode->i_mapping, GFP_F2FS_ZERO);
188 } else if (ino == F2FS_META_INO(sbi)) {
189 inode->i_mapping->a_ops = &f2fs_meta_aops;
190 mapping_set_gfp_mask(inode->i_mapping, GFP_F2FS_ZERO);
191 } else if (S_ISREG(inode->i_mode)) {
192 inode->i_op = &f2fs_file_inode_operations;
193 inode->i_fop = &f2fs_file_operations;
194 inode->i_mapping->a_ops = &f2fs_dblock_aops;
195 } else if (S_ISDIR(inode->i_mode)) {
196 inode->i_op = &f2fs_dir_inode_operations;
197 inode->i_fop = &f2fs_dir_operations;
198 inode->i_mapping->a_ops = &f2fs_dblock_aops;
Jaegeuk Kima78186e2014-10-17 17:57:29 -0700199 mapping_set_gfp_mask(inode->i_mapping, GFP_F2FS_HIGH_ZERO);
Jaegeuk Kim19f99ce2012-11-02 17:10:40 +0900200 } else if (S_ISLNK(inode->i_mode)) {
Jaegeuk Kimcbaf0422015-04-29 15:10:53 -0700201 if (f2fs_encrypted_inode(inode))
202 inode->i_op = &f2fs_encrypted_symlink_inode_operations;
203 else
204 inode->i_op = &f2fs_symlink_inode_operations;
Jaegeuk Kim19f99ce2012-11-02 17:10:40 +0900205 inode->i_mapping->a_ops = &f2fs_dblock_aops;
206 } else if (S_ISCHR(inode->i_mode) || S_ISBLK(inode->i_mode) ||
207 S_ISFIFO(inode->i_mode) || S_ISSOCK(inode->i_mode)) {
208 inode->i_op = &f2fs_special_inode_operations;
209 init_special_inode(inode, inode->i_mode, inode->i_rdev);
210 } else {
211 ret = -EIO;
212 goto bad_inode;
213 }
214 unlock_new_inode(inode);
Namjae Jeona2a4a7e2013-04-20 01:28:40 +0900215 trace_f2fs_iget(inode);
Jaegeuk Kim19f99ce2012-11-02 17:10:40 +0900216 return inode;
217
218bad_inode:
219 iget_failed(inode);
Namjae Jeona2a4a7e2013-04-20 01:28:40 +0900220 trace_f2fs_iget_exit(inode, ret);
Jaegeuk Kim19f99ce2012-11-02 17:10:40 +0900221 return ERR_PTR(ret);
222}
223
224void update_inode(struct inode *inode, struct page *node_page)
225{
Jaegeuk Kim19f99ce2012-11-02 17:10:40 +0900226 struct f2fs_inode *ri;
227
Yuan Zhong5514f0a2014-01-10 07:26:14 +0000228 f2fs_wait_on_page_writeback(node_page, NODE);
Jaegeuk Kim19f99ce2012-11-02 17:10:40 +0900229
Jaegeuk Kim58bfaf42013-12-26 16:30:41 +0900230 ri = F2FS_INODE(node_page);
Jaegeuk Kim19f99ce2012-11-02 17:10:40 +0900231
232 ri->i_mode = cpu_to_le16(inode->i_mode);
233 ri->i_advise = F2FS_I(inode)->i_advise;
234 ri->i_uid = cpu_to_le32(i_uid_read(inode));
235 ri->i_gid = cpu_to_le32(i_gid_read(inode));
236 ri->i_links = cpu_to_le32(inode->i_nlink);
237 ri->i_size = cpu_to_le64(i_size_read(inode));
238 ri->i_blocks = cpu_to_le64(inode->i_blocks);
Chao Yu0c872e22015-02-05 17:46:29 +0800239
Jaegeuk Kim3e72f722015-06-19 17:53:26 -0700240 if (F2FS_I(inode)->extent_tree)
241 set_raw_extent(&F2FS_I(inode)->extent_tree->largest,
242 &ri->i_ext);
243 else
244 memset(&ri->i_ext, 0, sizeof(ri->i_ext));
Jaegeuk Kim444c5802013-08-08 15:16:22 +0900245 set_raw_inline(F2FS_I(inode), ri);
Jaegeuk Kim19f99ce2012-11-02 17:10:40 +0900246
247 ri->i_atime = cpu_to_le64(inode->i_atime.tv_sec);
248 ri->i_ctime = cpu_to_le64(inode->i_ctime.tv_sec);
249 ri->i_mtime = cpu_to_le64(inode->i_mtime.tv_sec);
250 ri->i_atime_nsec = cpu_to_le32(inode->i_atime.tv_nsec);
251 ri->i_ctime_nsec = cpu_to_le32(inode->i_ctime.tv_nsec);
252 ri->i_mtime_nsec = cpu_to_le32(inode->i_mtime.tv_nsec);
253 ri->i_current_depth = cpu_to_le32(F2FS_I(inode)->i_current_depth);
254 ri->i_xattr_nid = cpu_to_le32(F2FS_I(inode)->i_xattr_nid);
255 ri->i_flags = cpu_to_le32(F2FS_I(inode)->i_flags);
Jaegeuk Kim6666e6a2012-12-10 17:52:48 +0900256 ri->i_pino = cpu_to_le32(F2FS_I(inode)->i_pino);
Jaegeuk Kim19f99ce2012-11-02 17:10:40 +0900257 ri->i_generation = cpu_to_le32(inode->i_generation);
Jaegeuk Kim38431542014-02-27 18:20:00 +0900258 ri->i_dir_level = F2FS_I(inode)->i_dir_level;
Changman Lee7d79e752013-01-23 09:40:23 +0900259
Jaegeuk Kim3d1e3802013-10-08 18:01:51 +0900260 __set_inode_rdev(inode, ri);
Jaegeuk Kim398b1ac2012-12-19 15:28:39 +0900261 set_cold_node(inode, node_page);
Jaegeuk Kim19f99ce2012-11-02 17:10:40 +0900262 set_page_dirty(node_page);
Jaegeuk Kim3d1e3802013-10-08 18:01:51 +0900263
Jaegeuk Kimb3783872013-06-10 09:17:01 +0900264 clear_inode_flag(F2FS_I(inode), FI_DIRTY_INODE);
Jaegeuk Kim19f99ce2012-11-02 17:10:40 +0900265}
266
Jaegeuk Kim744602c2014-01-24 09:42:16 +0900267void update_inode_page(struct inode *inode)
Jaegeuk Kim19f99ce2012-11-02 17:10:40 +0900268{
Jaegeuk Kim40813632014-09-02 15:31:18 -0700269 struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
Jaegeuk Kim19f99ce2012-11-02 17:10:40 +0900270 struct page *node_page;
Jaegeuk Kim744602c2014-01-24 09:42:16 +0900271retry:
Jaegeuk Kim39936832012-11-22 16:21:29 +0900272 node_page = get_node_page(sbi, inode->i_ino);
Jaegeuk Kim744602c2014-01-24 09:42:16 +0900273 if (IS_ERR(node_page)) {
274 int err = PTR_ERR(node_page);
275 if (err == -ENOMEM) {
276 cond_resched();
277 goto retry;
278 } else if (err != -ENOENT) {
279 f2fs_stop_checkpoint(sbi);
280 }
281 return;
282 }
Jaegeuk Kim39936832012-11-22 16:21:29 +0900283 update_inode(inode, node_page);
284 f2fs_put_page(node_page, 1);
Jaegeuk Kim39936832012-11-22 16:21:29 +0900285}
286
287int f2fs_write_inode(struct inode *inode, struct writeback_control *wbc)
288{
Jaegeuk Kim40813632014-09-02 15:31:18 -0700289 struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
Jaegeuk Kim19f99ce2012-11-02 17:10:40 +0900290
291 if (inode->i_ino == F2FS_NODE_INO(sbi) ||
292 inode->i_ino == F2FS_META_INO(sbi))
293 return 0;
294
Jaegeuk Kimb3783872013-06-10 09:17:01 +0900295 if (!is_inode_flag_set(F2FS_I(inode), FI_DIRTY_INODE))
296 return 0;
297
Jaegeuk Kim39936832012-11-22 16:21:29 +0900298 /*
Jaegeuk Kimc5cd29d2015-09-12 11:25:30 -0700299 * We need to balance fs here to prevent from producing dirty node pages
Jaegeuk Kim39936832012-11-22 16:21:29 +0900300 * during the urgent cleaning time when runing out of free sections.
301 */
Jaegeuk Kim744602c2014-01-24 09:42:16 +0900302 update_inode_page(inode);
Jin Xu92c43422013-08-15 19:17:01 +0800303
Jaegeuk Kimc5cd29d2015-09-12 11:25:30 -0700304 f2fs_balance_fs(sbi);
Jaegeuk Kim744602c2014-01-24 09:42:16 +0900305 return 0;
Jaegeuk Kim19f99ce2012-11-02 17:10:40 +0900306}
307
Jaegeuk Kim0a8165d2012-11-29 13:28:09 +0900308/*
Jaegeuk Kim19f99ce2012-11-02 17:10:40 +0900309 * Called at the last iput() if i_nlink is zero
310 */
311void f2fs_evict_inode(struct inode *inode)
312{
Jaegeuk Kim40813632014-09-02 15:31:18 -0700313 struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
Jaegeuk Kimc9b63bd2015-06-23 10:36:08 -0700314 struct f2fs_inode_info *fi = F2FS_I(inode);
315 nid_t xnid = fi->i_xattr_nid;
Chao Yu13ec7292015-08-24 17:40:45 +0800316 int err = 0;
Jaegeuk Kim19f99ce2012-11-02 17:10:40 +0900317
Jaegeuk Kim88b88a62014-10-06 17:39:50 -0700318 /* some remained atomic pages should discarded */
Jaegeuk Kim1e843712014-12-09 06:08:59 -0800319 if (f2fs_is_atomic_file(inode))
Jaegeuk Kim88b88a62014-10-06 17:39:50 -0700320 commit_inmem_pages(inode, true);
321
Namjae Jeona2a4a7e2013-04-20 01:28:40 +0900322 trace_f2fs_evict_inode(inode);
Johannes Weiner91b0abe2014-04-03 14:47:49 -0700323 truncate_inode_pages_final(&inode->i_data);
Jaegeuk Kim19f99ce2012-11-02 17:10:40 +0900324
325 if (inode->i_ino == F2FS_NODE_INO(sbi) ||
326 inode->i_ino == F2FS_META_INO(sbi))
Chao Yudbf20cb2014-07-25 12:00:57 +0800327 goto out_clear;
Jaegeuk Kim19f99ce2012-11-02 17:10:40 +0900328
Jaegeuk Kima7ffdbe2014-09-12 15:53:45 -0700329 f2fs_bug_on(sbi, get_dirty_pages(inode));
Jaegeuk Kim19f99ce2012-11-02 17:10:40 +0900330 remove_dirty_dir_inode(inode);
331
Jaegeuk Kim3e72f722015-06-19 17:53:26 -0700332 f2fs_destroy_extent_tree(inode);
333
Jaegeuk Kim19f99ce2012-11-02 17:10:40 +0900334 if (inode->i_nlink || is_bad_inode(inode))
335 goto no_delete;
336
Changman Leed6212a52013-01-29 18:30:07 +0900337 sb_start_intwrite(inode->i_sb);
Jaegeuk Kimc9b63bd2015-06-23 10:36:08 -0700338 set_inode_flag(fi, FI_NO_ALLOC);
Jaegeuk Kim19f99ce2012-11-02 17:10:40 +0900339 i_size_write(inode, 0);
340
341 if (F2FS_HAS_BLOCKS(inode))
Chao Yu13ec7292015-08-24 17:40:45 +0800342 err = f2fs_truncate(inode, true);
Jaegeuk Kim19f99ce2012-11-02 17:10:40 +0900343
Chao Yu13ec7292015-08-24 17:40:45 +0800344 if (!err) {
345 f2fs_lock_op(sbi);
346 err = remove_inode_page(inode);
347 f2fs_unlock_op(sbi);
348 }
Jaegeuk Kim39936832012-11-22 16:21:29 +0900349
Changman Leed6212a52013-01-29 18:30:07 +0900350 sb_end_intwrite(inode->i_sb);
Jaegeuk Kim19f99ce2012-11-02 17:10:40 +0900351no_delete:
Chao Yud5e8f6c2015-07-15 17:28:53 +0800352 stat_dec_inline_xattr(inode);
Jaegeuk Kim3289c062014-10-13 20:00:16 -0700353 stat_dec_inline_dir(inode);
Jaegeuk Kime7a2bf22014-10-14 10:29:50 -0700354 stat_dec_inline_inode(inode);
Chao Yu0bdee482015-03-19 19:27:51 +0800355
Jaegeuk Kim81988992014-04-30 15:04:39 +0900356 invalidate_mapping_pages(NODE_MAPPING(sbi), inode->i_ino, inode->i_ino);
Chao Yu002a41c2014-08-04 09:54:58 +0800357 if (xnid)
358 invalidate_mapping_pages(NODE_MAPPING(sbi), xnid, xnid);
Jaegeuk Kimc9b63bd2015-06-23 10:36:08 -0700359 if (is_inode_flag_set(fi, FI_APPEND_WRITE))
Jaegeuk Kimfff04f92014-07-25 07:40:59 -0700360 add_dirty_inode(sbi, inode->i_ino, APPEND_INO);
Jaegeuk Kimc9b63bd2015-06-23 10:36:08 -0700361 if (is_inode_flag_set(fi, FI_UPDATE_WRITE))
Jaegeuk Kimfff04f92014-07-25 07:40:59 -0700362 add_dirty_inode(sbi, inode->i_ino, UPDATE_INO);
Jaegeuk Kimc9b63bd2015-06-23 10:36:08 -0700363 if (is_inode_flag_set(fi, FI_FREE_NID)) {
Chao Yu13ec7292015-08-24 17:40:45 +0800364 if (err && err != -ENOENT)
365 alloc_nid_done(sbi, inode->i_ino);
366 else
367 alloc_nid_failed(sbi, inode->i_ino);
Jaegeuk Kimc9b63bd2015-06-23 10:36:08 -0700368 clear_inode_flag(fi, FI_FREE_NID);
369 }
Chao Yu13ec7292015-08-24 17:40:45 +0800370
371 if (err && err != -ENOENT) {
372 if (!exist_written_data(sbi, inode->i_ino, ORPHAN_INO)) {
373 /*
374 * get here because we failed to release resource
375 * of inode previously, reminder our user to run fsck
376 * for fixing.
377 */
378 set_sbi_flag(sbi, SBI_NEED_FSCK);
379 f2fs_msg(sbi->sb, KERN_WARNING,
380 "inode (ino:%lu) resource leak, run fsck "
381 "to fix this issue!", inode->i_ino);
382 }
383 }
Chao Yudbf20cb2014-07-25 12:00:57 +0800384out_clear:
Jaegeuk Kimfcc85a42015-04-21 20:39:58 -0700385#ifdef CONFIG_F2FS_FS_ENCRYPTION
Jaegeuk Kimc9b63bd2015-06-23 10:36:08 -0700386 if (fi->i_crypt_info)
387 f2fs_free_encryption_info(inode, fi->i_crypt_info);
Jaegeuk Kimfcc85a42015-04-21 20:39:58 -0700388#endif
Chao Yudbf20cb2014-07-25 12:00:57 +0800389 clear_inode(inode);
Jaegeuk Kim19f99ce2012-11-02 17:10:40 +0900390}
Jaegeuk Kim44c16152014-09-25 11:55:53 -0700391
392/* caller should call f2fs_lock_op() */
393void handle_failed_inode(struct inode *inode)
394{
395 struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
Chao Yu13ec7292015-08-24 17:40:45 +0800396 int err = 0;
Jaegeuk Kim44c16152014-09-25 11:55:53 -0700397
398 clear_nlink(inode);
399 make_bad_inode(inode);
400 unlock_new_inode(inode);
401
402 i_size_write(inode, 0);
403 if (F2FS_HAS_BLOCKS(inode))
Chao Yu13ec7292015-08-24 17:40:45 +0800404 err = f2fs_truncate(inode, false);
Jaegeuk Kim44c16152014-09-25 11:55:53 -0700405
Chao Yu13ec7292015-08-24 17:40:45 +0800406 if (!err)
407 err = remove_inode_page(inode);
408
409 /*
410 * if we skip truncate_node in remove_inode_page bacause we failed
411 * before, it's better to find another way to release resource of
412 * this inode (e.g. valid block count, node block or nid). Here we
413 * choose to add this inode to orphan list, so that we can call iput
414 * for releasing in orphan recovery flow.
415 *
416 * Note: we should add inode to orphan list before f2fs_unlock_op()
417 * so we can prevent losing this orphan when encoutering checkpoint
418 * and following suddenly power-off.
419 */
420 if (err && err != -ENOENT) {
421 err = acquire_orphan_inode(sbi);
422 if (!err)
423 add_orphan_inode(sbi, inode->i_ino);
424 }
Jaegeuk Kim44c16152014-09-25 11:55:53 -0700425
Jaegeuk Kimc9b63bd2015-06-23 10:36:08 -0700426 set_inode_flag(F2FS_I(inode), FI_FREE_NID);
Jaegeuk Kim44c16152014-09-25 11:55:53 -0700427 f2fs_unlock_op(sbi);
428
429 /* iput will drop the inode object */
430 iput(inode);
431}