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
 16#include "f2fs.h"
 17#include "node.h"
 18
 19#include <trace/events/f2fs.h>
 20
 21void f2fs_set_inode_flags(struct inode *inode)
 22{
 23	unsigned int flags = F2FS_I(inode)->i_flags;
 24
 25	inode->i_flags &= ~(S_SYNC | S_APPEND | S_IMMUTABLE |
 26			S_NOATIME | S_DIRSYNC);
 27
 28	if (flags & FS_SYNC_FL)
 29		inode->i_flags |= S_SYNC;
 30	if (flags & FS_APPEND_FL)
 31		inode->i_flags |= S_APPEND;
 32	if (flags & FS_IMMUTABLE_FL)
 33		inode->i_flags |= S_IMMUTABLE;
 34	if (flags & FS_NOATIME_FL)
 35		inode->i_flags |= S_NOATIME;
 36	if (flags & FS_DIRSYNC_FL)
 37		inode->i_flags |= S_DIRSYNC;
 38}
 39
 40static 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])
 45			inode->i_rdev =
 46				old_decode_dev(le32_to_cpu(ri->i_addr[0]));
 47		else
 48			inode->i_rdev =
 49				new_decode_dev(le32_to_cpu(ri->i_addr[1]));
 50	}
 51}
 52
 53static void __set_inode_rdev(struct inode *inode, struct f2fs_inode *ri)
 54{
 55	if (S_ISCHR(inode->i_mode) || S_ISBLK(inode->i_mode)) {
 56		if (old_valid_dev(inode->i_rdev)) {
 57			ri->i_addr[0] =
 58				cpu_to_le32(old_encode_dev(inode->i_rdev));
 59			ri->i_addr[1] = 0;
 60		} else {
 61			ri->i_addr[0] = 0;
 62			ri->i_addr[1] =
 63				cpu_to_le32(new_encode_dev(inode->i_rdev));
 64			ri->i_addr[2] = 0;
 65		}
 66	}
 67}
 68
 69static int do_read_inode(struct inode *inode)
 70{
 71	struct f2fs_sb_info *sbi = F2FS_SB(inode->i_sb);
 72	struct f2fs_inode_info *fi = F2FS_I(inode);
 73	struct page *node_page;
 74	struct f2fs_inode *ri;
 75
 76	/* Check if ino is within scope */
 77	if (check_nid_range(sbi, inode->i_ino)) {
 78		f2fs_msg(inode->i_sb, KERN_ERR, "bad inode number: %lu",
 79			 (unsigned long) inode->i_ino);
 80		return -EINVAL;
 81	}
 82
 83	node_page = get_node_page(sbi, inode->i_ino);
 84	if (IS_ERR(node_page))
 85		return PTR_ERR(node_page);
 86
 87	ri = F2FS_INODE(node_page);
 88
 89	inode->i_mode = le16_to_cpu(ri->i_mode);
 90	i_uid_write(inode, le32_to_cpu(ri->i_uid));
 91	i_gid_write(inode, le32_to_cpu(ri->i_gid));
 92	set_nlink(inode, le32_to_cpu(ri->i_links));
 93	inode->i_size = le64_to_cpu(ri->i_size);
 94	inode->i_blocks = le64_to_cpu(ri->i_blocks);
 95
 96	inode->i_atime.tv_sec = le64_to_cpu(ri->i_atime);
 97	inode->i_ctime.tv_sec = le64_to_cpu(ri->i_ctime);
 98	inode->i_mtime.tv_sec = le64_to_cpu(ri->i_mtime);
 99	inode->i_atime.tv_nsec = le32_to_cpu(ri->i_atime_nsec);
100	inode->i_ctime.tv_nsec = le32_to_cpu(ri->i_ctime_nsec);
101	inode->i_mtime.tv_nsec = le32_to_cpu(ri->i_mtime_nsec);
102	inode->i_generation = le32_to_cpu(ri->i_generation);
103
104	fi->i_current_depth = le32_to_cpu(ri->i_current_depth);
105	fi->i_xattr_nid = le32_to_cpu(ri->i_xattr_nid);
106	fi->i_flags = le32_to_cpu(ri->i_flags);
107	fi->flags = 0;
108	fi->i_advise = ri->i_advise;
109	fi->i_pino = le32_to_cpu(ri->i_pino);
110	fi->i_dir_level = ri->i_dir_level;
111
112	get_extent_info(&fi->ext, ri->i_ext);
113	get_inline_info(fi, ri);
114
115	/* get rdev by using inline_info */
116	__get_inode_rdev(inode, ri);
117
118	f2fs_put_page(node_page, 1);
119	return 0;
120}
121
122struct inode *f2fs_iget(struct super_block *sb, unsigned long ino)
123{
124	struct f2fs_sb_info *sbi = F2FS_SB(sb);
125	struct inode *inode;
126	int ret = 0;
127
128	inode = iget_locked(sb, ino);
129	if (!inode)
130		return ERR_PTR(-ENOMEM);
131
132	if (!(inode->i_state & I_NEW)) {
133		trace_f2fs_iget(inode);
134		return inode;
135	}
136	if (ino == F2FS_NODE_INO(sbi) || ino == F2FS_META_INO(sbi))
137		goto make_now;
138
139	ret = do_read_inode(inode);
140	if (ret)
141		goto bad_inode;
142make_now:
143	if (ino == F2FS_NODE_INO(sbi)) {
144		inode->i_mapping->a_ops = &f2fs_node_aops;
145		mapping_set_gfp_mask(inode->i_mapping, GFP_F2FS_ZERO);
146	} else if (ino == F2FS_META_INO(sbi)) {
147		inode->i_mapping->a_ops = &f2fs_meta_aops;
148		mapping_set_gfp_mask(inode->i_mapping, GFP_F2FS_ZERO);
149	} else if (S_ISREG(inode->i_mode)) {
150		inode->i_op = &f2fs_file_inode_operations;
151		inode->i_fop = &f2fs_file_operations;
152		inode->i_mapping->a_ops = &f2fs_dblock_aops;
153	} else if (S_ISDIR(inode->i_mode)) {
154		inode->i_op = &f2fs_dir_inode_operations;
155		inode->i_fop = &f2fs_dir_operations;
156		inode->i_mapping->a_ops = &f2fs_dblock_aops;
157		mapping_set_gfp_mask(inode->i_mapping, GFP_F2FS_ZERO);
158	} else if (S_ISLNK(inode->i_mode)) {
159		inode->i_op = &f2fs_symlink_inode_operations;
160		inode->i_mapping->a_ops = &f2fs_dblock_aops;
161	} else if (S_ISCHR(inode->i_mode) || S_ISBLK(inode->i_mode) ||
162			S_ISFIFO(inode->i_mode) || S_ISSOCK(inode->i_mode)) {
163		inode->i_op = &f2fs_special_inode_operations;
164		init_special_inode(inode, inode->i_mode, inode->i_rdev);
165	} else {
166		ret = -EIO;
167		goto bad_inode;
168	}
169	unlock_new_inode(inode);
170	trace_f2fs_iget(inode);
171	return inode;
172
173bad_inode:
174	iget_failed(inode);
175	trace_f2fs_iget_exit(inode, ret);
176	return ERR_PTR(ret);
177}
178
179void update_inode(struct inode *inode, struct page *node_page)
180{
181	struct f2fs_inode *ri;
182
183	f2fs_wait_on_page_writeback(node_page, NODE);
184
185	ri = F2FS_INODE(node_page);
186
187	ri->i_mode = cpu_to_le16(inode->i_mode);
188	ri->i_advise = F2FS_I(inode)->i_advise;
189	ri->i_uid = cpu_to_le32(i_uid_read(inode));
190	ri->i_gid = cpu_to_le32(i_gid_read(inode));
191	ri->i_links = cpu_to_le32(inode->i_nlink);
192	ri->i_size = cpu_to_le64(i_size_read(inode));
193	ri->i_blocks = cpu_to_le64(inode->i_blocks);
194	set_raw_extent(&F2FS_I(inode)->ext, &ri->i_ext);
195	set_raw_inline(F2FS_I(inode), ri);
196
197	ri->i_atime = cpu_to_le64(inode->i_atime.tv_sec);
198	ri->i_ctime = cpu_to_le64(inode->i_ctime.tv_sec);
199	ri->i_mtime = cpu_to_le64(inode->i_mtime.tv_sec);
200	ri->i_atime_nsec = cpu_to_le32(inode->i_atime.tv_nsec);
201	ri->i_ctime_nsec = cpu_to_le32(inode->i_ctime.tv_nsec);
202	ri->i_mtime_nsec = cpu_to_le32(inode->i_mtime.tv_nsec);
203	ri->i_current_depth = cpu_to_le32(F2FS_I(inode)->i_current_depth);
204	ri->i_xattr_nid = cpu_to_le32(F2FS_I(inode)->i_xattr_nid);
205	ri->i_flags = cpu_to_le32(F2FS_I(inode)->i_flags);
206	ri->i_pino = cpu_to_le32(F2FS_I(inode)->i_pino);
207	ri->i_generation = cpu_to_le32(inode->i_generation);
208	ri->i_dir_level = F2FS_I(inode)->i_dir_level;
209
210	__set_inode_rdev(inode, ri);
211	set_cold_node(inode, node_page);
212	set_page_dirty(node_page);
213
214	clear_inode_flag(F2FS_I(inode), FI_DIRTY_INODE);
215}
216
217void update_inode_page(struct inode *inode)
218{
219	struct f2fs_sb_info *sbi = F2FS_SB(inode->i_sb);
220	struct page *node_page;
221retry:
222	node_page = get_node_page(sbi, inode->i_ino);
223	if (IS_ERR(node_page)) {
224		int err = PTR_ERR(node_page);
225		if (err == -ENOMEM) {
226			cond_resched();
227			goto retry;
228		} else if (err != -ENOENT) {
229			f2fs_stop_checkpoint(sbi);
230		}
231		return;
232	}
233	update_inode(inode, node_page);
234	f2fs_put_page(node_page, 1);
235}
236
237int f2fs_write_inode(struct inode *inode, struct writeback_control *wbc)
238{
239	struct f2fs_sb_info *sbi = F2FS_SB(inode->i_sb);
240
241	if (inode->i_ino == F2FS_NODE_INO(sbi) ||
242			inode->i_ino == F2FS_META_INO(sbi))
243		return 0;
244
245	if (!is_inode_flag_set(F2FS_I(inode), FI_DIRTY_INODE))
246		return 0;
247
248	/*
249	 * We need to lock here to prevent from producing dirty node pages
250	 * during the urgent cleaning time when runing out of free sections.
251	 */
252	f2fs_lock_op(sbi);
253	update_inode_page(inode);
254	f2fs_unlock_op(sbi);
255
256	if (wbc)
257		f2fs_balance_fs(sbi);
258
259	return 0;
260}
261
262/*
263 * Called at the last iput() if i_nlink is zero
264 */
265void f2fs_evict_inode(struct inode *inode)
266{
267	struct f2fs_sb_info *sbi = F2FS_SB(inode->i_sb);
268
269	trace_f2fs_evict_inode(inode);
270	truncate_inode_pages_final(&inode->i_data);
271
272	if (inode->i_ino == F2FS_NODE_INO(sbi) ||
273			inode->i_ino == F2FS_META_INO(sbi))
274		goto no_delete;
275
276	f2fs_bug_on(get_dirty_dents(inode));
277	remove_dirty_dir_inode(inode);
278
279	if (inode->i_nlink || is_bad_inode(inode))
280		goto no_delete;
281
282	sb_start_intwrite(inode->i_sb);
283	set_inode_flag(F2FS_I(inode), FI_NO_ALLOC);
284	i_size_write(inode, 0);
285
286	if (F2FS_HAS_BLOCKS(inode))
287		f2fs_truncate(inode);
288
289	f2fs_lock_op(sbi);
290	remove_inode_page(inode);
291	stat_dec_inline_inode(inode);
292	f2fs_unlock_op(sbi);
293
294	sb_end_intwrite(inode->i_sb);
295no_delete:
296	clear_inode(inode);
297}