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