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