projects / deliverable / linux.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Merge branch 'acpica-fixes'
[deliverable/linux.git] / fs / f2fs / dir.c
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 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 == 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 namehash = f2fs_dentry_hash(&name);
176
177 nbucket = dir_buckets(level, F2FS_I(dir)->i_dir_level);
178 nblock = bucket_blocks(level);
179
180 bidx = dir_block_index(level, F2FS_I(dir)->i_dir_level,
181 le32_to_cpu(namehash) % nbucket);
182 end_block = bidx + nblock;
183
184 for (; bidx < end_block; bidx++) {
185 /* no need to allocate new dentry pages to all the indices */
186 dentry_page = find_data_page(dir, bidx);
187 if (IS_ERR(dentry_page)) {
188 room = true;
189 continue;
190 }
191
192 de = find_in_block(dentry_page, fname, namehash, &max_slots,
193 res_page);
194 if (de)
195 break;
196
197 if (max_slots >= s)
198 room = true;
199 f2fs_put_page(dentry_page, 0);
200 }
201
202 if (!de && room && F2FS_I(dir)->chash != namehash) {
203 F2FS_I(dir)->chash = namehash;
204 F2FS_I(dir)->clevel = level;
205 }
206
207 return de;
208 }
209
210 /*
211 * Find an entry in the specified directory with the wanted name.
212 * It returns the page where the entry was found (as a parameter - res_page),
213 * and the entry itself. Page is returned mapped and unlocked.
214 * Entry is guaranteed to be valid.
215 */
216 struct f2fs_dir_entry *f2fs_find_entry(struct inode *dir,
217 struct qstr *child, struct page **res_page)
218 {
219 unsigned long npages = dir_blocks(dir);
220 struct f2fs_dir_entry *de = NULL;
221 unsigned int max_depth;
222 unsigned int level;
223 struct fscrypt_name fname;
224 int err;
225
226 *res_page = NULL;
227
228 err = fscrypt_setup_filename(dir, child, 1, &fname);
229 if (err)
230 return NULL;
231
232 if (f2fs_has_inline_dentry(dir)) {
233 de = find_in_inline_dir(dir, &fname, res_page);
234 goto out;
235 }
236
237 if (npages == 0)
238 goto out;
239
240 max_depth = F2FS_I(dir)->i_current_depth;
241 if (unlikely(max_depth > MAX_DIR_HASH_DEPTH)) {
242 f2fs_msg(F2FS_I_SB(dir)->sb, KERN_WARNING,
243 "Corrupted max_depth of %lu: %u",
244 dir->i_ino, max_depth);
245 max_depth = MAX_DIR_HASH_DEPTH;
246 F2FS_I(dir)->i_current_depth = max_depth;
247 mark_inode_dirty(dir);
248 }
249
250 for (level = 0; level < max_depth; level++) {
251 de = find_in_level(dir, level, &fname, res_page);
252 if (de)
253 break;
254 }
255 out:
256 fscrypt_free_filename(&fname);
257 return de;
258 }
259
260 struct f2fs_dir_entry *f2fs_parent_dir(struct inode *dir, struct page **p)
261 {
262 struct page *page;
263 struct f2fs_dir_entry *de;
264 struct f2fs_dentry_block *dentry_blk;
265
266 if (f2fs_has_inline_dentry(dir))
267 return f2fs_parent_inline_dir(dir, p);
268
269 page = get_lock_data_page(dir, 0, false);
270 if (IS_ERR(page))
271 return NULL;
272
273 dentry_blk = kmap(page);
274 de = &dentry_blk->dentry[1];
275 *p = page;
276 unlock_page(page);
277 return de;
278 }
279
280 ino_t f2fs_inode_by_name(struct inode *dir, struct qstr *qstr)
281 {
282 ino_t res = 0;
283 struct f2fs_dir_entry *de;
284 struct page *page;
285
286 de = f2fs_find_entry(dir, qstr, &page);
287 if (de) {
288 res = le32_to_cpu(de->ino);
289 f2fs_dentry_kunmap(dir, page);
290 f2fs_put_page(page, 0);
291 }
292
293 return res;
294 }
295
296 void f2fs_set_link(struct inode *dir, struct f2fs_dir_entry *de,
297 struct page *page, struct inode *inode)
298 {
299 enum page_type type = f2fs_has_inline_dentry(dir) ? NODE : DATA;
300 lock_page(page);
301 f2fs_wait_on_page_writeback(page, type, true);
302 de->ino = cpu_to_le32(inode->i_ino);
303 set_de_type(de, inode->i_mode);
304 f2fs_dentry_kunmap(dir, page);
305 set_page_dirty(page);
306 dir->i_mtime = dir->i_ctime = CURRENT_TIME;
307 mark_inode_dirty(dir);
308
309 f2fs_put_page(page, 1);
310 }
311
312 static void init_dent_inode(const struct qstr *name, struct page *ipage)
313 {
314 struct f2fs_inode *ri;
315
316 f2fs_wait_on_page_writeback(ipage, NODE, true);
317
318 /* copy name info. to this inode page */
319 ri = F2FS_INODE(ipage);
320 ri->i_namelen = cpu_to_le32(name->len);
321 memcpy(ri->i_name, name->name, name->len);
322 set_page_dirty(ipage);
323 }
324
325 int update_dent_inode(struct inode *inode, struct inode *to,
326 const struct qstr *name)
327 {
328 struct page *page;
329
330 if (file_enc_name(to))
331 return 0;
332
333 page = get_node_page(F2FS_I_SB(inode), inode->i_ino);
334 if (IS_ERR(page))
335 return PTR_ERR(page);
336
337 init_dent_inode(name, page);
338 f2fs_put_page(page, 1);
339
340 return 0;
341 }
342
343 void do_make_empty_dir(struct inode *inode, struct inode *parent,
344 struct f2fs_dentry_ptr *d)
345 {
346 struct qstr dot = QSTR_INIT(".", 1);
347 struct qstr dotdot = QSTR_INIT("..", 2);
348
349 /* update dirent of "." */
350 f2fs_update_dentry(inode->i_ino, inode->i_mode, d, &dot, 0, 0);
351
352 /* update dirent of ".." */
353 f2fs_update_dentry(parent->i_ino, parent->i_mode, d, &dotdot, 0, 1);
354 }
355
356 static int make_empty_dir(struct inode *inode,
357 struct inode *parent, struct page *page)
358 {
359 struct page *dentry_page;
360 struct f2fs_dentry_block *dentry_blk;
361 struct f2fs_dentry_ptr d;
362
363 if (f2fs_has_inline_dentry(inode))
364 return make_empty_inline_dir(inode, parent, page);
365
366 dentry_page = get_new_data_page(inode, page, 0, true);
367 if (IS_ERR(dentry_page))
368 return PTR_ERR(dentry_page);
369
370 dentry_blk = kmap_atomic(dentry_page);
371
372 make_dentry_ptr(NULL, &d, (void *)dentry_blk, 1);
373 do_make_empty_dir(inode, parent, &d);
374
375 kunmap_atomic(dentry_blk);
376
377 set_page_dirty(dentry_page);
378 f2fs_put_page(dentry_page, 1);
379 return 0;
380 }
381
382 struct page *init_inode_metadata(struct inode *inode, struct inode *dir,
383 const struct qstr *name, struct page *dpage)
384 {
385 struct page *page;
386 int err;
387
388 if (is_inode_flag_set(F2FS_I(inode), FI_NEW_INODE)) {
389 page = new_inode_page(inode);
390 if (IS_ERR(page))
391 return page;
392
393 if (S_ISDIR(inode->i_mode)) {
394 /* in order to handle error case */
395 get_page(page);
396 err = make_empty_dir(inode, dir, page);
397 if (err) {
398 lock_page(page);
399 goto put_error;
400 }
401 put_page(page);
402 }
403
404 err = f2fs_init_acl(inode, dir, page, dpage);
405 if (err)
406 goto put_error;
407
408 err = f2fs_init_security(inode, dir, name, page);
409 if (err)
410 goto put_error;
411
412 if (f2fs_encrypted_inode(dir) && f2fs_may_encrypt(inode)) {
413 err = fscrypt_inherit_context(dir, inode, page, false);
414 if (err)
415 goto put_error;
416 }
417 } else {
418 page = get_node_page(F2FS_I_SB(dir), inode->i_ino);
419 if (IS_ERR(page))
420 return page;
421
422 set_cold_node(inode, page);
423 }
424
425 if (name)
426 init_dent_inode(name, page);
427
428 /*
429 * This file should be checkpointed during fsync.
430 * We lost i_pino from now on.
431 */
432 if (is_inode_flag_set(F2FS_I(inode), FI_INC_LINK)) {
433 file_lost_pino(inode);
434 /*
435 * If link the tmpfile to alias through linkat path,
436 * we should remove this inode from orphan list.
437 */
438 if (inode->i_nlink == 0)
439 remove_orphan_inode(F2FS_I_SB(dir), inode->i_ino);
440 inc_nlink(inode);
441 }
442 return page;
443
444 put_error:
445 /* truncate empty dir pages */
446 truncate_inode_pages(&inode->i_data, 0);
447
448 clear_nlink(inode);
449 update_inode(inode, page);
450 f2fs_put_page(page, 1);
451 return ERR_PTR(err);
452 }
453
454 void update_parent_metadata(struct inode *dir, struct inode *inode,
455 unsigned int current_depth)
456 {
457 if (inode && is_inode_flag_set(F2FS_I(inode), FI_NEW_INODE)) {
458 if (S_ISDIR(inode->i_mode)) {
459 inc_nlink(dir);
460 set_inode_flag(F2FS_I(dir), FI_UPDATE_DIR);
461 }
462 clear_inode_flag(F2FS_I(inode), FI_NEW_INODE);
463 }
464 dir->i_mtime = dir->i_ctime = CURRENT_TIME;
465 mark_inode_dirty(dir);
466
467 if (F2FS_I(dir)->i_current_depth != current_depth) {
468 F2FS_I(dir)->i_current_depth = current_depth;
469 set_inode_flag(F2FS_I(dir), FI_UPDATE_DIR);
470 }
471
472 if (inode && is_inode_flag_set(F2FS_I(inode), FI_INC_LINK))
473 clear_inode_flag(F2FS_I(inode), FI_INC_LINK);
474 }
475
476 int room_for_filename(const void *bitmap, int slots, int max_slots)
477 {
478 int bit_start = 0;
479 int zero_start, zero_end;
480 next:
481 zero_start = find_next_zero_bit_le(bitmap, max_slots, bit_start);
482 if (zero_start >= max_slots)
483 return max_slots;
484
485 zero_end = find_next_bit_le(bitmap, max_slots, zero_start);
486 if (zero_end - zero_start >= slots)
487 return zero_start;
488
489 bit_start = zero_end + 1;
490
491 if (zero_end + 1 >= max_slots)
492 return max_slots;
493 goto next;
494 }
495
496 void f2fs_update_dentry(nid_t ino, umode_t mode, struct f2fs_dentry_ptr *d,
497 const struct qstr *name, f2fs_hash_t name_hash,
498 unsigned int bit_pos)
499 {
500 struct f2fs_dir_entry *de;
501 int slots = GET_DENTRY_SLOTS(name->len);
502 int i;
503
504 de = &d->dentry[bit_pos];
505 de->hash_code = name_hash;
506 de->name_len = cpu_to_le16(name->len);
507 memcpy(d->filename[bit_pos], name->name, name->len);
508 de->ino = cpu_to_le32(ino);
509 set_de_type(de, mode);
510 for (i = 0; i < slots; i++) {
511 test_and_set_bit_le(bit_pos + i, (void *)d->bitmap);
512 /* avoid wrong garbage data for readdir */
513 if (i)
514 (de + i)->name_len = 0;
515 }
516 }
517
518 int f2fs_add_regular_entry(struct inode *dir, const struct qstr *new_name,
519 struct inode *inode, nid_t ino, umode_t mode)
520 {
521 unsigned int bit_pos;
522 unsigned int level;
523 unsigned int current_depth;
524 unsigned long bidx, block;
525 f2fs_hash_t dentry_hash;
526 unsigned int nbucket, nblock;
527 struct page *dentry_page = NULL;
528 struct f2fs_dentry_block *dentry_blk = NULL;
529 struct f2fs_dentry_ptr d;
530 struct page *page = NULL;
531 int slots, err = 0;
532
533 level = 0;
534 slots = GET_DENTRY_SLOTS(new_name->len);
535 dentry_hash = f2fs_dentry_hash(new_name);
536
537 current_depth = F2FS_I(dir)->i_current_depth;
538 if (F2FS_I(dir)->chash == dentry_hash) {
539 level = F2FS_I(dir)->clevel;
540 F2FS_I(dir)->chash = 0;
541 }
542
543 start:
544 #ifdef CONFIG_F2FS_FAULT_INJECTION
545 if (time_to_inject(FAULT_DIR_DEPTH))
546 return -ENOSPC;
547 #endif
548 if (unlikely(current_depth == MAX_DIR_HASH_DEPTH))
549 return -ENOSPC;
550
551 /* Increase the depth, if required */
552 if (level == current_depth)
553 ++current_depth;
554
555 nbucket = dir_buckets(level, F2FS_I(dir)->i_dir_level);
556 nblock = bucket_blocks(level);
557
558 bidx = dir_block_index(level, F2FS_I(dir)->i_dir_level,
559 (le32_to_cpu(dentry_hash) % nbucket));
560
561 for (block = bidx; block <= (bidx + nblock - 1); block++) {
562 dentry_page = get_new_data_page(dir, NULL, block, true);
563 if (IS_ERR(dentry_page))
564 return PTR_ERR(dentry_page);
565
566 dentry_blk = kmap(dentry_page);
567 bit_pos = room_for_filename(&dentry_blk->dentry_bitmap,
568 slots, NR_DENTRY_IN_BLOCK);
569 if (bit_pos < NR_DENTRY_IN_BLOCK)
570 goto add_dentry;
571
572 kunmap(dentry_page);
573 f2fs_put_page(dentry_page, 1);
574 }
575
576 /* Move to next level to find the empty slot for new dentry */
577 ++level;
578 goto start;
579 add_dentry:
580 f2fs_wait_on_page_writeback(dentry_page, DATA, true);
581
582 if (inode) {
583 down_write(&F2FS_I(inode)->i_sem);
584 page = init_inode_metadata(inode, dir, new_name, NULL);
585 if (IS_ERR(page)) {
586 err = PTR_ERR(page);
587 goto fail;
588 }
589 if (f2fs_encrypted_inode(dir))
590 file_set_enc_name(inode);
591 }
592
593 make_dentry_ptr(NULL, &d, (void *)dentry_blk, 1);
594 f2fs_update_dentry(ino, mode, &d, new_name, dentry_hash, bit_pos);
595
596 set_page_dirty(dentry_page);
597
598 if (inode) {
599 /* we don't need to mark_inode_dirty now */
600 F2FS_I(inode)->i_pino = dir->i_ino;
601 update_inode(inode, page);
602 f2fs_put_page(page, 1);
603 }
604
605 update_parent_metadata(dir, inode, current_depth);
606 fail:
607 if (inode)
608 up_write(&F2FS_I(inode)->i_sem);
609
610 if (is_inode_flag_set(F2FS_I(dir), FI_UPDATE_DIR)) {
611 update_inode_page(dir);
612 clear_inode_flag(F2FS_I(dir), FI_UPDATE_DIR);
613 }
614 kunmap(dentry_page);
615 f2fs_put_page(dentry_page, 1);
616
617 return err;
618 }
619
620 /*
621 * Caller should grab and release a rwsem by calling f2fs_lock_op() and
622 * f2fs_unlock_op().
623 */
624 int __f2fs_add_link(struct inode *dir, const struct qstr *name,
625 struct inode *inode, nid_t ino, umode_t mode)
626 {
627 struct fscrypt_name fname;
628 struct qstr new_name;
629 int err;
630
631 err = fscrypt_setup_filename(dir, name, 0, &fname);
632 if (err)
633 return err;
634
635 new_name.name = fname_name(&fname);
636 new_name.len = fname_len(&fname);
637
638 err = -EAGAIN;
639 if (f2fs_has_inline_dentry(dir))
640 err = f2fs_add_inline_entry(dir, &new_name, inode, ino, mode);
641 if (err == -EAGAIN)
642 err = f2fs_add_regular_entry(dir, &new_name, inode, ino, mode);
643
644 fscrypt_free_filename(&fname);
645 f2fs_update_time(F2FS_I_SB(dir), REQ_TIME);
646 return err;
647 }
648
649 int f2fs_do_tmpfile(struct inode *inode, struct inode *dir)
650 {
651 struct page *page;
652 int err = 0;
653
654 down_write(&F2FS_I(inode)->i_sem);
655 page = init_inode_metadata(inode, dir, NULL, NULL);
656 if (IS_ERR(page)) {
657 err = PTR_ERR(page);
658 goto fail;
659 }
660 /* we don't need to mark_inode_dirty now */
661 update_inode(inode, page);
662 f2fs_put_page(page, 1);
663
664 clear_inode_flag(F2FS_I(inode), FI_NEW_INODE);
665 fail:
666 up_write(&F2FS_I(inode)->i_sem);
667 f2fs_update_time(F2FS_I_SB(inode), REQ_TIME);
668 return err;
669 }
670
671 void f2fs_drop_nlink(struct inode *dir, struct inode *inode, struct page *page)
672 {
673 struct f2fs_sb_info *sbi = F2FS_I_SB(dir);
674
675 down_write(&F2FS_I(inode)->i_sem);
676
677 if (S_ISDIR(inode->i_mode)) {
678 drop_nlink(dir);
679 if (page)
680 update_inode(dir, page);
681 else
682 update_inode_page(dir);
683 }
684 inode->i_ctime = CURRENT_TIME;
685
686 drop_nlink(inode);
687 if (S_ISDIR(inode->i_mode)) {
688 drop_nlink(inode);
689 i_size_write(inode, 0);
690 }
691 up_write(&F2FS_I(inode)->i_sem);
692 update_inode_page(inode);
693
694 if (inode->i_nlink == 0)
695 add_orphan_inode(sbi, inode->i_ino);
696 else
697 release_orphan_inode(sbi);
698 }
699
700 /*
701 * It only removes the dentry from the dentry page, corresponding name
702 * entry in name page does not need to be touched during deletion.
703 */
704 void f2fs_delete_entry(struct f2fs_dir_entry *dentry, struct page *page,
705 struct inode *dir, struct inode *inode)
706 {
707 struct f2fs_dentry_block *dentry_blk;
708 unsigned int bit_pos;
709 int slots = GET_DENTRY_SLOTS(le16_to_cpu(dentry->name_len));
710 int i;
711
712 f2fs_update_time(F2FS_I_SB(dir), REQ_TIME);
713
714 if (f2fs_has_inline_dentry(dir))
715 return f2fs_delete_inline_entry(dentry, page, dir, inode);
716
717 lock_page(page);
718 f2fs_wait_on_page_writeback(page, DATA, true);
719
720 dentry_blk = page_address(page);
721 bit_pos = dentry - dentry_blk->dentry;
722 for (i = 0; i < slots; i++)
723 clear_bit_le(bit_pos + i, &dentry_blk->dentry_bitmap);
724
725 /* Let's check and deallocate this dentry page */
726 bit_pos = find_next_bit_le(&dentry_blk->dentry_bitmap,
727 NR_DENTRY_IN_BLOCK,
728 0);
729 kunmap(page); /* kunmap - pair of f2fs_find_entry */
730 set_page_dirty(page);
731
732 dir->i_ctime = dir->i_mtime = CURRENT_TIME;
733
734 if (inode)
735 f2fs_drop_nlink(dir, inode, NULL);
736
737 if (bit_pos == NR_DENTRY_IN_BLOCK &&
738 !truncate_hole(dir, page->index, page->index + 1)) {
739 clear_page_dirty_for_io(page);
740 ClearPagePrivate(page);
741 ClearPageUptodate(page);
742 inode_dec_dirty_pages(dir);
743 }
744 f2fs_put_page(page, 1);
745 }
746
747 bool f2fs_empty_dir(struct inode *dir)
748 {
749 unsigned long bidx;
750 struct page *dentry_page;
751 unsigned int bit_pos;
752 struct f2fs_dentry_block *dentry_blk;
753 unsigned long nblock = dir_blocks(dir);
754
755 if (f2fs_has_inline_dentry(dir))
756 return f2fs_empty_inline_dir(dir);
757
758 for (bidx = 0; bidx < nblock; bidx++) {
759 dentry_page = get_lock_data_page(dir, bidx, false);
760 if (IS_ERR(dentry_page)) {
761 if (PTR_ERR(dentry_page) == -ENOENT)
762 continue;
763 else
764 return false;
765 }
766
767 dentry_blk = kmap_atomic(dentry_page);
768 if (bidx == 0)
769 bit_pos = 2;
770 else
771 bit_pos = 0;
772 bit_pos = find_next_bit_le(&dentry_blk->dentry_bitmap,
773 NR_DENTRY_IN_BLOCK,
774 bit_pos);
775 kunmap_atomic(dentry_blk);
776
777 f2fs_put_page(dentry_page, 1);
778
779 if (bit_pos < NR_DENTRY_IN_BLOCK)
780 return false;
781 }
782 return true;
783 }
784
785 bool f2fs_fill_dentries(struct dir_context *ctx, struct f2fs_dentry_ptr *d,
786 unsigned int start_pos, struct fscrypt_str *fstr)
787 {
788 unsigned char d_type = DT_UNKNOWN;
789 unsigned int bit_pos;
790 struct f2fs_dir_entry *de = NULL;
791 struct fscrypt_str de_name = FSTR_INIT(NULL, 0);
792
793 bit_pos = ((unsigned long)ctx->pos % d->max);
794
795 while (bit_pos < d->max) {
796 bit_pos = find_next_bit_le(d->bitmap, d->max, bit_pos);
797 if (bit_pos >= d->max)
798 break;
799
800 de = &d->dentry[bit_pos];
801 if (de->name_len == 0) {
802 bit_pos++;
803 ctx->pos = start_pos + bit_pos;
804 continue;
805 }
806
807 d_type = get_de_type(de);
808
809 de_name.name = d->filename[bit_pos];
810 de_name.len = le16_to_cpu(de->name_len);
811
812 if (f2fs_encrypted_inode(d->inode)) {
813 int save_len = fstr->len;
814 int ret;
815
816 de_name.name = f2fs_kmalloc(de_name.len, GFP_NOFS);
817 if (!de_name.name)
818 return false;
819
820 memcpy(de_name.name, d->filename[bit_pos], de_name.len);
821
822 ret = fscrypt_fname_disk_to_usr(d->inode,
823 (u32)de->hash_code, 0,
824 &de_name, fstr);
825 kfree(de_name.name);
826 if (ret < 0)
827 return true;
828
829 de_name = *fstr;
830 fstr->len = save_len;
831 }
832
833 if (!dir_emit(ctx, de_name.name, de_name.len,
834 le32_to_cpu(de->ino), d_type))
835 return true;
836
837 bit_pos += GET_DENTRY_SLOTS(le16_to_cpu(de->name_len));
838 ctx->pos = start_pos + bit_pos;
839 }
840 return false;
841 }
842
843 static int f2fs_readdir(struct file *file, struct dir_context *ctx)
844 {
845 struct inode *inode = file_inode(file);
846 unsigned long npages = dir_blocks(inode);
847 struct f2fs_dentry_block *dentry_blk = NULL;
848 struct page *dentry_page = NULL;
849 struct file_ra_state *ra = &file->f_ra;
850 unsigned int n = ((unsigned long)ctx->pos / NR_DENTRY_IN_BLOCK);
851 struct f2fs_dentry_ptr d;
852 struct fscrypt_str fstr = FSTR_INIT(NULL, 0);
853 int err = 0;
854
855 if (f2fs_encrypted_inode(inode)) {
856 err = fscrypt_get_encryption_info(inode);
857 if (err && err != -ENOKEY)
858 return err;
859
860 err = fscrypt_fname_alloc_buffer(inode, F2FS_NAME_LEN, &fstr);
861 if (err < 0)
862 return err;
863 }
864
865 if (f2fs_has_inline_dentry(inode)) {
866 err = f2fs_read_inline_dir(file, ctx, &fstr);
867 goto out;
868 }
869
870 /* readahead for multi pages of dir */
871 if (npages - n > 1 && !ra_has_index(ra, n))
872 page_cache_sync_readahead(inode->i_mapping, ra, file, n,
873 min(npages - n, (pgoff_t)MAX_DIR_RA_PAGES));
874
875 for (; n < npages; n++) {
876 dentry_page = get_lock_data_page(inode, n, false);
877 if (IS_ERR(dentry_page)) {
878 err = PTR_ERR(dentry_page);
879 if (err == -ENOENT)
880 continue;
881 else
882 goto out;
883 }
884
885 dentry_blk = kmap(dentry_page);
886
887 make_dentry_ptr(inode, &d, (void *)dentry_blk, 1);
888
889 if (f2fs_fill_dentries(ctx, &d, n * NR_DENTRY_IN_BLOCK, &fstr)) {
890 kunmap(dentry_page);
891 f2fs_put_page(dentry_page, 1);
892 break;
893 }
894
895 ctx->pos = (n + 1) * NR_DENTRY_IN_BLOCK;
896 kunmap(dentry_page);
897 f2fs_put_page(dentry_page, 1);
898 }
899 err = 0;
900 out:
901 fscrypt_fname_free_buffer(&fstr);
902 return err;
903 }
904
905 static int f2fs_dir_open(struct inode *inode, struct file *filp)
906 {
907 if (f2fs_encrypted_inode(inode))
908 return fscrypt_get_encryption_info(inode) ? -EACCES : 0;
909 return 0;
910 }
911
912 const struct file_operations f2fs_dir_operations = {
913 .llseek = generic_file_llseek,
914 .read = generic_read_dir,
915 .iterate_shared = f2fs_readdir,
916 .fsync = f2fs_sync_file,
917 .open = f2fs_dir_open,
918 .unlocked_ioctl = f2fs_ioctl,
919 #ifdef CONFIG_COMPAT
920 .compat_ioctl = f2fs_compat_ioctl,
921 #endif
922 };
Linux kernel - Deliverables
This page took 0.049359 seconds and 6 git commands to generate.