fs/f2fs/data.c

   1 /*
   2  * fs/f2fs/data.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 <linux/buffer_head.h>
  14 #include <linux/mpage.h>
  15 #include <linux/aio.h>
  16 #include <linux/writeback.h>
  17 #include <linux/backing-dev.h>
  18 #include <linux/blkdev.h>
  19 #include <linux/bio.h>
  20 #include <linux/prefetch.h>
  21
  22 #include "f2fs.h"
  23 #include "node.h"
  24 #include "segment.h"
  25 #include "trace.h"
  26 #include <trace/events/f2fs.h>
  27
  28 static void f2fs_read_end_io(struct bio *bio, int err)
  29 {
  30         struct bio_vec *bvec;
  31         int i;
  32
  33         bio_for_each_segment_all(bvec, bio, i) {
  34                 struct page *page = bvec->bv_page;
  35
  36                 if (!err) {
  37                         SetPageUptodate(page);
  38                 } else {
  39                         ClearPageUptodate(page);
  40                         SetPageError(page);
  41                 }
  42                 unlock_page(page);
  43         }
  44         bio_put(bio);
  45 }
  46
  47 static void f2fs_write_end_io(struct bio *bio, int err)
  48 {
  49         struct f2fs_sb_info *sbi = bio->bi_private;
  50         struct bio_vec *bvec;
  51         int i;
  52
  53         bio_for_each_segment_all(bvec, bio, i) {
  54                 struct page *page = bvec->bv_page;
  55
  56                 if (unlikely(err)) {
  57                         set_page_dirty(page);
  58                         set_bit(AS_EIO, &page->mapping->flags);
  59                         f2fs_stop_checkpoint(sbi);
  60                 }
  61                 end_page_writeback(page);
  62                 dec_page_count(sbi, F2FS_WRITEBACK);
  63         }
  64
  65         if (!get_pages(sbi, F2FS_WRITEBACK) &&
  66                         !list_empty(&sbi->cp_wait.task_list))
  67                 wake_up(&sbi->cp_wait);
  68
  69         bio_put(bio);
  70 }
  71
  72 /*
  73  * Low-level block read/write IO operations.
  74  */
  75 static struct bio *__bio_alloc(struct f2fs_sb_info *sbi, block_t blk_addr,
  76                                 int npages, bool is_read)
  77 {
  78         struct bio *bio;
  79
  80         /* No failure on bio allocation */
  81         bio = bio_alloc(GFP_NOIO, npages);
  82
  83         bio->bi_bdev = sbi->sb->s_bdev;
  84         bio->bi_iter.bi_sector = SECTOR_FROM_BLOCK(blk_addr);
  85         bio->bi_end_io = is_read ? f2fs_read_end_io : f2fs_write_end_io;
  86         bio->bi_private = sbi;
  87
  88         return bio;
  89 }
  90
  91 static void __submit_merged_bio(struct f2fs_bio_info *io)
  92 {
  93         struct f2fs_io_info *fio = &io->fio;
  94
  95         if (!io->bio)
  96                 return;
  97
  98         if (is_read_io(fio->rw))
  99                 trace_f2fs_submit_read_bio(io->sbi->sb, fio, io->bio);
 100         else
 101                 trace_f2fs_submit_write_bio(io->sbi->sb, fio, io->bio);
 102
 103         submit_bio(fio->rw, io->bio);
 104         io->bio = NULL;
 105 }
 106
 107 void f2fs_submit_merged_bio(struct f2fs_sb_info *sbi,
 108                                 enum page_type type, int rw)
 109 {
 110         enum page_type btype = PAGE_TYPE_OF_BIO(type);
 111         struct f2fs_bio_info *io;
 112
 113         io = is_read_io(rw) ? &sbi->read_io : &sbi->write_io[btype];
 114
 115         down_write(&io->io_rwsem);
 116
 117         /* change META to META_FLUSH in the checkpoint procedure */
 118         if (type >= META_FLUSH) {
 119                 io->fio.type = META_FLUSH;
 120                 if (test_opt(sbi, NOBARRIER))
 121                         io->fio.rw = WRITE_FLUSH | REQ_META | REQ_PRIO;
 122                 else
 123                         io->fio.rw = WRITE_FLUSH_FUA | REQ_META | REQ_PRIO;
 124         }
 125         __submit_merged_bio(io);
 126         up_write(&io->io_rwsem);
 127 }
 128
 129 /*
 130  * Fill the locked page with data located in the block address.
 131  * Return unlocked page.
 132  */
 133 int f2fs_submit_page_bio(struct f2fs_sb_info *sbi, struct page *page,
 134                                         struct f2fs_io_info *fio)
 135 {
 136         struct bio *bio;
 137
 138         trace_f2fs_submit_page_bio(page, fio);
 139         f2fs_trace_ios(page, fio, 0);
 140
 141         /* Allocate a new bio */
 142         bio = __bio_alloc(sbi, fio->blk_addr, 1, is_read_io(fio->rw));
 143
 144         if (bio_add_page(bio, page, PAGE_CACHE_SIZE, 0) < PAGE_CACHE_SIZE) {
 145                 bio_put(bio);
 146                 f2fs_put_page(page, 1);
 147                 return -EFAULT;
 148         }
 149
 150         submit_bio(fio->rw, bio);
 151         return 0;
 152 }
 153
 154 void f2fs_submit_page_mbio(struct f2fs_sb_info *sbi, struct page *page,
 155                                         struct f2fs_io_info *fio)
 156 {
 157         enum page_type btype = PAGE_TYPE_OF_BIO(fio->type);
 158         struct f2fs_bio_info *io;
 159         bool is_read = is_read_io(fio->rw);
 160
 161         io = is_read ? &sbi->read_io : &sbi->write_io[btype];
 162
 163         verify_block_addr(sbi, fio->blk_addr);
 164
 165         down_write(&io->io_rwsem);
 166
 167         if (!is_read)
 168                 inc_page_count(sbi, F2FS_WRITEBACK);
 169
 170         if (io->bio && (io->last_block_in_bio != fio->blk_addr - 1 ||
 171                                                 io->fio.rw != fio->rw))
 172                 __submit_merged_bio(io);
 173 alloc_new:
 174         if (io->bio == NULL) {
 175                 int bio_blocks = MAX_BIO_BLOCKS(sbi);
 176
 177                 io->bio = __bio_alloc(sbi, fio->blk_addr, bio_blocks, is_read);
 178                 io->fio = *fio;
 179         }
 180
 181         if (bio_add_page(io->bio, page, PAGE_CACHE_SIZE, 0) <
 182                                                         PAGE_CACHE_SIZE) {
 183                 __submit_merged_bio(io);
 184                 goto alloc_new;
 185         }
 186
 187         io->last_block_in_bio = fio->blk_addr;
 188         f2fs_trace_ios(page, fio, 0);
 189
 190         up_write(&io->io_rwsem);
 191         trace_f2fs_submit_page_mbio(page, fio);
 192 }
 193
 194 /*
 195  * Lock ordering for the change of data block address:
 196  * ->data_page
 197  *  ->node_page
 198  *    update block addresses in the node page
 199  */
 200 static void __set_data_blkaddr(struct dnode_of_data *dn)
 201 {
 202         struct f2fs_node *rn;
 203         __le32 *addr_array;
 204         struct page *node_page = dn->node_page;
 205         unsigned int ofs_in_node = dn->ofs_in_node;
 206
 207         f2fs_wait_on_page_writeback(node_page, NODE);
 208
 209         rn = F2FS_NODE(node_page);
 210
 211         /* Get physical address of data block */
 212         addr_array = blkaddr_in_node(rn);
 213         addr_array[ofs_in_node] = cpu_to_le32(dn->data_blkaddr);
 214         set_page_dirty(node_page);
 215 }
 216
 217 int reserve_new_block(struct dnode_of_data *dn)
 218 {
 219         struct f2fs_sb_info *sbi = F2FS_I_SB(dn->inode);
 220
 221         if (unlikely(is_inode_flag_set(F2FS_I(dn->inode), FI_NO_ALLOC)))
 222                 return -EPERM;
 223         if (unlikely(!inc_valid_block_count(sbi, dn->inode, 1)))
 224                 return -ENOSPC;
 225
 226         trace_f2fs_reserve_new_block(dn->inode, dn->nid, dn->ofs_in_node);
 227
 228         dn->data_blkaddr = NEW_ADDR;
 229         __set_data_blkaddr(dn);
 230         mark_inode_dirty(dn->inode);
 231         sync_inode_page(dn);
 232         return 0;
 233 }
 234
 235 int f2fs_reserve_block(struct dnode_of_data *dn, pgoff_t index)
 236 {
 237         bool need_put = dn->inode_page ? false : true;
 238         int err;
 239
 240         err = get_dnode_of_data(dn, index, ALLOC_NODE);
 241         if (err)
 242                 return err;
 243
 244         if (dn->data_blkaddr == NULL_ADDR)
 245                 err = reserve_new_block(dn);
 246         if (err || need_put)
 247                 f2fs_put_dnode(dn);
 248         return err;
 249 }
 250
 251 static void f2fs_map_bh(struct super_block *sb, pgoff_t pgofs,
 252                         struct extent_info *ei, struct buffer_head *bh_result)
 253 {
 254         unsigned int blkbits = sb->s_blocksize_bits;
 255         size_t count;
 256
 257         set_buffer_new(bh_result);
 258         map_bh(bh_result, sb, ei->blk + pgofs - ei->fofs);
 259         count = ei->fofs + ei->len - pgofs;
 260         if (count < (UINT_MAX >> blkbits))
 261                 bh_result->b_size = (count << blkbits);
 262         else
 263                 bh_result->b_size = UINT_MAX;
 264 }
 265
 266 static bool lookup_extent_info(struct inode *inode, pgoff_t pgofs,
 267                                                         struct extent_info *ei)
 268 {
 269         struct f2fs_inode_info *fi = F2FS_I(inode);
 270         pgoff_t start_fofs, end_fofs;
 271         block_t start_blkaddr;
 272
 273         if (is_inode_flag_set(fi, FI_NO_EXTENT))
 274                 return false;
 275
 276         read_lock(&fi->ext_lock);
 277         if (fi->ext.len == 0) {
 278                 read_unlock(&fi->ext_lock);
 279                 return false;
 280         }
 281
 282         stat_inc_total_hit(inode->i_sb);
 283
 284         start_fofs = fi->ext.fofs;
 285         end_fofs = fi->ext.fofs + fi->ext.len - 1;
 286         start_blkaddr = fi->ext.blk;
 287
 288         if (pgofs >= start_fofs && pgofs <= end_fofs) {
 289                 *ei = fi->ext;
 290                 stat_inc_read_hit(inode->i_sb);
 291                 read_unlock(&fi->ext_lock);
 292                 return true;
 293         }
 294         read_unlock(&fi->ext_lock);
 295         return false;
 296 }
 297
 298 static bool update_extent_info(struct inode *inode, pgoff_t fofs,
 299                                                                 block_t blkaddr)
 300 {
 301         struct f2fs_inode_info *fi = F2FS_I(inode);
 302         pgoff_t start_fofs, end_fofs;
 303         block_t start_blkaddr, end_blkaddr;
 304         int need_update = true;
 305
 306         if (is_inode_flag_set(fi, FI_NO_EXTENT))
 307                 return false;
 308
 309         write_lock(&fi->ext_lock);
 310
 311         start_fofs = fi->ext.fofs;
 312         end_fofs = fi->ext.fofs + fi->ext.len - 1;
 313         start_blkaddr = fi->ext.blk;
 314         end_blkaddr = fi->ext.blk + fi->ext.len - 1;
 315
 316         /* Drop and initialize the matched extent */
 317         if (fi->ext.len == 1 && fofs == start_fofs)
 318                 fi->ext.len = 0;
 319
 320         /* Initial extent */
 321         if (fi->ext.len == 0) {
 322                 if (blkaddr != NULL_ADDR) {
 323                         fi->ext.fofs = fofs;
 324                         fi->ext.blk = blkaddr;
 325                         fi->ext.len = 1;
 326                 }
 327                 goto end_update;
 328         }
 329
 330         /* Front merge */
 331         if (fofs == start_fofs - 1 && blkaddr == start_blkaddr - 1) {
 332                 fi->ext.fofs--;
 333                 fi->ext.blk--;
 334                 fi->ext.len++;
 335                 goto end_update;
 336         }
 337
 338         /* Back merge */
 339         if (fofs == end_fofs + 1 && blkaddr == end_blkaddr + 1) {
 340                 fi->ext.len++;
 341                 goto end_update;
 342         }
 343
 344         /* Split the existing extent */
 345         if (fi->ext.len > 1 &&
 346                 fofs >= start_fofs && fofs <= end_fofs) {
 347                 if ((end_fofs - fofs) < (fi->ext.len >> 1)) {
 348                         fi->ext.len = fofs - start_fofs;
 349                 } else {
 350                         fi->ext.fofs = fofs + 1;
 351                         fi->ext.blk = start_blkaddr + fofs - start_fofs + 1;
 352                         fi->ext.len -= fofs - start_fofs + 1;
 353                 }
 354         } else {
 355                 need_update = false;
 356         }
 357
 358         /* Finally, if the extent is very fragmented, let's drop the cache. */
 359         if (fi->ext.len < F2FS_MIN_EXTENT_LEN) {
 360                 fi->ext.len = 0;
 361                 set_inode_flag(fi, FI_NO_EXTENT);
 362                 need_update = true;
 363         }
 364 end_update:
 365         write_unlock(&fi->ext_lock);
 366         return need_update;
 367 }
 368
 369 static bool f2fs_lookup_extent_cache(struct inode *inode, pgoff_t pgofs,
 370                                                         struct extent_info *ei)
 371 {
 372         return lookup_extent_info(inode, pgofs, ei);
 373 }
 374
 375 void f2fs_update_extent_cache(struct dnode_of_data *dn)
 376 {
 377         struct f2fs_inode_info *fi = F2FS_I(dn->inode);
 378         pgoff_t fofs;
 379
 380         f2fs_bug_on(F2FS_I_SB(dn->inode), dn->data_blkaddr == NEW_ADDR);
 381
 382         /* Update the page address in the parent node */
 383         __set_data_blkaddr(dn);
 384
 385         fofs = start_bidx_of_node(ofs_of_node(dn->node_page), fi) +
 386                                                         dn->ofs_in_node;
 387
 388         if (update_extent_info(dn->inode, fofs, dn->data_blkaddr))
 389                 sync_inode_page(dn);
 390 }
 391
 392 struct page *find_data_page(struct inode *inode, pgoff_t index, bool sync)
 393 {
 394         struct address_space *mapping = inode->i_mapping;
 395         struct dnode_of_data dn;
 396         struct page *page;
 397         int err;
 398         struct f2fs_io_info fio = {
 399                 .type = DATA,
 400                 .rw = sync ? READ_SYNC : READA,
 401         };
 402
 403         page = find_get_page(mapping, index);
 404         if (page && PageUptodate(page))
 405                 return page;
 406         f2fs_put_page(page, 0);
 407
 408         set_new_dnode(&dn, inode, NULL, NULL, 0);
 409         err = get_dnode_of_data(&dn, index, LOOKUP_NODE);
 410         if (err)
 411                 return ERR_PTR(err);
 412         f2fs_put_dnode(&dn);
 413
 414         if (dn.data_blkaddr == NULL_ADDR)
 415                 return ERR_PTR(-ENOENT);
 416
 417         /* By fallocate(), there is no cached page, but with NEW_ADDR */
 418         if (unlikely(dn.data_blkaddr == NEW_ADDR))
 419                 return ERR_PTR(-EINVAL);
 420
 421         page = grab_cache_page(mapping, index);
 422         if (!page)
 423                 return ERR_PTR(-ENOMEM);
 424
 425         if (PageUptodate(page)) {
 426                 unlock_page(page);
 427                 return page;
 428         }
 429
 430         fio.blk_addr = dn.data_blkaddr;
 431         err = f2fs_submit_page_bio(F2FS_I_SB(inode), page, &fio);
 432         if (err)
 433                 return ERR_PTR(err);
 434
 435         if (sync) {
 436                 wait_on_page_locked(page);
 437                 if (unlikely(!PageUptodate(page))) {
 438                         f2fs_put_page(page, 0);
 439                         return ERR_PTR(-EIO);
 440                 }
 441         }
 442         return page;
 443 }
 444
 445 /*
 446  * If it tries to access a hole, return an error.
 447  * Because, the callers, functions in dir.c and GC, should be able to know
 448  * whether this page exists or not.
 449  */
 450 struct page *get_lock_data_page(struct inode *inode, pgoff_t index)
 451 {
 452         struct address_space *mapping = inode->i_mapping;
 453         struct dnode_of_data dn;
 454         struct page *page;
 455         int err;
 456         struct f2fs_io_info fio = {
 457                 .type = DATA,
 458                 .rw = READ_SYNC,
 459         };
 460 repeat:
 461         page = grab_cache_page(mapping, index);
 462         if (!page)
 463                 return ERR_PTR(-ENOMEM);
 464
 465         set_new_dnode(&dn, inode, NULL, NULL, 0);
 466         err = get_dnode_of_data(&dn, index, LOOKUP_NODE);
 467         if (err) {
 468                 f2fs_put_page(page, 1);
 469                 return ERR_PTR(err);
 470         }
 471         f2fs_put_dnode(&dn);
 472
 473         if (unlikely(dn.data_blkaddr == NULL_ADDR)) {
 474                 f2fs_put_page(page, 1);
 475                 return ERR_PTR(-ENOENT);
 476         }
 477
 478         if (PageUptodate(page))
 479                 return page;
 480
 481         /*
 482          * A new dentry page is allocated but not able to be written, since its
 483          * new inode page couldn't be allocated due to -ENOSPC.
 484          * In such the case, its blkaddr can be remained as NEW_ADDR.
 485          * see, f2fs_add_link -> get_new_data_page -> init_inode_metadata.
 486          */
 487         if (dn.data_blkaddr == NEW_ADDR) {
 488                 zero_user_segment(page, 0, PAGE_CACHE_SIZE);
 489                 SetPageUptodate(page);
 490                 return page;
 491         }
 492
 493         fio.blk_addr = dn.data_blkaddr;
 494         err = f2fs_submit_page_bio(F2FS_I_SB(inode), page, &fio);
 495         if (err)
 496                 return ERR_PTR(err);
 497
 498         lock_page(page);
 499         if (unlikely(!PageUptodate(page))) {
 500                 f2fs_put_page(page, 1);
 501                 return ERR_PTR(-EIO);
 502         }
 503         if (unlikely(page->mapping != mapping)) {
 504                 f2fs_put_page(page, 1);
 505                 goto repeat;
 506         }
 507         return page;
 508 }
 509
 510 /*
 511  * Caller ensures that this data page is never allocated.
 512  * A new zero-filled data page is allocated in the page cache.
 513  *
 514  * Also, caller should grab and release a rwsem by calling f2fs_lock_op() and
 515  * f2fs_unlock_op().
 516  * Note that, ipage is set only by make_empty_dir.
 517  */
 518 struct page *get_new_data_page(struct inode *inode,
 519                 struct page *ipage, pgoff_t index, bool new_i_size)
 520 {
 521         struct address_space *mapping = inode->i_mapping;
 522         struct page *page;
 523         struct dnode_of_data dn;
 524         int err;
 525
 526         set_new_dnode(&dn, inode, ipage, NULL, 0);
 527         err = f2fs_reserve_block(&dn, index);
 528         if (err)
 529                 return ERR_PTR(err);
 530 repeat:
 531         page = grab_cache_page(mapping, index);
 532         if (!page) {
 533                 err = -ENOMEM;
 534                 goto put_err;
 535         }
 536
 537         if (PageUptodate(page))
 538                 return page;
 539
 540         if (dn.data_blkaddr == NEW_ADDR) {
 541                 zero_user_segment(page, 0, PAGE_CACHE_SIZE);
 542                 SetPageUptodate(page);
 543         } else {
 544                 struct f2fs_io_info fio = {
 545                         .type = DATA,
 546                         .rw = READ_SYNC,
 547                         .blk_addr = dn.data_blkaddr,
 548                 };
 549                 err = f2fs_submit_page_bio(F2FS_I_SB(inode), page, &fio);
 550                 if (err)
 551                         goto put_err;
 552
 553                 lock_page(page);
 554                 if (unlikely(!PageUptodate(page))) {
 555                         f2fs_put_page(page, 1);
 556                         err = -EIO;
 557                         goto put_err;
 558                 }
 559                 if (unlikely(page->mapping != mapping)) {
 560                         f2fs_put_page(page, 1);
 561                         goto repeat;
 562                 }
 563         }
 564
 565         if (new_i_size &&
 566                 i_size_read(inode) < ((index + 1) << PAGE_CACHE_SHIFT)) {
 567                 i_size_write(inode, ((index + 1) << PAGE_CACHE_SHIFT));
 568                 /* Only the directory inode sets new_i_size */
 569                 set_inode_flag(F2FS_I(inode), FI_UPDATE_DIR);
 570         }
 571         return page;
 572
 573 put_err:
 574         f2fs_put_dnode(&dn);
 575         return ERR_PTR(err);
 576 }
 577
 578 static int __allocate_data_block(struct dnode_of_data *dn)
 579 {
 580         struct f2fs_sb_info *sbi = F2FS_I_SB(dn->inode);
 581         struct f2fs_inode_info *fi = F2FS_I(dn->inode);
 582         struct f2fs_summary sum;
 583         struct node_info ni;
 584         int seg = CURSEG_WARM_DATA;
 585         pgoff_t fofs;
 586
 587         if (unlikely(is_inode_flag_set(F2FS_I(dn->inode), FI_NO_ALLOC)))
 588                 return -EPERM;
 589         if (unlikely(!inc_valid_block_count(sbi, dn->inode, 1)))
 590                 return -ENOSPC;
 591
 592         get_node_info(sbi, dn->nid, &ni);
 593         set_summary(&sum, dn->nid, dn->ofs_in_node, ni.version);
 594
 595         if (dn->ofs_in_node == 0 && dn->inode_page == dn->node_page)
 596                 seg = CURSEG_DIRECT_IO;
 597
 598         allocate_data_block(sbi, NULL, NULL_ADDR, &dn->data_blkaddr, &sum, seg);
 599
 600         /* direct IO doesn't use extent cache to maximize the performance */
 601         __set_data_blkaddr(dn);
 602
 603         /* update i_size */
 604         fofs = start_bidx_of_node(ofs_of_node(dn->node_page), fi) +
 605                                                         dn->ofs_in_node;
 606         if (i_size_read(dn->inode) < ((fofs + 1) << PAGE_CACHE_SHIFT))
 607                 i_size_write(dn->inode, ((fofs + 1) << PAGE_CACHE_SHIFT));
 608
 609         return 0;
 610 }
 611
 612 static void __allocate_data_blocks(struct inode *inode, loff_t offset,
 613                                                         size_t count)
 614 {
 615         struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
 616         struct dnode_of_data dn;
 617         u64 start = F2FS_BYTES_TO_BLK(offset);
 618         u64 len = F2FS_BYTES_TO_BLK(count);
 619         bool allocated;
 620         u64 end_offset;
 621
 622         while (len) {
 623                 f2fs_balance_fs(sbi);
 624                 f2fs_lock_op(sbi);
 625
 626                 /* When reading holes, we need its node page */
 627                 set_new_dnode(&dn, inode, NULL, NULL, 0);
 628                 if (get_dnode_of_data(&dn, start, ALLOC_NODE))
 629                         goto out;
 630
 631                 allocated = false;
 632                 end_offset = ADDRS_PER_PAGE(dn.node_page, F2FS_I(inode));
 633
 634                 while (dn.ofs_in_node < end_offset && len) {
 635                         if (dn.data_blkaddr == NULL_ADDR) {
 636                                 if (__allocate_data_block(&dn))
 637                                         goto sync_out;
 638                                 allocated = true;
 639                         }
 640                         len--;
 641                         start++;
 642                         dn.ofs_in_node++;
 643                 }
 644
 645                 if (allocated)
 646                         sync_inode_page(&dn);
 647
 648                 f2fs_put_dnode(&dn);
 649                 f2fs_unlock_op(sbi);
 650         }
 651         return;
 652
 653 sync_out:
 654         if (allocated)
 655                 sync_inode_page(&dn);
 656         f2fs_put_dnode(&dn);
 657 out:
 658         f2fs_unlock_op(sbi);
 659         return;
 660 }
 661
 662 /*
 663  * get_data_block() now supported readahead/bmap/rw direct_IO with mapped bh.
 664  * If original data blocks are allocated, then give them to blockdev.
 665  * Otherwise,
 666  *     a. preallocate requested block addresses
 667  *     b. do not use extent cache for better performance
 668  *     c. give the block addresses to blockdev
 669  */
 670 static int __get_data_block(struct inode *inode, sector_t iblock,
 671                         struct buffer_head *bh_result, int create, bool fiemap)
 672 {
 673         unsigned int blkbits = inode->i_sb->s_blocksize_bits;
 674         unsigned maxblocks = bh_result->b_size >> blkbits;
 675         struct dnode_of_data dn;
 676         int mode = create ? ALLOC_NODE : LOOKUP_NODE_RA;
 677         pgoff_t pgofs, end_offset;
 678         int err = 0, ofs = 1;
 679         struct extent_info ei;
 680         bool allocated = false;
 681
 682         /* Get the page offset from the block offset(iblock) */
 683         pgofs = (pgoff_t)(iblock >> (PAGE_CACHE_SHIFT - blkbits));
 684
 685         if (f2fs_lookup_extent_cache(inode, pgofs, &ei)) {
 686                 f2fs_map_bh(inode->i_sb, pgofs, &ei, bh_result);
 687                 goto out;
 688         }
 689
 690         if (create)
 691                 f2fs_lock_op(F2FS_I_SB(inode));
 692
 693         /* When reading holes, we need its node page */
 694         set_new_dnode(&dn, inode, NULL, NULL, 0);
 695         err = get_dnode_of_data(&dn, pgofs, mode);
 696         if (err) {
 697                 if (err == -ENOENT)
 698                         err = 0;
 699                 goto unlock_out;
 700         }
 701         if (dn.data_blkaddr == NEW_ADDR && !fiemap)
 702                 goto put_out;
 703
 704         if (dn.data_blkaddr != NULL_ADDR) {
 705                 set_buffer_new(bh_result);
 706                 map_bh(bh_result, inode->i_sb, dn.data_blkaddr);
 707         } else if (create) {
 708                 err = __allocate_data_block(&dn);
 709                 if (err)
 710                         goto put_out;
 711                 allocated = true;
 712                 set_buffer_new(bh_result);
 713                 map_bh(bh_result, inode->i_sb, dn.data_blkaddr);
 714         } else {
 715                 goto put_out;
 716         }
 717
 718         end_offset = ADDRS_PER_PAGE(dn.node_page, F2FS_I(inode));
 719         bh_result->b_size = (((size_t)1) << blkbits);
 720         dn.ofs_in_node++;
 721         pgofs++;
 722
 723 get_next:
 724         if (dn.ofs_in_node >= end_offset) {
 725                 if (allocated)
 726                         sync_inode_page(&dn);
 727                 allocated = false;
 728                 f2fs_put_dnode(&dn);
 729
 730                 set_new_dnode(&dn, inode, NULL, NULL, 0);
 731                 err = get_dnode_of_data(&dn, pgofs, mode);
 732                 if (err) {
 733                         if (err == -ENOENT)
 734                                 err = 0;
 735                         goto unlock_out;
 736                 }
 737                 if (dn.data_blkaddr == NEW_ADDR && !fiemap)
 738                         goto put_out;
 739
 740                 end_offset = ADDRS_PER_PAGE(dn.node_page, F2FS_I(inode));
 741         }
 742
 743         if (maxblocks > (bh_result->b_size >> blkbits)) {
 744                 block_t blkaddr = datablock_addr(dn.node_page, dn.ofs_in_node);
 745                 if (blkaddr == NULL_ADDR && create) {
 746                         err = __allocate_data_block(&dn);
 747                         if (err)
 748                                 goto sync_out;
 749                         allocated = true;
 750                         blkaddr = dn.data_blkaddr;
 751                 }
 752                 /* Give more consecutive addresses for the readahead */
 753                 if (blkaddr == (bh_result->b_blocknr + ofs)) {
 754                         ofs++;
 755                         dn.ofs_in_node++;
 756                         pgofs++;
 757                         bh_result->b_size += (((size_t)1) << blkbits);
 758                         goto get_next;
 759                 }
 760         }
 761 sync_out:
 762         if (allocated)
 763                 sync_inode_page(&dn);
 764 put_out:
 765         f2fs_put_dnode(&dn);
 766 unlock_out:
 767         if (create)
 768                 f2fs_unlock_op(F2FS_I_SB(inode));
 769 out:
 770         trace_f2fs_get_data_block(inode, iblock, bh_result, err);
 771         return err;
 772 }
 773
 774 static int get_data_block(struct inode *inode, sector_t iblock,
 775                         struct buffer_head *bh_result, int create)
 776 {
 777         return __get_data_block(inode, iblock, bh_result, create, false);
 778 }
 779
 780 static int get_data_block_fiemap(struct inode *inode, sector_t iblock,
 781                         struct buffer_head *bh_result, int create)
 782 {
 783         return __get_data_block(inode, iblock, bh_result, create, true);
 784 }
 785
 786 int f2fs_fiemap(struct inode *inode, struct fiemap_extent_info *fieinfo,
 787                 u64 start, u64 len)
 788 {
 789         return generic_block_fiemap(inode, fieinfo,
 790                                 start, len, get_data_block_fiemap);
 791 }
 792
 793 static int f2fs_read_data_page(struct file *file, struct page *page)
 794 {
 795         struct inode *inode = page->mapping->host;
 796         int ret = -EAGAIN;
 797
 798         trace_f2fs_readpage(page, DATA);
 799
 800         /* If the file has inline data, try to read it directly */
 801         if (f2fs_has_inline_data(inode))
 802                 ret = f2fs_read_inline_data(inode, page);
 803         if (ret == -EAGAIN)
 804                 ret = mpage_readpage(page, get_data_block);
 805
 806         return ret;
 807 }
 808
 809 static int f2fs_read_data_pages(struct file *file,
 810                         struct address_space *mapping,
 811                         struct list_head *pages, unsigned nr_pages)
 812 {
 813         struct inode *inode = file->f_mapping->host;
 814
 815         /* If the file has inline data, skip readpages */
 816         if (f2fs_has_inline_data(inode))
 817                 return 0;
 818
 819         return mpage_readpages(mapping, pages, nr_pages, get_data_block);
 820 }
 821
 822 int do_write_data_page(struct page *page, struct f2fs_io_info *fio)
 823 {
 824         struct inode *inode = page->mapping->host;
 825         struct dnode_of_data dn;
 826         int err = 0;
 827
 828         set_new_dnode(&dn, inode, NULL, NULL, 0);
 829         err = get_dnode_of_data(&dn, page->index, LOOKUP_NODE);
 830         if (err)
 831                 return err;
 832
 833         fio->blk_addr = dn.data_blkaddr;
 834
 835         /* This page is already truncated */
 836         if (fio->blk_addr == NULL_ADDR)
 837                 goto out_writepage;
 838
 839         set_page_writeback(page);
 840
 841         /*
 842          * If current allocation needs SSR,
 843          * it had better in-place writes for updated data.
 844          */
 845         if (unlikely(fio->blk_addr != NEW_ADDR &&
 846                         !is_cold_data(page) &&
 847                         need_inplace_update(inode))) {
 848                 rewrite_data_page(page, fio);
 849                 set_inode_flag(F2FS_I(inode), FI_UPDATE_WRITE);
 850         } else {
 851                 write_data_page(page, &dn, fio);
 852                 f2fs_update_extent_cache(&dn);
 853                 set_inode_flag(F2FS_I(inode), FI_APPEND_WRITE);
 854         }
 855 out_writepage:
 856         f2fs_put_dnode(&dn);
 857         return err;
 858 }
 859
 860 static int f2fs_write_data_page(struct page *page,
 861                                         struct writeback_control *wbc)
 862 {
 863         struct inode *inode = page->mapping->host;
 864         struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
 865         loff_t i_size = i_size_read(inode);
 866         const pgoff_t end_index = ((unsigned long long) i_size)
 867                                                         >> PAGE_CACHE_SHIFT;
 868         unsigned offset = 0;
 869         bool need_balance_fs = false;
 870         int err = 0;
 871         struct f2fs_io_info fio = {
 872                 .type = DATA,
 873                 .rw = (wbc->sync_mode == WB_SYNC_ALL) ? WRITE_SYNC : WRITE,
 874         };
 875
 876         trace_f2fs_writepage(page, DATA);
 877
 878         if (page->index < end_index)
 879                 goto write;
 880
 881         /*
 882          * If the offset is out-of-range of file size,
 883          * this page does not have to be written to disk.
 884          */
 885         offset = i_size & (PAGE_CACHE_SIZE - 1);
 886         if ((page->index >= end_index + 1) || !offset)
 887                 goto out;
 888
 889         zero_user_segment(page, offset, PAGE_CACHE_SIZE);
 890 write:
 891         if (unlikely(is_sbi_flag_set(sbi, SBI_POR_DOING)))
 892                 goto redirty_out;
 893         if (f2fs_is_drop_cache(inode))
 894                 goto out;
 895         if (f2fs_is_volatile_file(inode) && !wbc->for_reclaim &&
 896                         available_free_memory(sbi, BASE_CHECK))
 897                 goto redirty_out;
 898
 899         /* Dentry blocks are controlled by checkpoint */
 900         if (S_ISDIR(inode->i_mode)) {
 901                 if (unlikely(f2fs_cp_error(sbi)))
 902                         goto redirty_out;
 903                 err = do_write_data_page(page, &fio);
 904                 goto done;
 905         }
 906
 907         /* we should bypass data pages to proceed the kworkder jobs */
 908         if (unlikely(f2fs_cp_error(sbi))) {
 909                 SetPageError(page);
 910                 goto out;
 911         }
 912
 913         if (!wbc->for_reclaim)
 914                 need_balance_fs = true;
 915         else if (has_not_enough_free_secs(sbi, 0))
 916                 goto redirty_out;
 917
 918         err = -EAGAIN;
 919         f2fs_lock_op(sbi);
 920         if (f2fs_has_inline_data(inode))
 921                 err = f2fs_write_inline_data(inode, page);
 922         if (err == -EAGAIN)
 923                 err = do_write_data_page(page, &fio);
 924         f2fs_unlock_op(sbi);
 925 done:
 926         if (err && err != -ENOENT)
 927                 goto redirty_out;
 928
 929         clear_cold_data(page);
 930 out:
 931         inode_dec_dirty_pages(inode);
 932         unlock_page(page);
 933         if (need_balance_fs)
 934                 f2fs_balance_fs(sbi);
 935         if (wbc->for_reclaim)
 936                 f2fs_submit_merged_bio(sbi, DATA, WRITE);
 937         return 0;
 938
 939 redirty_out:
 940         redirty_page_for_writepage(wbc, page);
 941         return AOP_WRITEPAGE_ACTIVATE;
 942 }
 943
 944 static int __f2fs_writepage(struct page *page, struct writeback_control *wbc,
 945                         void *data)
 946 {
 947         struct address_space *mapping = data;
 948         int ret = mapping->a_ops->writepage(page, wbc);
 949         mapping_set_error(mapping, ret);
 950         return ret;
 951 }
 952
 953 static int f2fs_write_data_pages(struct address_space *mapping,
 954                             struct writeback_control *wbc)
 955 {
 956         struct inode *inode = mapping->host;
 957         struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
 958         bool locked = false;
 959         int ret;
 960         long diff;
 961
 962         trace_f2fs_writepages(mapping->host, wbc, DATA);
 963
 964         /* deal with chardevs and other special file */
 965         if (!mapping->a_ops->writepage)
 966                 return 0;
 967
 968         if (S_ISDIR(inode->i_mode) && wbc->sync_mode == WB_SYNC_NONE &&
 969                         get_dirty_pages(inode) < nr_pages_to_skip(sbi, DATA) &&
 970                         available_free_memory(sbi, DIRTY_DENTS))
 971                 goto skip_write;
 972
 973         diff = nr_pages_to_write(sbi, DATA, wbc);
 974
 975         if (!S_ISDIR(inode->i_mode)) {
 976                 mutex_lock(&sbi->writepages);
 977                 locked = true;
 978         }
 979         ret = write_cache_pages(mapping, wbc, __f2fs_writepage, mapping);
 980         if (locked)
 981                 mutex_unlock(&sbi->writepages);
 982
 983         f2fs_submit_merged_bio(sbi, DATA, WRITE);
 984
 985         remove_dirty_dir_inode(inode);
 986
 987         wbc->nr_to_write = max((long)0, wbc->nr_to_write - diff);
 988         return ret;
 989
 990 skip_write:
 991         wbc->pages_skipped += get_dirty_pages(inode);
 992         return 0;
 993 }
 994
 995 static void f2fs_write_failed(struct address_space *mapping, loff_t to)
 996 {
 997         struct inode *inode = mapping->host;
 998
 999         if (to > inode->i_size) {
1000                 truncate_pagecache(inode, inode->i_size);
1001                 truncate_blocks(inode, inode->i_size, true);
1002         }
1003 }
1004
1005 static int f2fs_write_begin(struct file *file, struct address_space *mapping,
1006                 loff_t pos, unsigned len, unsigned flags,
1007                 struct page **pagep, void **fsdata)
1008 {
1009         struct inode *inode = mapping->host;
1010         struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
1011         struct page *page, *ipage;
1012         pgoff_t index = ((unsigned long long) pos) >> PAGE_CACHE_SHIFT;
1013         struct dnode_of_data dn;
1014         int err = 0;
1015
1016         trace_f2fs_write_begin(inode, pos, len, flags);
1017
1018         f2fs_balance_fs(sbi);
1019
1020         /*
1021          * We should check this at this moment to avoid deadlock on inode page
1022          * and #0 page. The locking rule for inline_data conversion should be:
1023          * lock_page(page #0) -> lock_page(inode_page)
1024          */
1025         if (index != 0) {
1026                 err = f2fs_convert_inline_inode(inode);
1027                 if (err)
1028                         goto fail;
1029         }
1030 repeat:
1031         page = grab_cache_page_write_begin(mapping, index, flags);
1032         if (!page) {
1033                 err = -ENOMEM;
1034                 goto fail;
1035         }
1036
1037         *pagep = page;
1038
1039         f2fs_lock_op(sbi);
1040
1041         /* check inline_data */
1042         ipage = get_node_page(sbi, inode->i_ino);
1043         if (IS_ERR(ipage)) {
1044                 err = PTR_ERR(ipage);
1045                 goto unlock_fail;
1046         }
1047
1048         set_new_dnode(&dn, inode, ipage, ipage, 0);
1049
1050         if (f2fs_has_inline_data(inode)) {
1051                 if (pos + len <= MAX_INLINE_DATA) {
1052                         read_inline_data(page, ipage);
1053                         set_inode_flag(F2FS_I(inode), FI_DATA_EXIST);
1054                         sync_inode_page(&dn);
1055                         goto put_next;
1056                 }
1057                 err = f2fs_convert_inline_page(&dn, page);
1058                 if (err)
1059                         goto put_fail;
1060         }
1061         err = f2fs_reserve_block(&dn, index);
1062         if (err)
1063                 goto put_fail;
1064 put_next:
1065         f2fs_put_dnode(&dn);
1066         f2fs_unlock_op(sbi);
1067
1068         if ((len == PAGE_CACHE_SIZE) || PageUptodate(page))
1069                 return 0;
1070
1071         f2fs_wait_on_page_writeback(page, DATA);
1072
1073         if ((pos & PAGE_CACHE_MASK) >= i_size_read(inode)) {
1074                 unsigned start = pos & (PAGE_CACHE_SIZE - 1);
1075                 unsigned end = start + len;
1076
1077                 /* Reading beyond i_size is simple: memset to zero */
1078                 zero_user_segments(page, 0, start, end, PAGE_CACHE_SIZE);
1079                 goto out;
1080         }
1081
1082         if (dn.data_blkaddr == NEW_ADDR) {
1083                 zero_user_segment(page, 0, PAGE_CACHE_SIZE);
1084         } else {
1085                 struct f2fs_io_info fio = {
1086                         .type = DATA,
1087                         .rw = READ_SYNC,
1088                         .blk_addr = dn.data_blkaddr,
1089                 };
1090                 err = f2fs_submit_page_bio(sbi, page, &fio);
1091                 if (err)
1092                         goto fail;
1093
1094                 lock_page(page);
1095                 if (unlikely(!PageUptodate(page))) {
1096                         f2fs_put_page(page, 1);
1097                         err = -EIO;
1098                         goto fail;
1099                 }
1100                 if (unlikely(page->mapping != mapping)) {
1101                         f2fs_put_page(page, 1);
1102                         goto repeat;
1103                 }
1104         }
1105 out:
1106         SetPageUptodate(page);
1107         clear_cold_data(page);
1108         return 0;
1109
1110 put_fail:
1111         f2fs_put_dnode(&dn);
1112 unlock_fail:
1113         f2fs_unlock_op(sbi);
1114         f2fs_put_page(page, 1);
1115 fail:
1116         f2fs_write_failed(mapping, pos + len);
1117         return err;
1118 }
1119
1120 static int f2fs_write_end(struct file *file,
1121                         struct address_space *mapping,
1122                         loff_t pos, unsigned len, unsigned copied,
1123                         struct page *page, void *fsdata)
1124 {
1125         struct inode *inode = page->mapping->host;
1126
1127         trace_f2fs_write_end(inode, pos, len, copied);
1128
1129         set_page_dirty(page);
1130
1131         if (pos + copied > i_size_read(inode)) {
1132                 i_size_write(inode, pos + copied);
1133                 mark_inode_dirty(inode);
1134                 update_inode_page(inode);
1135         }
1136
1137         f2fs_put_page(page, 1);
1138         return copied;
1139 }
1140
1141 static int check_direct_IO(struct inode *inode, int rw,
1142                 struct iov_iter *iter, loff_t offset)
1143 {
1144         unsigned blocksize_mask = inode->i_sb->s_blocksize - 1;
1145
1146         if (rw == READ)
1147                 return 0;
1148
1149         if (offset & blocksize_mask)
1150                 return -EINVAL;
1151
1152         if (iov_iter_alignment(iter) & blocksize_mask)
1153                 return -EINVAL;
1154
1155         return 0;
1156 }
1157
1158 static ssize_t f2fs_direct_IO(int rw, struct kiocb *iocb,
1159                 struct iov_iter *iter, loff_t offset)
1160 {
1161         struct file *file = iocb->ki_filp;
1162         struct address_space *mapping = file->f_mapping;
1163         struct inode *inode = mapping->host;
1164         size_t count = iov_iter_count(iter);
1165         int err;
1166
1167         /* we don't need to use inline_data strictly */
1168         if (f2fs_has_inline_data(inode)) {
1169                 err = f2fs_convert_inline_inode(inode);
1170                 if (err)
1171                         return err;
1172         }
1173
1174         if (check_direct_IO(inode, rw, iter, offset))
1175                 return 0;
1176
1177         trace_f2fs_direct_IO_enter(inode, offset, count, rw);
1178
1179         if (rw & WRITE)
1180                 __allocate_data_blocks(inode, offset, count);
1181
1182         err = blockdev_direct_IO(rw, iocb, inode, iter, offset, get_data_block);
1183         if (err < 0 && (rw & WRITE))
1184                 f2fs_write_failed(mapping, offset + count);
1185
1186         trace_f2fs_direct_IO_exit(inode, offset, count, rw, err);
1187
1188         return err;
1189 }
1190
1191 void f2fs_invalidate_page(struct page *page, unsigned int offset,
1192                                                         unsigned int length)
1193 {
1194         struct inode *inode = page->mapping->host;
1195         struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
1196
1197         if (inode->i_ino >= F2FS_ROOT_INO(sbi) &&
1198                 (offset % PAGE_CACHE_SIZE || length != PAGE_CACHE_SIZE))
1199                 return;
1200
1201         if (PageDirty(page)) {
1202                 if (inode->i_ino == F2FS_META_INO(sbi))
1203                         dec_page_count(sbi, F2FS_DIRTY_META);
1204                 else if (inode->i_ino == F2FS_NODE_INO(sbi))
1205                         dec_page_count(sbi, F2FS_DIRTY_NODES);
1206                 else
1207                         inode_dec_dirty_pages(inode);
1208         }
1209         ClearPagePrivate(page);
1210 }
1211
1212 int f2fs_release_page(struct page *page, gfp_t wait)
1213 {
1214         /* If this is dirty page, keep PagePrivate */
1215         if (PageDirty(page))
1216                 return 0;
1217
1218         ClearPagePrivate(page);
1219         return 1;
1220 }
1221
1222 static int f2fs_set_data_page_dirty(struct page *page)
1223 {
1224         struct address_space *mapping = page->mapping;
1225         struct inode *inode = mapping->host;
1226
1227         trace_f2fs_set_page_dirty(page, DATA);
1228
1229         SetPageUptodate(page);
1230
1231         if (f2fs_is_atomic_file(inode)) {
1232                 register_inmem_page(inode, page);
1233                 return 1;
1234         }
1235
1236         mark_inode_dirty(inode);
1237
1238         if (!PageDirty(page)) {
1239                 __set_page_dirty_nobuffers(page);
1240                 update_dirty_page(inode, page);
1241                 return 1;
1242         }
1243         return 0;
1244 }
1245
1246 static sector_t f2fs_bmap(struct address_space *mapping, sector_t block)
1247 {
1248         struct inode *inode = mapping->host;
1249
1250         /* we don't need to use inline_data strictly */
1251         if (f2fs_has_inline_data(inode)) {
1252                 int err = f2fs_convert_inline_inode(inode);
1253                 if (err)
1254                         return err;
1255         }
1256         return generic_block_bmap(mapping, block, get_data_block);
1257 }
1258
1259 const struct address_space_operations f2fs_dblock_aops = {
1260         .readpage       = f2fs_read_data_page,
1261         .readpages      = f2fs_read_data_pages,
1262         .writepage      = f2fs_write_data_page,
1263         .writepages     = f2fs_write_data_pages,
1264         .write_begin    = f2fs_write_begin,
1265         .write_end      = f2fs_write_end,
1266         .set_page_dirty = f2fs_set_data_page_dirty,
1267         .invalidatepage = f2fs_invalidate_page,
1268         .releasepage    = f2fs_release_page,
1269         .direct_IO      = f2fs_direct_IO,
1270         .bmap           = f2fs_bmap,
1271 };