fs/f2fs/inline.c

   1 /*
   2  * fs/f2fs/inline.c
   3  * Copyright (c) 2013, Intel Corporation
   4  * Authors: Huajun Li <huajun.li@intel.com>
   5  *          Haicheng Li <haicheng.li@intel.com>
   6  * This program is free software; you can redistribute it and/or modify
   7  * it under the terms of the GNU General Public License version 2 as
   8  * published by the Free Software Foundation.
   9  */
  10
  11 #include <linux/fs.h>
  12 #include <linux/f2fs_fs.h>
  13
  14 #include "f2fs.h"
  15 #include "node.h"
  16
  17 bool f2fs_may_inline_data(struct inode *inode)
  18 {
  19         if (f2fs_is_atomic_file(inode))
  20                 return false;
  21
  22         if (!S_ISREG(inode->i_mode) && !S_ISLNK(inode->i_mode))
  23                 return false;
  24
  25         if (i_size_read(inode) > MAX_INLINE_DATA)
  26                 return false;
  27
  28         if (f2fs_encrypted_inode(inode) && S_ISREG(inode->i_mode))
  29                 return false;
  30
  31         return true;
  32 }
  33
  34 bool f2fs_may_inline_dentry(struct inode *inode)
  35 {
  36         if (!test_opt(F2FS_I_SB(inode), INLINE_DENTRY))
  37                 return false;
  38
  39         if (!S_ISDIR(inode->i_mode))
  40                 return false;
  41
  42         return true;
  43 }
  44
  45 void read_inline_data(struct page *page, struct page *ipage)
  46 {
  47         void *src_addr, *dst_addr;
  48
  49         if (PageUptodate(page))
  50                 return;
  51
  52         f2fs_bug_on(F2FS_P_SB(page), page->index);
  53
  54         zero_user_segment(page, MAX_INLINE_DATA, PAGE_CACHE_SIZE);
  55
  56         /* Copy the whole inline data block */
  57         src_addr = inline_data_addr(ipage);
  58         dst_addr = kmap_atomic(page);
  59         memcpy(dst_addr, src_addr, MAX_INLINE_DATA);
  60         flush_dcache_page(page);
  61         kunmap_atomic(dst_addr);
  62         SetPageUptodate(page);
  63 }
  64
  65 bool truncate_inline_inode(struct page *ipage, u64 from)
  66 {
  67         void *addr;
  68
  69         if (from >= MAX_INLINE_DATA)
  70                 return false;
  71
  72         addr = inline_data_addr(ipage);
  73
  74         f2fs_wait_on_page_writeback(ipage, NODE, true);
  75         memset(addr + from, 0, MAX_INLINE_DATA - from);
  76
  77         return true;
  78 }
  79
  80 int f2fs_read_inline_data(struct inode *inode, struct page *page)
  81 {
  82         struct page *ipage;
  83
  84         ipage = get_node_page(F2FS_I_SB(inode), inode->i_ino);
  85         if (IS_ERR(ipage)) {
  86                 unlock_page(page);
  87                 return PTR_ERR(ipage);
  88         }
  89
  90         if (!f2fs_has_inline_data(inode)) {
  91                 f2fs_put_page(ipage, 1);
  92                 return -EAGAIN;
  93         }
  94
  95         if (page->index)
  96                 zero_user_segment(page, 0, PAGE_CACHE_SIZE);
  97         else
  98                 read_inline_data(page, ipage);
  99
 100         SetPageUptodate(page);
 101         f2fs_put_page(ipage, 1);
 102         unlock_page(page);
 103         return 0;
 104 }
 105
 106 int f2fs_convert_inline_page(struct dnode_of_data *dn, struct page *page)
 107 {
 108         struct f2fs_io_info fio = {
 109                 .sbi = F2FS_I_SB(dn->inode),
 110                 .type = DATA,
 111                 .rw = WRITE_SYNC | REQ_PRIO,
 112                 .page = page,
 113                 .encrypted_page = NULL,
 114         };
 115         int dirty, err;
 116
 117         if (!f2fs_exist_data(dn->inode))
 118                 goto clear_out;
 119
 120         err = f2fs_reserve_block(dn, 0);
 121         if (err)
 122                 return err;
 123
 124         f2fs_bug_on(F2FS_P_SB(page), PageWriteback(page));
 125
 126         read_inline_data(page, dn->inode_page);
 127         set_page_dirty(page);
 128
 129         /* clear dirty state */
 130         dirty = clear_page_dirty_for_io(page);
 131
 132         /* write data page to try to make data consistent */
 133         set_page_writeback(page);
 134         fio.old_blkaddr = dn->data_blkaddr;
 135         write_data_page(dn, &fio);
 136         f2fs_wait_on_page_writeback(page, DATA, true);
 137         if (dirty)
 138                 inode_dec_dirty_pages(dn->inode);
 139
 140         /* this converted inline_data should be recovered. */
 141         set_inode_flag(F2FS_I(dn->inode), FI_APPEND_WRITE);
 142
 143         /* clear inline data and flag after data writeback */
 144         truncate_inline_inode(dn->inode_page, 0);
 145         clear_inline_node(dn->inode_page);
 146 clear_out:
 147         stat_dec_inline_inode(dn->inode);
 148         f2fs_clear_inline_inode(dn->inode);
 149         sync_inode_page(dn);
 150         f2fs_put_dnode(dn);
 151         return 0;
 152 }
 153
 154 int f2fs_convert_inline_inode(struct inode *inode)
 155 {
 156         struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
 157         struct dnode_of_data dn;
 158         struct page *ipage, *page;
 159         int err = 0;
 160
 161         if (!f2fs_has_inline_data(inode))
 162                 return 0;
 163
 164         page = grab_cache_page(inode->i_mapping, 0);
 165         if (!page)
 166                 return -ENOMEM;
 167
 168         f2fs_lock_op(sbi);
 169
 170         ipage = get_node_page(sbi, inode->i_ino);
 171         if (IS_ERR(ipage)) {
 172                 err = PTR_ERR(ipage);
 173                 goto out;
 174         }
 175
 176         set_new_dnode(&dn, inode, ipage, ipage, 0);
 177
 178         if (f2fs_has_inline_data(inode))
 179                 err = f2fs_convert_inline_page(&dn, page);
 180
 181         f2fs_put_dnode(&dn);
 182 out:
 183         f2fs_unlock_op(sbi);
 184
 185         f2fs_put_page(page, 1);
 186
 187         f2fs_balance_fs(sbi, dn.node_changed);
 188
 189         return err;
 190 }
 191
 192 int f2fs_write_inline_data(struct inode *inode, struct page *page)
 193 {
 194         void *src_addr, *dst_addr;
 195         struct dnode_of_data dn;
 196         int err;
 197
 198         set_new_dnode(&dn, inode, NULL, NULL, 0);
 199         err = get_dnode_of_data(&dn, 0, LOOKUP_NODE);
 200         if (err)
 201                 return err;
 202
 203         if (!f2fs_has_inline_data(inode)) {
 204                 f2fs_put_dnode(&dn);
 205                 return -EAGAIN;
 206         }
 207
 208         f2fs_bug_on(F2FS_I_SB(inode), page->index);
 209
 210         f2fs_wait_on_page_writeback(dn.inode_page, NODE, true);
 211         src_addr = kmap_atomic(page);
 212         dst_addr = inline_data_addr(dn.inode_page);
 213         memcpy(dst_addr, src_addr, MAX_INLINE_DATA);
 214         kunmap_atomic(src_addr);
 215
 216         set_inode_flag(F2FS_I(inode), FI_APPEND_WRITE);
 217         set_inode_flag(F2FS_I(inode), FI_DATA_EXIST);
 218
 219         sync_inode_page(&dn);
 220         clear_inline_node(dn.inode_page);
 221         f2fs_put_dnode(&dn);
 222         return 0;
 223 }
 224
 225 bool recover_inline_data(struct inode *inode, struct page *npage)
 226 {
 227         struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
 228         struct f2fs_inode *ri = NULL;
 229         void *src_addr, *dst_addr;
 230         struct page *ipage;
 231
 232         /*
 233          * The inline_data recovery policy is as follows.
 234          * [prev.] [next] of inline_data flag
 235          *    o       o  -> recover inline_data
 236          *    o       x  -> remove inline_data, and then recover data blocks
 237          *    x       o  -> remove inline_data, and then recover inline_data
 238          *    x       x  -> recover data blocks
 239          */
 240         if (IS_INODE(npage))
 241                 ri = F2FS_INODE(npage);
 242
 243         if (f2fs_has_inline_data(inode) &&
 244                         ri && (ri->i_inline & F2FS_INLINE_DATA)) {
 245 process_inline:
 246                 ipage = get_node_page(sbi, inode->i_ino);
 247                 f2fs_bug_on(sbi, IS_ERR(ipage));
 248
 249                 f2fs_wait_on_page_writeback(ipage, NODE, true);
 250
 251                 src_addr = inline_data_addr(npage);
 252                 dst_addr = inline_data_addr(ipage);
 253                 memcpy(dst_addr, src_addr, MAX_INLINE_DATA);
 254
 255                 set_inode_flag(F2FS_I(inode), FI_INLINE_DATA);
 256                 set_inode_flag(F2FS_I(inode), FI_DATA_EXIST);
 257
 258                 update_inode(inode, ipage);
 259                 f2fs_put_page(ipage, 1);
 260                 return true;
 261         }
 262
 263         if (f2fs_has_inline_data(inode)) {
 264                 ipage = get_node_page(sbi, inode->i_ino);
 265                 f2fs_bug_on(sbi, IS_ERR(ipage));
 266                 if (!truncate_inline_inode(ipage, 0))
 267                         return false;
 268                 f2fs_clear_inline_inode(inode);
 269                 update_inode(inode, ipage);
 270                 f2fs_put_page(ipage, 1);
 271         } else if (ri && (ri->i_inline & F2FS_INLINE_DATA)) {
 272                 if (truncate_blocks(inode, 0, false))
 273                         return false;
 274                 goto process_inline;
 275         }
 276         return false;
 277 }
 278
 279 struct f2fs_dir_entry *find_in_inline_dir(struct inode *dir,
 280                         struct fscrypt_name *fname, struct page **res_page)
 281 {
 282         struct f2fs_sb_info *sbi = F2FS_SB(dir->i_sb);
 283         struct f2fs_inline_dentry *inline_dentry;
 284         struct qstr name = FSTR_TO_QSTR(&fname->disk_name);
 285         struct f2fs_dir_entry *de;
 286         struct f2fs_dentry_ptr d;
 287         struct page *ipage;
 288         f2fs_hash_t namehash;
 289
 290         ipage = get_node_page(sbi, dir->i_ino);
 291         if (IS_ERR(ipage))
 292                 return NULL;
 293
 294         namehash = f2fs_dentry_hash(&name);
 295
 296         inline_dentry = inline_data_addr(ipage);
 297
 298         make_dentry_ptr(NULL, &d, (void *)inline_dentry, 2);
 299         de = find_target_dentry(fname, namehash, NULL, &d);
 300         unlock_page(ipage);
 301         if (de)
 302                 *res_page = ipage;
 303         else
 304                 f2fs_put_page(ipage, 0);
 305
 306         /*
 307          * For the most part, it should be a bug when name_len is zero.
 308          * We stop here for figuring out where the bugs has occurred.
 309          */
 310         f2fs_bug_on(sbi, d.max < 0);
 311         return de;
 312 }
 313
 314 struct f2fs_dir_entry *f2fs_parent_inline_dir(struct inode *dir,
 315                                                         struct page **p)
 316 {
 317         struct f2fs_sb_info *sbi = F2FS_I_SB(dir);
 318         struct page *ipage;
 319         struct f2fs_dir_entry *de;
 320         struct f2fs_inline_dentry *dentry_blk;
 321
 322         ipage = get_node_page(sbi, dir->i_ino);
 323         if (IS_ERR(ipage))
 324                 return NULL;
 325
 326         dentry_blk = inline_data_addr(ipage);
 327         de = &dentry_blk->dentry[1];
 328         *p = ipage;
 329         unlock_page(ipage);
 330         return de;
 331 }
 332
 333 int make_empty_inline_dir(struct inode *inode, struct inode *parent,
 334                                                         struct page *ipage)
 335 {
 336         struct f2fs_inline_dentry *dentry_blk;
 337         struct f2fs_dentry_ptr d;
 338
 339         dentry_blk = inline_data_addr(ipage);
 340
 341         make_dentry_ptr(NULL, &d, (void *)dentry_blk, 2);
 342         do_make_empty_dir(inode, parent, &d);
 343
 344         set_page_dirty(ipage);
 345
 346         /* update i_size to MAX_INLINE_DATA */
 347         if (i_size_read(inode) < MAX_INLINE_DATA) {
 348                 i_size_write(inode, MAX_INLINE_DATA);
 349                 set_inode_flag(F2FS_I(inode), FI_UPDATE_DIR);
 350         }
 351         return 0;
 352 }
 353
 354 /*
 355  * NOTE: ipage is grabbed by caller, but if any error occurs, we should
 356  * release ipage in this function.
 357  */
 358 static int f2fs_convert_inline_dir(struct inode *dir, struct page *ipage,
 359                                 struct f2fs_inline_dentry *inline_dentry)
 360 {
 361         struct page *page;
 362         struct dnode_of_data dn;
 363         struct f2fs_dentry_block *dentry_blk;
 364         int err;
 365
 366         page = grab_cache_page(dir->i_mapping, 0);
 367         if (!page) {
 368                 f2fs_put_page(ipage, 1);
 369                 return -ENOMEM;
 370         }
 371
 372         set_new_dnode(&dn, dir, ipage, NULL, 0);
 373         err = f2fs_reserve_block(&dn, 0);
 374         if (err)
 375                 goto out;
 376
 377         f2fs_wait_on_page_writeback(page, DATA, true);
 378         zero_user_segment(page, MAX_INLINE_DATA, PAGE_CACHE_SIZE);
 379
 380         dentry_blk = kmap_atomic(page);
 381
 382         /* copy data from inline dentry block to new dentry block */
 383         memcpy(dentry_blk->dentry_bitmap, inline_dentry->dentry_bitmap,
 384                                         INLINE_DENTRY_BITMAP_SIZE);
 385         memset(dentry_blk->dentry_bitmap + INLINE_DENTRY_BITMAP_SIZE, 0,
 386                         SIZE_OF_DENTRY_BITMAP - INLINE_DENTRY_BITMAP_SIZE);
 387         /*
 388          * we do not need to zero out remainder part of dentry and filename
 389          * field, since we have used bitmap for marking the usage status of
 390          * them, besides, we can also ignore copying/zeroing reserved space
 391          * of dentry block, because them haven't been used so far.
 392          */
 393         memcpy(dentry_blk->dentry, inline_dentry->dentry,
 394                         sizeof(struct f2fs_dir_entry) * NR_INLINE_DENTRY);
 395         memcpy(dentry_blk->filename, inline_dentry->filename,
 396                                         NR_INLINE_DENTRY * F2FS_SLOT_LEN);
 397
 398         kunmap_atomic(dentry_blk);
 399         SetPageUptodate(page);
 400         set_page_dirty(page);
 401
 402         /* clear inline dir and flag after data writeback */
 403         truncate_inline_inode(ipage, 0);
 404
 405         stat_dec_inline_dir(dir);
 406         clear_inode_flag(F2FS_I(dir), FI_INLINE_DENTRY);
 407
 408         if (i_size_read(dir) < PAGE_CACHE_SIZE) {
 409                 i_size_write(dir, PAGE_CACHE_SIZE);
 410                 set_inode_flag(F2FS_I(dir), FI_UPDATE_DIR);
 411         }
 412
 413         sync_inode_page(&dn);
 414 out:
 415         f2fs_put_page(page, 1);
 416         return err;
 417 }
 418
 419 int f2fs_add_inline_entry(struct inode *dir, const struct qstr *name,
 420                         struct inode *inode, nid_t ino, umode_t mode)
 421 {
 422         struct f2fs_sb_info *sbi = F2FS_I_SB(dir);
 423         struct page *ipage;
 424         unsigned int bit_pos;
 425         f2fs_hash_t name_hash;
 426         size_t namelen = name->len;
 427         struct f2fs_inline_dentry *dentry_blk = NULL;
 428         struct f2fs_dentry_ptr d;
 429         int slots = GET_DENTRY_SLOTS(namelen);
 430         struct page *page = NULL;
 431         int err = 0;
 432
 433         ipage = get_node_page(sbi, dir->i_ino);
 434         if (IS_ERR(ipage))
 435                 return PTR_ERR(ipage);
 436
 437         dentry_blk = inline_data_addr(ipage);
 438         bit_pos = room_for_filename(&dentry_blk->dentry_bitmap,
 439                                                 slots, NR_INLINE_DENTRY);
 440         if (bit_pos >= NR_INLINE_DENTRY) {
 441                 err = f2fs_convert_inline_dir(dir, ipage, dentry_blk);
 442                 if (err)
 443                         return err;
 444                 err = -EAGAIN;
 445                 goto out;
 446         }
 447
 448         if (inode) {
 449                 down_write(&F2FS_I(inode)->i_sem);
 450                 page = init_inode_metadata(inode, dir, name, ipage);
 451                 if (IS_ERR(page)) {
 452                         err = PTR_ERR(page);
 453                         goto fail;
 454                 }
 455         }
 456
 457         f2fs_wait_on_page_writeback(ipage, NODE, true);
 458
 459         name_hash = f2fs_dentry_hash(name);
 460         make_dentry_ptr(NULL, &d, (void *)dentry_blk, 2);
 461         f2fs_update_dentry(ino, mode, &d, name, name_hash, bit_pos);
 462
 463         set_page_dirty(ipage);
 464
 465         /* we don't need to mark_inode_dirty now */
 466         if (inode) {
 467                 F2FS_I(inode)->i_pino = dir->i_ino;
 468                 update_inode(inode, page);
 469                 f2fs_put_page(page, 1);
 470         }
 471
 472         update_parent_metadata(dir, inode, 0);
 473 fail:
 474         if (inode)
 475                 up_write(&F2FS_I(inode)->i_sem);
 476
 477         if (is_inode_flag_set(F2FS_I(dir), FI_UPDATE_DIR)) {
 478                 update_inode(dir, ipage);
 479                 clear_inode_flag(F2FS_I(dir), FI_UPDATE_DIR);
 480         }
 481 out:
 482         f2fs_put_page(ipage, 1);
 483         return err;
 484 }
 485
 486 void f2fs_delete_inline_entry(struct f2fs_dir_entry *dentry, struct page *page,
 487                                         struct inode *dir, struct inode *inode)
 488 {
 489         struct f2fs_inline_dentry *inline_dentry;
 490         int slots = GET_DENTRY_SLOTS(le16_to_cpu(dentry->name_len));
 491         unsigned int bit_pos;
 492         int i;
 493
 494         lock_page(page);
 495         f2fs_wait_on_page_writeback(page, NODE, true);
 496
 497         inline_dentry = inline_data_addr(page);
 498         bit_pos = dentry - inline_dentry->dentry;
 499         for (i = 0; i < slots; i++)
 500                 test_and_clear_bit_le(bit_pos + i,
 501                                 &inline_dentry->dentry_bitmap);
 502
 503         set_page_dirty(page);
 504
 505         dir->i_ctime = dir->i_mtime = CURRENT_TIME;
 506
 507         if (inode)
 508                 f2fs_drop_nlink(dir, inode, page);
 509
 510         f2fs_put_page(page, 1);
 511 }
 512
 513 bool f2fs_empty_inline_dir(struct inode *dir)
 514 {
 515         struct f2fs_sb_info *sbi = F2FS_I_SB(dir);
 516         struct page *ipage;
 517         unsigned int bit_pos = 2;
 518         struct f2fs_inline_dentry *dentry_blk;
 519
 520         ipage = get_node_page(sbi, dir->i_ino);
 521         if (IS_ERR(ipage))
 522                 return false;
 523
 524         dentry_blk = inline_data_addr(ipage);
 525         bit_pos = find_next_bit_le(&dentry_blk->dentry_bitmap,
 526                                         NR_INLINE_DENTRY,
 527                                         bit_pos);
 528
 529         f2fs_put_page(ipage, 1);
 530
 531         if (bit_pos < NR_INLINE_DENTRY)
 532                 return false;
 533
 534         return true;
 535 }
 536
 537 int f2fs_read_inline_dir(struct file *file, struct dir_context *ctx,
 538                                 struct fscrypt_str *fstr)
 539 {
 540         struct inode *inode = file_inode(file);
 541         struct f2fs_inline_dentry *inline_dentry = NULL;
 542         struct page *ipage = NULL;
 543         struct f2fs_dentry_ptr d;
 544
 545         if (ctx->pos == NR_INLINE_DENTRY)
 546                 return 0;
 547
 548         ipage = get_node_page(F2FS_I_SB(inode), inode->i_ino);
 549         if (IS_ERR(ipage))
 550                 return PTR_ERR(ipage);
 551
 552         inline_dentry = inline_data_addr(ipage);
 553
 554         make_dentry_ptr(inode, &d, (void *)inline_dentry, 2);
 555
 556         if (!f2fs_fill_dentries(ctx, &d, 0, fstr))
 557                 ctx->pos = NR_INLINE_DENTRY;
 558
 559         f2fs_put_page(ipage, 1);
 560         return 0;
 561 }
 562
 563 int f2fs_inline_data_fiemap(struct inode *inode,
 564                 struct fiemap_extent_info *fieinfo, __u64 start, __u64 len)
 565 {
 566         __u64 byteaddr, ilen;
 567         __u32 flags = FIEMAP_EXTENT_DATA_INLINE | FIEMAP_EXTENT_NOT_ALIGNED |
 568                 FIEMAP_EXTENT_LAST;
 569         struct node_info ni;
 570         struct page *ipage;
 571         int err = 0;
 572
 573         ipage = get_node_page(F2FS_I_SB(inode), inode->i_ino);
 574         if (IS_ERR(ipage))
 575                 return PTR_ERR(ipage);
 576
 577         if (!f2fs_has_inline_data(inode)) {
 578                 err = -EAGAIN;
 579                 goto out;
 580         }
 581
 582         ilen = min_t(size_t, MAX_INLINE_DATA, i_size_read(inode));
 583         if (start >= ilen)
 584                 goto out;
 585         if (start + len < ilen)
 586                 ilen = start + len;
 587         ilen -= start;
 588
 589         get_node_info(F2FS_I_SB(inode), inode->i_ino, &ni);
 590         byteaddr = (__u64)ni.blk_addr << inode->i_sb->s_blocksize_bits;
 591         byteaddr += (char *)inline_data_addr(ipage) - (char *)F2FS_INODE(ipage);
 592         err = fiemap_fill_next_extent(fieinfo, start, byteaddr, ilen, flags);
 593 out:
 594         f2fs_put_page(ipage, 1);
 595         return err;
 596 }