blob: dc7ce79672b8dab985a5b35ad4a50ec60b51bc1e [file] [log] [blame]
Chao Yu7c1a0002018-09-12 09:16:07 +08001// SPDX-License-Identifier: GPL-2.0
Jaegeuk Kim0a8165d2012-11-29 13:28:09 +09002/*
Jaegeuk Kim6b4ea012012-11-14 16:59:04 +09003 * fs/f2fs/dir.c
4 *
5 * Copyright (c) 2012 Samsung Electronics Co., Ltd.
6 * http://www.samsung.com/
Jaegeuk Kim6b4ea012012-11-14 16:59:04 +09007 */
Daniel Rosenberg7ad08a52020-11-19 06:09:04 +00008#include <asm/unaligned.h>
Jaegeuk Kim6b4ea012012-11-14 16:59:04 +09009#include <linux/fs.h>
10#include <linux/f2fs_fs.h>
Chao Yu4414dea2017-10-13 18:01:34 +080011#include <linux/sched/signal.h>
Daniel Rosenberg2c2eb7a2019-07-23 16:05:29 -070012#include <linux/unicode.h>
Jaegeuk Kim6b4ea012012-11-14 16:59:04 +090013#include "f2fs.h"
Jaegeuk Kim398b1ac2012-12-19 15:28:39 +090014#include "node.h"
Jaegeuk Kim6b4ea012012-11-14 16:59:04 +090015#include "acl.h"
Jaegeuk Kim8ae8f162013-06-03 19:46:19 +090016#include "xattr.h"
Chao Yue97a3c42017-10-13 18:01:33 +080017#include <trace/events/f2fs.h>
Jaegeuk Kim6b4ea012012-11-14 16:59:04 +090018
19static unsigned long dir_blocks(struct inode *inode)
20{
Kirill A. Shutemov09cbfea2016-04-01 15:29:47 +030021 return ((unsigned long long) (i_size_read(inode) + PAGE_SIZE - 1))
22 >> PAGE_SHIFT;
Jaegeuk Kim6b4ea012012-11-14 16:59:04 +090023}
24
Jaegeuk Kim38431542014-02-27 18:20:00 +090025static unsigned int dir_buckets(unsigned int level, int dir_level)
Jaegeuk Kim6b4ea012012-11-14 16:59:04 +090026{
Chao Yubfec07d2014-05-28 08:56:09 +080027 if (level + dir_level < MAX_DIR_HASH_DEPTH / 2)
Jaegeuk Kim38431542014-02-27 18:20:00 +090028 return 1 << (level + dir_level);
Jaegeuk Kim6b4ea012012-11-14 16:59:04 +090029 else
Chao Yubfec07d2014-05-28 08:56:09 +080030 return MAX_DIR_BUCKETS;
Jaegeuk Kim6b4ea012012-11-14 16:59:04 +090031}
32
33static unsigned int bucket_blocks(unsigned int level)
34{
35 if (level < MAX_DIR_HASH_DEPTH / 2)
36 return 2;
37 else
38 return 4;
39}
40
Chao Yuebfa7322016-09-18 23:30:03 +080041static unsigned char f2fs_filetype_table[F2FS_FT_MAX] = {
Jaegeuk Kim6b4ea012012-11-14 16:59:04 +090042 [F2FS_FT_UNKNOWN] = DT_UNKNOWN,
43 [F2FS_FT_REG_FILE] = DT_REG,
44 [F2FS_FT_DIR] = DT_DIR,
45 [F2FS_FT_CHRDEV] = DT_CHR,
46 [F2FS_FT_BLKDEV] = DT_BLK,
47 [F2FS_FT_FIFO] = DT_FIFO,
48 [F2FS_FT_SOCK] = DT_SOCK,
49 [F2FS_FT_SYMLINK] = DT_LNK,
50};
51
Jaegeuk Kim6b4ea012012-11-14 16:59:04 +090052static unsigned char f2fs_type_by_mode[S_IFMT >> S_SHIFT] = {
53 [S_IFREG >> S_SHIFT] = F2FS_FT_REG_FILE,
54 [S_IFDIR >> S_SHIFT] = F2FS_FT_DIR,
55 [S_IFCHR >> S_SHIFT] = F2FS_FT_CHRDEV,
56 [S_IFBLK >> S_SHIFT] = F2FS_FT_BLKDEV,
57 [S_IFIFO >> S_SHIFT] = F2FS_FT_FIFO,
58 [S_IFSOCK >> S_SHIFT] = F2FS_FT_SOCK,
59 [S_IFLNK >> S_SHIFT] = F2FS_FT_SYMLINK,
60};
61
Chao Yu2e79d952018-05-30 00:20:40 +080062static void set_de_type(struct f2fs_dir_entry *de, umode_t mode)
Jaegeuk Kim6b4ea012012-11-14 16:59:04 +090063{
Jaegeuk Kim6b4ea012012-11-14 16:59:04 +090064 de->file_type = f2fs_type_by_mode[(mode & S_IFMT) >> S_SHIFT];
65}
66
Chao Yu4d57b862018-05-30 00:20:41 +080067unsigned char f2fs_get_de_type(struct f2fs_dir_entry *de)
Chao Yu675f10b2016-02-22 18:29:18 +080068{
69 if (de->file_type < F2FS_FT_MAX)
70 return f2fs_filetype_table[de->file_type];
71 return DT_UNKNOWN;
72}
73
Eric Biggers43c780b2020-05-07 00:59:04 -070074/* If @dir is casefolded, initialize @fname->cf_name from @fname->usr_fname. */
75int f2fs_init_casefolded_name(const struct inode *dir,
76 struct f2fs_filename *fname)
77{
78#ifdef CONFIG_UNICODE
Daniel Rosenbergeca48732020-07-08 02:12:36 -070079 struct super_block *sb = dir->i_sb;
80 struct f2fs_sb_info *sbi = F2FS_SB(sb);
Eric Biggers43c780b2020-05-07 00:59:04 -070081
82 if (IS_CASEFOLDED(dir)) {
83 fname->cf_name.name = f2fs_kmalloc(sbi, F2FS_NAME_LEN,
84 GFP_NOFS);
85 if (!fname->cf_name.name)
86 return -ENOMEM;
Daniel Rosenbergeca48732020-07-08 02:12:36 -070087 fname->cf_name.len = utf8_casefold(sb->s_encoding,
Eric Biggers43c780b2020-05-07 00:59:04 -070088 fname->usr_fname,
89 fname->cf_name.name,
90 F2FS_NAME_LEN);
91 if ((int)fname->cf_name.len <= 0) {
92 kfree(fname->cf_name.name);
93 fname->cf_name.name = NULL;
Daniel Rosenbergeca48732020-07-08 02:12:36 -070094 if (sb_has_strict_encoding(sb))
Eric Biggers43c780b2020-05-07 00:59:04 -070095 return -EINVAL;
96 /* fall back to treating name as opaque byte sequence */
97 }
98 }
99#endif
100 return 0;
101}
102
103static int __f2fs_setup_filename(const struct inode *dir,
104 const struct fscrypt_name *crypt_name,
105 struct f2fs_filename *fname)
106{
107 int err;
108
109 memset(fname, 0, sizeof(*fname));
110
111 fname->usr_fname = crypt_name->usr_fname;
112 fname->disk_name = crypt_name->disk_name;
113#ifdef CONFIG_FS_ENCRYPTION
114 fname->crypto_buf = crypt_name->crypto_buf;
115#endif
Eric Biggers70fb2612020-09-23 21:26:23 -0700116 if (crypt_name->is_nokey_name) {
Eric Biggers43c780b2020-05-07 00:59:04 -0700117 /* hash was decoded from the no-key name */
118 fname->hash = cpu_to_le32(crypt_name->hash);
119 } else {
120 err = f2fs_init_casefolded_name(dir, fname);
121 if (err) {
122 f2fs_free_filename(fname);
123 return err;
124 }
125 f2fs_hash_filename(dir, fname);
126 }
127 return 0;
128}
129
130/*
131 * Prepare to search for @iname in @dir. This is similar to
132 * fscrypt_setup_filename(), but this also handles computing the casefolded name
133 * and the f2fs dirhash if needed, then packing all the information about this
134 * filename up into a 'struct f2fs_filename'.
135 */
136int f2fs_setup_filename(struct inode *dir, const struct qstr *iname,
137 int lookup, struct f2fs_filename *fname)
138{
139 struct fscrypt_name crypt_name;
140 int err;
141
142 err = fscrypt_setup_filename(dir, iname, lookup, &crypt_name);
143 if (err)
144 return err;
145
146 return __f2fs_setup_filename(dir, &crypt_name, fname);
147}
148
149/*
150 * Prepare to look up @dentry in @dir. This is similar to
151 * fscrypt_prepare_lookup(), but this also handles computing the casefolded name
152 * and the f2fs dirhash if needed, then packing all the information about this
153 * filename up into a 'struct f2fs_filename'.
154 */
155int f2fs_prepare_lookup(struct inode *dir, struct dentry *dentry,
156 struct f2fs_filename *fname)
157{
158 struct fscrypt_name crypt_name;
159 int err;
160
161 err = fscrypt_prepare_lookup(dir, dentry, &crypt_name);
162 if (err)
163 return err;
164
165 return __f2fs_setup_filename(dir, &crypt_name, fname);
166}
167
168void f2fs_free_filename(struct f2fs_filename *fname)
169{
170#ifdef CONFIG_FS_ENCRYPTION
171 kfree(fname->crypto_buf.name);
172 fname->crypto_buf.name = NULL;
173#endif
174#ifdef CONFIG_UNICODE
175 kfree(fname->cf_name.name);
176 fname->cf_name.name = NULL;
177#endif
178}
179
Jaegeuk Kim38431542014-02-27 18:20:00 +0900180static unsigned long dir_block_index(unsigned int level,
181 int dir_level, unsigned int idx)
Jaegeuk Kim6b4ea012012-11-14 16:59:04 +0900182{
183 unsigned long i;
184 unsigned long bidx = 0;
185
186 for (i = 0; i < level; i++)
Jaegeuk Kim38431542014-02-27 18:20:00 +0900187 bidx += dir_buckets(i, dir_level) * bucket_blocks(i);
Jaegeuk Kim6b4ea012012-11-14 16:59:04 +0900188 bidx += idx * bucket_blocks(level);
189 return bidx;
190}
191
Daniel Rosenberg2c2eb7a2019-07-23 16:05:29 -0700192static struct f2fs_dir_entry *find_in_block(struct inode *dir,
193 struct page *dentry_page,
Eric Biggers43c780b2020-05-07 00:59:04 -0700194 const struct f2fs_filename *fname,
Chao Yu17f930e2020-09-26 08:20:46 +0800195 int *max_slots)
Jaegeuk Kim4e6ebf62014-10-13 17:26:14 -0700196{
197 struct f2fs_dentry_block *dentry_blk;
Jaegeuk Kim7b3cd7d2014-10-18 22:52:52 -0700198 struct f2fs_dentry_ptr d;
Jaegeuk Kim4e6ebf62014-10-13 17:26:14 -0700199
Yunlong Songbdbc90f2018-02-28 20:31:52 +0800200 dentry_blk = (struct f2fs_dentry_block *)page_address(dentry_page);
Jaegeuk Kim7b3cd7d2014-10-18 22:52:52 -0700201
Daniel Rosenberg2c2eb7a2019-07-23 16:05:29 -0700202 make_dentry_ptr_block(dir, &d, dentry_blk);
Chao Yu17f930e2020-09-26 08:20:46 +0800203 return f2fs_find_target_dentry(&d, fname, max_slots);
Jaegeuk Kim4e6ebf62014-10-13 17:26:14 -0700204}
205
Daniel Rosenberg2c2eb7a2019-07-23 16:05:29 -0700206#ifdef CONFIG_UNICODE
207/*
208 * Test whether a case-insensitive directory entry matches the filename
209 * being searched for.
Daniel Rosenberg7ad08a52020-11-19 06:09:04 +0000210 *
211 * Returns 1 for a match, 0 for no match, and -errno on an error.
Daniel Rosenberg2c2eb7a2019-07-23 16:05:29 -0700212 */
Daniel Rosenberg7ad08a52020-11-19 06:09:04 +0000213static int f2fs_match_ci_name(const struct inode *dir, const struct qstr *name,
Eric Biggers43c780b2020-05-07 00:59:04 -0700214 const u8 *de_name, u32 de_name_len)
Daniel Rosenberg2c2eb7a2019-07-23 16:05:29 -0700215{
Daniel Rosenbergeca48732020-07-08 02:12:36 -0700216 const struct super_block *sb = dir->i_sb;
217 const struct unicode_map *um = sb->s_encoding;
Daniel Rosenberg7ad08a52020-11-19 06:09:04 +0000218 struct fscrypt_str decrypted_name = FSTR_INIT(NULL, de_name_len);
Eric Biggers43c780b2020-05-07 00:59:04 -0700219 struct qstr entry = QSTR_INIT(de_name, de_name_len);
Eric Biggersf874fa12020-05-07 00:59:03 -0700220 int res;
Daniel Rosenberg2c2eb7a2019-07-23 16:05:29 -0700221
Daniel Rosenberg7ad08a52020-11-19 06:09:04 +0000222 if (IS_ENCRYPTED(dir)) {
223 const struct fscrypt_str encrypted_name =
224 FSTR_INIT((u8 *)de_name, de_name_len);
225
226 if (WARN_ON_ONCE(!fscrypt_has_encryption_key(dir)))
227 return -EINVAL;
228
229 decrypted_name.name = kmalloc(de_name_len, GFP_KERNEL);
230 if (!decrypted_name.name)
231 return -ENOMEM;
232 res = fscrypt_fname_disk_to_usr(dir, 0, 0, &encrypted_name,
233 &decrypted_name);
234 if (res < 0)
235 goto out;
236 entry.name = decrypted_name.name;
237 entry.len = decrypted_name.len;
Daniel Rosenberg2c2eb7a2019-07-23 16:05:29 -0700238 }
Daniel Rosenberg7ad08a52020-11-19 06:09:04 +0000239
240 res = utf8_strncasecmp_folded(um, name, &entry);
241 /*
242 * In strict mode, ignore invalid names. In non-strict mode,
243 * fall back to treating them as opaque byte sequences.
244 */
245 if (res < 0 && !sb_has_strict_encoding(sb)) {
246 res = name->len == entry.len &&
247 memcmp(name->name, entry.name, name->len) == 0;
248 } else {
249 /* utf8_strncasecmp_folded returns 0 on match */
250 res = (res == 0);
251 }
252out:
253 kfree(decrypted_name.name);
254 return res;
Daniel Rosenberg2c2eb7a2019-07-23 16:05:29 -0700255}
Eric Biggers43c780b2020-05-07 00:59:04 -0700256#endif /* CONFIG_UNICODE */
Chao Yu950d47f2019-08-21 23:13:35 +0800257
Daniel Rosenberg7ad08a52020-11-19 06:09:04 +0000258static inline int f2fs_match_name(const struct inode *dir,
Eric Biggers43c780b2020-05-07 00:59:04 -0700259 const struct f2fs_filename *fname,
260 const u8 *de_name, u32 de_name_len)
Chao Yu950d47f2019-08-21 23:13:35 +0800261{
Eric Biggers43c780b2020-05-07 00:59:04 -0700262 struct fscrypt_name f;
Chao Yufe76a162019-08-21 23:13:34 +0800263
264#ifdef CONFIG_UNICODE
Eric Biggers43c780b2020-05-07 00:59:04 -0700265 if (fname->cf_name.name) {
266 struct qstr cf = FSTR_TO_QSTR(&fname->cf_name);
Chao Yufe76a162019-08-21 23:13:34 +0800267
Eric Biggers43c780b2020-05-07 00:59:04 -0700268 return f2fs_match_ci_name(dir, &cf, de_name, de_name_len);
Chao Yu950d47f2019-08-21 23:13:35 +0800269 }
Chao Yufe76a162019-08-21 23:13:34 +0800270#endif
Eric Biggers43c780b2020-05-07 00:59:04 -0700271 f.usr_fname = fname->usr_fname;
272 f.disk_name = fname->disk_name;
273#ifdef CONFIG_FS_ENCRYPTION
274 f.crypto_buf = fname->crypto_buf;
275#endif
276 return fscrypt_match_name(&f, de_name, de_name_len);
Chao Yufe76a162019-08-21 23:13:34 +0800277}
278
Eric Biggers43c780b2020-05-07 00:59:04 -0700279struct f2fs_dir_entry *f2fs_find_target_dentry(const struct f2fs_dentry_ptr *d,
280 const struct f2fs_filename *fname, int *max_slots)
Jaegeuk Kim6b4ea012012-11-14 16:59:04 +0900281{
282 struct f2fs_dir_entry *de;
Jaegeuk Kim5d0c66712014-02-27 13:57:53 +0900283 unsigned long bit_pos = 0;
Jaegeuk Kim5d0c66712014-02-27 13:57:53 +0900284 int max_len = 0;
Daniel Rosenberg7ad08a52020-11-19 06:09:04 +0000285 int res = 0;
Jaegeuk Kim6b4ea012012-11-14 16:59:04 +0900286
Jaegeuk Kim7b3cd7d2014-10-18 22:52:52 -0700287 if (max_slots)
288 *max_slots = 0;
289 while (bit_pos < d->max) {
290 if (!test_bit_le(bit_pos, d->bitmap)) {
Jaegeuk Kim5d0c66712014-02-27 13:57:53 +0900291 bit_pos++;
Chao Yubda19072015-03-09 17:33:16 +0800292 max_len++;
Jaegeuk Kim5d0c66712014-02-27 13:57:53 +0900293 continue;
294 }
Chao Yubda19072015-03-09 17:33:16 +0800295
Jaegeuk Kim7b3cd7d2014-10-18 22:52:52 -0700296 de = &d->dentry[bit_pos];
Jaegeuk Kim6e22c692015-04-27 17:12:39 -0700297
Chao Yua4a13f52016-04-27 22:22:20 +0800298 if (unlikely(!de->name_len)) {
299 bit_pos++;
300 continue;
301 }
302
Daniel Rosenberg7ad08a52020-11-19 06:09:04 +0000303 if (de->hash_code == fname->hash) {
304 res = f2fs_match_name(d->inode, fname,
305 d->filename[bit_pos],
306 le16_to_cpu(de->name_len));
307 if (res < 0)
308 return ERR_PTR(res);
309 if (res)
310 goto found;
311 }
Eric Biggers1f73d492017-04-24 10:00:12 -0700312
Chao Yubda19072015-03-09 17:33:16 +0800313 if (max_slots && max_len > *max_slots)
Jaegeuk Kim5d0c66712014-02-27 13:57:53 +0900314 *max_slots = max_len;
Chao Yubda19072015-03-09 17:33:16 +0800315 max_len = 0;
Chao Yu81e366f2014-07-10 12:37:46 +0800316
Jaegeuk Kim5d0c66712014-02-27 13:57:53 +0900317 bit_pos += GET_DENTRY_SLOTS(le16_to_cpu(de->name_len));
Jaegeuk Kim6b4ea012012-11-14 16:59:04 +0900318 }
319
320 de = NULL;
Jaegeuk Kim6b4ea012012-11-14 16:59:04 +0900321found:
Jaegeuk Kim7b3cd7d2014-10-18 22:52:52 -0700322 if (max_slots && max_len > *max_slots)
Jaegeuk Kim5d0c66712014-02-27 13:57:53 +0900323 *max_slots = max_len;
Jaegeuk Kim6b4ea012012-11-14 16:59:04 +0900324 return de;
325}
326
327static struct f2fs_dir_entry *find_in_level(struct inode *dir,
Jaegeuk Kim6e22c692015-04-27 17:12:39 -0700328 unsigned int level,
Eric Biggers43c780b2020-05-07 00:59:04 -0700329 const struct f2fs_filename *fname,
Jaegeuk Kim6e22c692015-04-27 17:12:39 -0700330 struct page **res_page)
Jaegeuk Kim6b4ea012012-11-14 16:59:04 +0900331{
Eric Biggers43c780b2020-05-07 00:59:04 -0700332 int s = GET_DENTRY_SLOTS(fname->disk_name.len);
Jaegeuk Kim6b4ea012012-11-14 16:59:04 +0900333 unsigned int nbucket, nblock;
334 unsigned int bidx, end_block;
335 struct page *dentry_page;
336 struct f2fs_dir_entry *de = NULL;
337 bool room = false;
Jaegeuk Kim4e6ebf62014-10-13 17:26:14 -0700338 int max_slots;
Jaegeuk Kim6b4ea012012-11-14 16:59:04 +0900339
Jaegeuk Kim38431542014-02-27 18:20:00 +0900340 nbucket = dir_buckets(level, F2FS_I(dir)->i_dir_level);
Jaegeuk Kim6b4ea012012-11-14 16:59:04 +0900341 nblock = bucket_blocks(level);
342
Jaegeuk Kim38431542014-02-27 18:20:00 +0900343 bidx = dir_block_index(level, F2FS_I(dir)->i_dir_level,
Eric Biggers43c780b2020-05-07 00:59:04 -0700344 le32_to_cpu(fname->hash) % nbucket);
Jaegeuk Kim6b4ea012012-11-14 16:59:04 +0900345 end_block = bidx + nblock;
346
347 for (; bidx < end_block; bidx++) {
348 /* no need to allocate new dentry pages to all the indices */
Chao Yu4d57b862018-05-30 00:20:41 +0800349 dentry_page = f2fs_find_data_page(dir, bidx);
Jaegeuk Kim6b4ea012012-11-14 16:59:04 +0900350 if (IS_ERR(dentry_page)) {
Jaegeuk Kim42d96402016-05-25 14:29:11 -0700351 if (PTR_ERR(dentry_page) == -ENOENT) {
352 room = true;
353 continue;
354 } else {
355 *res_page = dentry_page;
356 break;
357 }
Jaegeuk Kim6b4ea012012-11-14 16:59:04 +0900358 }
359
Chao Yu17f930e2020-09-26 08:20:46 +0800360 de = find_in_block(dir, dentry_page, fname, &max_slots);
Daniel Rosenberg7ad08a52020-11-19 06:09:04 +0000361 if (IS_ERR(de)) {
362 *res_page = ERR_CAST(de);
363 de = NULL;
364 break;
365 } else if (de) {
Chao Yu17f930e2020-09-26 08:20:46 +0800366 *res_page = dentry_page;
Jaegeuk Kim6b4ea012012-11-14 16:59:04 +0900367 break;
Chao Yu17f930e2020-09-26 08:20:46 +0800368 }
Jaegeuk Kim6b4ea012012-11-14 16:59:04 +0900369
370 if (max_slots >= s)
371 room = true;
372 f2fs_put_page(dentry_page, 0);
373 }
374
Eric Biggers43c780b2020-05-07 00:59:04 -0700375 if (!de && room && F2FS_I(dir)->chash != fname->hash) {
376 F2FS_I(dir)->chash = fname->hash;
Sheng Yongd3bb9102017-04-22 10:39:20 +0800377 F2FS_I(dir)->clevel = level;
Jaegeuk Kim6b4ea012012-11-14 16:59:04 +0900378 }
379
380 return de;
381}
382
Shuoran Liue7ba1082016-08-29 11:27:56 +0800383struct f2fs_dir_entry *__f2fs_find_entry(struct inode *dir,
Eric Biggers43c780b2020-05-07 00:59:04 -0700384 const struct f2fs_filename *fname,
385 struct page **res_page)
Jaegeuk Kim6b4ea012012-11-14 16:59:04 +0900386{
Jaegeuk Kim6b4ea012012-11-14 16:59:04 +0900387 unsigned long npages = dir_blocks(dir);
388 struct f2fs_dir_entry *de = NULL;
Jaegeuk Kim6b4ea012012-11-14 16:59:04 +0900389 unsigned int max_depth;
390 unsigned int level;
Jaegeuk Kim6b4ea012012-11-14 16:59:04 +0900391
Chao Yu6d7ab882020-09-29 09:22:50 +0800392 *res_page = NULL;
393
Jaegeuk Kim6e22c692015-04-27 17:12:39 -0700394 if (f2fs_has_inline_dentry(dir)) {
Chao Yu4d57b862018-05-30 00:20:41 +0800395 de = f2fs_find_in_inline_dir(dir, fname, res_page);
Jaegeuk Kim6e22c692015-04-27 17:12:39 -0700396 goto out;
397 }
398
Chao Yu6d7ab882020-09-29 09:22:50 +0800399 if (npages == 0)
Jaegeuk Kim6e22c692015-04-27 17:12:39 -0700400 goto out;
401
Jaegeuk Kim6b4ea012012-11-14 16:59:04 +0900402 max_depth = F2FS_I(dir)->i_current_depth;
Jaegeuk Kim1f6fa262015-12-31 10:28:52 -0800403 if (unlikely(max_depth > MAX_DIR_HASH_DEPTH)) {
Joe Perchesdcbb4c12019-06-18 17:48:42 +0800404 f2fs_warn(F2FS_I_SB(dir), "Corrupted max_depth of %lu: %u",
405 dir->i_ino, max_depth);
Jaegeuk Kim1f6fa262015-12-31 10:28:52 -0800406 max_depth = MAX_DIR_HASH_DEPTH;
Jaegeuk Kim205b9822016-05-20 09:52:20 -0700407 f2fs_i_depth_write(dir, max_depth);
Jaegeuk Kim1f6fa262015-12-31 10:28:52 -0800408 }
Jaegeuk Kim6b4ea012012-11-14 16:59:04 +0900409
410 for (level = 0; level < max_depth; level++) {
Shuoran Liue7ba1082016-08-29 11:27:56 +0800411 de = find_in_level(dir, level, fname, res_page);
Jaegeuk Kim42d96402016-05-25 14:29:11 -0700412 if (de || IS_ERR(*res_page))
Jaegeuk Kim6b4ea012012-11-14 16:59:04 +0900413 break;
414 }
Jaegeuk Kim6e22c692015-04-27 17:12:39 -0700415out:
Sheng Yongd3bb9102017-04-22 10:39:20 +0800416 /* This is to increase the speed of f2fs_create */
417 if (!de)
418 F2FS_I(dir)->task = current;
Shuoran Liue7ba1082016-08-29 11:27:56 +0800419 return de;
420}
421
422/*
423 * Find an entry in the specified directory with the wanted name.
424 * It returns the page where the entry was found (as a parameter - res_page),
425 * and the entry itself. Page is returned mapped and unlocked.
426 * Entry is guaranteed to be valid.
427 */
428struct f2fs_dir_entry *f2fs_find_entry(struct inode *dir,
429 const struct qstr *child, struct page **res_page)
430{
431 struct f2fs_dir_entry *de = NULL;
Eric Biggers43c780b2020-05-07 00:59:04 -0700432 struct f2fs_filename fname;
Shuoran Liue7ba1082016-08-29 11:27:56 +0800433 int err;
434
Eric Biggers43c780b2020-05-07 00:59:04 -0700435 err = f2fs_setup_filename(dir, child, 1, &fname);
Shuoran Liue7ba1082016-08-29 11:27:56 +0800436 if (err) {
Eric Biggers54475f52016-12-05 11:12:44 -0800437 if (err == -ENOENT)
438 *res_page = NULL;
439 else
440 *res_page = ERR_PTR(err);
Shuoran Liue7ba1082016-08-29 11:27:56 +0800441 return NULL;
442 }
443
444 de = __f2fs_find_entry(dir, &fname, res_page);
445
Eric Biggers43c780b2020-05-07 00:59:04 -0700446 f2fs_free_filename(&fname);
Jaegeuk Kim6b4ea012012-11-14 16:59:04 +0900447 return de;
448}
449
450struct f2fs_dir_entry *f2fs_parent_dir(struct inode *dir, struct page **p)
451{
Al Viro80e5d1ff52021-04-15 19:46:50 -0400452 return f2fs_find_entry(dir, &dotdot_name, p);
Jaegeuk Kim6b4ea012012-11-14 16:59:04 +0900453}
454
Linus Torvalds835c92d2016-08-06 09:49:02 -0400455ino_t f2fs_inode_by_name(struct inode *dir, const struct qstr *qstr,
Chao Yu91246c22016-07-19 08:27:47 +0800456 struct page **page)
Jaegeuk Kim6b4ea012012-11-14 16:59:04 +0900457{
458 ino_t res = 0;
459 struct f2fs_dir_entry *de;
Jaegeuk Kim6b4ea012012-11-14 16:59:04 +0900460
Chao Yu91246c22016-07-19 08:27:47 +0800461 de = f2fs_find_entry(dir, qstr, page);
Jaegeuk Kim6b4ea012012-11-14 16:59:04 +0900462 if (de) {
463 res = le32_to_cpu(de->ino);
Chao Yu91246c22016-07-19 08:27:47 +0800464 f2fs_put_page(*page, 0);
Jaegeuk Kim6b4ea012012-11-14 16:59:04 +0900465 }
466
467 return res;
468}
469
470void f2fs_set_link(struct inode *dir, struct f2fs_dir_entry *de,
471 struct page *page, struct inode *inode)
472{
Jaegeuk Kim59a06152014-10-13 19:34:26 -0700473 enum page_type type = f2fs_has_inline_dentry(dir) ? NODE : DATA;
Yi Zhuang5f029c02021-04-06 09:47:35 +0800474
Jaegeuk Kim6b4ea012012-11-14 16:59:04 +0900475 lock_page(page);
Chao Yubae0ee72018-12-25 17:43:42 +0800476 f2fs_wait_on_page_writeback(page, type, true, true);
Jaegeuk Kim6b4ea012012-11-14 16:59:04 +0900477 de->ino = cpu_to_le32(inode->i_ino);
Jaegeuk Kim510022a2015-03-30 15:07:16 -0700478 set_de_type(de, inode->i_mode);
Jaegeuk Kim6b4ea012012-11-14 16:59:04 +0900479 set_page_dirty(page);
Jaegeuk Kim6666e6a2012-12-10 17:52:48 +0900480
Deepa Dinamani078cd822016-09-14 07:48:04 -0700481 dir->i_mtime = dir->i_ctime = current_time(dir);
Jaegeuk Kim7c457292016-10-14 11:51:23 -0700482 f2fs_mark_inode_dirty_sync(dir, false);
Jaegeuk Kim6b4ea012012-11-14 16:59:04 +0900483 f2fs_put_page(page, 1);
Jaegeuk Kim6b4ea012012-11-14 16:59:04 +0900484}
485
Daniel Rosenberg7ad08a52020-11-19 06:09:04 +0000486static void init_dent_inode(struct inode *dir, struct inode *inode,
487 const struct f2fs_filename *fname,
Eric Biggers43c780b2020-05-07 00:59:04 -0700488 struct page *ipage)
Jaegeuk Kim6b4ea012012-11-14 16:59:04 +0900489{
Jaegeuk Kim58bfaf42013-12-26 16:30:41 +0900490 struct f2fs_inode *ri;
Jaegeuk Kim6b4ea012012-11-14 16:59:04 +0900491
Daniel Rosenberg7ad08a52020-11-19 06:09:04 +0000492 if (!fname) /* tmpfile case? */
493 return;
494
Chao Yubae0ee72018-12-25 17:43:42 +0800495 f2fs_wait_on_page_writeback(ipage, NODE, true, true);
Jaegeuk Kim54b591d2014-04-29 17:28:32 +0900496
Al Viro53dc9a62013-01-25 16:01:21 -0500497 /* copy name info. to this inode page */
Jaegeuk Kim58bfaf42013-12-26 16:30:41 +0900498 ri = F2FS_INODE(ipage);
Eric Biggers43c780b2020-05-07 00:59:04 -0700499 ri->i_namelen = cpu_to_le32(fname->disk_name.len);
500 memcpy(ri->i_name, fname->disk_name.name, fname->disk_name.len);
Daniel Rosenberg7ad08a52020-11-19 06:09:04 +0000501 if (IS_ENCRYPTED(dir)) {
502 file_set_enc_name(inode);
503 /*
504 * Roll-forward recovery doesn't have encryption keys available,
505 * so it can't compute the dirhash for encrypted+casefolded
506 * filenames. Append it to i_name if possible. Else, disable
507 * roll-forward recovery of the dentry (i.e., make fsync'ing the
508 * file force a checkpoint) by setting LOST_PINO.
509 */
510 if (IS_CASEFOLDED(dir)) {
511 if (fname->disk_name.len + sizeof(f2fs_hash_t) <=
512 F2FS_NAME_LEN)
513 put_unaligned(fname->hash, (f2fs_hash_t *)
514 &ri->i_name[fname->disk_name.len]);
515 else
516 file_lost_pino(inode);
517 }
518 }
Jaegeuk Kim6b4ea012012-11-14 16:59:04 +0900519 set_page_dirty(ipage);
520}
521
Chao Yu4d57b862018-05-30 00:20:41 +0800522void f2fs_do_make_empty_dir(struct inode *inode, struct inode *parent,
Jaegeuk Kim062a3e72014-10-18 23:06:41 -0700523 struct f2fs_dentry_ptr *d)
524{
Eric Biggers43c780b2020-05-07 00:59:04 -0700525 struct fscrypt_str dot = FSTR_INIT(".", 1);
526 struct fscrypt_str dotdot = FSTR_INIT("..", 2);
Jaegeuk Kim062a3e72014-10-18 23:06:41 -0700527
Chao Yu291bf802016-03-09 22:07:28 +0800528 /* update dirent of "." */
529 f2fs_update_dentry(inode->i_ino, inode->i_mode, d, &dot, 0, 0);
Jaegeuk Kim062a3e72014-10-18 23:06:41 -0700530
Chao Yu291bf802016-03-09 22:07:28 +0800531 /* update dirent of ".." */
532 f2fs_update_dentry(parent->i_ino, parent->i_mode, d, &dotdot, 0, 1);
Jaegeuk Kim062a3e72014-10-18 23:06:41 -0700533}
534
Jaegeuk Kim44a83ff2013-05-20 10:10:29 +0900535static int make_empty_dir(struct inode *inode,
536 struct inode *parent, struct page *page)
Jaegeuk Kim39936832012-11-22 16:21:29 +0900537{
538 struct page *dentry_page;
539 struct f2fs_dentry_block *dentry_blk;
Jaegeuk Kim062a3e72014-10-18 23:06:41 -0700540 struct f2fs_dentry_ptr d;
Jaegeuk Kim39936832012-11-22 16:21:29 +0900541
Chao Yu622f28a2014-09-24 18:19:10 +0800542 if (f2fs_has_inline_dentry(inode))
Chao Yu4d57b862018-05-30 00:20:41 +0800543 return f2fs_make_empty_inline_dir(inode, parent, page);
Chao Yu622f28a2014-09-24 18:19:10 +0800544
Chao Yu4d57b862018-05-30 00:20:41 +0800545 dentry_page = f2fs_get_new_data_page(inode, page, 0, true);
Jaegeuk Kim39936832012-11-22 16:21:29 +0900546 if (IS_ERR(dentry_page))
547 return PTR_ERR(dentry_page);
548
Yunlong Songbdbc90f2018-02-28 20:31:52 +0800549 dentry_blk = page_address(dentry_page);
Jaegeuk Kim39936832012-11-22 16:21:29 +0900550
Tomohiro Kusumi64c24ec2017-04-04 13:01:22 +0300551 make_dentry_ptr_block(NULL, &d, dentry_blk);
Chao Yu4d57b862018-05-30 00:20:41 +0800552 f2fs_do_make_empty_dir(inode, parent, &d);
Jaegeuk Kim39936832012-11-22 16:21:29 +0900553
Jaegeuk Kim39936832012-11-22 16:21:29 +0900554 set_page_dirty(dentry_page);
555 f2fs_put_page(dentry_page, 1);
556 return 0;
557}
558
Chao Yu4d57b862018-05-30 00:20:41 +0800559struct page *f2fs_init_inode_metadata(struct inode *inode, struct inode *dir,
Eric Biggers43c780b2020-05-07 00:59:04 -0700560 const struct f2fs_filename *fname, struct page *dpage)
Jaegeuk Kim6b4ea012012-11-14 16:59:04 +0900561{
Jaegeuk Kim44a83ff2013-05-20 10:10:29 +0900562 struct page *page;
563 int err;
564
Jaegeuk Kim91942322016-05-20 10:13:22 -0700565 if (is_inode_flag_set(inode, FI_NEW_INODE)) {
Chao Yu4d57b862018-05-30 00:20:41 +0800566 page = f2fs_new_inode_page(inode);
Jaegeuk Kim44a83ff2013-05-20 10:10:29 +0900567 if (IS_ERR(page))
568 return page;
Jaegeuk Kim6b4ea012012-11-14 16:59:04 +0900569
570 if (S_ISDIR(inode->i_mode)) {
Jaegeuk Kim221149c2016-05-02 12:34:48 -0700571 /* in order to handle error case */
572 get_page(page);
Jaegeuk Kim44a83ff2013-05-20 10:10:29 +0900573 err = make_empty_dir(inode, dir, page);
Jaegeuk Kim221149c2016-05-02 12:34:48 -0700574 if (err) {
575 lock_page(page);
576 goto put_error;
577 }
578 put_page(page);
Jaegeuk Kim6b4ea012012-11-14 16:59:04 +0900579 }
580
Jaegeuk Kimbce8d112014-10-13 19:42:53 -0700581 err = f2fs_init_acl(inode, dir, page, dpage);
Jaegeuk Kim44a83ff2013-05-20 10:10:29 +0900582 if (err)
Jaegeuk Kima8865372013-12-27 17:04:17 +0900583 goto put_error;
Jaegeuk Kim44a83ff2013-05-20 10:10:29 +0900584
Eric Biggers43c780b2020-05-07 00:59:04 -0700585 err = f2fs_init_security(inode, dir,
586 fname ? fname->usr_fname : NULL, page);
Jaegeuk Kim8ae8f162013-06-03 19:46:19 +0900587 if (err)
Jaegeuk Kima8865372013-12-27 17:04:17 +0900588 goto put_error;
Jaegeuk Kimfcc85a42015-04-21 20:39:58 -0700589
Chao Yu8c7d4b52020-03-21 20:19:33 +0800590 if (IS_ENCRYPTED(inode)) {
Eric Biggerse075b692020-09-16 21:11:27 -0700591 err = fscrypt_set_context(inode, page);
Jaegeuk Kimfcc85a42015-04-21 20:39:58 -0700592 if (err)
593 goto put_error;
594 }
Jaegeuk Kim6b4ea012012-11-14 16:59:04 +0900595 } else {
Chao Yu4d57b862018-05-30 00:20:41 +0800596 page = f2fs_get_node_page(F2FS_I_SB(dir), inode->i_ino);
Jaegeuk Kim44a83ff2013-05-20 10:10:29 +0900597 if (IS_ERR(page))
598 return page;
Jaegeuk Kim6b4ea012012-11-14 16:59:04 +0900599 }
Jaegeuk Kim44a83ff2013-05-20 10:10:29 +0900600
Daniel Rosenberg7ad08a52020-11-19 06:09:04 +0000601 init_dent_inode(dir, inode, fname, page);
Jaegeuk Kim44a83ff2013-05-20 10:10:29 +0900602
Jaegeuk Kim83d5d6f2013-05-28 12:25:47 +0900603 /*
604 * This file should be checkpointed during fsync.
605 * We lost i_pino from now on.
606 */
Jaegeuk Kim91942322016-05-20 10:13:22 -0700607 if (is_inode_flag_set(inode, FI_INC_LINK)) {
Sheng Yongd58dfb72017-06-26 10:41:35 +0800608 if (!S_ISDIR(inode->i_mode))
609 file_lost_pino(inode);
Chao Yu50732df2014-06-19 16:23:19 +0800610 /*
611 * If link the tmpfile to alias through linkat path,
612 * we should remove this inode from orphan list.
613 */
614 if (inode->i_nlink == 0)
Chao Yu4d57b862018-05-30 00:20:41 +0800615 f2fs_remove_orphan_inode(F2FS_I_SB(dir), inode->i_ino);
Jaegeuk Kima1961242016-05-20 09:43:20 -0700616 f2fs_i_links_write(inode, true);
Jaegeuk Kim6b4ea012012-11-14 16:59:04 +0900617 }
Jaegeuk Kim44a83ff2013-05-20 10:10:29 +0900618 return page;
619
Jaegeuk Kima8865372013-12-27 17:04:17 +0900620put_error:
Jaegeuk Kim221149c2016-05-02 12:34:48 -0700621 clear_nlink(inode);
Chao Yu4d57b862018-05-30 00:20:41 +0800622 f2fs_update_inode(inode, page);
Jaegeuk Kim221149c2016-05-02 12:34:48 -0700623 f2fs_put_page(page, 1);
Jaegeuk Kim44a83ff2013-05-20 10:10:29 +0900624 return ERR_PTR(err);
Jaegeuk Kim6b4ea012012-11-14 16:59:04 +0900625}
626
Chao Yu4d57b862018-05-30 00:20:41 +0800627void f2fs_update_parent_metadata(struct inode *dir, struct inode *inode,
Jaegeuk Kim6b4ea012012-11-14 16:59:04 +0900628 unsigned int current_depth)
629{
Jaegeuk Kim91942322016-05-20 10:13:22 -0700630 if (inode && is_inode_flag_set(inode, FI_NEW_INODE)) {
Jaegeuk Kimee6d1822016-05-20 16:32:49 -0700631 if (S_ISDIR(inode->i_mode))
Jaegeuk Kima1961242016-05-20 09:43:20 -0700632 f2fs_i_links_write(dir, true);
Jaegeuk Kim91942322016-05-20 10:13:22 -0700633 clear_inode_flag(inode, FI_NEW_INODE);
Jaegeuk Kim6b4ea012012-11-14 16:59:04 +0900634 }
Deepa Dinamani078cd822016-09-14 07:48:04 -0700635 dir->i_mtime = dir->i_ctime = current_time(dir);
Jaegeuk Kim7c457292016-10-14 11:51:23 -0700636 f2fs_mark_inode_dirty_sync(dir, false);
Jaegeuk Kima18ff062014-01-21 13:32:12 +0900637
Jaegeuk Kimee6d1822016-05-20 16:32:49 -0700638 if (F2FS_I(dir)->i_current_depth != current_depth)
Jaegeuk Kim205b9822016-05-20 09:52:20 -0700639 f2fs_i_depth_write(dir, current_depth);
Jaegeuk Kim6b4ea012012-11-14 16:59:04 +0900640
Jaegeuk Kim91942322016-05-20 10:13:22 -0700641 if (inode && is_inode_flag_set(inode, FI_INC_LINK))
642 clear_inode_flag(inode, FI_INC_LINK);
Jaegeuk Kim6b4ea012012-11-14 16:59:04 +0900643}
644
Chao Yu4d57b862018-05-30 00:20:41 +0800645int f2fs_room_for_filename(const void *bitmap, int slots, int max_slots)
Jaegeuk Kim6b4ea012012-11-14 16:59:04 +0900646{
647 int bit_start = 0;
648 int zero_start, zero_end;
649next:
Jaegeuk Kima82afa22014-10-13 16:28:13 -0700650 zero_start = find_next_zero_bit_le(bitmap, max_slots, bit_start);
651 if (zero_start >= max_slots)
652 return max_slots;
Jaegeuk Kim6b4ea012012-11-14 16:59:04 +0900653
Jaegeuk Kima82afa22014-10-13 16:28:13 -0700654 zero_end = find_next_bit_le(bitmap, max_slots, zero_start);
Jaegeuk Kim6b4ea012012-11-14 16:59:04 +0900655 if (zero_end - zero_start >= slots)
656 return zero_start;
657
658 bit_start = zero_end + 1;
659
Jaegeuk Kima82afa22014-10-13 16:28:13 -0700660 if (zero_end + 1 >= max_slots)
661 return max_slots;
Jaegeuk Kim6b4ea012012-11-14 16:59:04 +0900662 goto next;
663}
664
Jaegeuk Kimb06af2a2019-12-09 19:03:05 -0800665bool f2fs_has_enough_room(struct inode *dir, struct page *ipage,
Eric Biggers43c780b2020-05-07 00:59:04 -0700666 const struct f2fs_filename *fname)
Jaegeuk Kimb06af2a2019-12-09 19:03:05 -0800667{
668 struct f2fs_dentry_ptr d;
669 unsigned int bit_pos;
Eric Biggers43c780b2020-05-07 00:59:04 -0700670 int slots = GET_DENTRY_SLOTS(fname->disk_name.len);
Jaegeuk Kimb06af2a2019-12-09 19:03:05 -0800671
672 make_dentry_ptr_inline(dir, &d, inline_data_addr(dir, ipage));
673
674 bit_pos = f2fs_room_for_filename(d.bitmap, slots, d.max);
675
676 return bit_pos < d.max;
677}
678
Jaegeuk Kim510022a2015-03-30 15:07:16 -0700679void f2fs_update_dentry(nid_t ino, umode_t mode, struct f2fs_dentry_ptr *d,
Eric Biggers43c780b2020-05-07 00:59:04 -0700680 const struct fscrypt_str *name, f2fs_hash_t name_hash,
681 unsigned int bit_pos)
Chao Yu3b4d7322015-02-16 16:17:20 +0800682{
683 struct f2fs_dir_entry *de;
684 int slots = GET_DENTRY_SLOTS(name->len);
685 int i;
686
687 de = &d->dentry[bit_pos];
688 de->hash_code = name_hash;
689 de->name_len = cpu_to_le16(name->len);
690 memcpy(d->filename[bit_pos], name->name, name->len);
Jaegeuk Kim510022a2015-03-30 15:07:16 -0700691 de->ino = cpu_to_le32(ino);
692 set_de_type(de, mode);
Jaegeuk Kim7d9dfa12016-02-12 14:29:28 -0800693 for (i = 0; i < slots; i++) {
Jaegeuk Kim6bf6b262016-08-31 16:20:37 -0700694 __set_bit_le(bit_pos + i, (void *)d->bitmap);
Jaegeuk Kim7d9dfa12016-02-12 14:29:28 -0800695 /* avoid wrong garbage data for readdir */
696 if (i)
697 (de + i)->name_len = 0;
698 }
Chao Yu3b4d7322015-02-16 16:17:20 +0800699}
700
Eric Biggers43c780b2020-05-07 00:59:04 -0700701int f2fs_add_regular_entry(struct inode *dir, const struct f2fs_filename *fname,
702 struct inode *inode, nid_t ino, umode_t mode)
Jaegeuk Kim6b4ea012012-11-14 16:59:04 +0900703{
704 unsigned int bit_pos;
705 unsigned int level;
706 unsigned int current_depth;
707 unsigned long bidx, block;
Jaegeuk Kim6b4ea012012-11-14 16:59:04 +0900708 unsigned int nbucket, nblock;
Jaegeuk Kim6b4ea012012-11-14 16:59:04 +0900709 struct page *dentry_page = NULL;
710 struct f2fs_dentry_block *dentry_blk = NULL;
Chao Yu3b4d7322015-02-16 16:17:20 +0800711 struct f2fs_dentry_ptr d;
Jaegeuk Kim510022a2015-03-30 15:07:16 -0700712 struct page *page = NULL;
Chao Yu675f10b2016-02-22 18:29:18 +0800713 int slots, err = 0;
Chao Yu622f28a2014-09-24 18:19:10 +0800714
Jaegeuk Kim6b4ea012012-11-14 16:59:04 +0900715 level = 0;
Eric Biggers43c780b2020-05-07 00:59:04 -0700716 slots = GET_DENTRY_SLOTS(fname->disk_name.len);
Jaegeuk Kim9ea97162015-04-27 14:51:02 -0700717
Jaegeuk Kim6b4ea012012-11-14 16:59:04 +0900718 current_depth = F2FS_I(dir)->i_current_depth;
Eric Biggers43c780b2020-05-07 00:59:04 -0700719 if (F2FS_I(dir)->chash == fname->hash) {
Jaegeuk Kim6b4ea012012-11-14 16:59:04 +0900720 level = F2FS_I(dir)->clevel;
721 F2FS_I(dir)->chash = 0;
722 }
723
724start:
Chao Yu55523512017-02-25 11:08:28 +0800725 if (time_to_inject(F2FS_I_SB(dir), FAULT_DIR_DEPTH)) {
Chao Yuc45d6002019-11-01 17:53:23 +0800726 f2fs_show_injection_info(F2FS_I_SB(dir), FAULT_DIR_DEPTH);
Jaegeuk Kimcb789422016-04-29 16:29:22 -0700727 return -ENOSPC;
Chao Yu55523512017-02-25 11:08:28 +0800728 }
Arnd Bergmann7fa750a2018-08-13 23:38:06 +0200729
Chao Yu675f10b2016-02-22 18:29:18 +0800730 if (unlikely(current_depth == MAX_DIR_HASH_DEPTH))
731 return -ENOSPC;
Jaegeuk Kim6b4ea012012-11-14 16:59:04 +0900732
733 /* Increase the depth, if required */
734 if (level == current_depth)
735 ++current_depth;
736
Jaegeuk Kim38431542014-02-27 18:20:00 +0900737 nbucket = dir_buckets(level, F2FS_I(dir)->i_dir_level);
Jaegeuk Kim6b4ea012012-11-14 16:59:04 +0900738 nblock = bucket_blocks(level);
739
Jaegeuk Kim38431542014-02-27 18:20:00 +0900740 bidx = dir_block_index(level, F2FS_I(dir)->i_dir_level,
Eric Biggers43c780b2020-05-07 00:59:04 -0700741 (le32_to_cpu(fname->hash) % nbucket));
Jaegeuk Kim6b4ea012012-11-14 16:59:04 +0900742
743 for (block = bidx; block <= (bidx + nblock - 1); block++) {
Chao Yu4d57b862018-05-30 00:20:41 +0800744 dentry_page = f2fs_get_new_data_page(dir, NULL, block, true);
Chao Yu675f10b2016-02-22 18:29:18 +0800745 if (IS_ERR(dentry_page))
746 return PTR_ERR(dentry_page);
Jaegeuk Kim6b4ea012012-11-14 16:59:04 +0900747
Yunlong Songbdbc90f2018-02-28 20:31:52 +0800748 dentry_blk = page_address(dentry_page);
Chao Yu4d57b862018-05-30 00:20:41 +0800749 bit_pos = f2fs_room_for_filename(&dentry_blk->dentry_bitmap,
Jaegeuk Kima82afa22014-10-13 16:28:13 -0700750 slots, NR_DENTRY_IN_BLOCK);
Jaegeuk Kim6b4ea012012-11-14 16:59:04 +0900751 if (bit_pos < NR_DENTRY_IN_BLOCK)
752 goto add_dentry;
753
Jaegeuk Kim6b4ea012012-11-14 16:59:04 +0900754 f2fs_put_page(dentry_page, 1);
Jaegeuk Kim6b4ea012012-11-14 16:59:04 +0900755 }
756
757 /* Move to next level to find the empty slot for new dentry */
758 ++level;
759 goto start;
760add_dentry:
Chao Yubae0ee72018-12-25 17:43:42 +0800761 f2fs_wait_on_page_writeback(dentry_page, DATA, true, true);
Jaegeuk Kim6b4ea012012-11-14 16:59:04 +0900762
Jaegeuk Kim510022a2015-03-30 15:07:16 -0700763 if (inode) {
764 down_write(&F2FS_I(inode)->i_sem);
Eric Biggers43c780b2020-05-07 00:59:04 -0700765 page = f2fs_init_inode_metadata(inode, dir, fname, NULL);
Jaegeuk Kim510022a2015-03-30 15:07:16 -0700766 if (IS_ERR(page)) {
767 err = PTR_ERR(page);
768 goto fail;
769 }
Jaegeuk Kim44a83ff2013-05-20 10:10:29 +0900770 }
Chao Yu3b4d7322015-02-16 16:17:20 +0800771
Tomohiro Kusumi64c24ec2017-04-04 13:01:22 +0300772 make_dentry_ptr_block(NULL, &d, dentry_blk);
Eric Biggers43c780b2020-05-07 00:59:04 -0700773 f2fs_update_dentry(ino, mode, &d, &fname->disk_name, fname->hash,
774 bit_pos);
Chao Yu3b4d7322015-02-16 16:17:20 +0800775
Jaegeuk Kim6b4ea012012-11-14 16:59:04 +0900776 set_page_dirty(dentry_page);
Jaegeuk Kim6666e6a2012-12-10 17:52:48 +0900777
Jaegeuk Kim510022a2015-03-30 15:07:16 -0700778 if (inode) {
Jaegeuk Kim205b9822016-05-20 09:52:20 -0700779 f2fs_i_pino_write(inode, dir->i_ino);
Chao Yu98194032019-09-10 09:14:16 +0800780
781 /* synchronize inode page's data from inode cache */
782 if (is_inode_flag_set(inode, FI_NEW_INODE))
783 f2fs_update_inode(inode, page);
784
Jaegeuk Kim510022a2015-03-30 15:07:16 -0700785 f2fs_put_page(page, 1);
786 }
Jaegeuk Kim44a83ff2013-05-20 10:10:29 +0900787
Chao Yu4d57b862018-05-30 00:20:41 +0800788 f2fs_update_parent_metadata(dir, inode, current_depth);
Jaegeuk Kim6b4ea012012-11-14 16:59:04 +0900789fail:
Jaegeuk Kim510022a2015-03-30 15:07:16 -0700790 if (inode)
791 up_write(&F2FS_I(inode)->i_sem);
Jaegeuk Kimd928bfb2014-03-20 19:10:08 +0900792
Jaegeuk Kim6b4ea012012-11-14 16:59:04 +0900793 f2fs_put_page(dentry_page, 1);
Chao Yu675f10b2016-02-22 18:29:18 +0800794
795 return err;
796}
797
Eric Biggers43c780b2020-05-07 00:59:04 -0700798int f2fs_add_dentry(struct inode *dir, const struct f2fs_filename *fname,
799 struct inode *inode, nid_t ino, umode_t mode)
Shuoran Liue7ba1082016-08-29 11:27:56 +0800800{
Shuoran Liue7ba1082016-08-29 11:27:56 +0800801 int err = -EAGAIN;
802
Shuoran Liue7ba1082016-08-29 11:27:56 +0800803 if (f2fs_has_inline_dentry(dir))
Eric Biggers43c780b2020-05-07 00:59:04 -0700804 err = f2fs_add_inline_entry(dir, fname, inode, ino, mode);
Shuoran Liue7ba1082016-08-29 11:27:56 +0800805 if (err == -EAGAIN)
Eric Biggers43c780b2020-05-07 00:59:04 -0700806 err = f2fs_add_regular_entry(dir, fname, inode, ino, mode);
Shuoran Liue7ba1082016-08-29 11:27:56 +0800807
808 f2fs_update_time(F2FS_I_SB(dir), REQ_TIME);
809 return err;
810}
811
Chao Yu675f10b2016-02-22 18:29:18 +0800812/*
813 * Caller should grab and release a rwsem by calling f2fs_lock_op() and
814 * f2fs_unlock_op().
815 */
Chao Yu4d57b862018-05-30 00:20:41 +0800816int f2fs_do_add_link(struct inode *dir, const struct qstr *name,
Chao Yu675f10b2016-02-22 18:29:18 +0800817 struct inode *inode, nid_t ino, umode_t mode)
818{
Eric Biggers43c780b2020-05-07 00:59:04 -0700819 struct f2fs_filename fname;
Jaegeuk Kim88c5c132017-02-14 09:54:37 -0800820 struct page *page = NULL;
821 struct f2fs_dir_entry *de = NULL;
Chao Yu675f10b2016-02-22 18:29:18 +0800822 int err;
823
Eric Biggers43c780b2020-05-07 00:59:04 -0700824 err = f2fs_setup_filename(dir, name, 0, &fname);
Chao Yu675f10b2016-02-22 18:29:18 +0800825 if (err)
826 return err;
827
Jaegeuk Kim88c5c132017-02-14 09:54:37 -0800828 /*
Liu Songe5cc2c52020-06-25 20:40:11 +0800829 * An immature stackable filesystem shows a race condition between lookup
Jaegeuk Kim88c5c132017-02-14 09:54:37 -0800830 * and create. If we have same task when doing lookup and create, it's
831 * definitely fine as expected by VFS normally. Otherwise, let's just
832 * verify on-disk dentry one more time, which guarantees filesystem
833 * consistency more.
834 */
835 if (current != F2FS_I(dir)->task) {
836 de = __f2fs_find_entry(dir, &fname, &page);
837 F2FS_I(dir)->task = NULL;
838 }
839 if (de) {
Jaegeuk Kim88c5c132017-02-14 09:54:37 -0800840 f2fs_put_page(page, 0);
841 err = -EEXIST;
842 } else if (IS_ERR(page)) {
843 err = PTR_ERR(page);
844 } else {
Chao Yu4d57b862018-05-30 00:20:41 +0800845 err = f2fs_add_dentry(dir, &fname, inode, ino, mode);
Jaegeuk Kim88c5c132017-02-14 09:54:37 -0800846 }
Eric Biggers43c780b2020-05-07 00:59:04 -0700847 f2fs_free_filename(&fname);
Jaegeuk Kim6b4ea012012-11-14 16:59:04 +0900848 return err;
849}
850
Jaegeuk Kimb97a9b52014-06-20 21:37:02 -0700851int f2fs_do_tmpfile(struct inode *inode, struct inode *dir)
852{
853 struct page *page;
854 int err = 0;
855
856 down_write(&F2FS_I(inode)->i_sem);
Eric Biggers43c780b2020-05-07 00:59:04 -0700857 page = f2fs_init_inode_metadata(inode, dir, NULL, NULL);
Jaegeuk Kimb97a9b52014-06-20 21:37:02 -0700858 if (IS_ERR(page)) {
859 err = PTR_ERR(page);
860 goto fail;
861 }
Jaegeuk Kimb97a9b52014-06-20 21:37:02 -0700862 f2fs_put_page(page, 1);
863
Jaegeuk Kim91942322016-05-20 10:13:22 -0700864 clear_inode_flag(inode, FI_NEW_INODE);
Sahitya Tummalac75f2fe2018-10-05 10:47:39 +0530865 f2fs_update_time(F2FS_I_SB(inode), REQ_TIME);
Jaegeuk Kimb97a9b52014-06-20 21:37:02 -0700866fail:
867 up_write(&F2FS_I(inode)->i_sem);
868 return err;
869}
870
Jaegeuk Kim9f7c45c2016-06-01 21:18:25 -0700871void f2fs_drop_nlink(struct inode *dir, struct inode *inode)
Chao Yudbeacf02014-09-24 18:17:04 +0800872{
873 struct f2fs_sb_info *sbi = F2FS_I_SB(dir);
874
875 down_write(&F2FS_I(inode)->i_sem);
876
Jaegeuk Kimee6d1822016-05-20 16:32:49 -0700877 if (S_ISDIR(inode->i_mode))
Jaegeuk Kima1961242016-05-20 09:43:20 -0700878 f2fs_i_links_write(dir, false);
Deepa Dinamani078cd822016-09-14 07:48:04 -0700879 inode->i_ctime = current_time(inode);
Chao Yudbeacf02014-09-24 18:17:04 +0800880
Jaegeuk Kima1961242016-05-20 09:43:20 -0700881 f2fs_i_links_write(inode, false);
Chao Yudbeacf02014-09-24 18:17:04 +0800882 if (S_ISDIR(inode->i_mode)) {
Jaegeuk Kima1961242016-05-20 09:43:20 -0700883 f2fs_i_links_write(inode, false);
Jaegeuk Kimfc9581c2016-05-20 09:22:03 -0700884 f2fs_i_size_write(inode, 0);
Chao Yudbeacf02014-09-24 18:17:04 +0800885 }
886 up_write(&F2FS_I(inode)->i_sem);
Chao Yudbeacf02014-09-24 18:17:04 +0800887
888 if (inode->i_nlink == 0)
Chao Yu4d57b862018-05-30 00:20:41 +0800889 f2fs_add_orphan_inode(inode);
Chao Yudbeacf02014-09-24 18:17:04 +0800890 else
Chao Yu4d57b862018-05-30 00:20:41 +0800891 f2fs_release_orphan_inode(sbi);
Chao Yudbeacf02014-09-24 18:17:04 +0800892}
893
Jaegeuk Kim0a8165d2012-11-29 13:28:09 +0900894/*
arter97e1c42042014-08-06 23:22:50 +0900895 * It only removes the dentry from the dentry page, corresponding name
Jaegeuk Kim6b4ea012012-11-14 16:59:04 +0900896 * entry in name page does not need to be touched during deletion.
897 */
898void f2fs_delete_entry(struct f2fs_dir_entry *dentry, struct page *page,
Chao Yudbeacf02014-09-24 18:17:04 +0800899 struct inode *dir, struct inode *inode)
Jaegeuk Kim6b4ea012012-11-14 16:59:04 +0900900{
901 struct f2fs_dentry_block *dentry_blk;
902 unsigned int bit_pos;
Namjae Jeon457d08e2012-12-08 14:54:50 +0900903 int slots = GET_DENTRY_SLOTS(le16_to_cpu(dentry->name_len));
Jaegeuk Kim6b4ea012012-11-14 16:59:04 +0900904 int i;
905
Jaegeuk Kimd0239e12016-01-08 16:57:48 -0800906 f2fs_update_time(F2FS_I_SB(dir), REQ_TIME);
907
Chao Yu63189b72018-03-08 14:22:56 +0800908 if (F2FS_OPTION(F2FS_I_SB(dir)).fsync_mode == FSYNC_MODE_STRICT)
Chao Yu4d57b862018-05-30 00:20:41 +0800909 f2fs_add_ino_entry(F2FS_I_SB(dir), dir->i_ino, TRANS_DIR_INO);
Jaegeuk Kim0a007b972017-12-28 08:09:44 -0800910
Chao Yu622f28a2014-09-24 18:19:10 +0800911 if (f2fs_has_inline_dentry(dir))
912 return f2fs_delete_inline_entry(dentry, page, dir, inode);
913
Jaegeuk Kim6b4ea012012-11-14 16:59:04 +0900914 lock_page(page);
Chao Yubae0ee72018-12-25 17:43:42 +0800915 f2fs_wait_on_page_writeback(page, DATA, true, true);
Jaegeuk Kim6b4ea012012-11-14 16:59:04 +0900916
Gu Zheng1c3bb972014-06-27 17:57:04 +0800917 dentry_blk = page_address(page);
918 bit_pos = dentry - dentry_blk->dentry;
Jaegeuk Kim6b4ea012012-11-14 16:59:04 +0900919 for (i = 0; i < slots; i++)
Jaegeuk Kim23380b82017-03-07 14:11:06 -0800920 __clear_bit_le(bit_pos + i, &dentry_blk->dentry_bitmap);
Jaegeuk Kim6b4ea012012-11-14 16:59:04 +0900921
922 /* Let's check and deallocate this dentry page */
923 bit_pos = find_next_bit_le(&dentry_blk->dentry_bitmap,
924 NR_DENTRY_IN_BLOCK,
925 0);
Jaegeuk Kim6b4ea012012-11-14 16:59:04 +0900926 set_page_dirty(page);
927
Chao Yu206e61b2015-08-12 17:48:21 +0800928 if (bit_pos == NR_DENTRY_IN_BLOCK &&
Chao Yu4d57b862018-05-30 00:20:41 +0800929 !f2fs_truncate_hole(dir, page->index, page->index + 1)) {
Matthew Wilcox5ec2d992017-12-04 20:25:25 -0500930 f2fs_clear_page_cache_dirty_tag(page);
Jaegeuk Kim6b4ea012012-11-14 16:59:04 +0900931 clear_page_dirty_for_io(page);
Chao Yu240a5912019-03-06 17:30:59 +0800932 f2fs_clear_page_private(page);
Jaegeuk Kim6b4ea012012-11-14 16:59:04 +0900933 ClearPageUptodate(page);
Chao Yu2baf0782018-07-27 18:15:16 +0800934 clear_cold_data(page);
Jaegeuk Kima7ffdbe2014-09-12 15:53:45 -0700935 inode_dec_dirty_pages(dir);
Chao Yu4d57b862018-05-30 00:20:41 +0800936 f2fs_remove_dirty_inode(dir);
Jaegeuk Kim6b4ea012012-11-14 16:59:04 +0900937 }
Namjae Jeon508198b2012-12-08 14:54:35 +0900938 f2fs_put_page(page, 1);
Chao Yu9995e402020-03-20 18:17:54 +0800939
940 dir->i_ctime = dir->i_mtime = current_time(dir);
941 f2fs_mark_inode_dirty_sync(dir, false);
942
943 if (inode)
944 f2fs_drop_nlink(dir, inode);
Jaegeuk Kim6b4ea012012-11-14 16:59:04 +0900945}
946
947bool f2fs_empty_dir(struct inode *dir)
948{
949 unsigned long bidx;
950 struct page *dentry_page;
951 unsigned int bit_pos;
Chao Yudbeacf02014-09-24 18:17:04 +0800952 struct f2fs_dentry_block *dentry_blk;
Jaegeuk Kim6b4ea012012-11-14 16:59:04 +0900953 unsigned long nblock = dir_blocks(dir);
954
Chao Yu622f28a2014-09-24 18:19:10 +0800955 if (f2fs_has_inline_dentry(dir))
956 return f2fs_empty_inline_dir(dir);
957
Jaegeuk Kim6b4ea012012-11-14 16:59:04 +0900958 for (bidx = 0; bidx < nblock; bidx++) {
Chao Yu4d57b862018-05-30 00:20:41 +0800959 dentry_page = f2fs_get_lock_data_page(dir, bidx, false);
Jaegeuk Kim6b4ea012012-11-14 16:59:04 +0900960 if (IS_ERR(dentry_page)) {
961 if (PTR_ERR(dentry_page) == -ENOENT)
962 continue;
963 else
964 return false;
965 }
966
Yunlong Songbdbc90f2018-02-28 20:31:52 +0800967 dentry_blk = page_address(dentry_page);
Jaegeuk Kim6b4ea012012-11-14 16:59:04 +0900968 if (bidx == 0)
969 bit_pos = 2;
970 else
971 bit_pos = 0;
972 bit_pos = find_next_bit_le(&dentry_blk->dentry_bitmap,
973 NR_DENTRY_IN_BLOCK,
974 bit_pos);
Jaegeuk Kim6b4ea012012-11-14 16:59:04 +0900975
976 f2fs_put_page(dentry_page, 1);
977
978 if (bit_pos < NR_DENTRY_IN_BLOCK)
979 return false;
980 }
981 return true;
982}
983
Chao Yued6bd4b2016-10-29 18:46:34 +0800984int f2fs_fill_dentries(struct dir_context *ctx, struct f2fs_dentry_ptr *d,
Jaegeuk Kim0b81d072015-05-15 16:26:10 -0700985 unsigned int start_pos, struct fscrypt_str *fstr)
Jaegeuk Kim38594de2014-10-15 21:29:51 -0700986{
987 unsigned char d_type = DT_UNKNOWN;
988 unsigned int bit_pos;
989 struct f2fs_dir_entry *de = NULL;
Jaegeuk Kim0b81d072015-05-15 16:26:10 -0700990 struct fscrypt_str de_name = FSTR_INIT(NULL, 0);
Sheng Yongf6df8f22017-11-22 18:23:38 +0800991 struct f2fs_sb_info *sbi = F2FS_I_SB(d->inode);
Chao Yue1293bd2018-09-07 19:49:07 +0800992 struct blk_plug plug;
993 bool readdir_ra = sbi->readdir_ra == 1;
994 int err = 0;
Jaegeuk Kim38594de2014-10-15 21:29:51 -0700995
Jaegeuk Kim7b3cd7d2014-10-18 22:52:52 -0700996 bit_pos = ((unsigned long)ctx->pos % d->max);
Jaegeuk Kim38594de2014-10-15 21:29:51 -0700997
Chao Yue1293bd2018-09-07 19:49:07 +0800998 if (readdir_ra)
999 blk_start_plug(&plug);
1000
Jaegeuk Kim7b3cd7d2014-10-18 22:52:52 -07001001 while (bit_pos < d->max) {
1002 bit_pos = find_next_bit_le(d->bitmap, d->max, bit_pos);
1003 if (bit_pos >= d->max)
Jaegeuk Kim38594de2014-10-15 21:29:51 -07001004 break;
1005
Jaegeuk Kim7b3cd7d2014-10-18 22:52:52 -07001006 de = &d->dentry[bit_pos];
Jaegeuk Kim7d9dfa12016-02-12 14:29:28 -08001007 if (de->name_len == 0) {
1008 bit_pos++;
1009 ctx->pos = start_pos + bit_pos;
Chao Yuddf06b72019-01-08 10:21:24 +08001010 printk_ratelimited(
Chao Yuc45d6002019-11-01 17:53:23 +08001011 "%sF2FS-fs (%s): invalid namelen(0), ino:%u, run fsck to fix.",
1012 KERN_WARNING, sbi->sb->s_id,
1013 le32_to_cpu(de->ino));
Chao Yuddf06b72019-01-08 10:21:24 +08001014 set_sbi_flag(sbi, SBI_NEED_FSCK);
Jaegeuk Kim7d9dfa12016-02-12 14:29:28 -08001015 continue;
1016 }
1017
Chao Yu4d57b862018-05-30 00:20:41 +08001018 d_type = f2fs_get_de_type(de);
Jaegeuk Kimd8c68222015-04-27 16:26:24 -07001019
Jaegeuk Kimd8c68222015-04-27 16:26:24 -07001020 de_name.name = d->filename[bit_pos];
1021 de_name.len = le16_to_cpu(de->name_len);
1022
Jaegeuk Kim4e240d12018-11-14 12:40:30 -08001023 /* check memory boundary before moving forward */
1024 bit_pos += GET_DENTRY_SLOTS(le16_to_cpu(de->name_len));
Sheng Yong720db062019-01-07 15:02:34 +08001025 if (unlikely(bit_pos > d->max ||
1026 le16_to_cpu(de->name_len) > F2FS_NAME_LEN)) {
Joe Perchesdcbb4c12019-06-18 17:48:42 +08001027 f2fs_warn(sbi, "%s: corrupted namelen=%d, run fsck to fix.",
1028 __func__, le16_to_cpu(de->name_len));
Jaegeuk Kim4e240d12018-11-14 12:40:30 -08001029 set_sbi_flag(sbi, SBI_NEED_FSCK);
Chao Yu10f966b2019-06-20 11:36:14 +08001030 err = -EFSCORRUPTED;
Jaegeuk Kim4e240d12018-11-14 12:40:30 -08001031 goto out;
1032 }
1033
Chandan Rajendra62230e0d2018-12-12 15:20:11 +05301034 if (IS_ENCRYPTED(d->inode)) {
Jaegeuk Kimd8c68222015-04-27 16:26:24 -07001035 int save_len = fstr->len;
Jaegeuk Kimd8c68222015-04-27 16:26:24 -07001036
Eric Biggersef1eb3a2016-09-15 17:25:55 -04001037 err = fscrypt_fname_disk_to_usr(d->inode,
Chao Yu36af5f42019-05-28 17:23:33 +08001038 (u32)le32_to_cpu(de->hash_code),
1039 0, &de_name, fstr);
Eric Biggersef1eb3a2016-09-15 17:25:55 -04001040 if (err)
Chao Yue1293bd2018-09-07 19:49:07 +08001041 goto out;
Jaegeuk Kim569cf182015-09-03 13:38:23 -07001042
1043 de_name = *fstr;
1044 fstr->len = save_len;
Jaegeuk Kimd8c68222015-04-27 16:26:24 -07001045 }
1046
1047 if (!dir_emit(ctx, de_name.name, de_name.len,
Chao Yue1293bd2018-09-07 19:49:07 +08001048 le32_to_cpu(de->ino), d_type)) {
1049 err = 1;
1050 goto out;
1051 }
Jaegeuk Kim38594de2014-10-15 21:29:51 -07001052
Chao Yue1293bd2018-09-07 19:49:07 +08001053 if (readdir_ra)
Chao Yu4d57b862018-05-30 00:20:41 +08001054 f2fs_ra_node_page(sbi, le32_to_cpu(de->ino));
Sheng Yongf6df8f22017-11-22 18:23:38 +08001055
Jaegeuk Kim38594de2014-10-15 21:29:51 -07001056 ctx->pos = start_pos + bit_pos;
1057 }
Chao Yue1293bd2018-09-07 19:49:07 +08001058out:
1059 if (readdir_ra)
1060 blk_finish_plug(&plug);
1061 return err;
Jaegeuk Kim38594de2014-10-15 21:29:51 -07001062}
1063
Al Viro6f7f2312013-05-17 18:02:17 -04001064static int f2fs_readdir(struct file *file, struct dir_context *ctx)
Jaegeuk Kim6b4ea012012-11-14 16:59:04 +09001065{
Al Viro496ad9a2013-01-23 17:07:38 -05001066 struct inode *inode = file_inode(file);
Jaegeuk Kim6b4ea012012-11-14 16:59:04 +09001067 unsigned long npages = dir_blocks(inode);
Jaegeuk Kim6b4ea012012-11-14 16:59:04 +09001068 struct f2fs_dentry_block *dentry_blk = NULL;
Jaegeuk Kim6b4ea012012-11-14 16:59:04 +09001069 struct page *dentry_page = NULL;
Chao Yu817202d92014-04-28 17:59:43 +08001070 struct file_ra_state *ra = &file->f_ra;
Chao Yue97a3c42017-10-13 18:01:33 +08001071 loff_t start_pos = ctx->pos;
Al Viro6f7f2312013-05-17 18:02:17 -04001072 unsigned int n = ((unsigned long)ctx->pos / NR_DENTRY_IN_BLOCK);
Jaegeuk Kim7b3cd7d2014-10-18 22:52:52 -07001073 struct f2fs_dentry_ptr d;
Jaegeuk Kim0b81d072015-05-15 16:26:10 -07001074 struct fscrypt_str fstr = FSTR_INIT(NULL, 0);
Jaegeuk Kimd8c68222015-04-27 16:26:24 -07001075 int err = 0;
Jaegeuk Kim6b4ea012012-11-14 16:59:04 +09001076
Chandan Rajendra62230e0d2018-12-12 15:20:11 +05301077 if (IS_ENCRYPTED(inode)) {
Eric Biggersec0caa972020-12-02 18:20:37 -08001078 err = fscrypt_prepare_readdir(inode);
Eric Biggers3b1ada552019-12-09 13:23:48 -08001079 if (err)
Chao Yue97a3c42017-10-13 18:01:33 +08001080 goto out;
Jaegeuk Kim26bf3dc2015-05-19 22:26:54 -07001081
Jeff Layton8b10fe62020-08-10 10:21:39 -04001082 err = fscrypt_fname_alloc_buffer(F2FS_NAME_LEN, &fstr);
Jaegeuk Kimd8c68222015-04-27 16:26:24 -07001083 if (err < 0)
Chao Yue97a3c42017-10-13 18:01:33 +08001084 goto out;
Jaegeuk Kimd8c68222015-04-27 16:26:24 -07001085 }
1086
1087 if (f2fs_has_inline_dentry(inode)) {
1088 err = f2fs_read_inline_dir(file, ctx, &fstr);
Chao Yue97a3c42017-10-13 18:01:33 +08001089 goto out_free;
Jaegeuk Kimd8c68222015-04-27 16:26:24 -07001090 }
Chao Yu622f28a2014-09-24 18:19:10 +08001091
Chao Yuab383be2017-10-13 18:01:36 +08001092 for (; n < npages; n++, ctx->pos = n * NR_DENTRY_IN_BLOCK) {
Chao Yu4414dea2017-10-13 18:01:34 +08001093
1094 /* allow readdir() to be interrupted */
1095 if (fatal_signal_pending(current)) {
1096 err = -ERESTARTSYS;
1097 goto out_free;
1098 }
1099 cond_resched();
1100
Chao Yucb7a8442017-10-13 18:01:35 +08001101 /* readahead for multi pages of dir */
1102 if (npages - n > 1 && !ra_has_index(ra, n))
1103 page_cache_sync_readahead(inode->i_mapping, ra, file, n,
1104 min(npages - n, (pgoff_t)MAX_DIR_RA_PAGES));
1105
Gao Xiang613f3dc2019-02-21 12:57:35 +08001106 dentry_page = f2fs_find_data_page(inode, n);
Chao Yu57b62d22015-11-19 16:09:07 +08001107 if (IS_ERR(dentry_page)) {
1108 err = PTR_ERR(dentry_page);
Chao Yued6bd4b2016-10-29 18:46:34 +08001109 if (err == -ENOENT) {
1110 err = 0;
Chao Yu57b62d22015-11-19 16:09:07 +08001111 continue;
Chao Yued6bd4b2016-10-29 18:46:34 +08001112 } else {
Chao Yue97a3c42017-10-13 18:01:33 +08001113 goto out_free;
Chao Yued6bd4b2016-10-29 18:46:34 +08001114 }
Chao Yu57b62d22015-11-19 16:09:07 +08001115 }
Jaegeuk Kim6b4ea012012-11-14 16:59:04 +09001116
Yunlong Songbdbc90f2018-02-28 20:31:52 +08001117 dentry_blk = page_address(dentry_page);
Jaegeuk Kim6b4ea012012-11-14 16:59:04 +09001118
Tomohiro Kusumi64c24ec2017-04-04 13:01:22 +03001119 make_dentry_ptr_block(inode, &d, dentry_blk);
Jaegeuk Kim7b3cd7d2014-10-18 22:52:52 -07001120
Chao Yued6bd4b2016-10-29 18:46:34 +08001121 err = f2fs_fill_dentries(ctx, &d,
1122 n * NR_DENTRY_IN_BLOCK, &fstr);
1123 if (err) {
Gao Xiang613f3dc2019-02-21 12:57:35 +08001124 f2fs_put_page(dentry_page, 0);
Chao Yue9837bc2015-12-01 11:41:50 +08001125 break;
1126 }
Jaegeuk Kim99b072bb2013-07-05 17:28:12 +09001127
Gao Xiang613f3dc2019-02-21 12:57:35 +08001128 f2fs_put_page(dentry_page, 0);
Jaegeuk Kim6b4ea012012-11-14 16:59:04 +09001129 }
Chao Yue97a3c42017-10-13 18:01:33 +08001130out_free:
Jaegeuk Kim0b81d072015-05-15 16:26:10 -07001131 fscrypt_fname_free_buffer(&fstr);
Chao Yue97a3c42017-10-13 18:01:33 +08001132out:
1133 trace_f2fs_readdir(inode, start_pos, ctx->pos, err);
Chao Yued6bd4b2016-10-29 18:46:34 +08001134 return err < 0 ? err : 0;
Jaegeuk Kim6b4ea012012-11-14 16:59:04 +09001135}
1136
1137const struct file_operations f2fs_dir_operations = {
1138 .llseek = generic_file_llseek,
1139 .read = generic_read_dir,
Al Viroe77d0c62016-05-10 16:41:13 -04001140 .iterate_shared = f2fs_readdir,
Jaegeuk Kim6b4ea012012-11-14 16:59:04 +09001141 .fsync = f2fs_sync_file,
1142 .unlocked_ioctl = f2fs_ioctl,
hujianyang08b95122015-05-12 16:05:57 +08001143#ifdef CONFIG_COMPAT
1144 .compat_ioctl = f2fs_compat_ioctl,
1145#endif
Jaegeuk Kim6b4ea012012-11-14 16:59:04 +09001146};