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