~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/fs/f2fs/dir.c

Version: ~ [ linux-5.9.1 ] ~ [ linux-5.8.16 ] ~ [ linux-5.7.19 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.72 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.152 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.202 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.240 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.240 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.140 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.85 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  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 };
923 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp