blob: 2952d0e36cd9850e94f8e70ca88640e711b042b1 [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 Kim67f8cf3c2015-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
Chao Yuf2470372017-07-19 00:19:05 +080025 if (i_size_read(inode) > MAX_INLINE_DATA(inode))
Jaegeuk Kim92dffd02014-11-11 14:10:01 -080026 return false;
27
Jaegeuk Kim19585932017-09-05 16:54:24 -070028 if (f2fs_encrypted_file(inode))
Jaegeuk Kimfcc85a42015-04-21 20:39:58 -070029 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{
Chao Yuf2470372017-07-19 00:19:05 +080047 struct inode *inode = page->mapping->host;
Huajun Lie18c65b2013-11-10 23:13:19 +080048 void *src_addr, *dst_addr;
49
Jaegeuk Kimb3d208f2014-10-23 19:48:09 -070050 if (PageUptodate(page))
51 return;
Chao Yu04a17fb2013-12-30 18:36:23 +080052
Jaegeuk Kimb3d208f2014-10-23 19:48:09 -070053 f2fs_bug_on(F2FS_P_SB(page), page->index);
Huajun Lie18c65b2013-11-10 23:13:19 +080054
Chao Yuf2470372017-07-19 00:19:05 +080055 zero_user_segment(page, MAX_INLINE_DATA(inode), PAGE_SIZE);
Huajun Lie18c65b2013-11-10 23:13:19 +080056
57 /* Copy the whole inline data block */
Chao Yuf2470372017-07-19 00:19:05 +080058 src_addr = inline_data_addr(inode, ipage);
Jaegeuk Kimf1e33a02014-10-18 23:41:38 -070059 dst_addr = kmap_atomic(page);
Chao Yuf2470372017-07-19 00:19:05 +080060 memcpy(dst_addr, src_addr, MAX_INLINE_DATA(inode));
Jaegeuk Kim427a45c2014-10-26 22:59:27 -070061 flush_dcache_page(page);
Jaegeuk Kimf1e33a02014-10-18 23:41:38 -070062 kunmap_atomic(dst_addr);
Jaegeuk Kim237c0792016-06-30 18:49:15 -070063 if (!PageUptodate(page))
64 SetPageUptodate(page);
Jaegeuk Kimb3d208f2014-10-23 19:48:09 -070065}
Huajun Lie18c65b2013-11-10 23:13:19 +080066
Kinglong Meebd4667c2017-03-10 20:43:20 +080067void truncate_inline_inode(struct inode *inode, struct page *ipage, u64 from)
Chao Yufeeb0de2015-01-26 20:22:55 +080068{
Chao Yu0bfcfcc2015-03-10 13:16:25 +080069 void *addr;
70
Chao Yuf2470372017-07-19 00:19:05 +080071 if (from >= MAX_INLINE_DATA(inode))
Kinglong Meebd4667c2017-03-10 20:43:20 +080072 return;
Chao Yu0bfcfcc2015-03-10 13:16:25 +080073
Chao Yuf2470372017-07-19 00:19:05 +080074 addr = inline_data_addr(inode, ipage);
Chao Yu0bfcfcc2015-03-10 13:16:25 +080075
Jaegeuk Kimfec1d652016-01-20 23:43:51 +080076 f2fs_wait_on_page_writeback(ipage, NODE, true);
Chao Yuf2470372017-07-19 00:19:05 +080077 memset(addr + from, 0, MAX_INLINE_DATA(inode) - from);
Jaegeuk Kimee6d1822016-05-20 16:32:49 -070078 set_page_dirty(ipage);
Kinglong Meebd4667c2017-03-10 20:43:20 +080079
80 if (from == 0)
81 clear_inode_flag(inode, FI_DATA_EXIST);
Chao Yufeeb0de2015-01-26 20:22:55 +080082}
83
Jaegeuk Kimb3d208f2014-10-23 19:48:09 -070084int f2fs_read_inline_data(struct inode *inode, struct page *page)
85{
86 struct page *ipage;
87
88 ipage = get_node_page(F2FS_I_SB(inode), inode->i_ino);
89 if (IS_ERR(ipage)) {
90 unlock_page(page);
91 return PTR_ERR(ipage);
92 }
93
94 if (!f2fs_has_inline_data(inode)) {
95 f2fs_put_page(ipage, 1);
96 return -EAGAIN;
97 }
98
99 if (page->index)
Kirill A. Shutemov09cbfea2016-04-01 15:29:47 +0300100 zero_user_segment(page, 0, PAGE_SIZE);
Jaegeuk Kimb3d208f2014-10-23 19:48:09 -0700101 else
102 read_inline_data(page, ipage);
103
Jaegeuk Kim237c0792016-06-30 18:49:15 -0700104 if (!PageUptodate(page))
105 SetPageUptodate(page);
Jaegeuk Kimb3d208f2014-10-23 19:48:09 -0700106 f2fs_put_page(ipage, 1);
107 unlock_page(page);
Huajun Lie18c65b2013-11-10 23:13:19 +0800108 return 0;
109}
110
Jaegeuk Kimb3d208f2014-10-23 19:48:09 -0700111int f2fs_convert_inline_page(struct dnode_of_data *dn, struct page *page)
Huajun Lie18c65b2013-11-10 23:13:19 +0800112{
Huajun Lie18c65b2013-11-10 23:13:19 +0800113 struct f2fs_io_info fio = {
Jaegeuk Kim05ca3632015-04-23 14:38:15 -0700114 .sbi = F2FS_I_SB(dn->inode),
Huajun Lie18c65b2013-11-10 23:13:19 +0800115 .type = DATA,
Mike Christie04d328d2016-06-05 14:31:55 -0500116 .op = REQ_OP_WRITE,
Christoph Hellwig70fd7612016-11-01 07:40:10 -0600117 .op_flags = REQ_SYNC | REQ_PRIO,
Jaegeuk Kim05ca3632015-04-23 14:38:15 -0700118 .page = page,
Jaegeuk Kim4375a332015-04-23 12:04:33 -0700119 .encrypted_page = NULL,
Chao Yub0af6d42017-08-02 23:21:48 +0800120 .io_type = FS_DATA_IO,
Huajun Lie18c65b2013-11-10 23:13:19 +0800121 };
Jaegeuk Kim158c1942014-11-25 11:34:02 -0800122 int dirty, err;
Huajun Lie18c65b2013-11-10 23:13:19 +0800123
Jaegeuk Kimb3d208f2014-10-23 19:48:09 -0700124 if (!f2fs_exist_data(dn->inode))
125 goto clear_out;
Jaegeuk Kimec4e7af2014-08-18 14:41:11 -0700126
Jaegeuk Kimb3d208f2014-10-23 19:48:09 -0700127 err = f2fs_reserve_block(dn, 0);
Jaegeuk Kim15c6e3a2014-04-16 14:22:50 +0900128 if (err)
Jaegeuk Kimb3d208f2014-10-23 19:48:09 -0700129 return err;
Huajun Lie18c65b2013-11-10 23:13:19 +0800130
Chao Yu7fb2b502018-06-30 18:13:40 +0800131 if (unlikely(dn->data_blkaddr != NEW_ADDR)) {
132 f2fs_put_dnode(dn);
133 set_sbi_flag(fio.sbi, SBI_NEED_FSCK);
134 f2fs_msg(fio.sbi->sb, KERN_WARNING,
135 "%s: corrupted inline inode ino=%lx, i_addr[0]:0x%x, "
136 "run fsck to fix.",
137 __func__, dn->inode->i_ino, dn->data_blkaddr);
Chao Yue991f022019-06-20 11:36:14 +0800138 return -EFSCORRUPTED;
Chao Yu7fb2b502018-06-30 18:13:40 +0800139 }
140
Yunlei He85ead812016-02-03 10:26:13 +0800141 f2fs_bug_on(F2FS_P_SB(page), PageWriteback(page));
Jaegeuk Kimb3d208f2014-10-23 19:48:09 -0700142
Shawn Lin80606562016-02-19 16:02:51 +0800143 read_inline_data(page, dn->inode_page);
Jaegeuk Kim6282adb2015-07-25 00:29:17 -0700144 set_page_dirty(page);
145
Jaegeuk Kim158c1942014-11-25 11:34:02 -0800146 /* clear dirty state */
147 dirty = clear_page_dirty_for_io(page);
148
Huajun Lie18c65b2013-11-10 23:13:19 +0800149 /* write data page to try to make data consistent */
150 set_page_writeback(page);
Chao Yu7a9d7542016-02-22 18:36:38 +0800151 fio.old_blkaddr = dn->data_blkaddr;
Jaegeuk Kimef095d12017-03-24 20:05:13 -0400152 set_inode_flag(dn->inode, FI_HOT_DATA);
Jaegeuk Kim05ca3632015-04-23 14:38:15 -0700153 write_data_page(dn, &fio);
Jaegeuk Kimfec1d652016-01-20 23:43:51 +0800154 f2fs_wait_on_page_writeback(page, DATA, true);
Chao Yu933439c2016-10-11 22:57:01 +0800155 if (dirty) {
Jaegeuk Kim158c1942014-11-25 11:34:02 -0800156 inode_dec_dirty_pages(dn->inode);
Chao Yu933439c2016-10-11 22:57:01 +0800157 remove_dirty_inode(dn->inode);
158 }
Huajun Lie18c65b2013-11-10 23:13:19 +0800159
Jaegeuk Kim95f5b0f2014-11-25 17:27:38 -0800160 /* this converted inline_data should be recovered. */
Jaegeuk Kim91942322016-05-20 10:13:22 -0700161 set_inode_flag(dn->inode, FI_APPEND_WRITE);
Jaegeuk Kim95f5b0f2014-11-25 17:27:38 -0800162
Huajun Lie18c65b2013-11-10 23:13:19 +0800163 /* clear inline data and flag after data writeback */
Kinglong Meebd4667c2017-03-10 20:43:20 +0800164 truncate_inline_inode(dn->inode, dn->inode_page, 0);
Jaegeuk Kim2049d4f2016-01-25 05:57:05 -0800165 clear_inline_node(dn->inode_page);
Jaegeuk Kimb3d208f2014-10-23 19:48:09 -0700166clear_out:
Jaegeuk Kimb3d208f2014-10-23 19:48:09 -0700167 stat_dec_inline_inode(dn->inode);
Kinglong Meebd4667c2017-03-10 20:43:20 +0800168 clear_inode_flag(dn->inode, FI_INLINE_DATA);
Jaegeuk Kimb3d208f2014-10-23 19:48:09 -0700169 f2fs_put_dnode(dn);
170 return 0;
Huajun Lie18c65b2013-11-10 23:13:19 +0800171}
172
Jaegeuk Kimb3d208f2014-10-23 19:48:09 -0700173int f2fs_convert_inline_inode(struct inode *inode)
Huajun Lie18c65b2013-11-10 23:13:19 +0800174{
Jaegeuk Kimb3d208f2014-10-23 19:48:09 -0700175 struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
176 struct dnode_of_data dn;
177 struct page *ipage, *page;
178 int err = 0;
Huajun Lie18c65b2013-11-10 23:13:19 +0800179
Jaegeuk Kimb9d777b2015-12-22 11:09:35 -0800180 if (!f2fs_has_inline_data(inode))
181 return 0;
182
Jaegeuk Kim300e1292016-04-29 16:11:53 -0700183 page = f2fs_grab_cache_page(inode->i_mapping, 0, false);
Jaegeuk Kimb3d208f2014-10-23 19:48:09 -0700184 if (!page)
185 return -ENOMEM;
Jaegeuk Kim9e09fc82013-12-27 12:28:59 +0900186
Jaegeuk Kimb3d208f2014-10-23 19:48:09 -0700187 f2fs_lock_op(sbi);
188
189 ipage = get_node_page(sbi, inode->i_ino);
190 if (IS_ERR(ipage)) {
Jaegeuk Kim6d20aff2014-11-17 16:06:55 -0800191 err = PTR_ERR(ipage);
192 goto out;
Jaegeuk Kimb067ba12014-08-07 16:32:25 -0700193 }
Huajun Lie18c65b2013-11-10 23:13:19 +0800194
Jaegeuk Kimb3d208f2014-10-23 19:48:09 -0700195 set_new_dnode(&dn, inode, ipage, ipage, 0);
196
197 if (f2fs_has_inline_data(inode))
198 err = f2fs_convert_inline_page(&dn, page);
199
200 f2fs_put_dnode(&dn);
Jaegeuk Kim6d20aff2014-11-17 16:06:55 -0800201out:
Jaegeuk Kimb3d208f2014-10-23 19:48:09 -0700202 f2fs_unlock_op(sbi);
203
204 f2fs_put_page(page, 1);
Jaegeuk Kim2a340762015-12-22 13:23:35 -0800205
Colin Ian King769171e2021-03-04 09:21:18 +0000206 if (!err)
207 f2fs_balance_fs(sbi, dn.node_changed);
Jaegeuk Kim2a340762015-12-22 13:23:35 -0800208
Huajun Lie18c65b2013-11-10 23:13:19 +0800209 return err;
210}
211
Jaegeuk Kimb3d208f2014-10-23 19:48:09 -0700212int f2fs_write_inline_data(struct inode *inode, struct page *page)
Huajun Lie18c65b2013-11-10 23:13:19 +0800213{
214 void *src_addr, *dst_addr;
Huajun Lie18c65b2013-11-10 23:13:19 +0800215 struct dnode_of_data dn;
Daeho Jeong0abd8e72017-09-11 16:30:28 +0900216 struct address_space *mapping = page_mapping(page);
217 unsigned long flags;
Huajun Lie18c65b2013-11-10 23:13:19 +0800218 int err;
219
220 set_new_dnode(&dn, inode, NULL, NULL, 0);
221 err = get_dnode_of_data(&dn, 0, LOOKUP_NODE);
222 if (err)
223 return err;
Huajun Lie18c65b2013-11-10 23:13:19 +0800224
Jaegeuk Kimc08a6902014-10-15 10:16:54 -0700225 if (!f2fs_has_inline_data(inode)) {
Jaegeuk Kimb3d208f2014-10-23 19:48:09 -0700226 f2fs_put_dnode(&dn);
227 return -EAGAIN;
Jaegeuk Kimc08a6902014-10-15 10:16:54 -0700228 }
229
Jaegeuk Kimb3d208f2014-10-23 19:48:09 -0700230 f2fs_bug_on(F2FS_I_SB(inode), page->index);
231
Jaegeuk Kimfec1d652016-01-20 23:43:51 +0800232 f2fs_wait_on_page_writeback(dn.inode_page, NODE, true);
Jaegeuk Kimf1e33a02014-10-18 23:41:38 -0700233 src_addr = kmap_atomic(page);
Chao Yuf2470372017-07-19 00:19:05 +0800234 dst_addr = inline_data_addr(inode, dn.inode_page);
235 memcpy(dst_addr, src_addr, MAX_INLINE_DATA(inode));
Jaegeuk Kimf1e33a02014-10-18 23:41:38 -0700236 kunmap_atomic(src_addr);
Jaegeuk Kimee6d1822016-05-20 16:32:49 -0700237 set_page_dirty(dn.inode_page);
Huajun Lie18c65b2013-11-10 23:13:19 +0800238
Daeho Jeong0abd8e72017-09-11 16:30:28 +0900239 spin_lock_irqsave(&mapping->tree_lock, flags);
240 radix_tree_tag_clear(&mapping->page_tree, page_index(page),
241 PAGECACHE_TAG_DIRTY);
242 spin_unlock_irqrestore(&mapping->tree_lock, flags);
243
Jaegeuk Kim91942322016-05-20 10:13:22 -0700244 set_inode_flag(inode, FI_APPEND_WRITE);
245 set_inode_flag(inode, FI_DATA_EXIST);
Jaegeuk Kimb3d208f2014-10-23 19:48:09 -0700246
Jaegeuk Kim2049d4f2016-01-25 05:57:05 -0800247 clear_inline_node(dn.inode_page);
Huajun Lie18c65b2013-11-10 23:13:19 +0800248 f2fs_put_dnode(&dn);
Huajun Lie18c65b2013-11-10 23:13:19 +0800249 return 0;
250}
Jaegeuk Kim1e1bb4b2013-12-26 12:49:48 +0900251
Jaegeuk Kim0342fd32014-08-07 16:57:17 -0700252bool recover_inline_data(struct inode *inode, struct page *npage)
Jaegeuk Kim1e1bb4b2013-12-26 12:49:48 +0900253{
Jaegeuk Kim40813632014-09-02 15:31:18 -0700254 struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
Jaegeuk Kim1e1bb4b2013-12-26 12:49:48 +0900255 struct f2fs_inode *ri = NULL;
256 void *src_addr, *dst_addr;
257 struct page *ipage;
258
259 /*
260 * The inline_data recovery policy is as follows.
261 * [prev.] [next] of inline_data flag
262 * o o -> recover inline_data
263 * o x -> remove inline_data, and then recover data blocks
264 * x o -> remove inline_data, and then recover inline_data
265 * x x -> recover data blocks
266 */
267 if (IS_INODE(npage))
268 ri = F2FS_INODE(npage);
269
270 if (f2fs_has_inline_data(inode) &&
Jaegeuk Kim0342fd32014-08-07 16:57:17 -0700271 ri && (ri->i_inline & F2FS_INLINE_DATA)) {
Jaegeuk Kim1e1bb4b2013-12-26 12:49:48 +0900272process_inline:
273 ipage = get_node_page(sbi, inode->i_ino);
Jaegeuk Kim9850cf42014-09-02 15:52:58 -0700274 f2fs_bug_on(sbi, IS_ERR(ipage));
Jaegeuk Kim1e1bb4b2013-12-26 12:49:48 +0900275
Jaegeuk Kimfec1d652016-01-20 23:43:51 +0800276 f2fs_wait_on_page_writeback(ipage, NODE, true);
Jaegeuk Kim54b591d2014-04-29 17:28:32 +0900277
Chao Yuf2470372017-07-19 00:19:05 +0800278 src_addr = inline_data_addr(inode, npage);
279 dst_addr = inline_data_addr(inode, ipage);
280 memcpy(dst_addr, src_addr, MAX_INLINE_DATA(inode));
Jaegeuk Kimb3d208f2014-10-23 19:48:09 -0700281
Jaegeuk Kim91942322016-05-20 10:13:22 -0700282 set_inode_flag(inode, FI_INLINE_DATA);
283 set_inode_flag(inode, FI_DATA_EXIST);
Jaegeuk Kimb3d208f2014-10-23 19:48:09 -0700284
Jaegeuk Kimee6d1822016-05-20 16:32:49 -0700285 set_page_dirty(ipage);
Jaegeuk Kim1e1bb4b2013-12-26 12:49:48 +0900286 f2fs_put_page(ipage, 1);
Jaegeuk Kim0342fd32014-08-07 16:57:17 -0700287 return true;
Jaegeuk Kim1e1bb4b2013-12-26 12:49:48 +0900288 }
289
290 if (f2fs_has_inline_data(inode)) {
291 ipage = get_node_page(sbi, inode->i_ino);
Jaegeuk Kim9850cf42014-09-02 15:52:58 -0700292 f2fs_bug_on(sbi, IS_ERR(ipage));
Kinglong Meebd4667c2017-03-10 20:43:20 +0800293 truncate_inline_inode(inode, ipage, 0);
294 clear_inode_flag(inode, FI_INLINE_DATA);
Jaegeuk Kim1e1bb4b2013-12-26 12:49:48 +0900295 f2fs_put_page(ipage, 1);
Jaegeuk Kim0342fd32014-08-07 16:57:17 -0700296 } else if (ri && (ri->i_inline & F2FS_INLINE_DATA)) {
Nicholas Krause545fe422015-09-21 18:55:49 -0400297 if (truncate_blocks(inode, 0, false))
298 return false;
Jaegeuk Kim1e1bb4b2013-12-26 12:49:48 +0900299 goto process_inline;
300 }
Jaegeuk Kim0342fd32014-08-07 16:57:17 -0700301 return false;
Jaegeuk Kim1e1bb4b2013-12-26 12:49:48 +0900302}
Chao Yu201a05b2014-09-24 18:17:53 +0800303
304struct f2fs_dir_entry *find_in_inline_dir(struct inode *dir,
Jaegeuk Kim0b81d072015-05-15 16:26:10 -0700305 struct fscrypt_name *fname, struct page **res_page)
Chao Yu201a05b2014-09-24 18:17:53 +0800306{
307 struct f2fs_sb_info *sbi = F2FS_SB(dir->i_sb);
Jaegeuk Kim6e22c692015-04-27 17:12:39 -0700308 struct qstr name = FSTR_TO_QSTR(&fname->disk_name);
Chao Yu201a05b2014-09-24 18:17:53 +0800309 struct f2fs_dir_entry *de;
Jaegeuk Kim7b3cd7d2014-10-18 22:52:52 -0700310 struct f2fs_dentry_ptr d;
Jaegeuk Kim4e6ebf62014-10-13 17:26:14 -0700311 struct page *ipage;
Chao Yuf2470372017-07-19 00:19:05 +0800312 void *inline_dentry;
Jaegeuk Kim6e22c692015-04-27 17:12:39 -0700313 f2fs_hash_t namehash;
Chao Yu201a05b2014-09-24 18:17:53 +0800314
315 ipage = get_node_page(sbi, dir->i_ino);
Jaegeuk Kim42d96402016-05-25 14:29:11 -0700316 if (IS_ERR(ipage)) {
317 *res_page = ipage;
Chao Yu201a05b2014-09-24 18:17:53 +0800318 return NULL;
Jaegeuk Kim42d96402016-05-25 14:29:11 -0700319 }
Chao Yu201a05b2014-09-24 18:17:53 +0800320
Jaegeuk Kim6332cd32017-04-24 10:00:08 -0700321 namehash = f2fs_dentry_hash(&name, fname);
Jaegeuk Kim6e22c692015-04-27 17:12:39 -0700322
Chao Yuf2470372017-07-19 00:19:05 +0800323 inline_dentry = inline_data_addr(dir, ipage);
Chao Yu201a05b2014-09-24 18:17:53 +0800324
Chao Yuf2470372017-07-19 00:19:05 +0800325 make_dentry_ptr_inline(dir, &d, inline_dentry);
Jaegeuk Kim6e22c692015-04-27 17:12:39 -0700326 de = find_target_dentry(fname, namehash, NULL, &d);
Chao Yu201a05b2014-09-24 18:17:53 +0800327 unlock_page(ipage);
Jaegeuk Kim4e6ebf62014-10-13 17:26:14 -0700328 if (de)
329 *res_page = ipage;
330 else
331 f2fs_put_page(ipage, 0);
332
Chao Yu201a05b2014-09-24 18:17:53 +0800333 return de;
334}
335
Chao Yu201a05b2014-09-24 18:17:53 +0800336int make_empty_inline_dir(struct inode *inode, struct inode *parent,
337 struct page *ipage)
338{
Jaegeuk Kim062a3e72014-10-18 23:06:41 -0700339 struct f2fs_dentry_ptr d;
Chao Yuf2470372017-07-19 00:19:05 +0800340 void *inline_dentry;
Chao Yu201a05b2014-09-24 18:17:53 +0800341
Chao Yuf2470372017-07-19 00:19:05 +0800342 inline_dentry = inline_data_addr(inode, ipage);
Chao Yu201a05b2014-09-24 18:17:53 +0800343
Chao Yuf2470372017-07-19 00:19:05 +0800344 make_dentry_ptr_inline(inode, &d, inline_dentry);
Jaegeuk Kim062a3e72014-10-18 23:06:41 -0700345 do_make_empty_dir(inode, parent, &d);
Chao Yu201a05b2014-09-24 18:17:53 +0800346
347 set_page_dirty(ipage);
348
349 /* update i_size to MAX_INLINE_DATA */
Chao Yuf2470372017-07-19 00:19:05 +0800350 if (i_size_read(inode) < MAX_INLINE_DATA(inode))
351 f2fs_i_size_write(inode, MAX_INLINE_DATA(inode));
Chao Yu201a05b2014-09-24 18:17:53 +0800352 return 0;
353}
354
Chao Yu470f00e2015-07-14 18:14:06 +0800355/*
356 * NOTE: ipage is grabbed by caller, but if any error occurs, we should
357 * release ipage in this function.
358 */
Chao Yu675f10b2016-02-22 18:29:18 +0800359static int f2fs_move_inline_dirents(struct inode *dir, struct page *ipage,
Chao Yuf2470372017-07-19 00:19:05 +0800360 void *inline_dentry)
Chao Yu201a05b2014-09-24 18:17:53 +0800361{
362 struct page *page;
363 struct dnode_of_data dn;
364 struct f2fs_dentry_block *dentry_blk;
Chao Yu76a9dd82017-07-16 15:08:54 +0800365 struct f2fs_dentry_ptr src, dst;
Chao Yu201a05b2014-09-24 18:17:53 +0800366 int err;
367
Jaegeuk Kim300e1292016-04-29 16:11:53 -0700368 page = f2fs_grab_cache_page(dir->i_mapping, 0, false);
Chao Yu470f00e2015-07-14 18:14:06 +0800369 if (!page) {
370 f2fs_put_page(ipage, 1);
Chao Yu201a05b2014-09-24 18:17:53 +0800371 return -ENOMEM;
Chao Yu470f00e2015-07-14 18:14:06 +0800372 }
Chao Yu201a05b2014-09-24 18:17:53 +0800373
374 set_new_dnode(&dn, dir, ipage, NULL, 0);
375 err = f2fs_reserve_block(&dn, 0);
376 if (err)
377 goto out;
378
Chao Yu7fb2b502018-06-30 18:13:40 +0800379 if (unlikely(dn.data_blkaddr != NEW_ADDR)) {
380 f2fs_put_dnode(&dn);
381 set_sbi_flag(F2FS_P_SB(page), SBI_NEED_FSCK);
382 f2fs_msg(F2FS_P_SB(page)->sb, KERN_WARNING,
383 "%s: corrupted inline inode ino=%lx, i_addr[0]:0x%x, "
384 "run fsck to fix.",
385 __func__, dir->i_ino, dn.data_blkaddr);
Chao Yue991f022019-06-20 11:36:14 +0800386 err = -EFSCORRUPTED;
Chao Yu7fb2b502018-06-30 18:13:40 +0800387 goto out;
388 }
389
Jaegeuk Kimfec1d652016-01-20 23:43:51 +0800390 f2fs_wait_on_page_writeback(page, DATA, true);
Chao Yuf2470372017-07-19 00:19:05 +0800391 zero_user_segment(page, MAX_INLINE_DATA(dir), PAGE_SIZE);
Chao Yu201a05b2014-09-24 18:17:53 +0800392
Jaegeuk Kimf1e33a02014-10-18 23:41:38 -0700393 dentry_blk = kmap_atomic(page);
Chao Yu201a05b2014-09-24 18:17:53 +0800394
Eric Biggers4e3b4b12023-01-22 23:04:14 -0800395 /*
396 * Start by zeroing the full block, to ensure that all unused space is
397 * zeroed and no uninitialized memory is leaked to disk.
398 */
399 memset(dentry_blk, 0, F2FS_BLKSIZE);
400
Chao Yuf2470372017-07-19 00:19:05 +0800401 make_dentry_ptr_inline(dir, &src, inline_dentry);
402 make_dentry_ptr_block(dir, &dst, dentry_blk);
Chao Yu76a9dd82017-07-16 15:08:54 +0800403
Chao Yu201a05b2014-09-24 18:17:53 +0800404 /* copy data from inline dentry block to new dentry block */
Chao Yu76a9dd82017-07-16 15:08:54 +0800405 memcpy(dst.bitmap, src.bitmap, src.nr_bitmap);
Chao Yu76a9dd82017-07-16 15:08:54 +0800406 memcpy(dst.dentry, src.dentry, SIZE_OF_DIR_ENTRY * src.max);
407 memcpy(dst.filename, src.filename, src.max * F2FS_SLOT_LEN);
Chao Yu201a05b2014-09-24 18:17:53 +0800408
Jaegeuk Kimf1e33a02014-10-18 23:41:38 -0700409 kunmap_atomic(dentry_blk);
Jaegeuk Kim237c0792016-06-30 18:49:15 -0700410 if (!PageUptodate(page))
411 SetPageUptodate(page);
Chao Yu201a05b2014-09-24 18:17:53 +0800412 set_page_dirty(page);
413
414 /* clear inline dir and flag after data writeback */
Kinglong Meebd4667c2017-03-10 20:43:20 +0800415 truncate_inline_inode(dir, ipage, 0);
Jaegeuk Kimb3d208f2014-10-23 19:48:09 -0700416
Jaegeuk Kim3289c062014-10-13 20:00:16 -0700417 stat_dec_inline_dir(dir);
Jaegeuk Kim91942322016-05-20 10:13:22 -0700418 clear_inode_flag(dir, FI_INLINE_DENTRY);
Chao Yu201a05b2014-09-24 18:17:53 +0800419
Jaegeuk Kim205b9822016-05-20 09:52:20 -0700420 f2fs_i_depth_write(dir, 1);
Jaegeuk Kimee6d1822016-05-20 16:32:49 -0700421 if (i_size_read(dir) < PAGE_SIZE)
Jaegeuk Kimfc9581c2016-05-20 09:22:03 -0700422 f2fs_i_size_write(dir, PAGE_SIZE);
Chao Yu201a05b2014-09-24 18:17:53 +0800423out:
424 f2fs_put_page(page, 1);
425 return err;
426}
427
Chao Yuf2470372017-07-19 00:19:05 +0800428static int f2fs_add_inline_entries(struct inode *dir, void *inline_dentry)
Chao Yu675f10b2016-02-22 18:29:18 +0800429{
430 struct f2fs_dentry_ptr d;
431 unsigned long bit_pos = 0;
432 int err = 0;
433
Chao Yuf2470372017-07-19 00:19:05 +0800434 make_dentry_ptr_inline(dir, &d, inline_dentry);
Chao Yu675f10b2016-02-22 18:29:18 +0800435
436 while (bit_pos < d.max) {
437 struct f2fs_dir_entry *de;
438 struct qstr new_name;
439 nid_t ino;
440 umode_t fake_mode;
441
442 if (!test_bit_le(bit_pos, d.bitmap)) {
443 bit_pos++;
444 continue;
445 }
446
447 de = &d.dentry[bit_pos];
Chao Yua4a13f52016-04-27 22:22:20 +0800448
449 if (unlikely(!de->name_len)) {
450 bit_pos++;
451 continue;
452 }
453
Chao Yu675f10b2016-02-22 18:29:18 +0800454 new_name.name = d.filename[bit_pos];
Eric Biggers0c0b4712016-10-11 10:36:12 -0700455 new_name.len = le16_to_cpu(de->name_len);
Chao Yu675f10b2016-02-22 18:29:18 +0800456
457 ino = le32_to_cpu(de->ino);
458 fake_mode = get_de_type(de) << S_SHIFT;
459
Chao Yu9421d572016-08-28 18:57:55 +0800460 err = f2fs_add_regular_entry(dir, &new_name, NULL, NULL,
Chao Yu675f10b2016-02-22 18:29:18 +0800461 ino, fake_mode);
462 if (err)
463 goto punch_dentry_pages;
464
Chao Yu675f10b2016-02-22 18:29:18 +0800465 bit_pos += GET_DENTRY_SLOTS(le16_to_cpu(de->name_len));
466 }
467 return 0;
468punch_dentry_pages:
469 truncate_inode_pages(&dir->i_data, 0);
470 truncate_blocks(dir, 0, false);
471 remove_dirty_inode(dir);
472 return err;
473}
474
475static int f2fs_move_rehashed_dirents(struct inode *dir, struct page *ipage,
Chao Yuf2470372017-07-19 00:19:05 +0800476 void *inline_dentry)
Chao Yu675f10b2016-02-22 18:29:18 +0800477{
Chao Yuf2470372017-07-19 00:19:05 +0800478 void *backup_dentry;
Chao Yu675f10b2016-02-22 18:29:18 +0800479 int err;
480
Chao Yu1ecc0c52016-09-23 21:30:09 +0800481 backup_dentry = f2fs_kmalloc(F2FS_I_SB(dir),
Chao Yuf2470372017-07-19 00:19:05 +0800482 MAX_INLINE_DATA(dir), GFP_F2FS_ZERO);
Chao Yu8975bdf2016-05-14 19:03:53 +0800483 if (!backup_dentry) {
484 f2fs_put_page(ipage, 1);
Chao Yu675f10b2016-02-22 18:29:18 +0800485 return -ENOMEM;
Chao Yu8975bdf2016-05-14 19:03:53 +0800486 }
Chao Yu675f10b2016-02-22 18:29:18 +0800487
Chao Yuf2470372017-07-19 00:19:05 +0800488 memcpy(backup_dentry, inline_dentry, MAX_INLINE_DATA(dir));
Kinglong Meebd4667c2017-03-10 20:43:20 +0800489 truncate_inline_inode(dir, ipage, 0);
Chao Yu675f10b2016-02-22 18:29:18 +0800490
491 unlock_page(ipage);
492
493 err = f2fs_add_inline_entries(dir, backup_dentry);
494 if (err)
495 goto recover;
496
497 lock_page(ipage);
498
499 stat_dec_inline_dir(dir);
Jaegeuk Kim91942322016-05-20 10:13:22 -0700500 clear_inode_flag(dir, FI_INLINE_DENTRY);
Chao Yu675f10b2016-02-22 18:29:18 +0800501 kfree(backup_dentry);
502 return 0;
503recover:
504 lock_page(ipage);
Chao Yu9d54a482018-06-21 22:38:28 +0800505 f2fs_wait_on_page_writeback(ipage, NODE, true);
Chao Yuf2470372017-07-19 00:19:05 +0800506 memcpy(inline_dentry, backup_dentry, MAX_INLINE_DATA(dir));
Jaegeuk Kim205b9822016-05-20 09:52:20 -0700507 f2fs_i_depth_write(dir, 0);
Chao Yuf2470372017-07-19 00:19:05 +0800508 f2fs_i_size_write(dir, MAX_INLINE_DATA(dir));
Jaegeuk Kimee6d1822016-05-20 16:32:49 -0700509 set_page_dirty(ipage);
Chao Yu675f10b2016-02-22 18:29:18 +0800510 f2fs_put_page(ipage, 1);
511
512 kfree(backup_dentry);
513 return err;
514}
515
516static int f2fs_convert_inline_dir(struct inode *dir, struct page *ipage,
Chao Yuf2470372017-07-19 00:19:05 +0800517 void *inline_dentry)
Chao Yu675f10b2016-02-22 18:29:18 +0800518{
519 if (!F2FS_I(dir)->i_dir_level)
520 return f2fs_move_inline_dirents(dir, ipage, inline_dentry);
521 else
522 return f2fs_move_rehashed_dirents(dir, ipage, inline_dentry);
523}
524
Chao Yu9421d572016-08-28 18:57:55 +0800525int f2fs_add_inline_entry(struct inode *dir, const struct qstr *new_name,
526 const struct qstr *orig_name,
527 struct inode *inode, nid_t ino, umode_t mode)
Chao Yu201a05b2014-09-24 18:17:53 +0800528{
529 struct f2fs_sb_info *sbi = F2FS_I_SB(dir);
530 struct page *ipage;
531 unsigned int bit_pos;
532 f2fs_hash_t name_hash;
Chao Yuf2470372017-07-19 00:19:05 +0800533 void *inline_dentry = NULL;
Chao Yu3b4d7322015-02-16 16:17:20 +0800534 struct f2fs_dentry_ptr d;
Chao Yu9421d572016-08-28 18:57:55 +0800535 int slots = GET_DENTRY_SLOTS(new_name->len);
Jaegeuk Kim510022a2015-03-30 15:07:16 -0700536 struct page *page = NULL;
Chao Yu201a05b2014-09-24 18:17:53 +0800537 int err = 0;
Chao Yu201a05b2014-09-24 18:17:53 +0800538
539 ipage = get_node_page(sbi, dir->i_ino);
540 if (IS_ERR(ipage))
541 return PTR_ERR(ipage);
542
Chao Yuf2470372017-07-19 00:19:05 +0800543 inline_dentry = inline_data_addr(dir, ipage);
544 make_dentry_ptr_inline(dir, &d, inline_dentry);
Chao Yu76a9dd82017-07-16 15:08:54 +0800545
546 bit_pos = room_for_filename(d.bitmap, slots, d.max);
547 if (bit_pos >= d.max) {
Tiezhu Yanga0057742017-06-09 06:32:54 +0800548 err = f2fs_convert_inline_dir(dir, ipage, inline_dentry);
Chao Yu470f00e2015-07-14 18:14:06 +0800549 if (err)
550 return err;
551 err = -EAGAIN;
Chao Yu201a05b2014-09-24 18:17:53 +0800552 goto out;
553 }
554
Jaegeuk Kim510022a2015-03-30 15:07:16 -0700555 if (inode) {
556 down_write(&F2FS_I(inode)->i_sem);
Chao Yu9421d572016-08-28 18:57:55 +0800557 page = init_inode_metadata(inode, dir, new_name,
558 orig_name, ipage);
Jaegeuk Kim510022a2015-03-30 15:07:16 -0700559 if (IS_ERR(page)) {
560 err = PTR_ERR(page);
561 goto fail;
562 }
Chao Yu201a05b2014-09-24 18:17:53 +0800563 }
Jaegeuk Kimbce8d112014-10-13 19:42:53 -0700564
Jaegeuk Kimfec1d652016-01-20 23:43:51 +0800565 f2fs_wait_on_page_writeback(ipage, NODE, true);
Chao Yu3b4d7322015-02-16 16:17:20 +0800566
Jaegeuk Kim6332cd32017-04-24 10:00:08 -0700567 name_hash = f2fs_dentry_hash(new_name, NULL);
Chao Yu9421d572016-08-28 18:57:55 +0800568 f2fs_update_dentry(ino, mode, &d, new_name, name_hash, bit_pos);
Chao Yu3b4d7322015-02-16 16:17:20 +0800569
Chao Yu201a05b2014-09-24 18:17:53 +0800570 set_page_dirty(ipage);
571
572 /* we don't need to mark_inode_dirty now */
Jaegeuk Kim510022a2015-03-30 15:07:16 -0700573 if (inode) {
Jaegeuk Kim205b9822016-05-20 09:52:20 -0700574 f2fs_i_pino_write(inode, dir->i_ino);
Jaegeuk Kim510022a2015-03-30 15:07:16 -0700575 f2fs_put_page(page, 1);
576 }
Chao Yu201a05b2014-09-24 18:17:53 +0800577
578 update_parent_metadata(dir, inode, 0);
579fail:
Jaegeuk Kim510022a2015-03-30 15:07:16 -0700580 if (inode)
581 up_write(&F2FS_I(inode)->i_sem);
Chao Yu201a05b2014-09-24 18:17:53 +0800582out:
583 f2fs_put_page(ipage, 1);
584 return err;
585}
586
587void f2fs_delete_inline_entry(struct f2fs_dir_entry *dentry, struct page *page,
588 struct inode *dir, struct inode *inode)
589{
Chao Yu76a9dd82017-07-16 15:08:54 +0800590 struct f2fs_dentry_ptr d;
Chao Yuf2470372017-07-19 00:19:05 +0800591 void *inline_dentry;
Chao Yu201a05b2014-09-24 18:17:53 +0800592 int slots = GET_DENTRY_SLOTS(le16_to_cpu(dentry->name_len));
593 unsigned int bit_pos;
594 int i;
595
596 lock_page(page);
Jaegeuk Kimfec1d652016-01-20 23:43:51 +0800597 f2fs_wait_on_page_writeback(page, NODE, true);
Chao Yu201a05b2014-09-24 18:17:53 +0800598
Chao Yuf2470372017-07-19 00:19:05 +0800599 inline_dentry = inline_data_addr(dir, page);
600 make_dentry_ptr_inline(dir, &d, inline_dentry);
Chao Yu76a9dd82017-07-16 15:08:54 +0800601
602 bit_pos = dentry - d.dentry;
Chao Yu201a05b2014-09-24 18:17:53 +0800603 for (i = 0; i < slots; i++)
Chao Yu76a9dd82017-07-16 15:08:54 +0800604 __clear_bit_le(bit_pos + i, d.bitmap);
Chao Yu201a05b2014-09-24 18:17:53 +0800605
606 set_page_dirty(page);
Jaegeuk Kim9f7c45c2016-06-01 21:18:25 -0700607 f2fs_put_page(page, 1);
Chao Yu201a05b2014-09-24 18:17:53 +0800608
Deepa Dinamani078cd822016-09-14 07:48:04 -0700609 dir->i_ctime = dir->i_mtime = current_time(dir);
Jaegeuk Kim7c457292016-10-14 11:51:23 -0700610 f2fs_mark_inode_dirty_sync(dir, false);
Chao Yu201a05b2014-09-24 18:17:53 +0800611
612 if (inode)
Jaegeuk Kim9f7c45c2016-06-01 21:18:25 -0700613 f2fs_drop_nlink(dir, inode);
Chao Yu201a05b2014-09-24 18:17:53 +0800614}
615
616bool f2fs_empty_inline_dir(struct inode *dir)
617{
618 struct f2fs_sb_info *sbi = F2FS_I_SB(dir);
619 struct page *ipage;
620 unsigned int bit_pos = 2;
Chao Yuf2470372017-07-19 00:19:05 +0800621 void *inline_dentry;
Chao Yu76a9dd82017-07-16 15:08:54 +0800622 struct f2fs_dentry_ptr d;
Chao Yu201a05b2014-09-24 18:17:53 +0800623
624 ipage = get_node_page(sbi, dir->i_ino);
625 if (IS_ERR(ipage))
626 return false;
627
Chao Yuf2470372017-07-19 00:19:05 +0800628 inline_dentry = inline_data_addr(dir, ipage);
629 make_dentry_ptr_inline(dir, &d, inline_dentry);
Chao Yu76a9dd82017-07-16 15:08:54 +0800630
631 bit_pos = find_next_bit_le(d.bitmap, d.max, bit_pos);
Chao Yu201a05b2014-09-24 18:17:53 +0800632
633 f2fs_put_page(ipage, 1);
634
Chao Yu76a9dd82017-07-16 15:08:54 +0800635 if (bit_pos < d.max)
Chao Yu201a05b2014-09-24 18:17:53 +0800636 return false;
637
638 return true;
639}
640
Jaegeuk Kimd8c68222015-04-27 16:26:24 -0700641int f2fs_read_inline_dir(struct file *file, struct dir_context *ctx,
Jaegeuk Kim0b81d072015-05-15 16:26:10 -0700642 struct fscrypt_str *fstr)
Chao Yu201a05b2014-09-24 18:17:53 +0800643{
644 struct inode *inode = file_inode(file);
Chao Yu201a05b2014-09-24 18:17:53 +0800645 struct page *ipage = NULL;
Jaegeuk Kim7b3cd7d2014-10-18 22:52:52 -0700646 struct f2fs_dentry_ptr d;
Chao Yuf2470372017-07-19 00:19:05 +0800647 void *inline_dentry = NULL;
Chao Yued6bd4b2016-10-29 18:46:34 +0800648 int err;
Chao Yu201a05b2014-09-24 18:17:53 +0800649
Chao Yu76a9dd82017-07-16 15:08:54 +0800650 make_dentry_ptr_inline(inode, &d, inline_dentry);
651
652 if (ctx->pos == d.max)
Chao Yu201a05b2014-09-24 18:17:53 +0800653 return 0;
654
Jaegeuk Kim38594de2014-10-15 21:29:51 -0700655 ipage = get_node_page(F2FS_I_SB(inode), inode->i_ino);
Chao Yu201a05b2014-09-24 18:17:53 +0800656 if (IS_ERR(ipage))
657 return PTR_ERR(ipage);
658
Chao Yu3d072092019-03-12 15:44:27 +0800659 /*
660 * f2fs_readdir was protected by inode.i_rwsem, it is safe to access
661 * ipage without page's lock held.
662 */
663 unlock_page(ipage);
664
Chao Yuf2470372017-07-19 00:19:05 +0800665 inline_dentry = inline_data_addr(inode, ipage);
Chao Yu201a05b2014-09-24 18:17:53 +0800666
Tomohiro Kusumi64c24ec2017-04-04 13:01:22 +0300667 make_dentry_ptr_inline(inode, &d, inline_dentry);
Jaegeuk Kim7b3cd7d2014-10-18 22:52:52 -0700668
Chao Yued6bd4b2016-10-29 18:46:34 +0800669 err = f2fs_fill_dentries(ctx, &d, 0, fstr);
670 if (!err)
Chao Yu76a9dd82017-07-16 15:08:54 +0800671 ctx->pos = d.max;
Chao Yu201a05b2014-09-24 18:17:53 +0800672
Chao Yu3d072092019-03-12 15:44:27 +0800673 f2fs_put_page(ipage, 0);
Chao Yued6bd4b2016-10-29 18:46:34 +0800674 return err < 0 ? err : 0;
Chao Yu201a05b2014-09-24 18:17:53 +0800675}
Jaegeuk Kim67f8cf3c2015-10-15 11:34:49 -0700676
677int f2fs_inline_data_fiemap(struct inode *inode,
678 struct fiemap_extent_info *fieinfo, __u64 start, __u64 len)
679{
680 __u64 byteaddr, ilen;
681 __u32 flags = FIEMAP_EXTENT_DATA_INLINE | FIEMAP_EXTENT_NOT_ALIGNED |
682 FIEMAP_EXTENT_LAST;
683 struct node_info ni;
684 struct page *ipage;
685 int err = 0;
686
687 ipage = get_node_page(F2FS_I_SB(inode), inode->i_ino);
688 if (IS_ERR(ipage))
689 return PTR_ERR(ipage);
690
691 if (!f2fs_has_inline_data(inode)) {
692 err = -EAGAIN;
693 goto out;
694 }
695
Chao Yuf2470372017-07-19 00:19:05 +0800696 ilen = min_t(size_t, MAX_INLINE_DATA(inode), i_size_read(inode));
Jaegeuk Kim67f8cf3c2015-10-15 11:34:49 -0700697 if (start >= ilen)
698 goto out;
699 if (start + len < ilen)
700 ilen = start + len;
701 ilen -= start;
702
703 get_node_info(F2FS_I_SB(inode), inode->i_ino, &ni);
704 byteaddr = (__u64)ni.blk_addr << inode->i_sb->s_blocksize_bits;
Chao Yuf2470372017-07-19 00:19:05 +0800705 byteaddr += (char *)inline_data_addr(inode, ipage) -
706 (char *)F2FS_INODE(ipage);
Jaegeuk Kim67f8cf3c2015-10-15 11:34:49 -0700707 err = fiemap_fill_next_extent(fieinfo, start, byteaddr, ilen, flags);
708out:
709 f2fs_put_page(ipage, 1);
710 return err;
711}