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