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/writeback.h>
15#include <linux/bitops.h>
16
17#include "f2fs.h"
18#include "node.h"
19
20#include <trace/events/f2fs.h>
21
22void f2fs_set_inode_flags(struct inode *inode)
23{
24	unsigned int flags = F2FS_I(inode)->i_flags;
25	unsigned int new_fl = 0;
26
27	if (flags & FS_SYNC_FL)
28		new_fl |= S_SYNC;
29	if (flags & FS_APPEND_FL)
30		new_fl |= S_APPEND;
31	if (flags & FS_IMMUTABLE_FL)
32		new_fl |= S_IMMUTABLE;
33	if (flags & FS_NOATIME_FL)
34		new_fl |= S_NOATIME;
35	if (flags & FS_DIRSYNC_FL)
36		new_fl |= S_DIRSYNC;
37	set_mask_bits(&inode->i_flags,
38			S_SYNC|S_APPEND|S_IMMUTABLE|S_NOATIME|S_DIRSYNC, new_fl);
39}
40
41static void __get_inode_rdev(struct inode *inode, struct f2fs_inode *ri)
42{
43	if (S_ISCHR(inode->i_mode) || S_ISBLK(inode->i_mode) ||
44			S_ISFIFO(inode->i_mode) || S_ISSOCK(inode->i_mode)) {
45		if (ri->i_addr[0])
46			inode->i_rdev =
47				old_decode_dev(le32_to_cpu(ri->i_addr[0]));
48		else
49			inode->i_rdev =
50				new_decode_dev(le32_to_cpu(ri->i_addr[1]));
51	}
52}
53
54static bool __written_first_block(struct f2fs_inode *ri)
55{
56	block_t addr = le32_to_cpu(ri->i_addr[0]);
57
58	if (addr != NEW_ADDR && addr != NULL_ADDR)
59		return true;
60	return false;
61}
62
63static void __set_inode_rdev(struct inode *inode, struct f2fs_inode *ri)
64{
65	if (S_ISCHR(inode->i_mode) || S_ISBLK(inode->i_mode)) {
66		if (old_valid_dev(inode->i_rdev)) {
67			ri->i_addr[0] =
68				cpu_to_le32(old_encode_dev(inode->i_rdev));
69			ri->i_addr[1] = 0;
70		} else {
71			ri->i_addr[0] = 0;
72			ri->i_addr[1] =
73				cpu_to_le32(new_encode_dev(inode->i_rdev));
74			ri->i_addr[2] = 0;
75		}
76	}
77}
78
79static void __recover_inline_status(struct inode *inode, struct page *ipage)
80{
81	void *inline_data = inline_data_addr(ipage);
82	__le32 *start = inline_data;
83	__le32 *end = start + MAX_INLINE_DATA / sizeof(__le32);
84
85	while (start < end) {
86		if (*start++) {
87			f2fs_wait_on_page_writeback(ipage, NODE);
88
89			set_inode_flag(F2FS_I(inode), FI_DATA_EXIST);
90			set_raw_inline(F2FS_I(inode), F2FS_INODE(ipage));
91			set_page_dirty(ipage);
92			return;
93		}
94	}
95	return;
96}
97
98static int do_read_inode(struct inode *inode)
99{
100	struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
101	struct f2fs_inode_info *fi = F2FS_I(inode);
102	struct page *node_page;
103	struct f2fs_inode *ri;
104
105	/* Check if ino is within scope */
106	if (check_nid_range(sbi, inode->i_ino)) {
107		f2fs_msg(inode->i_sb, KERN_ERR, "bad inode number: %lu",
108			 (unsigned long) inode->i_ino);
109		WARN_ON(1);
110		return -EINVAL;
111	}
112
113	node_page = get_node_page(sbi, inode->i_ino);
114	if (IS_ERR(node_page))
115		return PTR_ERR(node_page);
116
117	ri = F2FS_INODE(node_page);
118
119	inode->i_mode = le16_to_cpu(ri->i_mode);
120	i_uid_write(inode, le32_to_cpu(ri->i_uid));
121	i_gid_write(inode, le32_to_cpu(ri->i_gid));
122	set_nlink(inode, le32_to_cpu(ri->i_links));
123	inode->i_size = le64_to_cpu(ri->i_size);
124	inode->i_blocks = le64_to_cpu(ri->i_blocks);
125
126	inode->i_atime.tv_sec = le64_to_cpu(ri->i_atime);
127	inode->i_ctime.tv_sec = le64_to_cpu(ri->i_ctime);
128	inode->i_mtime.tv_sec = le64_to_cpu(ri->i_mtime);
129	inode->i_atime.tv_nsec = le32_to_cpu(ri->i_atime_nsec);
130	inode->i_ctime.tv_nsec = le32_to_cpu(ri->i_ctime_nsec);
131	inode->i_mtime.tv_nsec = le32_to_cpu(ri->i_mtime_nsec);
132	inode->i_generation = le32_to_cpu(ri->i_generation);
133
134	fi->i_current_depth = le32_to_cpu(ri->i_current_depth);
135	fi->i_xattr_nid = le32_to_cpu(ri->i_xattr_nid);
136	fi->i_flags = le32_to_cpu(ri->i_flags);
137	fi->flags = 0;
138	fi->i_advise = ri->i_advise;
139	fi->i_pino = le32_to_cpu(ri->i_pino);
140	fi->i_dir_level = ri->i_dir_level;
141
142	f2fs_init_extent_cache(inode, &ri->i_ext);
143
144	get_inline_info(fi, ri);
145
146	/* check data exist */
147	if (f2fs_has_inline_data(inode) && !f2fs_exist_data(inode))
148		__recover_inline_status(inode, node_page);
149
150	/* get rdev by using inline_info */
151	__get_inode_rdev(inode, ri);
152
153	if (__written_first_block(ri))
154		set_inode_flag(F2FS_I(inode), FI_FIRST_BLOCK_WRITTEN);
155
156	f2fs_put_page(node_page, 1);
157
158	stat_inc_inline_inode(inode);
159	stat_inc_inline_dir(inode);
160
161	return 0;
162}
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;
168	int ret = 0;
169
170	inode = iget_locked(sb, ino);
171	if (!inode)
172		return ERR_PTR(-ENOMEM);
173
174	if (!(inode->i_state & I_NEW)) {
175		trace_f2fs_iget(inode);
176		return inode;
177	}
178	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;
184make_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;
199		mapping_set_gfp_mask(inode->i_mapping, GFP_F2FS_HIGH_ZERO);
200	} else if (S_ISLNK(inode->i_mode)) {
201		inode->i_op = &f2fs_symlink_inode_operations;
202		inode->i_mapping->a_ops = &f2fs_dblock_aops;
203	} else if (S_ISCHR(inode->i_mode) || S_ISBLK(inode->i_mode) ||
204			S_ISFIFO(inode->i_mode) || S_ISSOCK(inode->i_mode)) {
205		inode->i_op = &f2fs_special_inode_operations;
206		init_special_inode(inode, inode->i_mode, inode->i_rdev);
207	} else {
208		ret = -EIO;
209		goto bad_inode;
210	}
211	unlock_new_inode(inode);
212	trace_f2fs_iget(inode);
213	return inode;
214
215bad_inode:
216	iget_failed(inode);
217	trace_f2fs_iget_exit(inode, ret);
218	return ERR_PTR(ret);
219}
220
221void update_inode(struct inode *inode, struct page *node_page)
222{
223	struct f2fs_inode *ri;
224
225	f2fs_wait_on_page_writeback(node_page, NODE);
226
227	ri = F2FS_INODE(node_page);
228
229	ri->i_mode = cpu_to_le16(inode->i_mode);
230	ri->i_advise = F2FS_I(inode)->i_advise;
231	ri->i_uid = cpu_to_le32(i_uid_read(inode));
232	ri->i_gid = cpu_to_le32(i_gid_read(inode));
233	ri->i_links = cpu_to_le32(inode->i_nlink);
234	ri->i_size = cpu_to_le64(i_size_read(inode));
235	ri->i_blocks = cpu_to_le64(inode->i_blocks);
236
237	read_lock(&F2FS_I(inode)->ext_lock);
238	set_raw_extent(&F2FS_I(inode)->ext, &ri->i_ext);
239	read_unlock(&F2FS_I(inode)->ext_lock);
240
241	set_raw_inline(F2FS_I(inode), ri);
242
243	ri->i_atime = cpu_to_le64(inode->i_atime.tv_sec);
244	ri->i_ctime = cpu_to_le64(inode->i_ctime.tv_sec);
245	ri->i_mtime = cpu_to_le64(inode->i_mtime.tv_sec);
246	ri->i_atime_nsec = cpu_to_le32(inode->i_atime.tv_nsec);
247	ri->i_ctime_nsec = cpu_to_le32(inode->i_ctime.tv_nsec);
248	ri->i_mtime_nsec = cpu_to_le32(inode->i_mtime.tv_nsec);
249	ri->i_current_depth = cpu_to_le32(F2FS_I(inode)->i_current_depth);
250	ri->i_xattr_nid = cpu_to_le32(F2FS_I(inode)->i_xattr_nid);
251	ri->i_flags = cpu_to_le32(F2FS_I(inode)->i_flags);
252	ri->i_pino = cpu_to_le32(F2FS_I(inode)->i_pino);
253	ri->i_generation = cpu_to_le32(inode->i_generation);
254	ri->i_dir_level = F2FS_I(inode)->i_dir_level;
255
256	__set_inode_rdev(inode, ri);
257	set_cold_node(inode, node_page);
258	set_page_dirty(node_page);
259
260	clear_inode_flag(F2FS_I(inode), FI_DIRTY_INODE);
261}
262
263void update_inode_page(struct inode *inode)
264{
265	struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
266	struct page *node_page;
267retry:
268	node_page = get_node_page(sbi, inode->i_ino);
269	if (IS_ERR(node_page)) {
270		int err = PTR_ERR(node_page);
271		if (err == -ENOMEM) {
272			cond_resched();
273			goto retry;
274		} else if (err != -ENOENT) {
275			f2fs_stop_checkpoint(sbi);
276		}
277		return;
278	}
279	update_inode(inode, node_page);
280	f2fs_put_page(node_page, 1);
281}
282
283int f2fs_write_inode(struct inode *inode, struct writeback_control *wbc)
284{
285	struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
286
287	if (inode->i_ino == F2FS_NODE_INO(sbi) ||
288			inode->i_ino == F2FS_META_INO(sbi))
289		return 0;
290
291	if (!is_inode_flag_set(F2FS_I(inode), FI_DIRTY_INODE))
292		return 0;
293
294	/*
295	 * We need to lock here to prevent from producing dirty node pages
296	 * during the urgent cleaning time when runing out of free sections.
297	 */
298	f2fs_lock_op(sbi);
299	update_inode_page(inode);
300	f2fs_unlock_op(sbi);
301
302	if (wbc)
303		f2fs_balance_fs(sbi);
304
305	return 0;
306}
307
308/*
309 * Called at the last iput() if i_nlink is zero
310 */
311void f2fs_evict_inode(struct inode *inode)
312{
313	struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
314	nid_t xnid = F2FS_I(inode)->i_xattr_nid;
315
316	/* some remained atomic pages should discarded */
317	if (f2fs_is_atomic_file(inode))
318		commit_inmem_pages(inode, true);
319
320	trace_f2fs_evict_inode(inode);
321	truncate_inode_pages_final(&inode->i_data);
322
323	if (inode->i_ino == F2FS_NODE_INO(sbi) ||
324			inode->i_ino == F2FS_META_INO(sbi))
325		goto out_clear;
326
327	f2fs_bug_on(sbi, get_dirty_pages(inode));
328	remove_dirty_dir_inode(inode);
329
330	if (inode->i_nlink || is_bad_inode(inode))
331		goto no_delete;
332
333	sb_start_intwrite(inode->i_sb);
334	set_inode_flag(F2FS_I(inode), FI_NO_ALLOC);
335	i_size_write(inode, 0);
336
337	if (F2FS_HAS_BLOCKS(inode))
338		f2fs_truncate(inode);
339
340	f2fs_lock_op(sbi);
341	remove_inode_page(inode);
342	f2fs_unlock_op(sbi);
343
344	sb_end_intwrite(inode->i_sb);
345no_delete:
346	stat_dec_inline_dir(inode);
347	stat_dec_inline_inode(inode);
348
349	/* update extent info in inode */
350	if (inode->i_nlink)
351		f2fs_preserve_extent_tree(inode);
352	f2fs_destroy_extent_tree(inode);
353
354	invalidate_mapping_pages(NODE_MAPPING(sbi), inode->i_ino, inode->i_ino);
355	if (xnid)
356		invalidate_mapping_pages(NODE_MAPPING(sbi), xnid, xnid);
357	if (is_inode_flag_set(F2FS_I(inode), FI_APPEND_WRITE))
358		add_dirty_inode(sbi, inode->i_ino, APPEND_INO);
359	if (is_inode_flag_set(F2FS_I(inode), FI_UPDATE_WRITE))
360		add_dirty_inode(sbi, inode->i_ino, UPDATE_INO);
361out_clear:
362	clear_inode(inode);
363}
364
365/* caller should call f2fs_lock_op() */
366void handle_failed_inode(struct inode *inode)
367{
368	struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
369
370	clear_nlink(inode);
371	make_bad_inode(inode);
372	unlock_new_inode(inode);
373
374	i_size_write(inode, 0);
375	if (F2FS_HAS_BLOCKS(inode))
376		f2fs_truncate(inode);
377
378	remove_inode_page(inode);
379
380	clear_inode_flag(F2FS_I(inode), FI_INLINE_DATA);
381	clear_inode_flag(F2FS_I(inode), FI_INLINE_DENTRY);
382	alloc_nid_failed(sbi, inode->i_ino);
383	f2fs_unlock_op(sbi);
384
385	/* iput will drop the inode object */
386	iput(inode);
387}
388