blob: 5f1a67f756afc449283d91c276fbce899fc360cb [file] [log] [blame]
Huajun Lie18c65b2013-11-10 23:13:19 +08001/*
2 * fs/f2fs/inline.c
3 * Copyright (c) 2013, Intel Corporation
4 * Authors: Huajun Li <huajun.li@intel.com>
5 * Haicheng Li <haicheng.li@intel.com>
6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License version 2 as
8 * published by the Free Software Foundation.
9 */
10
11#include <linux/fs.h>
12#include <linux/f2fs_fs.h>
13
14#include "f2fs.h"
Jaegeuk Kim67f8cf32015-10-15 11:34:49 -070015#include "node.h"
Huajun Lie18c65b2013-11-10 23:13:19 +080016
Jaegeuk Kim01b960e2015-04-23 10:27:21 -070017bool f2fs_may_inline_data(struct inode *inode)
Huajun Lie18c65b2013-11-10 23:13:19 +080018{
Jaegeuk Kim88b88a62014-10-06 17:39:50 -070019 if (f2fs_is_atomic_file(inode))
20 return false;
21
Wanpeng Li368a0e42015-03-19 13:23:48 +080022 if (!S_ISREG(inode->i_mode) && !S_ISLNK(inode->i_mode))
Huajun Lie18c65b2013-11-10 23:13:19 +080023 return false;
24
Jaegeuk Kim92dffd02014-11-11 14:10:01 -080025 if (i_size_read(inode) > MAX_INLINE_DATA)
26 return false;
27
Jaegeuk Kimfcc85a42015-04-21 20:39:58 -070028 if (f2fs_encrypted_inode(inode) && S_ISREG(inode->i_mode))
29 return false;
30
Huajun Lie18c65b2013-11-10 23:13:19 +080031 return true;
32}
33
Jaegeuk Kim01b960e2015-04-23 10:27:21 -070034bool f2fs_may_inline_dentry(struct inode *inode)
35{
36 if (!test_opt(F2FS_I_SB(inode), INLINE_DENTRY))
37 return false;
38
39 if (!S_ISDIR(inode->i_mode))
40 return false;
41
42 return true;
43}
44
Jaegeuk Kimb3d208f2014-10-23 19:48:09 -070045void read_inline_data(struct page *page, struct page *ipage)
Huajun Lie18c65b2013-11-10 23:13:19 +080046{
Huajun Lie18c65b2013-11-10 23:13:19 +080047 void *src_addr, *dst_addr;
48
Jaegeuk Kimb3d208f2014-10-23 19:48:09 -070049 if (PageUptodate(page))
50 return;
Chao Yu04a17fb2013-12-30 18:36:23 +080051
Jaegeuk Kimb3d208f2014-10-23 19:48:09 -070052 f2fs_bug_on(F2FS_P_SB(page), page->index);
Huajun Lie18c65b2013-11-10 23:13:19 +080053
Kirill A. Shutemov09cbfea2016-04-01 15:29:47 +030054 zero_user_segment(page, MAX_INLINE_DATA, PAGE_SIZE);
Huajun Lie18c65b2013-11-10 23:13:19 +080055
56 /* Copy the whole inline data block */
57 src_addr = inline_data_addr(ipage);
Jaegeuk Kimf1e33a02014-10-18 23:41:38 -070058 dst_addr = kmap_atomic(page);
Huajun Lie18c65b2013-11-10 23:13:19 +080059 memcpy(dst_addr, src_addr, MAX_INLINE_DATA);
Jaegeuk Kim427a45c2014-10-26 22:59:27 -070060 flush_dcache_page(page);
Jaegeuk Kimf1e33a02014-10-18 23:41:38 -070061 kunmap_atomic(dst_addr);
Jaegeuk Kim237c0792016-06-30 18:49:15 -070062 if (!PageUptodate(page))
63 SetPageUptodate(page);
Jaegeuk Kimb3d208f2014-10-23 19:48:09 -070064}
Huajun Lie18c65b2013-11-10 23:13:19 +080065
Chao Yu0bfcfcc2015-03-10 13:16:25 +080066bool truncate_inline_inode(struct page *ipage, u64 from)
Chao Yufeeb0de2015-01-26 20:22:55 +080067{
Chao Yu0bfcfcc2015-03-10 13:16:25 +080068 void *addr;
69
Chao Yu0bfcfcc2015-03-10 13:16:25 +080070 if (from >= MAX_INLINE_DATA)
71 return false;
72
73 addr = inline_data_addr(ipage);
74
Jaegeuk Kimfec1d652016-01-20 23:43:51 +080075 f2fs_wait_on_page_writeback(ipage, NODE, true);
Chao Yu0bfcfcc2015-03-10 13:16:25 +080076 memset(addr + from, 0, MAX_INLINE_DATA - from);
Jaegeuk Kimee6d1822016-05-20 16:32:49 -070077 set_page_dirty(ipage);
Chao Yu0bfcfcc2015-03-10 13:16:25 +080078 return true;
Chao Yufeeb0de2015-01-26 20:22:55 +080079}
80
Jaegeuk Kimb3d208f2014-10-23 19:48:09 -070081int f2fs_read_inline_data(struct inode *inode, struct page *page)
82{
83 struct page *ipage;
84
85 ipage = get_node_page(F2FS_I_SB(inode), inode->i_ino);
86 if (IS_ERR(ipage)) {
87 unlock_page(page);
88 return PTR_ERR(ipage);
89 }
90
91 if (!f2fs_has_inline_data(inode)) {
92 f2fs_put_page(ipage, 1);
93 return -EAGAIN;
94 }
95
96 if (page->index)
Kirill A. Shutemov09cbfea2016-04-01 15:29:47 +030097 zero_user_segment(page, 0, PAGE_SIZE);
Jaegeuk Kimb3d208f2014-10-23 19:48:09 -070098 else
99 read_inline_data(page, ipage);
100
Jaegeuk Kim237c0792016-06-30 18:49:15 -0700101 if (!PageUptodate(page))
102 SetPageUptodate(page);
Jaegeuk Kimb3d208f2014-10-23 19:48:09 -0700103 f2fs_put_page(ipage, 1);
104 unlock_page(page);
Huajun Lie18c65b2013-11-10 23:13:19 +0800105 return 0;
106}
107
Jaegeuk Kimb3d208f2014-10-23 19:48:09 -0700108int f2fs_convert_inline_page(struct dnode_of_data *dn, struct page *page)
Huajun Lie18c65b2013-11-10 23:13:19 +0800109{
Huajun Lie18c65b2013-11-10 23:13:19 +0800110 struct f2fs_io_info fio = {
Jaegeuk Kim05ca3632015-04-23 14:38:15 -0700111 .sbi = F2FS_I_SB(dn->inode),
Huajun Lie18c65b2013-11-10 23:13:19 +0800112 .type = DATA,
Mike Christie04d328d2016-06-05 14:31:55 -0500113 .op = REQ_OP_WRITE,
114 .op_flags = WRITE_SYNC | REQ_PRIO,
Jaegeuk Kim05ca3632015-04-23 14:38:15 -0700115 .page = page,
Jaegeuk Kim4375a332015-04-23 12:04:33 -0700116 .encrypted_page = NULL,
Huajun Lie18c65b2013-11-10 23:13:19 +0800117 };
Jaegeuk Kim158c1942014-11-25 11:34:02 -0800118 int dirty, err;
Huajun Lie18c65b2013-11-10 23:13:19 +0800119
Jaegeuk Kimb3d208f2014-10-23 19:48:09 -0700120 if (!f2fs_exist_data(dn->inode))
121 goto clear_out;
Jaegeuk Kimec4e7af2014-08-18 14:41:11 -0700122
Jaegeuk Kimb3d208f2014-10-23 19:48:09 -0700123 err = f2fs_reserve_block(dn, 0);
Jaegeuk Kim15c6e3a2014-04-16 14:22:50 +0900124 if (err)
Jaegeuk Kimb3d208f2014-10-23 19:48:09 -0700125 return err;
Huajun Lie18c65b2013-11-10 23:13:19 +0800126
Yunlei He85ead812016-02-03 10:26:13 +0800127 f2fs_bug_on(F2FS_P_SB(page), PageWriteback(page));
Jaegeuk Kimb3d208f2014-10-23 19:48:09 -0700128
Shawn Lin80606562016-02-19 16:02:51 +0800129 read_inline_data(page, dn->inode_page);
Jaegeuk Kim6282adb2015-07-25 00:29:17 -0700130 set_page_dirty(page);
131
Jaegeuk Kim158c1942014-11-25 11:34:02 -0800132 /* clear dirty state */
133 dirty = clear_page_dirty_for_io(page);
134
Huajun Lie18c65b2013-11-10 23:13:19 +0800135 /* write data page to try to make data consistent */
136 set_page_writeback(page);
Chao Yu7a9d7542016-02-22 18:36:38 +0800137 fio.old_blkaddr = dn->data_blkaddr;
Jaegeuk Kim05ca3632015-04-23 14:38:15 -0700138 write_data_page(dn, &fio);
Jaegeuk Kimfec1d652016-01-20 23:43:51 +0800139 f2fs_wait_on_page_writeback(page, DATA, true);
Jaegeuk Kim158c1942014-11-25 11:34:02 -0800140 if (dirty)
141 inode_dec_dirty_pages(dn->inode);
Huajun Lie18c65b2013-11-10 23:13:19 +0800142
Jaegeuk Kim95f5b0f2014-11-25 17:27:38 -0800143 /* this converted inline_data should be recovered. */
Jaegeuk Kim91942322016-05-20 10:13:22 -0700144 set_inode_flag(dn->inode, FI_APPEND_WRITE);
Jaegeuk Kim95f5b0f2014-11-25 17:27:38 -0800145
Huajun Lie18c65b2013-11-10 23:13:19 +0800146 /* clear inline data and flag after data writeback */
Chao Yu0bfcfcc2015-03-10 13:16:25 +0800147 truncate_inline_inode(dn->inode_page, 0);
Jaegeuk Kim2049d4f2016-01-25 05:57:05 -0800148 clear_inline_node(dn->inode_page);
Jaegeuk Kimb3d208f2014-10-23 19:48:09 -0700149clear_out:
Jaegeuk Kimb3d208f2014-10-23 19:48:09 -0700150 stat_dec_inline_inode(dn->inode);
Jaegeuk Kim57e2a2c2014-11-10 16:29:14 -0800151 f2fs_clear_inline_inode(dn->inode);
Jaegeuk Kimb3d208f2014-10-23 19:48:09 -0700152 f2fs_put_dnode(dn);
153 return 0;
Huajun Lie18c65b2013-11-10 23:13:19 +0800154}
155
Jaegeuk Kimb3d208f2014-10-23 19:48:09 -0700156int f2fs_convert_inline_inode(struct inode *inode)
Huajun Lie18c65b2013-11-10 23:13:19 +0800157{
Jaegeuk Kimb3d208f2014-10-23 19:48:09 -0700158 struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
159 struct dnode_of_data dn;
160 struct page *ipage, *page;
161 int err = 0;
Huajun Lie18c65b2013-11-10 23:13:19 +0800162
Jaegeuk Kimb9d777b2015-12-22 11:09:35 -0800163 if (!f2fs_has_inline_data(inode))
164 return 0;
165
Jaegeuk Kim300e1292016-04-29 16:11:53 -0700166 page = f2fs_grab_cache_page(inode->i_mapping, 0, false);
Jaegeuk Kimb3d208f2014-10-23 19:48:09 -0700167 if (!page)
168 return -ENOMEM;
Jaegeuk Kim9e09fc82013-12-27 12:28:59 +0900169
Jaegeuk Kimb3d208f2014-10-23 19:48:09 -0700170 f2fs_lock_op(sbi);
171
172 ipage = get_node_page(sbi, inode->i_ino);
173 if (IS_ERR(ipage)) {
Jaegeuk Kim6d20aff2014-11-17 16:06:55 -0800174 err = PTR_ERR(ipage);
175 goto out;
Jaegeuk Kimb067ba12014-08-07 16:32:25 -0700176 }
Huajun Lie18c65b2013-11-10 23:13:19 +0800177
Jaegeuk Kimb3d208f2014-10-23 19:48:09 -0700178 set_new_dnode(&dn, inode, ipage, ipage, 0);
179
180 if (f2fs_has_inline_data(inode))
181 err = f2fs_convert_inline_page(&dn, page);
182
183 f2fs_put_dnode(&dn);
Jaegeuk Kim6d20aff2014-11-17 16:06:55 -0800184out:
Jaegeuk Kimb3d208f2014-10-23 19:48:09 -0700185 f2fs_unlock_op(sbi);
186
187 f2fs_put_page(page, 1);
Jaegeuk Kim2a340762015-12-22 13:23:35 -0800188
Jaegeuk Kim2c4db1a2016-01-07 14:15:04 -0800189 f2fs_balance_fs(sbi, dn.node_changed);
Jaegeuk Kim2a340762015-12-22 13:23:35 -0800190
Huajun Lie18c65b2013-11-10 23:13:19 +0800191 return err;
192}
193
Jaegeuk Kimb3d208f2014-10-23 19:48:09 -0700194int f2fs_write_inline_data(struct inode *inode, struct page *page)
Huajun Lie18c65b2013-11-10 23:13:19 +0800195{
196 void *src_addr, *dst_addr;
Huajun Lie18c65b2013-11-10 23:13:19 +0800197 struct dnode_of_data dn;
198 int err;
199
200 set_new_dnode(&dn, inode, NULL, NULL, 0);
201 err = get_dnode_of_data(&dn, 0, LOOKUP_NODE);
202 if (err)
203 return err;
Huajun Lie18c65b2013-11-10 23:13:19 +0800204
Jaegeuk Kimc08a6902014-10-15 10:16:54 -0700205 if (!f2fs_has_inline_data(inode)) {
Jaegeuk Kimb3d208f2014-10-23 19:48:09 -0700206 f2fs_put_dnode(&dn);
207 return -EAGAIN;
Jaegeuk Kimc08a6902014-10-15 10:16:54 -0700208 }
209
Jaegeuk Kimb3d208f2014-10-23 19:48:09 -0700210 f2fs_bug_on(F2FS_I_SB(inode), page->index);
211
Jaegeuk Kimfec1d652016-01-20 23:43:51 +0800212 f2fs_wait_on_page_writeback(dn.inode_page, NODE, true);
Jaegeuk Kimf1e33a02014-10-18 23:41:38 -0700213 src_addr = kmap_atomic(page);
Jaegeuk Kimb3d208f2014-10-23 19:48:09 -0700214 dst_addr = inline_data_addr(dn.inode_page);
215 memcpy(dst_addr, src_addr, MAX_INLINE_DATA);
Jaegeuk Kimf1e33a02014-10-18 23:41:38 -0700216 kunmap_atomic(src_addr);
Jaegeuk Kimee6d1822016-05-20 16:32:49 -0700217 set_page_dirty(dn.inode_page);
Huajun Lie18c65b2013-11-10 23:13:19 +0800218
Jaegeuk Kim91942322016-05-20 10:13:22 -0700219 set_inode_flag(inode, FI_APPEND_WRITE);
220 set_inode_flag(inode, FI_DATA_EXIST);
Jaegeuk Kimb3d208f2014-10-23 19:48:09 -0700221
Jaegeuk Kim2049d4f2016-01-25 05:57:05 -0800222 clear_inline_node(dn.inode_page);
Huajun Lie18c65b2013-11-10 23:13:19 +0800223 f2fs_put_dnode(&dn);
Huajun Lie18c65b2013-11-10 23:13:19 +0800224 return 0;
225}
Jaegeuk Kim1e1bb4b2013-12-26 12:49:48 +0900226
Jaegeuk Kim0342fd32014-08-07 16:57:17 -0700227bool recover_inline_data(struct inode *inode, struct page *npage)
Jaegeuk Kim1e1bb4b2013-12-26 12:49:48 +0900228{
Jaegeuk Kim40813632014-09-02 15:31:18 -0700229 struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
Jaegeuk Kim1e1bb4b2013-12-26 12:49:48 +0900230 struct f2fs_inode *ri = NULL;
231 void *src_addr, *dst_addr;
232 struct page *ipage;
233
234 /*
235 * The inline_data recovery policy is as follows.
236 * [prev.] [next] of inline_data flag
237 * o o -> recover inline_data
238 * o x -> remove inline_data, and then recover data blocks
239 * x o -> remove inline_data, and then recover inline_data
240 * x x -> recover data blocks
241 */
242 if (IS_INODE(npage))
243 ri = F2FS_INODE(npage);
244
245 if (f2fs_has_inline_data(inode) &&
Jaegeuk Kim0342fd32014-08-07 16:57:17 -0700246 ri && (ri->i_inline & F2FS_INLINE_DATA)) {
Jaegeuk Kim1e1bb4b2013-12-26 12:49:48 +0900247process_inline:
248 ipage = get_node_page(sbi, inode->i_ino);
Jaegeuk Kim9850cf42014-09-02 15:52:58 -0700249 f2fs_bug_on(sbi, IS_ERR(ipage));
Jaegeuk Kim1e1bb4b2013-12-26 12:49:48 +0900250
Jaegeuk Kimfec1d652016-01-20 23:43:51 +0800251 f2fs_wait_on_page_writeback(ipage, NODE, true);
Jaegeuk Kim54b591d2014-04-29 17:28:32 +0900252
Jaegeuk Kim1e1bb4b2013-12-26 12:49:48 +0900253 src_addr = inline_data_addr(npage);
254 dst_addr = inline_data_addr(ipage);
255 memcpy(dst_addr, src_addr, MAX_INLINE_DATA);
Jaegeuk Kimb3d208f2014-10-23 19:48:09 -0700256
Jaegeuk Kim91942322016-05-20 10:13:22 -0700257 set_inode_flag(inode, FI_INLINE_DATA);
258 set_inode_flag(inode, FI_DATA_EXIST);
Jaegeuk Kimb3d208f2014-10-23 19:48:09 -0700259
Jaegeuk Kimee6d1822016-05-20 16:32:49 -0700260 set_page_dirty(ipage);
Jaegeuk Kim1e1bb4b2013-12-26 12:49:48 +0900261 f2fs_put_page(ipage, 1);
Jaegeuk Kim0342fd32014-08-07 16:57:17 -0700262 return true;
Jaegeuk Kim1e1bb4b2013-12-26 12:49:48 +0900263 }
264
265 if (f2fs_has_inline_data(inode)) {
266 ipage = get_node_page(sbi, inode->i_ino);
Jaegeuk Kim9850cf42014-09-02 15:52:58 -0700267 f2fs_bug_on(sbi, IS_ERR(ipage));
Nicholas Krause545fe422015-09-21 18:55:49 -0400268 if (!truncate_inline_inode(ipage, 0))
269 return false;
Jaegeuk Kimb3d208f2014-10-23 19:48:09 -0700270 f2fs_clear_inline_inode(inode);
Jaegeuk Kim1e1bb4b2013-12-26 12:49:48 +0900271 f2fs_put_page(ipage, 1);
Jaegeuk Kim0342fd32014-08-07 16:57:17 -0700272 } else if (ri && (ri->i_inline & F2FS_INLINE_DATA)) {
Nicholas Krause545fe422015-09-21 18:55:49 -0400273 if (truncate_blocks(inode, 0, false))
274 return false;
Jaegeuk Kim1e1bb4b2013-12-26 12:49:48 +0900275 goto process_inline;
276 }
Jaegeuk Kim0342fd32014-08-07 16:57:17 -0700277 return false;
Jaegeuk Kim1e1bb4b2013-12-26 12:49:48 +0900278}
Chao Yu201a05b2014-09-24 18:17:53 +0800279
280struct f2fs_dir_entry *find_in_inline_dir(struct inode *dir,
Jaegeuk Kim0b81d072015-05-15 16:26:10 -0700281 struct fscrypt_name *fname, struct page **res_page)
Chao Yu201a05b2014-09-24 18:17:53 +0800282{
283 struct f2fs_sb_info *sbi = F2FS_SB(dir->i_sb);
Jaegeuk Kim4e6ebf62014-10-13 17:26:14 -0700284 struct f2fs_inline_dentry *inline_dentry;
Jaegeuk Kim6e22c692015-04-27 17:12:39 -0700285 struct qstr name = FSTR_TO_QSTR(&fname->disk_name);
Chao Yu201a05b2014-09-24 18:17:53 +0800286 struct f2fs_dir_entry *de;
Jaegeuk Kim7b3cd7d2014-10-18 22:52:52 -0700287 struct f2fs_dentry_ptr d;
Jaegeuk Kim4e6ebf62014-10-13 17:26:14 -0700288 struct page *ipage;
Jaegeuk Kim6e22c692015-04-27 17:12:39 -0700289 f2fs_hash_t namehash;
Chao Yu201a05b2014-09-24 18:17:53 +0800290
291 ipage = get_node_page(sbi, dir->i_ino);
Jaegeuk Kim42d96402016-05-25 14:29:11 -0700292 if (IS_ERR(ipage)) {
293 *res_page = ipage;
Chao Yu201a05b2014-09-24 18:17:53 +0800294 return NULL;
Jaegeuk Kim42d96402016-05-25 14:29:11 -0700295 }
Chao Yu201a05b2014-09-24 18:17:53 +0800296
Jaegeuk Kim6e22c692015-04-27 17:12:39 -0700297 namehash = f2fs_dentry_hash(&name);
298
Jaegeuk Kim4e6ebf62014-10-13 17:26:14 -0700299 inline_dentry = inline_data_addr(ipage);
Chao Yu201a05b2014-09-24 18:17:53 +0800300
Jaegeuk Kimd8c68222015-04-27 16:26:24 -0700301 make_dentry_ptr(NULL, &d, (void *)inline_dentry, 2);
Jaegeuk Kim6e22c692015-04-27 17:12:39 -0700302 de = find_target_dentry(fname, namehash, NULL, &d);
Chao Yu201a05b2014-09-24 18:17:53 +0800303 unlock_page(ipage);
Jaegeuk Kim4e6ebf62014-10-13 17:26:14 -0700304 if (de)
305 *res_page = ipage;
306 else
307 f2fs_put_page(ipage, 0);
308
Chao Yu201a05b2014-09-24 18:17:53 +0800309 return de;
310}
311
Chao Yu201a05b2014-09-24 18:17:53 +0800312int make_empty_inline_dir(struct inode *inode, struct inode *parent,
313 struct page *ipage)
314{
315 struct f2fs_inline_dentry *dentry_blk;
Jaegeuk Kim062a3e72014-10-18 23:06:41 -0700316 struct f2fs_dentry_ptr d;
Chao Yu201a05b2014-09-24 18:17:53 +0800317
318 dentry_blk = inline_data_addr(ipage);
319
Jaegeuk Kimd8c68222015-04-27 16:26:24 -0700320 make_dentry_ptr(NULL, &d, (void *)dentry_blk, 2);
Jaegeuk Kim062a3e72014-10-18 23:06:41 -0700321 do_make_empty_dir(inode, parent, &d);
Chao Yu201a05b2014-09-24 18:17:53 +0800322
323 set_page_dirty(ipage);
324
325 /* update i_size to MAX_INLINE_DATA */
Jaegeuk Kimee6d1822016-05-20 16:32:49 -0700326 if (i_size_read(inode) < MAX_INLINE_DATA)
Jaegeuk Kimfc9581c2016-05-20 09:22:03 -0700327 f2fs_i_size_write(inode, MAX_INLINE_DATA);
Chao Yu201a05b2014-09-24 18:17:53 +0800328 return 0;
329}
330
Chao Yu470f00e2015-07-14 18:14:06 +0800331/*
332 * NOTE: ipage is grabbed by caller, but if any error occurs, we should
333 * release ipage in this function.
334 */
Chao Yu675f10b2016-02-22 18:29:18 +0800335static int f2fs_move_inline_dirents(struct inode *dir, struct page *ipage,
Chao Yu201a05b2014-09-24 18:17:53 +0800336 struct f2fs_inline_dentry *inline_dentry)
337{
338 struct page *page;
339 struct dnode_of_data dn;
340 struct f2fs_dentry_block *dentry_blk;
341 int err;
342
Jaegeuk Kim300e1292016-04-29 16:11:53 -0700343 page = f2fs_grab_cache_page(dir->i_mapping, 0, false);
Chao Yu470f00e2015-07-14 18:14:06 +0800344 if (!page) {
345 f2fs_put_page(ipage, 1);
Chao Yu201a05b2014-09-24 18:17:53 +0800346 return -ENOMEM;
Chao Yu470f00e2015-07-14 18:14:06 +0800347 }
Chao Yu201a05b2014-09-24 18:17:53 +0800348
349 set_new_dnode(&dn, dir, ipage, NULL, 0);
350 err = f2fs_reserve_block(&dn, 0);
351 if (err)
352 goto out;
353
Jaegeuk Kimfec1d652016-01-20 23:43:51 +0800354 f2fs_wait_on_page_writeback(page, DATA, true);
Kirill A. Shutemov09cbfea2016-04-01 15:29:47 +0300355 zero_user_segment(page, MAX_INLINE_DATA, PAGE_SIZE);
Chao Yu201a05b2014-09-24 18:17:53 +0800356
Jaegeuk Kimf1e33a02014-10-18 23:41:38 -0700357 dentry_blk = kmap_atomic(page);
Chao Yu201a05b2014-09-24 18:17:53 +0800358
359 /* copy data from inline dentry block to new dentry block */
360 memcpy(dentry_blk->dentry_bitmap, inline_dentry->dentry_bitmap,
361 INLINE_DENTRY_BITMAP_SIZE);
Chao Yu4ec17d62015-08-24 17:36:25 +0800362 memset(dentry_blk->dentry_bitmap + INLINE_DENTRY_BITMAP_SIZE, 0,
363 SIZE_OF_DENTRY_BITMAP - INLINE_DENTRY_BITMAP_SIZE);
364 /*
365 * we do not need to zero out remainder part of dentry and filename
366 * field, since we have used bitmap for marking the usage status of
367 * them, besides, we can also ignore copying/zeroing reserved space
368 * of dentry block, because them haven't been used so far.
369 */
Chao Yu201a05b2014-09-24 18:17:53 +0800370 memcpy(dentry_blk->dentry, inline_dentry->dentry,
371 sizeof(struct f2fs_dir_entry) * NR_INLINE_DENTRY);
372 memcpy(dentry_blk->filename, inline_dentry->filename,
373 NR_INLINE_DENTRY * F2FS_SLOT_LEN);
374
Jaegeuk Kimf1e33a02014-10-18 23:41:38 -0700375 kunmap_atomic(dentry_blk);
Jaegeuk Kim237c0792016-06-30 18:49:15 -0700376 if (!PageUptodate(page))
377 SetPageUptodate(page);
Chao Yu201a05b2014-09-24 18:17:53 +0800378 set_page_dirty(page);
379
380 /* clear inline dir and flag after data writeback */
Chao Yu0bfcfcc2015-03-10 13:16:25 +0800381 truncate_inline_inode(ipage, 0);
Jaegeuk Kimb3d208f2014-10-23 19:48:09 -0700382
Jaegeuk Kim3289c062014-10-13 20:00:16 -0700383 stat_dec_inline_dir(dir);
Jaegeuk Kim91942322016-05-20 10:13:22 -0700384 clear_inode_flag(dir, FI_INLINE_DENTRY);
Chao Yu201a05b2014-09-24 18:17:53 +0800385
Jaegeuk Kim205b9822016-05-20 09:52:20 -0700386 f2fs_i_depth_write(dir, 1);
Jaegeuk Kimee6d1822016-05-20 16:32:49 -0700387 if (i_size_read(dir) < PAGE_SIZE)
Jaegeuk Kimfc9581c2016-05-20 09:22:03 -0700388 f2fs_i_size_write(dir, PAGE_SIZE);
Chao Yu201a05b2014-09-24 18:17:53 +0800389out:
390 f2fs_put_page(page, 1);
391 return err;
392}
393
Chao Yu675f10b2016-02-22 18:29:18 +0800394static int f2fs_add_inline_entries(struct inode *dir,
395 struct f2fs_inline_dentry *inline_dentry)
396{
397 struct f2fs_dentry_ptr d;
398 unsigned long bit_pos = 0;
399 int err = 0;
400
401 make_dentry_ptr(NULL, &d, (void *)inline_dentry, 2);
402
403 while (bit_pos < d.max) {
404 struct f2fs_dir_entry *de;
405 struct qstr new_name;
406 nid_t ino;
407 umode_t fake_mode;
408
409 if (!test_bit_le(bit_pos, d.bitmap)) {
410 bit_pos++;
411 continue;
412 }
413
414 de = &d.dentry[bit_pos];
Chao Yua4a13f52016-04-27 22:22:20 +0800415
416 if (unlikely(!de->name_len)) {
417 bit_pos++;
418 continue;
419 }
420
Chao Yu675f10b2016-02-22 18:29:18 +0800421 new_name.name = d.filename[bit_pos];
422 new_name.len = de->name_len;
423
424 ino = le32_to_cpu(de->ino);
425 fake_mode = get_de_type(de) << S_SHIFT;
426
Chao Yu9421d572016-08-28 18:57:55 +0800427 err = f2fs_add_regular_entry(dir, &new_name, NULL, NULL,
Chao Yu675f10b2016-02-22 18:29:18 +0800428 ino, fake_mode);
429 if (err)
430 goto punch_dentry_pages;
431
Chao Yu675f10b2016-02-22 18:29:18 +0800432 bit_pos += GET_DENTRY_SLOTS(le16_to_cpu(de->name_len));
433 }
434 return 0;
435punch_dentry_pages:
436 truncate_inode_pages(&dir->i_data, 0);
437 truncate_blocks(dir, 0, false);
438 remove_dirty_inode(dir);
439 return err;
440}
441
442static int f2fs_move_rehashed_dirents(struct inode *dir, struct page *ipage,
443 struct f2fs_inline_dentry *inline_dentry)
444{
445 struct f2fs_inline_dentry *backup_dentry;
446 int err;
447
Chao Yu1ecc0c52016-09-23 21:30:09 +0800448 backup_dentry = f2fs_kmalloc(F2FS_I_SB(dir),
449 sizeof(struct f2fs_inline_dentry), GFP_F2FS_ZERO);
Chao Yu8975bdf2016-05-14 19:03:53 +0800450 if (!backup_dentry) {
451 f2fs_put_page(ipage, 1);
Chao Yu675f10b2016-02-22 18:29:18 +0800452 return -ENOMEM;
Chao Yu8975bdf2016-05-14 19:03:53 +0800453 }
Chao Yu675f10b2016-02-22 18:29:18 +0800454
455 memcpy(backup_dentry, inline_dentry, MAX_INLINE_DATA);
456 truncate_inline_inode(ipage, 0);
457
458 unlock_page(ipage);
459
460 err = f2fs_add_inline_entries(dir, backup_dentry);
461 if (err)
462 goto recover;
463
464 lock_page(ipage);
465
466 stat_dec_inline_dir(dir);
Jaegeuk Kim91942322016-05-20 10:13:22 -0700467 clear_inode_flag(dir, FI_INLINE_DENTRY);
Chao Yu675f10b2016-02-22 18:29:18 +0800468 kfree(backup_dentry);
469 return 0;
470recover:
471 lock_page(ipage);
472 memcpy(inline_dentry, backup_dentry, MAX_INLINE_DATA);
Jaegeuk Kim205b9822016-05-20 09:52:20 -0700473 f2fs_i_depth_write(dir, 0);
Jaegeuk Kimfc9581c2016-05-20 09:22:03 -0700474 f2fs_i_size_write(dir, MAX_INLINE_DATA);
Jaegeuk Kimee6d1822016-05-20 16:32:49 -0700475 set_page_dirty(ipage);
Chao Yu675f10b2016-02-22 18:29:18 +0800476 f2fs_put_page(ipage, 1);
477
478 kfree(backup_dentry);
479 return err;
480}
481
482static int f2fs_convert_inline_dir(struct inode *dir, struct page *ipage,
483 struct f2fs_inline_dentry *inline_dentry)
484{
485 if (!F2FS_I(dir)->i_dir_level)
486 return f2fs_move_inline_dirents(dir, ipage, inline_dentry);
487 else
488 return f2fs_move_rehashed_dirents(dir, ipage, inline_dentry);
489}
490
Chao Yu9421d572016-08-28 18:57:55 +0800491int f2fs_add_inline_entry(struct inode *dir, const struct qstr *new_name,
492 const struct qstr *orig_name,
493 struct inode *inode, nid_t ino, umode_t mode)
Chao Yu201a05b2014-09-24 18:17:53 +0800494{
495 struct f2fs_sb_info *sbi = F2FS_I_SB(dir);
496 struct page *ipage;
497 unsigned int bit_pos;
498 f2fs_hash_t name_hash;
Chao Yu201a05b2014-09-24 18:17:53 +0800499 struct f2fs_inline_dentry *dentry_blk = NULL;
Chao Yu3b4d7322015-02-16 16:17:20 +0800500 struct f2fs_dentry_ptr d;
Chao Yu9421d572016-08-28 18:57:55 +0800501 int slots = GET_DENTRY_SLOTS(new_name->len);
Jaegeuk Kim510022a2015-03-30 15:07:16 -0700502 struct page *page = NULL;
Chao Yu201a05b2014-09-24 18:17:53 +0800503 int err = 0;
Chao Yu201a05b2014-09-24 18:17:53 +0800504
505 ipage = get_node_page(sbi, dir->i_ino);
506 if (IS_ERR(ipage))
507 return PTR_ERR(ipage);
508
509 dentry_blk = inline_data_addr(ipage);
Jaegeuk Kima82afa22014-10-13 16:28:13 -0700510 bit_pos = room_for_filename(&dentry_blk->dentry_bitmap,
511 slots, NR_INLINE_DENTRY);
Chao Yu201a05b2014-09-24 18:17:53 +0800512 if (bit_pos >= NR_INLINE_DENTRY) {
513 err = f2fs_convert_inline_dir(dir, ipage, dentry_blk);
Chao Yu470f00e2015-07-14 18:14:06 +0800514 if (err)
515 return err;
516 err = -EAGAIN;
Chao Yu201a05b2014-09-24 18:17:53 +0800517 goto out;
518 }
519
Jaegeuk Kim510022a2015-03-30 15:07:16 -0700520 if (inode) {
521 down_write(&F2FS_I(inode)->i_sem);
Chao Yu9421d572016-08-28 18:57:55 +0800522 page = init_inode_metadata(inode, dir, new_name,
523 orig_name, ipage);
Jaegeuk Kim510022a2015-03-30 15:07:16 -0700524 if (IS_ERR(page)) {
525 err = PTR_ERR(page);
526 goto fail;
527 }
Shuoran Liu167451e2016-08-29 11:27:55 +0800528 if (f2fs_encrypted_inode(dir))
529 file_set_enc_name(inode);
Chao Yu201a05b2014-09-24 18:17:53 +0800530 }
Jaegeuk Kimbce8d112014-10-13 19:42:53 -0700531
Jaegeuk Kimfec1d652016-01-20 23:43:51 +0800532 f2fs_wait_on_page_writeback(ipage, NODE, true);
Chao Yu3b4d7322015-02-16 16:17:20 +0800533
Chao Yu9421d572016-08-28 18:57:55 +0800534 name_hash = f2fs_dentry_hash(new_name);
Jaegeuk Kimd8c68222015-04-27 16:26:24 -0700535 make_dentry_ptr(NULL, &d, (void *)dentry_blk, 2);
Chao Yu9421d572016-08-28 18:57:55 +0800536 f2fs_update_dentry(ino, mode, &d, new_name, name_hash, bit_pos);
Chao Yu3b4d7322015-02-16 16:17:20 +0800537
Chao Yu201a05b2014-09-24 18:17:53 +0800538 set_page_dirty(ipage);
539
540 /* we don't need to mark_inode_dirty now */
Jaegeuk Kim510022a2015-03-30 15:07:16 -0700541 if (inode) {
Jaegeuk Kim205b9822016-05-20 09:52:20 -0700542 f2fs_i_pino_write(inode, dir->i_ino);
Jaegeuk Kim510022a2015-03-30 15:07:16 -0700543 f2fs_put_page(page, 1);
544 }
Chao Yu201a05b2014-09-24 18:17:53 +0800545
546 update_parent_metadata(dir, inode, 0);
547fail:
Jaegeuk Kim510022a2015-03-30 15:07:16 -0700548 if (inode)
549 up_write(&F2FS_I(inode)->i_sem);
Chao Yu201a05b2014-09-24 18:17:53 +0800550out:
551 f2fs_put_page(ipage, 1);
552 return err;
553}
554
555void f2fs_delete_inline_entry(struct f2fs_dir_entry *dentry, struct page *page,
556 struct inode *dir, struct inode *inode)
557{
558 struct f2fs_inline_dentry *inline_dentry;
559 int slots = GET_DENTRY_SLOTS(le16_to_cpu(dentry->name_len));
560 unsigned int bit_pos;
561 int i;
562
563 lock_page(page);
Jaegeuk Kimfec1d652016-01-20 23:43:51 +0800564 f2fs_wait_on_page_writeback(page, NODE, true);
Chao Yu201a05b2014-09-24 18:17:53 +0800565
566 inline_dentry = inline_data_addr(page);
567 bit_pos = dentry - inline_dentry->dentry;
568 for (i = 0; i < slots; i++)
Jaegeuk Kim6bf6b262016-08-31 16:20:37 -0700569 __clear_bit_le(bit_pos + i,
Chao Yu201a05b2014-09-24 18:17:53 +0800570 &inline_dentry->dentry_bitmap);
571
572 set_page_dirty(page);
Jaegeuk Kim9f7c45c2016-06-01 21:18:25 -0700573 f2fs_put_page(page, 1);
Chao Yu201a05b2014-09-24 18:17:53 +0800574
Deepa Dinamani078cd822016-09-14 07:48:04 -0700575 dir->i_ctime = dir->i_mtime = current_time(dir);
Jaegeuk Kimb56ab832016-06-30 19:09:37 -0700576 f2fs_mark_inode_dirty_sync(dir);
Chao Yu201a05b2014-09-24 18:17:53 +0800577
578 if (inode)
Jaegeuk Kim9f7c45c2016-06-01 21:18:25 -0700579 f2fs_drop_nlink(dir, inode);
Chao Yu201a05b2014-09-24 18:17:53 +0800580}
581
582bool f2fs_empty_inline_dir(struct inode *dir)
583{
584 struct f2fs_sb_info *sbi = F2FS_I_SB(dir);
585 struct page *ipage;
586 unsigned int bit_pos = 2;
587 struct f2fs_inline_dentry *dentry_blk;
588
589 ipage = get_node_page(sbi, dir->i_ino);
590 if (IS_ERR(ipage))
591 return false;
592
593 dentry_blk = inline_data_addr(ipage);
594 bit_pos = find_next_bit_le(&dentry_blk->dentry_bitmap,
595 NR_INLINE_DENTRY,
596 bit_pos);
597
598 f2fs_put_page(ipage, 1);
599
600 if (bit_pos < NR_INLINE_DENTRY)
601 return false;
602
603 return true;
604}
605
Jaegeuk Kimd8c68222015-04-27 16:26:24 -0700606int f2fs_read_inline_dir(struct file *file, struct dir_context *ctx,
Jaegeuk Kim0b81d072015-05-15 16:26:10 -0700607 struct fscrypt_str *fstr)
Chao Yu201a05b2014-09-24 18:17:53 +0800608{
609 struct inode *inode = file_inode(file);
Chao Yu201a05b2014-09-24 18:17:53 +0800610 struct f2fs_inline_dentry *inline_dentry = NULL;
Chao Yu201a05b2014-09-24 18:17:53 +0800611 struct page *ipage = NULL;
Jaegeuk Kim7b3cd7d2014-10-18 22:52:52 -0700612 struct f2fs_dentry_ptr d;
Chao Yu201a05b2014-09-24 18:17:53 +0800613
614 if (ctx->pos == NR_INLINE_DENTRY)
615 return 0;
616
Jaegeuk Kim38594de2014-10-15 21:29:51 -0700617 ipage = get_node_page(F2FS_I_SB(inode), inode->i_ino);
Chao Yu201a05b2014-09-24 18:17:53 +0800618 if (IS_ERR(ipage))
619 return PTR_ERR(ipage);
620
Chao Yu201a05b2014-09-24 18:17:53 +0800621 inline_dentry = inline_data_addr(ipage);
Chao Yu201a05b2014-09-24 18:17:53 +0800622
Jaegeuk Kimd8c68222015-04-27 16:26:24 -0700623 make_dentry_ptr(inode, &d, (void *)inline_dentry, 2);
Jaegeuk Kim7b3cd7d2014-10-18 22:52:52 -0700624
Jaegeuk Kimd8c68222015-04-27 16:26:24 -0700625 if (!f2fs_fill_dentries(ctx, &d, 0, fstr))
Jaegeuk Kim38594de2014-10-15 21:29:51 -0700626 ctx->pos = NR_INLINE_DENTRY;
Chao Yu201a05b2014-09-24 18:17:53 +0800627
Chao Yu201a05b2014-09-24 18:17:53 +0800628 f2fs_put_page(ipage, 1);
Chao Yu201a05b2014-09-24 18:17:53 +0800629 return 0;
630}
Jaegeuk Kim67f8cf32015-10-15 11:34:49 -0700631
632int f2fs_inline_data_fiemap(struct inode *inode,
633 struct fiemap_extent_info *fieinfo, __u64 start, __u64 len)
634{
635 __u64 byteaddr, ilen;
636 __u32 flags = FIEMAP_EXTENT_DATA_INLINE | FIEMAP_EXTENT_NOT_ALIGNED |
637 FIEMAP_EXTENT_LAST;
638 struct node_info ni;
639 struct page *ipage;
640 int err = 0;
641
642 ipage = get_node_page(F2FS_I_SB(inode), inode->i_ino);
643 if (IS_ERR(ipage))
644 return PTR_ERR(ipage);
645
646 if (!f2fs_has_inline_data(inode)) {
647 err = -EAGAIN;
648 goto out;
649 }
650
651 ilen = min_t(size_t, MAX_INLINE_DATA, i_size_read(inode));
652 if (start >= ilen)
653 goto out;
654 if (start + len < ilen)
655 ilen = start + len;
656 ilen -= start;
657
658 get_node_info(F2FS_I_SB(inode), inode->i_ino, &ni);
659 byteaddr = (__u64)ni.blk_addr << inode->i_sb->s_blocksize_bits;
660 byteaddr += (char *)inline_data_addr(ipage) - (char *)F2FS_INODE(ipage);
661 err = fiemap_fill_next_extent(fieinfo, start, byteaddr, ilen, flags);
662out:
663 f2fs_put_page(ipage, 1);
664 return err;
665}