fs/xfs/xfs_aops.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  * Copyright (c) 2000-2005 Silicon Graphics, Inc.
   4  * Copyright (c) 2016-2018 Christoph Hellwig.
   5  * All Rights Reserved.
   6  */
   7 #include "xfs.h"
   8 #include "xfs_shared.h"
   9 #include "xfs_format.h"
  10 #include "xfs_log_format.h"
  11 #include "xfs_trans_resv.h"
  12 #include "xfs_mount.h"
  13 #include "xfs_inode.h"
  14 #include "xfs_trans.h"
  15 #include "xfs_inode_item.h"
  16 #include "xfs_alloc.h"
  17 #include "xfs_error.h"
  18 #include "xfs_iomap.h"
  19 #include "xfs_trace.h"
  20 #include "xfs_bmap.h"
  21 #include "xfs_bmap_util.h"
  22 #include "xfs_bmap_btree.h"
  23 #include "xfs_reflink.h"
  24 #include <linux/writeback.h>
  25
  26 /*
  27  * structure owned by writepages passed to individual writepage calls
  28  */
  29 struct xfs_writepage_ctx {
  30         struct xfs_bmbt_irec    imap;
  31         int                     fork;
  32         unsigned int            data_seq;
  33         unsigned int            cow_seq;
  34         struct xfs_ioend        *ioend;
  35 };
  36
  37 struct block_device *
  38 xfs_find_bdev_for_inode(
  39         struct inode            *inode)
  40 {
  41         struct xfs_inode        *ip = XFS_I(inode);
  42         struct xfs_mount        *mp = ip->i_mount;
  43
  44         if (XFS_IS_REALTIME_INODE(ip))
  45                 return mp->m_rtdev_targp->bt_bdev;
  46         else
  47                 return mp->m_ddev_targp->bt_bdev;
  48 }
  49
  50 struct dax_device *
  51 xfs_find_daxdev_for_inode(
  52         struct inode            *inode)
  53 {
  54         struct xfs_inode        *ip = XFS_I(inode);
  55         struct xfs_mount        *mp = ip->i_mount;
  56
  57         if (XFS_IS_REALTIME_INODE(ip))
  58                 return mp->m_rtdev_targp->bt_daxdev;
  59         else
  60                 return mp->m_ddev_targp->bt_daxdev;
  61 }
  62
  63 static void
  64 xfs_finish_page_writeback(
  65         struct inode            *inode,
  66         struct bio_vec  *bvec,
  67         int                     error)
  68 {
  69         struct iomap_page       *iop = to_iomap_page(bvec->bv_page);
  70
  71         if (error) {
  72                 SetPageError(bvec->bv_page);
  73                 mapping_set_error(inode->i_mapping, -EIO);
  74         }
  75
  76         ASSERT(iop || i_blocksize(inode) == PAGE_SIZE);
  77         ASSERT(!iop || atomic_read(&iop->write_count) > 0);
  78
  79         if (!iop || atomic_dec_and_test(&iop->write_count))
  80                 end_page_writeback(bvec->bv_page);
  81 }
  82
  83 /*
  84  * We're now finished for good with this ioend structure.  Update the page
  85  * state, release holds on bios, and finally free up memory.  Do not use the
  86  * ioend after this.
  87  */
  88 STATIC void
  89 xfs_destroy_ioend(
  90         struct xfs_ioend        *ioend,
  91         int                     error)
  92 {
  93         struct inode            *inode = ioend->io_inode;
  94         struct bio              *bio = &ioend->io_inline_bio;
  95         struct bio              *last = ioend->io_bio, *next;
  96         u64                     start = bio->bi_iter.bi_sector;
  97         bool                    quiet = bio_flagged(bio, BIO_QUIET);
  98
  99         for (bio = &ioend->io_inline_bio; bio; bio = next) {
 100                 struct bio_vec  *bvec;
 101                 struct bvec_iter_all iter_all;
 102
 103                 /*
 104                  * For the last bio, bi_private points to the ioend, so we
 105                  * need to explicitly end the iteration here.
 106                  */
 107                 if (bio == last)
 108                         next = NULL;
 109                 else
 110                         next = bio->bi_private;
 111
 112                 /* walk each page on bio, ending page IO on them */
 113                 bio_for_each_segment_all(bvec, bio, iter_all)
 114                         xfs_finish_page_writeback(inode, bvec, error);
 115                 bio_put(bio);
 116         }
 117
 118         if (unlikely(error && !quiet)) {
 119                 xfs_err_ratelimited(XFS_I(inode)->i_mount,
 120                         "writeback error on sector %llu", start);
 121         }
 122 }
 123
 124 /*
 125  * Fast and loose check if this write could update the on-disk inode size.
 126  */
 127 static inline bool xfs_ioend_is_append(struct xfs_ioend *ioend)
 128 {
 129         return ioend->io_offset + ioend->io_size >
 130                 XFS_I(ioend->io_inode)->i_d.di_size;
 131 }
 132
 133 STATIC int
 134 xfs_setfilesize_trans_alloc(
 135         struct xfs_ioend        *ioend)
 136 {
 137         struct xfs_mount        *mp = XFS_I(ioend->io_inode)->i_mount;
 138         struct xfs_trans        *tp;
 139         int                     error;
 140
 141         error = xfs_trans_alloc(mp, &M_RES(mp)->tr_fsyncts, 0, 0,
 142                                 XFS_TRANS_NOFS, &tp);
 143         if (error)
 144                 return error;
 145
 146         ioend->io_append_trans = tp;
 147
 148         /*
 149          * We may pass freeze protection with a transaction.  So tell lockdep
 150          * we released it.
 151          */
 152         __sb_writers_release(ioend->io_inode->i_sb, SB_FREEZE_FS);
 153         /*
 154          * We hand off the transaction to the completion thread now, so
 155          * clear the flag here.
 156          */
 157         current_restore_flags_nested(&tp->t_pflags, PF_MEMALLOC_NOFS);
 158         return 0;
 159 }
 160
 161 /*
 162  * Update on-disk file size now that data has been written to disk.
 163  */
 164 STATIC int
 165 __xfs_setfilesize(
 166         struct xfs_inode        *ip,
 167         struct xfs_trans        *tp,
 168         xfs_off_t               offset,
 169         size_t                  size)
 170 {
 171         xfs_fsize_t             isize;
 172
 173         xfs_ilock(ip, XFS_ILOCK_EXCL);
 174         isize = xfs_new_eof(ip, offset + size);
 175         if (!isize) {
 176                 xfs_iunlock(ip, XFS_ILOCK_EXCL);
 177                 xfs_trans_cancel(tp);
 178                 return 0;
 179         }
 180
 181         trace_xfs_setfilesize(ip, offset, size);
 182
 183         ip->i_d.di_size = isize;
 184         xfs_trans_ijoin(tp, ip, XFS_ILOCK_EXCL);
 185         xfs_trans_log_inode(tp, ip, XFS_ILOG_CORE);
 186
 187         return xfs_trans_commit(tp);
 188 }
 189
 190 int
 191 xfs_setfilesize(
 192         struct xfs_inode        *ip,
 193         xfs_off_t               offset,
 194         size_t                  size)
 195 {
 196         struct xfs_mount        *mp = ip->i_mount;
 197         struct xfs_trans        *tp;
 198         int                     error;
 199
 200         error = xfs_trans_alloc(mp, &M_RES(mp)->tr_fsyncts, 0, 0, 0, &tp);
 201         if (error)
 202                 return error;
 203
 204         return __xfs_setfilesize(ip, tp, offset, size);
 205 }
 206
 207 STATIC int
 208 xfs_setfilesize_ioend(
 209         struct xfs_ioend        *ioend,
 210         int                     error)
 211 {
 212         struct xfs_inode        *ip = XFS_I(ioend->io_inode);
 213         struct xfs_trans        *tp = ioend->io_append_trans;
 214
 215         /*
 216          * The transaction may have been allocated in the I/O submission thread,
 217          * thus we need to mark ourselves as being in a transaction manually.
 218          * Similarly for freeze protection.
 219          */
 220         current_set_flags_nested(&tp->t_pflags, PF_MEMALLOC_NOFS);
 221         __sb_writers_acquired(VFS_I(ip)->i_sb, SB_FREEZE_FS);
 222
 223         /* we abort the update if there was an IO error */
 224         if (error) {
 225                 xfs_trans_cancel(tp);
 226                 return error;
 227         }
 228
 229         return __xfs_setfilesize(ip, tp, ioend->io_offset, ioend->io_size);
 230 }
 231
 232 /*
 233  * IO write completion.
 234  */
 235 STATIC void
 236 xfs_end_ioend(
 237         struct xfs_ioend        *ioend)
 238 {
 239         struct list_head        ioend_list;
 240         struct xfs_inode        *ip = XFS_I(ioend->io_inode);
 241         xfs_off_t               offset = ioend->io_offset;
 242         size_t                  size = ioend->io_size;
 243         int                     error;
 244
 245         /*
 246          * Just clean up the in-memory strutures if the fs has been shut down.
 247          */
 248         if (XFS_FORCED_SHUTDOWN(ip->i_mount)) {
 249                 error = -EIO;
 250                 goto done;
 251         }
 252
 253         /*
 254          * Clean up any COW blocks on an I/O error.
 255          */
 256         error = blk_status_to_errno(ioend->io_bio->bi_status);
 257         if (unlikely(error)) {
 258                 if (ioend->io_fork == XFS_COW_FORK)
 259                         xfs_reflink_cancel_cow_range(ip, offset, size, true);
 260                 goto done;
 261         }
 262
 263         /*
 264          * Success: commit the COW or unwritten blocks if needed.
 265          */
 266         if (ioend->io_fork == XFS_COW_FORK)
 267                 error = xfs_reflink_end_cow(ip, offset, size);
 268         else if (ioend->io_state == XFS_EXT_UNWRITTEN)
 269                 error = xfs_iomap_write_unwritten(ip, offset, size, false);
 270         else
 271                 ASSERT(!xfs_ioend_is_append(ioend) || ioend->io_append_trans);
 272
 273 done:
 274         if (ioend->io_append_trans)
 275                 error = xfs_setfilesize_ioend(ioend, error);
 276         list_replace_init(&ioend->io_list, &ioend_list);
 277         xfs_destroy_ioend(ioend, error);
 278
 279         while (!list_empty(&ioend_list)) {
 280                 ioend = list_first_entry(&ioend_list, struct xfs_ioend,
 281                                 io_list);
 282                 list_del_init(&ioend->io_list);
 283                 xfs_destroy_ioend(ioend, error);
 284         }
 285 }
 286
 287 /*
 288  * We can merge two adjacent ioends if they have the same set of work to do.
 289  */
 290 static bool
 291 xfs_ioend_can_merge(
 292         struct xfs_ioend        *ioend,
 293         int                     ioend_error,
 294         struct xfs_ioend        *next)
 295 {
 296         int                     next_error;
 297
 298         next_error = blk_status_to_errno(next->io_bio->bi_status);
 299         if (ioend_error != next_error)
 300                 return false;
 301         if ((ioend->io_fork == XFS_COW_FORK) ^ (next->io_fork == XFS_COW_FORK))
 302                 return false;
 303         if ((ioend->io_state == XFS_EXT_UNWRITTEN) ^
 304             (next->io_state == XFS_EXT_UNWRITTEN))
 305                 return false;
 306         if (ioend->io_offset + ioend->io_size != next->io_offset)
 307                 return false;
 308         if (xfs_ioend_is_append(ioend) != xfs_ioend_is_append(next))
 309                 return false;
 310         return true;
 311 }
 312
 313 /* Try to merge adjacent completions. */
 314 STATIC void
 315 xfs_ioend_try_merge(
 316         struct xfs_ioend        *ioend,
 317         struct list_head        *more_ioends)
 318 {
 319         struct xfs_ioend        *next_ioend;
 320         int                     ioend_error;
 321         int                     error;
 322
 323         if (list_empty(more_ioends))
 324                 return;
 325
 326         ioend_error = blk_status_to_errno(ioend->io_bio->bi_status);
 327
 328         while (!list_empty(more_ioends)) {
 329                 next_ioend = list_first_entry(more_ioends, struct xfs_ioend,
 330                                 io_list);
 331                 if (!xfs_ioend_can_merge(ioend, ioend_error, next_ioend))
 332                         break;
 333                 list_move_tail(&next_ioend->io_list, &ioend->io_list);
 334                 ioend->io_size += next_ioend->io_size;
 335                 if (ioend->io_append_trans) {
 336                         error = xfs_setfilesize_ioend(next_ioend, 1);
 337                         ASSERT(error == 1);
 338                 }
 339         }
 340 }
 341
 342 /* list_sort compare function for ioends */
 343 static int
 344 xfs_ioend_compare(
 345         void                    *priv,
 346         struct list_head        *a,
 347         struct list_head        *b)
 348 {
 349         struct xfs_ioend        *ia;
 350         struct xfs_ioend        *ib;
 351
 352         ia = container_of(a, struct xfs_ioend, io_list);
 353         ib = container_of(b, struct xfs_ioend, io_list);
 354         if (ia->io_offset < ib->io_offset)
 355                 return -1;
 356         else if (ia->io_offset > ib->io_offset)
 357                 return 1;
 358         return 0;
 359 }
 360
 361 /* Finish all pending io completions. */
 362 void
 363 xfs_end_io(
 364         struct work_struct      *work)
 365 {
 366         struct xfs_inode        *ip;
 367         struct xfs_ioend        *ioend;
 368         struct list_head        completion_list;
 369         unsigned long           flags;
 370
 371         ip = container_of(work, struct xfs_inode, i_ioend_work);
 372
 373         spin_lock_irqsave(&ip->i_ioend_lock, flags);
 374         list_replace_init(&ip->i_ioend_list, &completion_list);
 375         spin_unlock_irqrestore(&ip->i_ioend_lock, flags);
 376
 377         list_sort(NULL, &completion_list, xfs_ioend_compare);
 378
 379         while (!list_empty(&completion_list)) {
 380                 ioend = list_first_entry(&completion_list, struct xfs_ioend,
 381                                 io_list);
 382                 list_del_init(&ioend->io_list);
 383                 xfs_ioend_try_merge(ioend, &completion_list);
 384                 xfs_end_ioend(ioend);
 385         }
 386 }
 387
 388 STATIC void
 389 xfs_end_bio(
 390         struct bio              *bio)
 391 {
 392         struct xfs_ioend        *ioend = bio->bi_private;
 393         struct xfs_inode        *ip = XFS_I(ioend->io_inode);
 394         struct xfs_mount        *mp = ip->i_mount;
 395         unsigned long           flags;
 396
 397         if (ioend->io_fork == XFS_COW_FORK ||
 398             ioend->io_state == XFS_EXT_UNWRITTEN ||
 399             ioend->io_append_trans != NULL) {
 400                 spin_lock_irqsave(&ip->i_ioend_lock, flags);
 401                 if (list_empty(&ip->i_ioend_list))
 402                         WARN_ON_ONCE(!queue_work(mp->m_unwritten_workqueue,
 403                                                  &ip->i_ioend_work));
 404                 list_add_tail(&ioend->io_list, &ip->i_ioend_list);
 405                 spin_unlock_irqrestore(&ip->i_ioend_lock, flags);
 406         } else
 407                 xfs_destroy_ioend(ioend, blk_status_to_errno(bio->bi_status));
 408 }
 409
 410 /*
 411  * Fast revalidation of the cached writeback mapping. Return true if the current
 412  * mapping is valid, false otherwise.
 413  */
 414 static bool
 415 xfs_imap_valid(
 416         struct xfs_writepage_ctx        *wpc,
 417         struct xfs_inode                *ip,
 418         xfs_fileoff_t                   offset_fsb)
 419 {
 420         if (offset_fsb < wpc->imap.br_startoff ||
 421             offset_fsb >= wpc->imap.br_startoff + wpc->imap.br_blockcount)
 422                 return false;
 423         /*
 424          * If this is a COW mapping, it is sufficient to check that the mapping
 425          * covers the offset. Be careful to check this first because the caller
 426          * can revalidate a COW mapping without updating the data seqno.
 427          */
 428         if (wpc->fork == XFS_COW_FORK)
 429                 return true;
 430
 431         /*
 432          * This is not a COW mapping. Check the sequence number of the data fork
 433          * because concurrent changes could have invalidated the extent. Check
 434          * the COW fork because concurrent changes since the last time we
 435          * checked (and found nothing at this offset) could have added
 436          * overlapping blocks.
 437          */
 438         if (wpc->data_seq != READ_ONCE(ip->i_df.if_seq))
 439                 return false;
 440         if (xfs_inode_has_cow_data(ip) &&
 441             wpc->cow_seq != READ_ONCE(ip->i_cowfp->if_seq))
 442                 return false;
 443         return true;
 444 }
 445
 446 /*
 447  * Pass in a dellalloc extent and convert it to real extents, return the real
 448  * extent that maps offset_fsb in wpc->imap.
 449  *
 450  * The current page is held locked so nothing could have removed the block
 451  * backing offset_fsb, although it could have moved from the COW to the data
 452  * fork by another thread.
 453  */
 454 static int
 455 xfs_convert_blocks(
 456         struct xfs_writepage_ctx *wpc,
 457         struct xfs_inode        *ip,
 458         xfs_fileoff_t           offset_fsb)
 459 {
 460         int                     error;
 461
 462         /*
 463          * Attempt to allocate whatever delalloc extent currently backs
 464          * offset_fsb and put the result into wpc->imap.  Allocate in a loop
 465          * because it may take several attempts to allocate real blocks for a
 466          * contiguous delalloc extent if free space is sufficiently fragmented.
 467          */
 468         do {
 469                 error = xfs_bmapi_convert_delalloc(ip, wpc->fork, offset_fsb,
 470                                 &wpc->imap, wpc->fork == XFS_COW_FORK ?
 471                                         &wpc->cow_seq : &wpc->data_seq);
 472                 if (error)
 473                         return error;
 474         } while (wpc->imap.br_startoff + wpc->imap.br_blockcount <= offset_fsb);
 475
 476         return 0;
 477 }
 478
 479 STATIC int
 480 xfs_map_blocks(
 481         struct xfs_writepage_ctx *wpc,
 482         struct inode            *inode,
 483         loff_t                  offset)
 484 {
 485         struct xfs_inode        *ip = XFS_I(inode);
 486         struct xfs_mount        *mp = ip->i_mount;
 487         ssize_t                 count = i_blocksize(inode);
 488         xfs_fileoff_t           offset_fsb = XFS_B_TO_FSBT(mp, offset);
 489         xfs_fileoff_t           end_fsb = XFS_B_TO_FSB(mp, offset + count);
 490         xfs_fileoff_t           cow_fsb = NULLFILEOFF;
 491         struct xfs_bmbt_irec    imap;
 492         struct xfs_iext_cursor  icur;
 493         int                     retries = 0;
 494         int                     error = 0;
 495
 496         if (XFS_FORCED_SHUTDOWN(mp))
 497                 return -EIO;
 498
 499         /*
 500          * COW fork blocks can overlap data fork blocks even if the blocks
 501          * aren't shared.  COW I/O always takes precedent, so we must always
 502          * check for overlap on reflink inodes unless the mapping is already a
 503          * COW one, or the COW fork hasn't changed from the last time we looked
 504          * at it.
 505          *
 506          * It's safe to check the COW fork if_seq here without the ILOCK because
 507          * we've indirectly protected against concurrent updates: writeback has
 508          * the page locked, which prevents concurrent invalidations by reflink
 509          * and directio and prevents concurrent buffered writes to the same
 510          * page.  Changes to if_seq always happen under i_lock, which protects
 511          * against concurrent updates and provides a memory barrier on the way
 512          * out that ensures that we always see the current value.
 513          */
 514         if (xfs_imap_valid(wpc, ip, offset_fsb))
 515                 return 0;
 516
 517         /*
 518          * If we don't have a valid map, now it's time to get a new one for this
 519          * offset.  This will convert delayed allocations (including COW ones)
 520          * into real extents.  If we return without a valid map, it means we
 521          * landed in a hole and we skip the block.
 522          */
 523 retry:
 524         xfs_ilock(ip, XFS_ILOCK_SHARED);
 525         ASSERT(ip->i_d.di_format != XFS_DINODE_FMT_BTREE ||
 526                (ip->i_df.if_flags & XFS_IFEXTENTS));
 527
 528         /*
 529          * Check if this is offset is covered by a COW extents, and if yes use
 530          * it directly instead of looking up anything in the data fork.
 531          */
 532         if (xfs_inode_has_cow_data(ip) &&
 533             xfs_iext_lookup_extent(ip, ip->i_cowfp, offset_fsb, &icur, &imap))
 534                 cow_fsb = imap.br_startoff;
 535         if (cow_fsb != NULLFILEOFF && cow_fsb <= offset_fsb) {
 536                 wpc->cow_seq = READ_ONCE(ip->i_cowfp->if_seq);
 537                 xfs_iunlock(ip, XFS_ILOCK_SHARED);
 538
 539                 wpc->fork = XFS_COW_FORK;
 540                 goto allocate_blocks;
 541         }
 542
 543         /*
 544          * No COW extent overlap. Revalidate now that we may have updated
 545          * ->cow_seq. If the data mapping is still valid, we're done.
 546          */
 547         if (xfs_imap_valid(wpc, ip, offset_fsb)) {
 548                 xfs_iunlock(ip, XFS_ILOCK_SHARED);
 549                 return 0;
 550         }
 551
 552         /*
 553          * If we don't have a valid map, now it's time to get a new one for this
 554          * offset.  This will convert delayed allocations (including COW ones)
 555          * into real extents.
 556          */
 557         if (!xfs_iext_lookup_extent(ip, &ip->i_df, offset_fsb, &icur, &imap))
 558                 imap.br_startoff = end_fsb;     /* fake a hole past EOF */
 559         wpc->data_seq = READ_ONCE(ip->i_df.if_seq);
 560         xfs_iunlock(ip, XFS_ILOCK_SHARED);
 561
 562         wpc->fork = XFS_DATA_FORK;
 563
 564         /* landed in a hole or beyond EOF? */
 565         if (imap.br_startoff > offset_fsb) {
 566                 imap.br_blockcount = imap.br_startoff - offset_fsb;
 567                 imap.br_startoff = offset_fsb;
 568                 imap.br_startblock = HOLESTARTBLOCK;
 569                 imap.br_state = XFS_EXT_NORM;
 570         }
 571
 572         /*
 573          * Truncate to the next COW extent if there is one.  This is the only
 574          * opportunity to do this because we can skip COW fork lookups for the
 575          * subsequent blocks in the mapping; however, the requirement to treat
 576          * the COW range separately remains.
 577          */
 578         if (cow_fsb != NULLFILEOFF &&
 579             cow_fsb < imap.br_startoff + imap.br_blockcount)
 580                 imap.br_blockcount = cow_fsb - imap.br_startoff;
 581
 582         /* got a delalloc extent? */
 583         if (imap.br_startblock != HOLESTARTBLOCK &&
 584             isnullstartblock(imap.br_startblock))
 585                 goto allocate_blocks;
 586
 587         wpc->imap = imap;
 588         trace_xfs_map_blocks_found(ip, offset, count, wpc->fork, &imap);
 589         return 0;
 590 allocate_blocks:
 591         error = xfs_convert_blocks(wpc, ip, offset_fsb);
 592         if (error) {
 593                 /*
 594                  * If we failed to find the extent in the COW fork we might have
 595                  * raced with a COW to data fork conversion or truncate.
 596                  * Restart the lookup to catch the extent in the data fork for
 597                  * the former case, but prevent additional retries to avoid
 598                  * looping forever for the latter case.
 599                  */
 600                 if (error == -EAGAIN && wpc->fork == XFS_COW_FORK && !retries++)
 601                         goto retry;
 602                 ASSERT(error != -EAGAIN);
 603                 return error;
 604         }
 605
 606         /*
 607          * Due to merging the return real extent might be larger than the
 608          * original delalloc one.  Trim the return extent to the next COW
 609          * boundary again to force a re-lookup.
 610          */
 611         if (wpc->fork != XFS_COW_FORK && cow_fsb != NULLFILEOFF &&
 612             cow_fsb < wpc->imap.br_startoff + wpc->imap.br_blockcount)
 613                 wpc->imap.br_blockcount = cow_fsb - wpc->imap.br_startoff;
 614
 615         ASSERT(wpc->imap.br_startoff <= offset_fsb);
 616         ASSERT(wpc->imap.br_startoff + wpc->imap.br_blockcount > offset_fsb);
 617         trace_xfs_map_blocks_alloc(ip, offset, count, wpc->fork, &imap);
 618         return 0;
 619 }
 620
 621 /*
 622  * Submit the bio for an ioend. We are passed an ioend with a bio attached to
 623  * it, and we submit that bio. The ioend may be used for multiple bio
 624  * submissions, so we only want to allocate an append transaction for the ioend
 625  * once. In the case of multiple bio submission, each bio will take an IO
 626  * reference to the ioend to ensure that the ioend completion is only done once
 627  * all bios have been submitted and the ioend is really done.
 628  *
 629  * If @fail is non-zero, it means that we have a situation where some part of
 630  * the submission process has failed after we have marked paged for writeback
 631  * and unlocked them. In this situation, we need to fail the bio and ioend
 632  * rather than submit it to IO. This typically only happens on a filesystem
 633  * shutdown.
 634  */
 635 STATIC int
 636 xfs_submit_ioend(
 637         struct writeback_control *wbc,
 638         struct xfs_ioend        *ioend,
 639         int                     status)
 640 {
 641         /* Convert CoW extents to regular */
 642         if (!status && ioend->io_fork == XFS_COW_FORK) {
 643                 /*
 644                  * Yuk. This can do memory allocation, but is not a
 645                  * transactional operation so everything is done in GFP_KERNEL
 646                  * context. That can deadlock, because we hold pages in
 647                  * writeback state and GFP_KERNEL allocations can block on them.
 648                  * Hence we must operate in nofs conditions here.
 649                  */
 650                 unsigned nofs_flag;
 651
 652                 nofs_flag = memalloc_nofs_save();
 653                 status = xfs_reflink_convert_cow(XFS_I(ioend->io_inode),
 654                                 ioend->io_offset, ioend->io_size);
 655                 memalloc_nofs_restore(nofs_flag);
 656         }
 657
 658         /* Reserve log space if we might write beyond the on-disk inode size. */
 659         if (!status &&
 660             (ioend->io_fork == XFS_COW_FORK ||
 661              ioend->io_state != XFS_EXT_UNWRITTEN) &&
 662             xfs_ioend_is_append(ioend) &&
 663             !ioend->io_append_trans)
 664                 status = xfs_setfilesize_trans_alloc(ioend);
 665
 666         ioend->io_bio->bi_private = ioend;
 667         ioend->io_bio->bi_end_io = xfs_end_bio;
 668         ioend->io_bio->bi_opf = REQ_OP_WRITE | wbc_to_write_flags(wbc);
 669
 670         /*
 671          * If we are failing the IO now, just mark the ioend with an
 672          * error and finish it. This will run IO completion immediately
 673          * as there is only one reference to the ioend at this point in
 674          * time.
 675          */
 676         if (status) {
 677                 ioend->io_bio->bi_status = errno_to_blk_status(status);
 678                 bio_endio(ioend->io_bio);
 679                 return status;
 680         }
 681
 682         ioend->io_bio->bi_write_hint = ioend->io_inode->i_write_hint;
 683         submit_bio(ioend->io_bio);
 684         return 0;
 685 }
 686
 687 static struct xfs_ioend *
 688 xfs_alloc_ioend(
 689         struct inode            *inode,
 690         int                     fork,
 691         xfs_exntst_t            state,
 692         xfs_off_t               offset,
 693         struct block_device     *bdev,
 694         sector_t                sector)
 695 {
 696         struct xfs_ioend        *ioend;
 697         struct bio              *bio;
 698
 699         bio = bio_alloc_bioset(GFP_NOFS, BIO_MAX_PAGES, &xfs_ioend_bioset);
 700         bio_set_dev(bio, bdev);
 701         bio->bi_iter.bi_sector = sector;
 702
 703         ioend = container_of(bio, struct xfs_ioend, io_inline_bio);
 704         INIT_LIST_HEAD(&ioend->io_list);
 705         ioend->io_fork = fork;
 706         ioend->io_state = state;
 707         ioend->io_inode = inode;
 708         ioend->io_size = 0;
 709         ioend->io_offset = offset;
 710         ioend->io_append_trans = NULL;
 711         ioend->io_bio = bio;
 712         return ioend;
 713 }
 714
 715 /*
 716  * Allocate a new bio, and chain the old bio to the new one.
 717  *
 718  * Note that we have to do perform the chaining in this unintuitive order
 719  * so that the bi_private linkage is set up in the right direction for the
 720  * traversal in xfs_destroy_ioend().
 721  */
 722 static void
 723 xfs_chain_bio(
 724         struct xfs_ioend        *ioend,
 725         struct writeback_control *wbc,
 726         struct block_device     *bdev,
 727         sector_t                sector)
 728 {
 729         struct bio *new;
 730
 731         new = bio_alloc(GFP_NOFS, BIO_MAX_PAGES);
 732         bio_set_dev(new, bdev);
 733         new->bi_iter.bi_sector = sector;
 734         bio_chain(ioend->io_bio, new);
 735         bio_get(ioend->io_bio);         /* for xfs_destroy_ioend */
 736         ioend->io_bio->bi_opf = REQ_OP_WRITE | wbc_to_write_flags(wbc);
 737         ioend->io_bio->bi_write_hint = ioend->io_inode->i_write_hint;
 738         submit_bio(ioend->io_bio);
 739         ioend->io_bio = new;
 740 }
 741
 742 /*
 743  * Test to see if we have an existing ioend structure that we could append to
 744  * first, otherwise finish off the current ioend and start another.
 745  */
 746 STATIC void
 747 xfs_add_to_ioend(
 748         struct inode            *inode,
 749         xfs_off_t               offset,
 750         struct page             *page,
 751         struct iomap_page       *iop,
 752         struct xfs_writepage_ctx *wpc,
 753         struct writeback_control *wbc,
 754         struct list_head        *iolist)
 755 {
 756         struct xfs_inode        *ip = XFS_I(inode);
 757         struct xfs_mount        *mp = ip->i_mount;
 758         struct block_device     *bdev = xfs_find_bdev_for_inode(inode);
 759         unsigned                len = i_blocksize(inode);
 760         unsigned                poff = offset & (PAGE_SIZE - 1);
 761         bool                    merged, same_page = false;
 762         sector_t                sector;
 763
 764         sector = xfs_fsb_to_db(ip, wpc->imap.br_startblock) +
 765                 ((offset - XFS_FSB_TO_B(mp, wpc->imap.br_startoff)) >> 9);
 766
 767         if (!wpc->ioend ||
 768             wpc->fork != wpc->ioend->io_fork ||
 769             wpc->imap.br_state != wpc->ioend->io_state ||
 770             sector != bio_end_sector(wpc->ioend->io_bio) ||
 771             offset != wpc->ioend->io_offset + wpc->ioend->io_size) {
 772                 if (wpc->ioend)
 773                         list_add(&wpc->ioend->io_list, iolist);
 774                 wpc->ioend = xfs_alloc_ioend(inode, wpc->fork,
 775                                 wpc->imap.br_state, offset, bdev, sector);
 776         }
 777
 778         merged = __bio_try_merge_page(wpc->ioend->io_bio, page, len, poff,
 779                         &same_page);
 780
 781         if (iop && !same_page)
 782                 atomic_inc(&iop->write_count);
 783
 784         if (!merged) {
 785                 if (bio_full(wpc->ioend->io_bio, len))
 786                         xfs_chain_bio(wpc->ioend, wbc, bdev, sector);
 787                 bio_add_page(wpc->ioend->io_bio, page, len, poff);
 788         }
 789
 790         wpc->ioend->io_size += len;
 791 }
 792
 793 STATIC void
 794 xfs_vm_invalidatepage(
 795         struct page             *page,
 796         unsigned int            offset,
 797         unsigned int            length)
 798 {
 799         trace_xfs_invalidatepage(page->mapping->host, page, offset, length);
 800         iomap_invalidatepage(page, offset, length);
 801 }
 802
 803 /*
 804  * If the page has delalloc blocks on it, we need to punch them out before we
 805  * invalidate the page.  If we don't, we leave a stale delalloc mapping on the
 806  * inode that can trip up a later direct I/O read operation on the same region.
 807  *
 808  * We prevent this by truncating away the delalloc regions on the page.  Because
 809  * they are delalloc, we can do this without needing a transaction. Indeed - if
 810  * we get ENOSPC errors, we have to be able to do this truncation without a
 811  * transaction as there is no space left for block reservation (typically why we
 812  * see a ENOSPC in writeback).
 813  */
 814 STATIC void
 815 xfs_aops_discard_page(
 816         struct page             *page)
 817 {
 818         struct inode            *inode = page->mapping->host;
 819         struct xfs_inode        *ip = XFS_I(inode);
 820         struct xfs_mount        *mp = ip->i_mount;
 821         loff_t                  offset = page_offset(page);
 822         xfs_fileoff_t           start_fsb = XFS_B_TO_FSBT(mp, offset);
 823         int                     error;
 824
 825         if (XFS_FORCED_SHUTDOWN(mp))
 826                 goto out_invalidate;
 827
 828         xfs_alert(mp,
 829                 "page discard on page "PTR_FMT", inode 0x%llx, offset %llu.",
 830                         page, ip->i_ino, offset);
 831
 832         error = xfs_bmap_punch_delalloc_range(ip, start_fsb,
 833                         PAGE_SIZE / i_blocksize(inode));
 834         if (error && !XFS_FORCED_SHUTDOWN(mp))
 835                 xfs_alert(mp, "page discard unable to remove delalloc mapping.");
 836 out_invalidate:
 837         xfs_vm_invalidatepage(page, 0, PAGE_SIZE);
 838 }
 839
 840 /*
 841  * We implement an immediate ioend submission policy here to avoid needing to
 842  * chain multiple ioends and hence nest mempool allocations which can violate
 843  * forward progress guarantees we need to provide. The current ioend we are
 844  * adding blocks to is cached on the writepage context, and if the new block
 845  * does not append to the cached ioend it will create a new ioend and cache that
 846  * instead.
 847  *
 848  * If a new ioend is created and cached, the old ioend is returned and queued
 849  * locally for submission once the entire page is processed or an error has been
 850  * detected.  While ioends are submitted immediately after they are completed,
 851  * batching optimisations are provided by higher level block plugging.
 852  *
 853  * At the end of a writeback pass, there will be a cached ioend remaining on the
 854  * writepage context that the caller will need to submit.
 855  */
 856 static int
 857 xfs_writepage_map(
 858         struct xfs_writepage_ctx *wpc,
 859         struct writeback_control *wbc,
 860         struct inode            *inode,
 861         struct page             *page,
 862         uint64_t                end_offset)
 863 {
 864         LIST_HEAD(submit_list);
 865         struct iomap_page       *iop = to_iomap_page(page);
 866         unsigned                len = i_blocksize(inode);
 867         struct xfs_ioend        *ioend, *next;
 868         uint64_t                file_offset;    /* file offset of page */
 869         int                     error = 0, count = 0, i;
 870
 871         ASSERT(iop || i_blocksize(inode) == PAGE_SIZE);
 872         ASSERT(!iop || atomic_read(&iop->write_count) == 0);
 873
 874         /*
 875          * Walk through the page to find areas to write back. If we run off the
 876          * end of the current map or find the current map invalid, grab a new
 877          * one.
 878          */
 879         for (i = 0, file_offset = page_offset(page);
 880              i < (PAGE_SIZE >> inode->i_blkbits) && file_offset < end_offset;
 881              i++, file_offset += len) {
 882                 if (iop && !test_bit(i, iop->uptodate))
 883                         continue;
 884
 885                 error = xfs_map_blocks(wpc, inode, file_offset);
 886                 if (error)
 887                         break;
 888                 if (wpc->imap.br_startblock == HOLESTARTBLOCK)
 889                         continue;
 890                 xfs_add_to_ioend(inode, file_offset, page, iop, wpc, wbc,
 891                                  &submit_list);
 892                 count++;
 893         }
 894
 895         ASSERT(wpc->ioend || list_empty(&submit_list));
 896         ASSERT(PageLocked(page));
 897         ASSERT(!PageWriteback(page));
 898
 899         /*
 900          * On error, we have to fail the ioend here because we may have set
 901          * pages under writeback, we have to make sure we run IO completion to
 902          * mark the error state of the IO appropriately, so we can't cancel the
 903          * ioend directly here.  That means we have to mark this page as under
 904          * writeback if we included any blocks from it in the ioend chain so
 905          * that completion treats it correctly.
 906          *
 907          * If we didn't include the page in the ioend, the on error we can
 908          * simply discard and unlock it as there are no other users of the page
 909          * now.  The caller will still need to trigger submission of outstanding
 910          * ioends on the writepage context so they are treated correctly on
 911          * error.
 912          */
 913         if (unlikely(error)) {
 914                 if (!count) {
 915                         xfs_aops_discard_page(page);
 916                         ClearPageUptodate(page);
 917                         unlock_page(page);
 918                         goto done;
 919                 }
 920
 921                 /*
 922                  * If the page was not fully cleaned, we need to ensure that the
 923                  * higher layers come back to it correctly.  That means we need
 924                  * to keep the page dirty, and for WB_SYNC_ALL writeback we need
 925                  * to ensure the PAGECACHE_TAG_TOWRITE index mark is not removed
 926                  * so another attempt to write this page in this writeback sweep
 927                  * will be made.
 928                  */
 929                 set_page_writeback_keepwrite(page);
 930         } else {
 931                 clear_page_dirty_for_io(page);
 932                 set_page_writeback(page);
 933         }
 934
 935         unlock_page(page);
 936
 937         /*
 938          * Preserve the original error if there was one, otherwise catch
 939          * submission errors here and propagate into subsequent ioend
 940          * submissions.
 941          */
 942         list_for_each_entry_safe(ioend, next, &submit_list, io_list) {
 943                 int error2;
 944
 945                 list_del_init(&ioend->io_list);
 946                 error2 = xfs_submit_ioend(wbc, ioend, error);
 947                 if (error2 && !error)
 948                         error = error2;
 949         }
 950
 951         /*
 952          * We can end up here with no error and nothing to write only if we race
 953          * with a partial page truncate on a sub-page block sized filesystem.
 954          */
 955         if (!count)
 956                 end_page_writeback(page);
 957 done:
 958         mapping_set_error(page->mapping, error);
 959         return error;
 960 }
 961
 962 /*
 963  * Write out a dirty page.
 964  *
 965  * For delalloc space on the page we need to allocate space and flush it.
 966  * For unwritten space on the page we need to start the conversion to
 967  * regular allocated space.
 968  */
 969 STATIC int
 970 xfs_do_writepage(
 971         struct page             *page,
 972         struct writeback_control *wbc,
 973         void                    *data)
 974 {
 975         struct xfs_writepage_ctx *wpc = data;
 976         struct inode            *inode = page->mapping->host;
 977         loff_t                  offset;
 978         uint64_t              end_offset;
 979         pgoff_t                 end_index;
 980
 981         trace_xfs_writepage(inode, page, 0, 0);
 982
 983         /*
 984          * Refuse to write the page out if we are called from reclaim context.
 985          *
 986          * This avoids stack overflows when called from deeply used stacks in
 987          * random callers for direct reclaim or memcg reclaim.  We explicitly
 988          * allow reclaim from kswapd as the stack usage there is relatively low.
 989          *
 990          * This should never happen except in the case of a VM regression so
 991          * warn about it.
 992          */
 993         if (WARN_ON_ONCE((current->flags & (PF_MEMALLOC|PF_KSWAPD)) ==
 994                         PF_MEMALLOC))
 995                 goto redirty;
 996
 997         /*
 998          * Given that we do not allow direct reclaim to call us, we should
 999          * never be called while in a filesystem transaction.
1000          */
1001         if (WARN_ON_ONCE(current->flags & PF_MEMALLOC_NOFS))
1002                 goto redirty;
1003
1004         /*
1005          * Is this page beyond the end of the file?
1006          *
1007          * The page index is less than the end_index, adjust the end_offset
1008          * to the highest offset that this page should represent.
1009          * -----------------------------------------------------
1010          * |                    file mapping           | <EOF> |
1011          * -----------------------------------------------------
1012          * | Page ... | Page N-2 | Page N-1 |  Page N  |       |
1013          * ^--------------------------------^----------|--------
1014          * |     desired writeback range    |      see else    |
1015          * ---------------------------------^------------------|
1016          */
1017         offset = i_size_read(inode);
1018         end_index = offset >> PAGE_SHIFT;
1019         if (page->index < end_index)
1020                 end_offset = (xfs_off_t)(page->index + 1) << PAGE_SHIFT;
1021         else {
1022                 /*
1023                  * Check whether the page to write out is beyond or straddles
1024                  * i_size or not.
1025                  * -------------------------------------------------------
1026                  * |            file mapping                    | <EOF>  |
1027                  * -------------------------------------------------------
1028                  * | Page ... | Page N-2 | Page N-1 |  Page N   | Beyond |
1029                  * ^--------------------------------^-----------|---------
1030                  * |                                |      Straddles     |
1031                  * ---------------------------------^-----------|--------|
1032                  */
1033                 unsigned offset_into_page = offset & (PAGE_SIZE - 1);
1034
1035                 /*
1036                  * Skip the page if it is fully outside i_size, e.g. due to a
1037                  * truncate operation that is in progress. We must redirty the
1038                  * page so that reclaim stops reclaiming it. Otherwise
1039                  * xfs_vm_releasepage() is called on it and gets confused.
1040                  *
1041                  * Note that the end_index is unsigned long, it would overflow
1042                  * if the given offset is greater than 16TB on 32-bit system
1043                  * and if we do check the page is fully outside i_size or not
1044                  * via "if (page->index >= end_index + 1)" as "end_index + 1"
1045                  * will be evaluated to 0.  Hence this page will be redirtied
1046                  * and be written out repeatedly which would result in an
1047                  * infinite loop, the user program that perform this operation
1048                  * will hang.  Instead, we can verify this situation by checking
1049                  * if the page to write is totally beyond the i_size or if it's
1050                  * offset is just equal to the EOF.
1051                  */
1052                 if (page->index > end_index ||
1053                     (page->index == end_index && offset_into_page == 0))
1054                         goto redirty;
1055
1056                 /*
1057                  * The page straddles i_size.  It must be zeroed out on each
1058                  * and every writepage invocation because it may be mmapped.
1059                  * "A file is mapped in multiples of the page size.  For a file
1060                  * that is not a multiple of the page size, the remaining
1061                  * memory is zeroed when mapped, and writes to that region are
1062                  * not written out to the file."
1063                  */
1064                 zero_user_segment(page, offset_into_page, PAGE_SIZE);
1065
1066                 /* Adjust the end_offset to the end of file */
1067                 end_offset = offset;
1068         }
1069
1070         return xfs_writepage_map(wpc, wbc, inode, page, end_offset);
1071
1072 redirty:
1073         redirty_page_for_writepage(wbc, page);
1074         unlock_page(page);
1075         return 0;
1076 }
1077
1078 STATIC int
1079 xfs_vm_writepage(
1080         struct page             *page,
1081         struct writeback_control *wbc)
1082 {
1083         struct xfs_writepage_ctx wpc = { };
1084         int                     ret;
1085
1086         ret = xfs_do_writepage(page, wbc, &wpc);
1087         if (wpc.ioend)
1088                 ret = xfs_submit_ioend(wbc, wpc.ioend, ret);
1089         return ret;
1090 }
1091
1092 STATIC int
1093 xfs_vm_writepages(
1094         struct address_space    *mapping,
1095         struct writeback_control *wbc)
1096 {
1097         struct xfs_writepage_ctx wpc = { };
1098         int                     ret;
1099
1100         xfs_iflags_clear(XFS_I(mapping->host), XFS_ITRUNCATED);
1101         ret = write_cache_pages(mapping, wbc, xfs_do_writepage, &wpc);
1102         if (wpc.ioend)
1103                 ret = xfs_submit_ioend(wbc, wpc.ioend, ret);
1104         return ret;
1105 }
1106
1107 STATIC int
1108 xfs_dax_writepages(
1109         struct address_space    *mapping,
1110         struct writeback_control *wbc)
1111 {
1112         xfs_iflags_clear(XFS_I(mapping->host), XFS_ITRUNCATED);
1113         return dax_writeback_mapping_range(mapping,
1114                         xfs_find_bdev_for_inode(mapping->host), wbc);
1115 }
1116
1117 STATIC int
1118 xfs_vm_releasepage(
1119         struct page             *page,
1120         gfp_t                   gfp_mask)
1121 {
1122         trace_xfs_releasepage(page->mapping->host, page, 0, 0);
1123         return iomap_releasepage(page, gfp_mask);
1124 }
1125
1126 STATIC sector_t
1127 xfs_vm_bmap(
1128         struct address_space    *mapping,
1129         sector_t                block)
1130 {
1131         struct xfs_inode        *ip = XFS_I(mapping->host);
1132
1133         trace_xfs_vm_bmap(ip);
1134
1135         /*
1136          * The swap code (ab-)uses ->bmap to get a block mapping and then
1137          * bypasses the file system for actual I/O.  We really can't allow
1138          * that on reflinks inodes, so we have to skip out here.  And yes,
1139          * 0 is the magic code for a bmap error.
1140          *
1141          * Since we don't pass back blockdev info, we can't return bmap
1142          * information for rt files either.
1143          */
1144         if (xfs_is_cow_inode(ip) || XFS_IS_REALTIME_INODE(ip))
1145                 return 0;
1146         return iomap_bmap(mapping, block, &xfs_iomap_ops);
1147 }
1148
1149 STATIC int
1150 xfs_vm_readpage(
1151         struct file             *unused,
1152         struct page             *page)
1153 {
1154         trace_xfs_vm_readpage(page->mapping->host, 1);
1155         return iomap_readpage(page, &xfs_iomap_ops);
1156 }
1157
1158 STATIC int
1159 xfs_vm_readpages(
1160         struct file             *unused,
1161         struct address_space    *mapping,
1162         struct list_head        *pages,
1163         unsigned                nr_pages)
1164 {
1165         trace_xfs_vm_readpages(mapping->host, nr_pages);
1166         return iomap_readpages(mapping, pages, nr_pages, &xfs_iomap_ops);
1167 }
1168
1169 static int
1170 xfs_iomap_swapfile_activate(
1171         struct swap_info_struct         *sis,
1172         struct file                     *swap_file,
1173         sector_t                        *span)
1174 {
1175         sis->bdev = xfs_find_bdev_for_inode(file_inode(swap_file));
1176         return iomap_swapfile_activate(sis, swap_file, span, &xfs_iomap_ops);
1177 }
1178
1179 const struct address_space_operations xfs_address_space_operations = {
1180         .readpage               = xfs_vm_readpage,
1181         .readpages              = xfs_vm_readpages,
1182         .writepage              = xfs_vm_writepage,
1183         .writepages             = xfs_vm_writepages,
1184         .set_page_dirty         = iomap_set_page_dirty,
1185         .releasepage            = xfs_vm_releasepage,
1186         .invalidatepage         = xfs_vm_invalidatepage,
1187         .bmap                   = xfs_vm_bmap,
1188         .direct_IO              = noop_direct_IO,
1189         .migratepage            = iomap_migrate_page,
1190         .is_partially_uptodate  = iomap_is_partially_uptodate,
1191         .error_remove_page      = generic_error_remove_page,
1192         .swap_activate          = xfs_iomap_swapfile_activate,
1193 };
1194
1195 const struct address_space_operations xfs_dax_aops = {
1196         .writepages             = xfs_dax_writepages,
1197         .direct_IO              = noop_direct_IO,
1198         .set_page_dirty         = noop_set_page_dirty,
1199         .invalidatepage         = noop_invalidatepage,
1200         .swap_activate          = xfs_iomap_swapfile_activate,
1201 };