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