xref: /openbmc/linux/fs/f2fs/dir.c (revision 4e1a33b1)
1 /*
2  * fs/f2fs/dir.c
3  *
4  * Copyright (c) 2012 Samsung Electronics Co., Ltd.
5  *             http://www.samsung.com/
6  *
7  * This program is free software; you can redistribute it and/or modify
8  * it under the terms of the GNU General Public License version 2 as
9  * published by the Free Software Foundation.
10  */
11 #include <linux/fs.h>
12 #include <linux/f2fs_fs.h>
13 #include "f2fs.h"
14 #include "node.h"
15 #include "acl.h"
16 #include "xattr.h"
17 
18 static unsigned long dir_blocks(struct inode *inode)
19 {
20 	return ((unsigned long long) (i_size_read(inode) + PAGE_SIZE - 1))
21 							>> PAGE_SHIFT;
22 }
23 
24 static unsigned int dir_buckets(unsigned int level, int dir_level)
25 {
26 	if (level + dir_level < MAX_DIR_HASH_DEPTH / 2)
27 		return 1 << (level + dir_level);
28 	else
29 		return MAX_DIR_BUCKETS;
30 }
31 
32 static unsigned int bucket_blocks(unsigned int level)
33 {
34 	if (level < MAX_DIR_HASH_DEPTH / 2)
35 		return 2;
36 	else
37 		return 4;
38 }
39 
40 static unsigned char f2fs_filetype_table[F2FS_FT_MAX] = {
41 	[F2FS_FT_UNKNOWN]	= DT_UNKNOWN,
42 	[F2FS_FT_REG_FILE]	= DT_REG,
43 	[F2FS_FT_DIR]		= DT_DIR,
44 	[F2FS_FT_CHRDEV]	= DT_CHR,
45 	[F2FS_FT_BLKDEV]	= DT_BLK,
46 	[F2FS_FT_FIFO]		= DT_FIFO,
47 	[F2FS_FT_SOCK]		= DT_SOCK,
48 	[F2FS_FT_SYMLINK]	= DT_LNK,
49 };
50 
51 static unsigned char f2fs_type_by_mode[S_IFMT >> S_SHIFT] = {
52 	[S_IFREG >> S_SHIFT]	= F2FS_FT_REG_FILE,
53 	[S_IFDIR >> S_SHIFT]	= F2FS_FT_DIR,
54 	[S_IFCHR >> S_SHIFT]	= F2FS_FT_CHRDEV,
55 	[S_IFBLK >> S_SHIFT]	= F2FS_FT_BLKDEV,
56 	[S_IFIFO >> S_SHIFT]	= F2FS_FT_FIFO,
57 	[S_IFSOCK >> S_SHIFT]	= F2FS_FT_SOCK,
58 	[S_IFLNK >> S_SHIFT]	= F2FS_FT_SYMLINK,
59 };
60 
61 void set_de_type(struct f2fs_dir_entry *de, umode_t mode)
62 {
63 	de->file_type = f2fs_type_by_mode[(mode & S_IFMT) >> S_SHIFT];
64 }
65 
66 unsigned char get_de_type(struct f2fs_dir_entry *de)
67 {
68 	if (de->file_type < F2FS_FT_MAX)
69 		return f2fs_filetype_table[de->file_type];
70 	return DT_UNKNOWN;
71 }
72 
73 static unsigned long dir_block_index(unsigned int level,
74 				int dir_level, unsigned int idx)
75 {
76 	unsigned long i;
77 	unsigned long bidx = 0;
78 
79 	for (i = 0; i < level; i++)
80 		bidx += dir_buckets(i, dir_level) * bucket_blocks(i);
81 	bidx += idx * bucket_blocks(level);
82 	return bidx;
83 }
84 
85 static struct f2fs_dir_entry *find_in_block(struct page *dentry_page,
86 				struct fscrypt_name *fname,
87 				f2fs_hash_t namehash,
88 				int *max_slots,
89 				struct page **res_page)
90 {
91 	struct f2fs_dentry_block *dentry_blk;
92 	struct f2fs_dir_entry *de;
93 	struct f2fs_dentry_ptr d;
94 
95 	dentry_blk = (struct f2fs_dentry_block *)kmap(dentry_page);
96 
97 	make_dentry_ptr(NULL, &d, (void *)dentry_blk, 1);
98 	de = find_target_dentry(fname, namehash, max_slots, &d);
99 	if (de)
100 		*res_page = dentry_page;
101 	else
102 		kunmap(dentry_page);
103 
104 	return de;
105 }
106 
107 struct f2fs_dir_entry *find_target_dentry(struct fscrypt_name *fname,
108 			f2fs_hash_t namehash, int *max_slots,
109 			struct f2fs_dentry_ptr *d)
110 {
111 	struct f2fs_dir_entry *de;
112 	unsigned long bit_pos = 0;
113 	int max_len = 0;
114 	struct fscrypt_str de_name = FSTR_INIT(NULL, 0);
115 	struct fscrypt_str *name = &fname->disk_name;
116 
117 	if (max_slots)
118 		*max_slots = 0;
119 	while (bit_pos < d->max) {
120 		if (!test_bit_le(bit_pos, d->bitmap)) {
121 			bit_pos++;
122 			max_len++;
123 			continue;
124 		}
125 
126 		de = &d->dentry[bit_pos];
127 
128 		if (unlikely(!de->name_len)) {
129 			bit_pos++;
130 			continue;
131 		}
132 
133 		/* encrypted case */
134 		de_name.name = d->filename[bit_pos];
135 		de_name.len = le16_to_cpu(de->name_len);
136 
137 		/* show encrypted name */
138 		if (fname->hash) {
139 			if (de->hash_code == cpu_to_le32(fname->hash))
140 				goto found;
141 		} else if (de_name.len == name->len &&
142 			de->hash_code == namehash &&
143 			!memcmp(de_name.name, name->name, name->len))
144 			goto found;
145 
146 		if (max_slots && max_len > *max_slots)
147 			*max_slots = max_len;
148 		max_len = 0;
149 
150 		bit_pos += GET_DENTRY_SLOTS(le16_to_cpu(de->name_len));
151 	}
152 
153 	de = NULL;
154 found:
155 	if (max_slots && max_len > *max_slots)
156 		*max_slots = max_len;
157 	return de;
158 }
159 
160 static struct f2fs_dir_entry *find_in_level(struct inode *dir,
161 					unsigned int level,
162 					struct fscrypt_name *fname,
163 					struct page **res_page)
164 {
165 	struct qstr name = FSTR_TO_QSTR(&fname->disk_name);
166 	int s = GET_DENTRY_SLOTS(name.len);
167 	unsigned int nbucket, nblock;
168 	unsigned int bidx, end_block;
169 	struct page *dentry_page;
170 	struct f2fs_dir_entry *de = NULL;
171 	bool room = false;
172 	int max_slots;
173 	f2fs_hash_t namehash;
174 
175 	if(fname->hash)
176 		namehash = cpu_to_le32(fname->hash);
177 	else
178 		namehash = f2fs_dentry_hash(&name);
179 
180 	nbucket = dir_buckets(level, F2FS_I(dir)->i_dir_level);
181 	nblock = bucket_blocks(level);
182 
183 	bidx = dir_block_index(level, F2FS_I(dir)->i_dir_level,
184 					le32_to_cpu(namehash) % nbucket);
185 	end_block = bidx + nblock;
186 
187 	for (; bidx < end_block; bidx++) {
188 		/* no need to allocate new dentry pages to all the indices */
189 		dentry_page = find_data_page(dir, bidx);
190 		if (IS_ERR(dentry_page)) {
191 			if (PTR_ERR(dentry_page) == -ENOENT) {
192 				room = true;
193 				continue;
194 			} else {
195 				*res_page = dentry_page;
196 				break;
197 			}
198 		}
199 
200 		de = find_in_block(dentry_page, fname, namehash, &max_slots,
201 								res_page);
202 		if (de)
203 			break;
204 
205 		if (max_slots >= s)
206 			room = true;
207 		f2fs_put_page(dentry_page, 0);
208 	}
209 
210 	if (!de && room && F2FS_I(dir)->chash != namehash) {
211 		F2FS_I(dir)->chash = namehash;
212 		F2FS_I(dir)->clevel = level;
213 	}
214 
215 	return de;
216 }
217 
218 struct f2fs_dir_entry *__f2fs_find_entry(struct inode *dir,
219 			struct fscrypt_name *fname, struct page **res_page)
220 {
221 	unsigned long npages = dir_blocks(dir);
222 	struct f2fs_dir_entry *de = NULL;
223 	unsigned int max_depth;
224 	unsigned int level;
225 
226 	if (f2fs_has_inline_dentry(dir)) {
227 		*res_page = NULL;
228 		de = find_in_inline_dir(dir, fname, res_page);
229 		goto out;
230 	}
231 
232 	if (npages == 0) {
233 		*res_page = NULL;
234 		goto out;
235 	}
236 
237 	max_depth = F2FS_I(dir)->i_current_depth;
238 	if (unlikely(max_depth > MAX_DIR_HASH_DEPTH)) {
239 		f2fs_msg(F2FS_I_SB(dir)->sb, KERN_WARNING,
240 				"Corrupted max_depth of %lu: %u",
241 				dir->i_ino, max_depth);
242 		max_depth = MAX_DIR_HASH_DEPTH;
243 		f2fs_i_depth_write(dir, max_depth);
244 	}
245 
246 	for (level = 0; level < max_depth; level++) {
247 		*res_page = NULL;
248 		de = find_in_level(dir, level, fname, res_page);
249 		if (de || IS_ERR(*res_page))
250 			break;
251 	}
252 out:
253 	return de;
254 }
255 
256 /*
257  * Find an entry in the specified directory with the wanted name.
258  * It returns the page where the entry was found (as a parameter - res_page),
259  * and the entry itself. Page is returned mapped and unlocked.
260  * Entry is guaranteed to be valid.
261  */
262 struct f2fs_dir_entry *f2fs_find_entry(struct inode *dir,
263 			const struct qstr *child, struct page **res_page)
264 {
265 	struct f2fs_dir_entry *de = NULL;
266 	struct fscrypt_name fname;
267 	int err;
268 
269 	err = fscrypt_setup_filename(dir, child, 1, &fname);
270 	if (err) {
271 		if (err == -ENOENT)
272 			*res_page = NULL;
273 		else
274 			*res_page = ERR_PTR(err);
275 		return NULL;
276 	}
277 
278 	de = __f2fs_find_entry(dir, &fname, res_page);
279 
280 	fscrypt_free_filename(&fname);
281 	return de;
282 }
283 
284 struct f2fs_dir_entry *f2fs_parent_dir(struct inode *dir, struct page **p)
285 {
286 	struct qstr dotdot = QSTR_INIT("..", 2);
287 
288 	return f2fs_find_entry(dir, &dotdot, p);
289 }
290 
291 ino_t f2fs_inode_by_name(struct inode *dir, const struct qstr *qstr,
292 							struct page **page)
293 {
294 	ino_t res = 0;
295 	struct f2fs_dir_entry *de;
296 
297 	de = f2fs_find_entry(dir, qstr, page);
298 	if (de) {
299 		res = le32_to_cpu(de->ino);
300 		f2fs_dentry_kunmap(dir, *page);
301 		f2fs_put_page(*page, 0);
302 	}
303 
304 	return res;
305 }
306 
307 void f2fs_set_link(struct inode *dir, struct f2fs_dir_entry *de,
308 		struct page *page, struct inode *inode)
309 {
310 	enum page_type type = f2fs_has_inline_dentry(dir) ? NODE : DATA;
311 	lock_page(page);
312 	f2fs_wait_on_page_writeback(page, type, true);
313 	de->ino = cpu_to_le32(inode->i_ino);
314 	set_de_type(de, inode->i_mode);
315 	f2fs_dentry_kunmap(dir, page);
316 	set_page_dirty(page);
317 
318 	dir->i_mtime = dir->i_ctime = current_time(dir);
319 	f2fs_mark_inode_dirty_sync(dir, false);
320 	f2fs_put_page(page, 1);
321 }
322 
323 static void init_dent_inode(const struct qstr *name, struct page *ipage)
324 {
325 	struct f2fs_inode *ri;
326 
327 	f2fs_wait_on_page_writeback(ipage, NODE, true);
328 
329 	/* copy name info. to this inode page */
330 	ri = F2FS_INODE(ipage);
331 	ri->i_namelen = cpu_to_le32(name->len);
332 	memcpy(ri->i_name, name->name, name->len);
333 	set_page_dirty(ipage);
334 }
335 
336 int update_dent_inode(struct inode *inode, struct inode *to,
337 					const struct qstr *name)
338 {
339 	struct page *page;
340 
341 	if (file_enc_name(to))
342 		return 0;
343 
344 	page = get_node_page(F2FS_I_SB(inode), inode->i_ino);
345 	if (IS_ERR(page))
346 		return PTR_ERR(page);
347 
348 	init_dent_inode(name, page);
349 	f2fs_put_page(page, 1);
350 
351 	return 0;
352 }
353 
354 void do_make_empty_dir(struct inode *inode, struct inode *parent,
355 					struct f2fs_dentry_ptr *d)
356 {
357 	struct qstr dot = QSTR_INIT(".", 1);
358 	struct qstr dotdot = QSTR_INIT("..", 2);
359 
360 	/* update dirent of "." */
361 	f2fs_update_dentry(inode->i_ino, inode->i_mode, d, &dot, 0, 0);
362 
363 	/* update dirent of ".." */
364 	f2fs_update_dentry(parent->i_ino, parent->i_mode, d, &dotdot, 0, 1);
365 }
366 
367 static int make_empty_dir(struct inode *inode,
368 		struct inode *parent, struct page *page)
369 {
370 	struct page *dentry_page;
371 	struct f2fs_dentry_block *dentry_blk;
372 	struct f2fs_dentry_ptr d;
373 
374 	if (f2fs_has_inline_dentry(inode))
375 		return make_empty_inline_dir(inode, parent, page);
376 
377 	dentry_page = get_new_data_page(inode, page, 0, true);
378 	if (IS_ERR(dentry_page))
379 		return PTR_ERR(dentry_page);
380 
381 	dentry_blk = kmap_atomic(dentry_page);
382 
383 	make_dentry_ptr(NULL, &d, (void *)dentry_blk, 1);
384 	do_make_empty_dir(inode, parent, &d);
385 
386 	kunmap_atomic(dentry_blk);
387 
388 	set_page_dirty(dentry_page);
389 	f2fs_put_page(dentry_page, 1);
390 	return 0;
391 }
392 
393 struct page *init_inode_metadata(struct inode *inode, struct inode *dir,
394 			const struct qstr *new_name, const struct qstr *orig_name,
395 			struct page *dpage)
396 {
397 	struct page *page;
398 	int err;
399 
400 	if (is_inode_flag_set(inode, FI_NEW_INODE)) {
401 		page = new_inode_page(inode);
402 		if (IS_ERR(page))
403 			return page;
404 
405 		if (S_ISDIR(inode->i_mode)) {
406 			/* in order to handle error case */
407 			get_page(page);
408 			err = make_empty_dir(inode, dir, page);
409 			if (err) {
410 				lock_page(page);
411 				goto put_error;
412 			}
413 			put_page(page);
414 		}
415 
416 		err = f2fs_init_acl(inode, dir, page, dpage);
417 		if (err)
418 			goto put_error;
419 
420 		err = f2fs_init_security(inode, dir, orig_name, page);
421 		if (err)
422 			goto put_error;
423 
424 		if (f2fs_encrypted_inode(dir) && f2fs_may_encrypt(inode)) {
425 			err = fscrypt_inherit_context(dir, inode, page, false);
426 			if (err)
427 				goto put_error;
428 		}
429 	} else {
430 		page = get_node_page(F2FS_I_SB(dir), inode->i_ino);
431 		if (IS_ERR(page))
432 			return page;
433 
434 		set_cold_node(inode, page);
435 	}
436 
437 	if (new_name)
438 		init_dent_inode(new_name, page);
439 
440 	/*
441 	 * This file should be checkpointed during fsync.
442 	 * We lost i_pino from now on.
443 	 */
444 	if (is_inode_flag_set(inode, FI_INC_LINK)) {
445 		file_lost_pino(inode);
446 		/*
447 		 * If link the tmpfile to alias through linkat path,
448 		 * we should remove this inode from orphan list.
449 		 */
450 		if (inode->i_nlink == 0)
451 			remove_orphan_inode(F2FS_I_SB(dir), inode->i_ino);
452 		f2fs_i_links_write(inode, true);
453 	}
454 	return page;
455 
456 put_error:
457 	clear_nlink(inode);
458 	update_inode(inode, page);
459 	f2fs_put_page(page, 1);
460 	return ERR_PTR(err);
461 }
462 
463 void update_parent_metadata(struct inode *dir, struct inode *inode,
464 						unsigned int current_depth)
465 {
466 	if (inode && is_inode_flag_set(inode, FI_NEW_INODE)) {
467 		if (S_ISDIR(inode->i_mode))
468 			f2fs_i_links_write(dir, true);
469 		clear_inode_flag(inode, FI_NEW_INODE);
470 	}
471 	dir->i_mtime = dir->i_ctime = current_time(dir);
472 	f2fs_mark_inode_dirty_sync(dir, false);
473 
474 	if (F2FS_I(dir)->i_current_depth != current_depth)
475 		f2fs_i_depth_write(dir, current_depth);
476 
477 	if (inode && is_inode_flag_set(inode, FI_INC_LINK))
478 		clear_inode_flag(inode, FI_INC_LINK);
479 }
480 
481 int room_for_filename(const void *bitmap, int slots, int max_slots)
482 {
483 	int bit_start = 0;
484 	int zero_start, zero_end;
485 next:
486 	zero_start = find_next_zero_bit_le(bitmap, max_slots, bit_start);
487 	if (zero_start >= max_slots)
488 		return max_slots;
489 
490 	zero_end = find_next_bit_le(bitmap, max_slots, zero_start);
491 	if (zero_end - zero_start >= slots)
492 		return zero_start;
493 
494 	bit_start = zero_end + 1;
495 
496 	if (zero_end + 1 >= max_slots)
497 		return max_slots;
498 	goto next;
499 }
500 
501 void f2fs_update_dentry(nid_t ino, umode_t mode, struct f2fs_dentry_ptr *d,
502 				const struct qstr *name, f2fs_hash_t name_hash,
503 				unsigned int bit_pos)
504 {
505 	struct f2fs_dir_entry *de;
506 	int slots = GET_DENTRY_SLOTS(name->len);
507 	int i;
508 
509 	de = &d->dentry[bit_pos];
510 	de->hash_code = name_hash;
511 	de->name_len = cpu_to_le16(name->len);
512 	memcpy(d->filename[bit_pos], name->name, name->len);
513 	de->ino = cpu_to_le32(ino);
514 	set_de_type(de, mode);
515 	for (i = 0; i < slots; i++) {
516 		__set_bit_le(bit_pos + i, (void *)d->bitmap);
517 		/* avoid wrong garbage data for readdir */
518 		if (i)
519 			(de + i)->name_len = 0;
520 	}
521 }
522 
523 int f2fs_add_regular_entry(struct inode *dir, const struct qstr *new_name,
524 				const struct qstr *orig_name,
525 				struct inode *inode, nid_t ino, umode_t mode)
526 {
527 	unsigned int bit_pos;
528 	unsigned int level;
529 	unsigned int current_depth;
530 	unsigned long bidx, block;
531 	f2fs_hash_t dentry_hash;
532 	unsigned int nbucket, nblock;
533 	struct page *dentry_page = NULL;
534 	struct f2fs_dentry_block *dentry_blk = NULL;
535 	struct f2fs_dentry_ptr d;
536 	struct page *page = NULL;
537 	int slots, err = 0;
538 
539 	level = 0;
540 	slots = GET_DENTRY_SLOTS(new_name->len);
541 	dentry_hash = f2fs_dentry_hash(new_name);
542 
543 	current_depth = F2FS_I(dir)->i_current_depth;
544 	if (F2FS_I(dir)->chash == dentry_hash) {
545 		level = F2FS_I(dir)->clevel;
546 		F2FS_I(dir)->chash = 0;
547 	}
548 
549 start:
550 #ifdef CONFIG_F2FS_FAULT_INJECTION
551 	if (time_to_inject(F2FS_I_SB(dir), FAULT_DIR_DEPTH))
552 		return -ENOSPC;
553 #endif
554 	if (unlikely(current_depth == MAX_DIR_HASH_DEPTH))
555 		return -ENOSPC;
556 
557 	/* Increase the depth, if required */
558 	if (level == current_depth)
559 		++current_depth;
560 
561 	nbucket = dir_buckets(level, F2FS_I(dir)->i_dir_level);
562 	nblock = bucket_blocks(level);
563 
564 	bidx = dir_block_index(level, F2FS_I(dir)->i_dir_level,
565 				(le32_to_cpu(dentry_hash) % nbucket));
566 
567 	for (block = bidx; block <= (bidx + nblock - 1); block++) {
568 		dentry_page = get_new_data_page(dir, NULL, block, true);
569 		if (IS_ERR(dentry_page))
570 			return PTR_ERR(dentry_page);
571 
572 		dentry_blk = kmap(dentry_page);
573 		bit_pos = room_for_filename(&dentry_blk->dentry_bitmap,
574 						slots, NR_DENTRY_IN_BLOCK);
575 		if (bit_pos < NR_DENTRY_IN_BLOCK)
576 			goto add_dentry;
577 
578 		kunmap(dentry_page);
579 		f2fs_put_page(dentry_page, 1);
580 	}
581 
582 	/* Move to next level to find the empty slot for new dentry */
583 	++level;
584 	goto start;
585 add_dentry:
586 	f2fs_wait_on_page_writeback(dentry_page, DATA, true);
587 
588 	if (inode) {
589 		down_write(&F2FS_I(inode)->i_sem);
590 		page = init_inode_metadata(inode, dir, new_name,
591 						orig_name, NULL);
592 		if (IS_ERR(page)) {
593 			err = PTR_ERR(page);
594 			goto fail;
595 		}
596 		if (f2fs_encrypted_inode(dir))
597 			file_set_enc_name(inode);
598 	}
599 
600 	make_dentry_ptr(NULL, &d, (void *)dentry_blk, 1);
601 	f2fs_update_dentry(ino, mode, &d, new_name, dentry_hash, bit_pos);
602 
603 	set_page_dirty(dentry_page);
604 
605 	if (inode) {
606 		f2fs_i_pino_write(inode, dir->i_ino);
607 		f2fs_put_page(page, 1);
608 	}
609 
610 	update_parent_metadata(dir, inode, current_depth);
611 fail:
612 	if (inode)
613 		up_write(&F2FS_I(inode)->i_sem);
614 
615 	kunmap(dentry_page);
616 	f2fs_put_page(dentry_page, 1);
617 
618 	return err;
619 }
620 
621 int __f2fs_do_add_link(struct inode *dir, struct fscrypt_name *fname,
622 				struct inode *inode, nid_t ino, umode_t mode)
623 {
624 	struct qstr new_name;
625 	int err = -EAGAIN;
626 
627 	new_name.name = fname_name(fname);
628 	new_name.len = fname_len(fname);
629 
630 	if (f2fs_has_inline_dentry(dir))
631 		err = f2fs_add_inline_entry(dir, &new_name, fname->usr_fname,
632 							inode, ino, mode);
633 	if (err == -EAGAIN)
634 		err = f2fs_add_regular_entry(dir, &new_name, fname->usr_fname,
635 							inode, ino, mode);
636 
637 	f2fs_update_time(F2FS_I_SB(dir), REQ_TIME);
638 	return err;
639 }
640 
641 /*
642  * Caller should grab and release a rwsem by calling f2fs_lock_op() and
643  * f2fs_unlock_op().
644  */
645 int __f2fs_add_link(struct inode *dir, const struct qstr *name,
646 				struct inode *inode, nid_t ino, umode_t mode)
647 {
648 	struct fscrypt_name fname;
649 	int err;
650 
651 	err = fscrypt_setup_filename(dir, name, 0, &fname);
652 	if (err)
653 		return err;
654 
655 	err = __f2fs_do_add_link(dir, &fname, inode, ino, mode);
656 
657 	fscrypt_free_filename(&fname);
658 	return err;
659 }
660 
661 int f2fs_do_tmpfile(struct inode *inode, struct inode *dir)
662 {
663 	struct page *page;
664 	int err = 0;
665 
666 	down_write(&F2FS_I(inode)->i_sem);
667 	page = init_inode_metadata(inode, dir, NULL, NULL, NULL);
668 	if (IS_ERR(page)) {
669 		err = PTR_ERR(page);
670 		goto fail;
671 	}
672 	f2fs_put_page(page, 1);
673 
674 	clear_inode_flag(inode, FI_NEW_INODE);
675 fail:
676 	up_write(&F2FS_I(inode)->i_sem);
677 	f2fs_update_time(F2FS_I_SB(inode), REQ_TIME);
678 	return err;
679 }
680 
681 void f2fs_drop_nlink(struct inode *dir, struct inode *inode)
682 {
683 	struct f2fs_sb_info *sbi = F2FS_I_SB(dir);
684 
685 	down_write(&F2FS_I(inode)->i_sem);
686 
687 	if (S_ISDIR(inode->i_mode))
688 		f2fs_i_links_write(dir, false);
689 	inode->i_ctime = current_time(inode);
690 
691 	f2fs_i_links_write(inode, false);
692 	if (S_ISDIR(inode->i_mode)) {
693 		f2fs_i_links_write(inode, false);
694 		f2fs_i_size_write(inode, 0);
695 	}
696 	up_write(&F2FS_I(inode)->i_sem);
697 
698 	if (inode->i_nlink == 0)
699 		add_orphan_inode(inode);
700 	else
701 		release_orphan_inode(sbi);
702 }
703 
704 /*
705  * It only removes the dentry from the dentry page, corresponding name
706  * entry in name page does not need to be touched during deletion.
707  */
708 void f2fs_delete_entry(struct f2fs_dir_entry *dentry, struct page *page,
709 					struct inode *dir, struct inode *inode)
710 {
711 	struct	f2fs_dentry_block *dentry_blk;
712 	unsigned int bit_pos;
713 	int slots = GET_DENTRY_SLOTS(le16_to_cpu(dentry->name_len));
714 	int i;
715 
716 	f2fs_update_time(F2FS_I_SB(dir), REQ_TIME);
717 
718 	if (f2fs_has_inline_dentry(dir))
719 		return f2fs_delete_inline_entry(dentry, page, dir, inode);
720 
721 	lock_page(page);
722 	f2fs_wait_on_page_writeback(page, DATA, true);
723 
724 	dentry_blk = page_address(page);
725 	bit_pos = dentry - dentry_blk->dentry;
726 	for (i = 0; i < slots; i++)
727 		clear_bit_le(bit_pos + i, &dentry_blk->dentry_bitmap);
728 
729 	/* Let's check and deallocate this dentry page */
730 	bit_pos = find_next_bit_le(&dentry_blk->dentry_bitmap,
731 			NR_DENTRY_IN_BLOCK,
732 			0);
733 	kunmap(page); /* kunmap - pair of f2fs_find_entry */
734 	set_page_dirty(page);
735 
736 	dir->i_ctime = dir->i_mtime = current_time(dir);
737 	f2fs_mark_inode_dirty_sync(dir, false);
738 
739 	if (inode)
740 		f2fs_drop_nlink(dir, inode);
741 
742 	if (bit_pos == NR_DENTRY_IN_BLOCK &&
743 			!truncate_hole(dir, page->index, page->index + 1)) {
744 		clear_page_dirty_for_io(page);
745 		ClearPagePrivate(page);
746 		ClearPageUptodate(page);
747 		inode_dec_dirty_pages(dir);
748 		remove_dirty_inode(dir);
749 	}
750 	f2fs_put_page(page, 1);
751 }
752 
753 bool f2fs_empty_dir(struct inode *dir)
754 {
755 	unsigned long bidx;
756 	struct page *dentry_page;
757 	unsigned int bit_pos;
758 	struct f2fs_dentry_block *dentry_blk;
759 	unsigned long nblock = dir_blocks(dir);
760 
761 	if (f2fs_has_inline_dentry(dir))
762 		return f2fs_empty_inline_dir(dir);
763 
764 	for (bidx = 0; bidx < nblock; bidx++) {
765 		dentry_page = get_lock_data_page(dir, bidx, false);
766 		if (IS_ERR(dentry_page)) {
767 			if (PTR_ERR(dentry_page) == -ENOENT)
768 				continue;
769 			else
770 				return false;
771 		}
772 
773 		dentry_blk = kmap_atomic(dentry_page);
774 		if (bidx == 0)
775 			bit_pos = 2;
776 		else
777 			bit_pos = 0;
778 		bit_pos = find_next_bit_le(&dentry_blk->dentry_bitmap,
779 						NR_DENTRY_IN_BLOCK,
780 						bit_pos);
781 		kunmap_atomic(dentry_blk);
782 
783 		f2fs_put_page(dentry_page, 1);
784 
785 		if (bit_pos < NR_DENTRY_IN_BLOCK)
786 			return false;
787 	}
788 	return true;
789 }
790 
791 int f2fs_fill_dentries(struct dir_context *ctx, struct f2fs_dentry_ptr *d,
792 			unsigned int start_pos, struct fscrypt_str *fstr)
793 {
794 	unsigned char d_type = DT_UNKNOWN;
795 	unsigned int bit_pos;
796 	struct f2fs_dir_entry *de = NULL;
797 	struct fscrypt_str de_name = FSTR_INIT(NULL, 0);
798 
799 	bit_pos = ((unsigned long)ctx->pos % d->max);
800 
801 	while (bit_pos < d->max) {
802 		bit_pos = find_next_bit_le(d->bitmap, d->max, bit_pos);
803 		if (bit_pos >= d->max)
804 			break;
805 
806 		de = &d->dentry[bit_pos];
807 		if (de->name_len == 0) {
808 			bit_pos++;
809 			ctx->pos = start_pos + bit_pos;
810 			continue;
811 		}
812 
813 		d_type = get_de_type(de);
814 
815 		de_name.name = d->filename[bit_pos];
816 		de_name.len = le16_to_cpu(de->name_len);
817 
818 		if (f2fs_encrypted_inode(d->inode)) {
819 			int save_len = fstr->len;
820 			int err;
821 
822 			err = fscrypt_fname_disk_to_usr(d->inode,
823 						(u32)de->hash_code, 0,
824 						&de_name, fstr);
825 			if (err)
826 				return err;
827 
828 			de_name = *fstr;
829 			fstr->len = save_len;
830 		}
831 
832 		if (!dir_emit(ctx, de_name.name, de_name.len,
833 					le32_to_cpu(de->ino), d_type))
834 			return 1;
835 
836 		bit_pos += GET_DENTRY_SLOTS(le16_to_cpu(de->name_len));
837 		ctx->pos = start_pos + bit_pos;
838 	}
839 	return 0;
840 }
841 
842 static int f2fs_readdir(struct file *file, struct dir_context *ctx)
843 {
844 	struct inode *inode = file_inode(file);
845 	unsigned long npages = dir_blocks(inode);
846 	struct f2fs_dentry_block *dentry_blk = NULL;
847 	struct page *dentry_page = NULL;
848 	struct file_ra_state *ra = &file->f_ra;
849 	unsigned int n = ((unsigned long)ctx->pos / NR_DENTRY_IN_BLOCK);
850 	struct f2fs_dentry_ptr d;
851 	struct fscrypt_str fstr = FSTR_INIT(NULL, 0);
852 	int err = 0;
853 
854 	if (f2fs_encrypted_inode(inode)) {
855 		err = fscrypt_get_encryption_info(inode);
856 		if (err && err != -ENOKEY)
857 			return err;
858 
859 		err = fscrypt_fname_alloc_buffer(inode, F2FS_NAME_LEN, &fstr);
860 		if (err < 0)
861 			return err;
862 	}
863 
864 	if (f2fs_has_inline_dentry(inode)) {
865 		err = f2fs_read_inline_dir(file, ctx, &fstr);
866 		goto out;
867 	}
868 
869 	/* readahead for multi pages of dir */
870 	if (npages - n > 1 && !ra_has_index(ra, n))
871 		page_cache_sync_readahead(inode->i_mapping, ra, file, n,
872 				min(npages - n, (pgoff_t)MAX_DIR_RA_PAGES));
873 
874 	for (; n < npages; n++) {
875 		dentry_page = get_lock_data_page(inode, n, false);
876 		if (IS_ERR(dentry_page)) {
877 			err = PTR_ERR(dentry_page);
878 			if (err == -ENOENT) {
879 				err = 0;
880 				continue;
881 			} else {
882 				goto out;
883 			}
884 		}
885 
886 		dentry_blk = kmap(dentry_page);
887 
888 		make_dentry_ptr(inode, &d, (void *)dentry_blk, 1);
889 
890 		err = f2fs_fill_dentries(ctx, &d,
891 				n * NR_DENTRY_IN_BLOCK, &fstr);
892 		if (err) {
893 			kunmap(dentry_page);
894 			f2fs_put_page(dentry_page, 1);
895 			break;
896 		}
897 
898 		ctx->pos = (n + 1) * NR_DENTRY_IN_BLOCK;
899 		kunmap(dentry_page);
900 		f2fs_put_page(dentry_page, 1);
901 	}
902 out:
903 	fscrypt_fname_free_buffer(&fstr);
904 	return err < 0 ? err : 0;
905 }
906 
907 static int f2fs_dir_open(struct inode *inode, struct file *filp)
908 {
909 	if (f2fs_encrypted_inode(inode))
910 		return fscrypt_get_encryption_info(inode) ? -EACCES : 0;
911 	return 0;
912 }
913 
914 const struct file_operations f2fs_dir_operations = {
915 	.llseek		= generic_file_llseek,
916 	.read		= generic_read_dir,
917 	.iterate_shared	= f2fs_readdir,
918 	.fsync		= f2fs_sync_file,
919 	.open		= f2fs_dir_open,
920 	.unlocked_ioctl	= f2fs_ioctl,
921 #ifdef CONFIG_COMPAT
922 	.compat_ioctl   = f2fs_compat_ioctl,
923 #endif
924 };
925