fs/xfs/xfs_aops.c

   1 /*
   2  * Copyright (c) 2000-2005 Silicon Graphics, Inc.
   3  * All Rights Reserved.
   4  *
   5  * This program is free software; you can redistribute it and/or
   6  * modify it under the terms of the GNU General Public License as
   7  * published by the Free Software Foundation.
   8  *
   9  * This program is distributed in the hope that it would be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12  * GNU General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU General Public License
  15  * along with this program; if not, write the Free Software Foundation,
  16  * Inc.,  51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  17  */
  18 #include "xfs.h"
  19 #include "xfs_shared.h"
  20 #include "xfs_format.h"
  21 #include "xfs_log_format.h"
  22 #include "xfs_trans_resv.h"
  23 #include "xfs_mount.h"
  24 #include "xfs_inode.h"
  25 #include "xfs_trans.h"
  26 #include "xfs_inode_item.h"
  27 #include "xfs_alloc.h"
  28 #include "xfs_error.h"
  29 #include "xfs_iomap.h"
  30 #include "xfs_trace.h"
  31 #include "xfs_bmap.h"
  32 #include "xfs_bmap_util.h"
  33 #include "xfs_bmap_btree.h"
  34 #include <linux/gfp.h>
  35 #include <linux/mpage.h>
  36 #include <linux/pagevec.h>
  37 #include <linux/writeback.h>
  38
  39 void
  40 xfs_count_page_state(
  41         struct page             *page,
  42         int                     *delalloc,
  43         int                     *unwritten)
  44 {
  45         struct buffer_head      *bh, *head;
  46
  47         *delalloc = *unwritten = 0;
  48
  49         bh = head = page_buffers(page);
  50         do {
  51                 if (buffer_unwritten(bh))
  52                         (*unwritten) = 1;
  53                 else if (buffer_delay(bh))
  54                         (*delalloc) = 1;
  55         } while ((bh = bh->b_this_page) != head);
  56 }
  57
  58 STATIC struct block_device *
  59 xfs_find_bdev_for_inode(
  60         struct inode            *inode)
  61 {
  62         struct xfs_inode        *ip = XFS_I(inode);
  63         struct xfs_mount        *mp = ip->i_mount;
  64
  65         if (XFS_IS_REALTIME_INODE(ip))
  66                 return mp->m_rtdev_targp->bt_bdev;
  67         else
  68                 return mp->m_ddev_targp->bt_bdev;
  69 }
  70
  71 /*
  72  * We're now finished for good with this ioend structure.
  73  * Update the page state via the associated buffer_heads,
  74  * release holds on the inode and bio, and finally free
  75  * up memory.  Do not use the ioend after this.
  76  */
  77 STATIC void
  78 xfs_destroy_ioend(
  79         xfs_ioend_t             *ioend)
  80 {
  81         struct buffer_head      *bh, *next;
  82
  83         for (bh = ioend->io_buffer_head; bh; bh = next) {
  84                 next = bh->b_private;
  85                 bh->b_end_io(bh, !ioend->io_error);
  86         }
  87
  88         mempool_free(ioend, xfs_ioend_pool);
  89 }
  90
  91 /*
  92  * Fast and loose check if this write could update the on-disk inode size.
  93  */
  94 static inline bool xfs_ioend_is_append(struct xfs_ioend *ioend)
  95 {
  96         return ioend->io_offset + ioend->io_size >
  97                 XFS_I(ioend->io_inode)->i_d.di_size;
  98 }
  99
 100 STATIC int
 101 xfs_setfilesize_trans_alloc(
 102         struct xfs_ioend        *ioend)
 103 {
 104         struct xfs_mount        *mp = XFS_I(ioend->io_inode)->i_mount;
 105         struct xfs_trans        *tp;
 106         int                     error;
 107
 108         tp = xfs_trans_alloc(mp, XFS_TRANS_FSYNC_TS);
 109
 110         error = xfs_trans_reserve(tp, &M_RES(mp)->tr_fsyncts, 0, 0);
 111         if (error) {
 112                 xfs_trans_cancel(tp, 0);
 113                 return error;
 114         }
 115
 116         ioend->io_append_trans = tp;
 117
 118         /*
 119          * We may pass freeze protection with a transaction.  So tell lockdep
 120          * we released it.
 121          */
 122         rwsem_release(&ioend->io_inode->i_sb->s_writers.lock_map[SB_FREEZE_FS-1],
 123                       1, _THIS_IP_);
 124         /*
 125          * We hand off the transaction to the completion thread now, so
 126          * clear the flag here.
 127          */
 128         current_restore_flags_nested(&tp->t_pflags, PF_FSTRANS);
 129         return 0;
 130 }
 131
 132 /*
 133  * Update on-disk file size now that data has been written to disk.
 134  */
 135 STATIC int
 136 xfs_setfilesize(
 137         struct xfs_inode        *ip,
 138         struct xfs_trans        *tp,
 139         xfs_off_t               offset,
 140         size_t                  size)
 141 {
 142         xfs_fsize_t             isize;
 143
 144         xfs_ilock(ip, XFS_ILOCK_EXCL);
 145         isize = xfs_new_eof(ip, offset + size);
 146         if (!isize) {
 147                 xfs_iunlock(ip, XFS_ILOCK_EXCL);
 148                 xfs_trans_cancel(tp, 0);
 149                 return 0;
 150         }
 151
 152         trace_xfs_setfilesize(ip, offset, size);
 153
 154         ip->i_d.di_size = isize;
 155         xfs_trans_ijoin(tp, ip, XFS_ILOCK_EXCL);
 156         xfs_trans_log_inode(tp, ip, XFS_ILOG_CORE);
 157
 158         return xfs_trans_commit(tp, 0);
 159 }
 160
 161 STATIC int
 162 xfs_setfilesize_ioend(
 163         struct xfs_ioend        *ioend)
 164 {
 165         struct xfs_inode        *ip = XFS_I(ioend->io_inode);
 166         struct xfs_trans        *tp = ioend->io_append_trans;
 167
 168         /*
 169          * The transaction may have been allocated in the I/O submission thread,
 170          * thus we need to mark ourselves as being in a transaction manually.
 171          * Similarly for freeze protection.
 172          */
 173         current_set_flags_nested(&tp->t_pflags, PF_FSTRANS);
 174         rwsem_acquire_read(&VFS_I(ip)->i_sb->s_writers.lock_map[SB_FREEZE_FS-1],
 175                            0, 1, _THIS_IP_);
 176
 177         return xfs_setfilesize(ip, tp, ioend->io_offset, ioend->io_size);
 178 }
 179
 180 /*
 181  * Schedule IO completion handling on the final put of an ioend.
 182  *
 183  * If there is no work to do we might as well call it a day and free the
 184  * ioend right now.
 185  */
 186 STATIC void
 187 xfs_finish_ioend(
 188         struct xfs_ioend        *ioend)
 189 {
 190         if (atomic_dec_and_test(&ioend->io_remaining)) {
 191                 struct xfs_mount        *mp = XFS_I(ioend->io_inode)->i_mount;
 192
 193                 if (ioend->io_type == XFS_IO_UNWRITTEN)
 194                         queue_work(mp->m_unwritten_workqueue, &ioend->io_work);
 195                 else if (ioend->io_append_trans)
 196                         queue_work(mp->m_data_workqueue, &ioend->io_work);
 197                 else
 198                         xfs_destroy_ioend(ioend);
 199         }
 200 }
 201
 202 /*
 203  * IO write completion.
 204  */
 205 STATIC void
 206 xfs_end_io(
 207         struct work_struct *work)
 208 {
 209         xfs_ioend_t     *ioend = container_of(work, xfs_ioend_t, io_work);
 210         struct xfs_inode *ip = XFS_I(ioend->io_inode);
 211         int             error = 0;
 212
 213         if (XFS_FORCED_SHUTDOWN(ip->i_mount)) {
 214                 ioend->io_error = -EIO;
 215                 goto done;
 216         }
 217         if (ioend->io_error)
 218                 goto done;
 219
 220         /*
 221          * For unwritten extents we need to issue transactions to convert a
 222          * range to normal written extens after the data I/O has finished.
 223          */
 224         if (ioend->io_type == XFS_IO_UNWRITTEN) {
 225                 error = xfs_iomap_write_unwritten(ip, ioend->io_offset,
 226                                                   ioend->io_size);
 227         } else if (ioend->io_append_trans) {
 228                 error = xfs_setfilesize_ioend(ioend);
 229         } else {
 230                 ASSERT(!xfs_ioend_is_append(ioend));
 231         }
 232
 233 done:
 234         if (error)
 235                 ioend->io_error = error;
 236         xfs_destroy_ioend(ioend);
 237 }
 238
 239 /*
 240  * Allocate and initialise an IO completion structure.
 241  * We need to track unwritten extent write completion here initially.
 242  * We'll need to extend this for updating the ondisk inode size later
 243  * (vs. incore size).
 244  */
 245 STATIC xfs_ioend_t *
 246 xfs_alloc_ioend(
 247         struct inode            *inode,
 248         unsigned int            type)
 249 {
 250         xfs_ioend_t             *ioend;
 251
 252         ioend = mempool_alloc(xfs_ioend_pool, GFP_NOFS);
 253
 254         /*
 255          * Set the count to 1 initially, which will prevent an I/O
 256          * completion callback from happening before we have started
 257          * all the I/O from calling the completion routine too early.
 258          */
 259         atomic_set(&ioend->io_remaining, 1);
 260         ioend->io_error = 0;
 261         ioend->io_list = NULL;
 262         ioend->io_type = type;
 263         ioend->io_inode = inode;
 264         ioend->io_buffer_head = NULL;
 265         ioend->io_buffer_tail = NULL;
 266         ioend->io_offset = 0;
 267         ioend->io_size = 0;
 268         ioend->io_append_trans = NULL;
 269
 270         INIT_WORK(&ioend->io_work, xfs_end_io);
 271         return ioend;
 272 }
 273
 274 STATIC int
 275 xfs_map_blocks(
 276         struct inode            *inode,
 277         loff_t                  offset,
 278         struct xfs_bmbt_irec    *imap,
 279         int                     type,
 280         int                     nonblocking)
 281 {
 282         struct xfs_inode        *ip = XFS_I(inode);
 283         struct xfs_mount        *mp = ip->i_mount;
 284         ssize_t                 count = 1 << inode->i_blkbits;
 285         xfs_fileoff_t           offset_fsb, end_fsb;
 286         int                     error = 0;
 287         int                     bmapi_flags = XFS_BMAPI_ENTIRE;
 288         int                     nimaps = 1;
 289
 290         if (XFS_FORCED_SHUTDOWN(mp))
 291                 return -EIO;
 292
 293         if (type == XFS_IO_UNWRITTEN)
 294                 bmapi_flags |= XFS_BMAPI_IGSTATE;
 295
 296         if (!xfs_ilock_nowait(ip, XFS_ILOCK_SHARED)) {
 297                 if (nonblocking)
 298                         return -EAGAIN;
 299                 xfs_ilock(ip, XFS_ILOCK_SHARED);
 300         }
 301
 302         ASSERT(ip->i_d.di_format != XFS_DINODE_FMT_BTREE ||
 303                (ip->i_df.if_flags & XFS_IFEXTENTS));
 304         ASSERT(offset <= mp->m_super->s_maxbytes);
 305
 306         if (offset + count > mp->m_super->s_maxbytes)
 307                 count = mp->m_super->s_maxbytes - offset;
 308         end_fsb = XFS_B_TO_FSB(mp, (xfs_ufsize_t)offset + count);
 309         offset_fsb = XFS_B_TO_FSBT(mp, offset);
 310         error = xfs_bmapi_read(ip, offset_fsb, end_fsb - offset_fsb,
 311                                 imap, &nimaps, bmapi_flags);
 312         xfs_iunlock(ip, XFS_ILOCK_SHARED);
 313
 314         if (error)
 315                 return error;
 316
 317         if (type == XFS_IO_DELALLOC &&
 318             (!nimaps || isnullstartblock(imap->br_startblock))) {
 319                 error = xfs_iomap_write_allocate(ip, offset, imap);
 320                 if (!error)
 321                         trace_xfs_map_blocks_alloc(ip, offset, count, type, imap);
 322                 return error;
 323         }
 324
 325 #ifdef DEBUG
 326         if (type == XFS_IO_UNWRITTEN) {
 327                 ASSERT(nimaps);
 328                 ASSERT(imap->br_startblock != HOLESTARTBLOCK);
 329                 ASSERT(imap->br_startblock != DELAYSTARTBLOCK);
 330         }
 331 #endif
 332         if (nimaps)
 333                 trace_xfs_map_blocks_found(ip, offset, count, type, imap);
 334         return 0;
 335 }
 336
 337 STATIC int
 338 xfs_imap_valid(
 339         struct inode            *inode,
 340         struct xfs_bmbt_irec    *imap,
 341         xfs_off_t               offset)
 342 {
 343         offset >>= inode->i_blkbits;
 344
 345         return offset >= imap->br_startoff &&
 346                 offset < imap->br_startoff + imap->br_blockcount;
 347 }
 348
 349 /*
 350  * BIO completion handler for buffered IO.
 351  */
 352 STATIC void
 353 xfs_end_bio(
 354         struct bio              *bio,
 355         int                     error)
 356 {
 357         xfs_ioend_t             *ioend = bio->bi_private;
 358
 359         ioend->io_error = test_bit(BIO_UPTODATE, &bio->bi_flags) ? 0 : error;
 360
 361         /* Toss bio and pass work off to an xfsdatad thread */
 362         bio->bi_private = NULL;
 363         bio->bi_end_io = NULL;
 364         bio_put(bio);
 365
 366         xfs_finish_ioend(ioend);
 367 }
 368
 369 STATIC void
 370 xfs_submit_ioend_bio(
 371         struct writeback_control *wbc,
 372         xfs_ioend_t             *ioend,
 373         struct bio              *bio)
 374 {
 375         atomic_inc(&ioend->io_remaining);
 376         bio->bi_private = ioend;
 377         bio->bi_end_io = xfs_end_bio;
 378         submit_bio(wbc->sync_mode == WB_SYNC_ALL ? WRITE_SYNC : WRITE, bio);
 379 }
 380
 381 STATIC struct bio *
 382 xfs_alloc_ioend_bio(
 383         struct buffer_head      *bh)
 384 {
 385         int                     nvecs = bio_get_nr_vecs(bh->b_bdev);
 386         struct bio              *bio = bio_alloc(GFP_NOIO, nvecs);
 387
 388         ASSERT(bio->bi_private == NULL);
 389         bio->bi_iter.bi_sector = bh->b_blocknr * (bh->b_size >> 9);
 390         bio->bi_bdev = bh->b_bdev;
 391         return bio;
 392 }
 393
 394 STATIC void
 395 xfs_start_buffer_writeback(
 396         struct buffer_head      *bh)
 397 {
 398         ASSERT(buffer_mapped(bh));
 399         ASSERT(buffer_locked(bh));
 400         ASSERT(!buffer_delay(bh));
 401         ASSERT(!buffer_unwritten(bh));
 402
 403         mark_buffer_async_write(bh);
 404         set_buffer_uptodate(bh);
 405         clear_buffer_dirty(bh);
 406 }
 407
 408 STATIC void
 409 xfs_start_page_writeback(
 410         struct page             *page,
 411         int                     clear_dirty,
 412         int                     buffers)
 413 {
 414         ASSERT(PageLocked(page));
 415         ASSERT(!PageWriteback(page));
 416
 417         /*
 418          * if the page was not fully cleaned, we need to ensure that the higher
 419          * layers come back to it correctly. That means we need to keep the page
 420          * dirty, and for WB_SYNC_ALL writeback we need to ensure the
 421          * PAGECACHE_TAG_TOWRITE index mark is not removed so another attempt to
 422          * write this page in this writeback sweep will be made.
 423          */
 424         if (clear_dirty) {
 425                 clear_page_dirty_for_io(page);
 426                 set_page_writeback(page);
 427         } else
 428                 set_page_writeback_keepwrite(page);
 429
 430         unlock_page(page);
 431
 432         /* If no buffers on the page are to be written, finish it here */
 433         if (!buffers)
 434                 end_page_writeback(page);
 435 }
 436
 437 static inline int xfs_bio_add_buffer(struct bio *bio, struct buffer_head *bh)
 438 {
 439         return bio_add_page(bio, bh->b_page, bh->b_size, bh_offset(bh));
 440 }
 441
 442 /*
 443  * Submit all of the bios for all of the ioends we have saved up, covering the
 444  * initial writepage page and also any probed pages.
 445  *
 446  * Because we may have multiple ioends spanning a page, we need to start
 447  * writeback on all the buffers before we submit them for I/O. If we mark the
 448  * buffers as we got, then we can end up with a page that only has buffers
 449  * marked async write and I/O complete on can occur before we mark the other
 450  * buffers async write.
 451  *
 452  * The end result of this is that we trip a bug in end_page_writeback() because
 453  * we call it twice for the one page as the code in end_buffer_async_write()
 454  * assumes that all buffers on the page are started at the same time.
 455  *
 456  * The fix is two passes across the ioend list - one to start writeback on the
 457  * buffer_heads, and then submit them for I/O on the second pass.
 458  *
 459  * If @fail is non-zero, it means that we have a situation where some part of
 460  * the submission process has failed after we have marked paged for writeback
 461  * and unlocked them. In this situation, we need to fail the ioend chain rather
 462  * than submit it to IO. This typically only happens on a filesystem shutdown.
 463  */
 464 STATIC void
 465 xfs_submit_ioend(
 466         struct writeback_control *wbc,
 467         xfs_ioend_t             *ioend,
 468         int                     fail)
 469 {
 470         xfs_ioend_t             *head = ioend;
 471         xfs_ioend_t             *next;
 472         struct buffer_head      *bh;
 473         struct bio              *bio;
 474         sector_t                lastblock = 0;
 475
 476         /* Pass 1 - start writeback */
 477         do {
 478                 next = ioend->io_list;
 479                 for (bh = ioend->io_buffer_head; bh; bh = bh->b_private)
 480                         xfs_start_buffer_writeback(bh);
 481         } while ((ioend = next) != NULL);
 482
 483         /* Pass 2 - submit I/O */
 484         ioend = head;
 485         do {
 486                 next = ioend->io_list;
 487                 bio = NULL;
 488
 489                 /*
 490                  * If we are failing the IO now, just mark the ioend with an
 491                  * error and finish it. This will run IO completion immediately
 492                  * as there is only one reference to the ioend at this point in
 493                  * time.
 494                  */
 495                 if (fail) {
 496                         ioend->io_error = fail;
 497                         xfs_finish_ioend(ioend);
 498                         continue;
 499                 }
 500
 501                 for (bh = ioend->io_buffer_head; bh; bh = bh->b_private) {
 502
 503                         if (!bio) {
 504  retry:
 505                                 bio = xfs_alloc_ioend_bio(bh);
 506                         } else if (bh->b_blocknr != lastblock + 1) {
 507                                 xfs_submit_ioend_bio(wbc, ioend, bio);
 508                                 goto retry;
 509                         }
 510
 511                         if (xfs_bio_add_buffer(bio, bh) != bh->b_size) {
 512                                 xfs_submit_ioend_bio(wbc, ioend, bio);
 513                                 goto retry;
 514                         }
 515
 516                         lastblock = bh->b_blocknr;
 517                 }
 518                 if (bio)
 519                         xfs_submit_ioend_bio(wbc, ioend, bio);
 520                 xfs_finish_ioend(ioend);
 521         } while ((ioend = next) != NULL);
 522 }
 523
 524 /*
 525  * Cancel submission of all buffer_heads so far in this endio.
 526  * Toss the endio too.  Only ever called for the initial page
 527  * in a writepage request, so only ever one page.
 528  */
 529 STATIC void
 530 xfs_cancel_ioend(
 531         xfs_ioend_t             *ioend)
 532 {
 533         xfs_ioend_t             *next;
 534         struct buffer_head      *bh, *next_bh;
 535
 536         do {
 537                 next = ioend->io_list;
 538                 bh = ioend->io_buffer_head;
 539                 do {
 540                         next_bh = bh->b_private;
 541                         clear_buffer_async_write(bh);
 542                         /*
 543                          * The unwritten flag is cleared when added to the
 544                          * ioend. We're not submitting for I/O so mark the
 545                          * buffer unwritten again for next time around.
 546                          */
 547                         if (ioend->io_type == XFS_IO_UNWRITTEN)
 548                                 set_buffer_unwritten(bh);
 549                         unlock_buffer(bh);
 550                 } while ((bh = next_bh) != NULL);
 551
 552                 mempool_free(ioend, xfs_ioend_pool);
 553         } while ((ioend = next) != NULL);
 554 }
 555
 556 /*
 557  * Test to see if we've been building up a completion structure for
 558  * earlier buffers -- if so, we try to append to this ioend if we
 559  * can, otherwise we finish off any current ioend and start another.
 560  * Return true if we've finished the given ioend.
 561  */
 562 STATIC void
 563 xfs_add_to_ioend(
 564         struct inode            *inode,
 565         struct buffer_head      *bh,
 566         xfs_off_t               offset,
 567         unsigned int            type,
 568         xfs_ioend_t             **result,
 569         int                     need_ioend)
 570 {
 571         xfs_ioend_t             *ioend = *result;
 572
 573         if (!ioend || need_ioend || type != ioend->io_type) {
 574                 xfs_ioend_t     *previous = *result;
 575
 576                 ioend = xfs_alloc_ioend(inode, type);
 577                 ioend->io_offset = offset;
 578                 ioend->io_buffer_head = bh;
 579                 ioend->io_buffer_tail = bh;
 580                 if (previous)
 581                         previous->io_list = ioend;
 582                 *result = ioend;
 583         } else {
 584                 ioend->io_buffer_tail->b_private = bh;
 585                 ioend->io_buffer_tail = bh;
 586         }
 587
 588         bh->b_private = NULL;
 589         ioend->io_size += bh->b_size;
 590 }
 591
 592 STATIC void
 593 xfs_map_buffer(
 594         struct inode            *inode,
 595         struct buffer_head      *bh,
 596         struct xfs_bmbt_irec    *imap,
 597         xfs_off_t               offset)
 598 {
 599         sector_t                bn;
 600         struct xfs_mount        *m = XFS_I(inode)->i_mount;
 601         xfs_off_t               iomap_offset = XFS_FSB_TO_B(m, imap->br_startoff);
 602         xfs_daddr_t             iomap_bn = xfs_fsb_to_db(XFS_I(inode), imap->br_startblock);
 603
 604         ASSERT(imap->br_startblock != HOLESTARTBLOCK);
 605         ASSERT(imap->br_startblock != DELAYSTARTBLOCK);
 606
 607         bn = (iomap_bn >> (inode->i_blkbits - BBSHIFT)) +
 608               ((offset - iomap_offset) >> inode->i_blkbits);
 609
 610         ASSERT(bn || XFS_IS_REALTIME_INODE(XFS_I(inode)));
 611
 612         bh->b_blocknr = bn;
 613         set_buffer_mapped(bh);
 614 }
 615
 616 STATIC void
 617 xfs_map_at_offset(
 618         struct inode            *inode,
 619         struct buffer_head      *bh,
 620         struct xfs_bmbt_irec    *imap,
 621         xfs_off_t               offset)
 622 {
 623         ASSERT(imap->br_startblock != HOLESTARTBLOCK);
 624         ASSERT(imap->br_startblock != DELAYSTARTBLOCK);
 625
 626         xfs_map_buffer(inode, bh, imap, offset);
 627         set_buffer_mapped(bh);
 628         clear_buffer_delay(bh);
 629         clear_buffer_unwritten(bh);
 630 }
 631
 632 /*
 633  * Test if a given page contains at least one buffer of a given @type.
 634  * If @check_all_buffers is true, then we walk all the buffers in the page to
 635  * try to find one of the type passed in. If it is not set, then the caller only
 636  * needs to check the first buffer on the page for a match.
 637  */
 638 STATIC bool
 639 xfs_check_page_type(
 640         struct page             *page,
 641         unsigned int            type,
 642         bool                    check_all_buffers)
 643 {
 644         struct buffer_head      *bh;
 645         struct buffer_head      *head;
 646
 647         if (PageWriteback(page))
 648                 return false;
 649         if (!page->mapping)
 650                 return false;
 651         if (!page_has_buffers(page))
 652                 return false;
 653
 654         bh = head = page_buffers(page);
 655         do {
 656                 if (buffer_unwritten(bh)) {
 657                         if (type == XFS_IO_UNWRITTEN)
 658                                 return true;
 659                 } else if (buffer_delay(bh)) {
 660                         if (type == XFS_IO_DELALLOC)
 661                                 return true;
 662                 } else if (buffer_dirty(bh) && buffer_mapped(bh)) {
 663                         if (type == XFS_IO_OVERWRITE)
 664                                 return true;
 665                 }
 666
 667                 /* If we are only checking the first buffer, we are done now. */
 668                 if (!check_all_buffers)
 669                         break;
 670         } while ((bh = bh->b_this_page) != head);
 671
 672         return false;
 673 }
 674
 675 /*
 676  * Allocate & map buffers for page given the extent map. Write it out.
 677  * except for the original page of a writepage, this is called on
 678  * delalloc/unwritten pages only, for the original page it is possible
 679  * that the page has no mapping at all.
 680  */
 681 STATIC int
 682 xfs_convert_page(
 683         struct inode            *inode,
 684         struct page             *page,
 685         loff_t                  tindex,
 686         struct xfs_bmbt_irec    *imap,
 687         xfs_ioend_t             **ioendp,
 688         struct writeback_control *wbc)
 689 {
 690         struct buffer_head      *bh, *head;
 691         xfs_off_t               end_offset;
 692         unsigned long           p_offset;
 693         unsigned int            type;
 694         int                     len, page_dirty;
 695         int                     count = 0, done = 0, uptodate = 1;
 696         xfs_off_t               offset = page_offset(page);
 697
 698         if (page->index != tindex)
 699                 goto fail;
 700         if (!trylock_page(page))
 701                 goto fail;
 702         if (PageWriteback(page))
 703                 goto fail_unlock_page;
 704         if (page->mapping != inode->i_mapping)
 705                 goto fail_unlock_page;
 706         if (!xfs_check_page_type(page, (*ioendp)->io_type, false))
 707                 goto fail_unlock_page;
 708
 709         /*
 710          * page_dirty is initially a count of buffers on the page before
 711          * EOF and is decremented as we move each into a cleanable state.
 712          *
 713          * Derivation:
 714          *
 715          * End offset is the highest offset that this page should represent.
 716          * If we are on the last page, (end_offset & (PAGE_CACHE_SIZE - 1))
 717          * will evaluate non-zero and be less than PAGE_CACHE_SIZE and
 718          * hence give us the correct page_dirty count. On any other page,
 719          * it will be zero and in that case we need page_dirty to be the
 720          * count of buffers on the page.
 721          */
 722         end_offset = min_t(unsigned long long,
 723                         (xfs_off_t)(page->index + 1) << PAGE_CACHE_SHIFT,
 724                         i_size_read(inode));
 725
 726         /*
 727          * If the current map does not span the entire page we are about to try
 728          * to write, then give up. The only way we can write a page that spans
 729          * multiple mappings in a single writeback iteration is via the
 730          * xfs_vm_writepage() function. Data integrity writeback requires the
 731          * entire page to be written in a single attempt, otherwise the part of
 732          * the page we don't write here doesn't get written as part of the data
 733          * integrity sync.
 734          *
 735          * For normal writeback, we also don't attempt to write partial pages
 736          * here as it simply means that write_cache_pages() will see it under
 737          * writeback and ignore the page until some point in the future, at
 738          * which time this will be the only page in the file that needs
 739          * writeback.  Hence for more optimal IO patterns, we should always
 740          * avoid partial page writeback due to multiple mappings on a page here.
 741          */
 742         if (!xfs_imap_valid(inode, imap, end_offset))
 743                 goto fail_unlock_page;
 744
 745         len = 1 << inode->i_blkbits;
 746         p_offset = min_t(unsigned long, end_offset & (PAGE_CACHE_SIZE - 1),
 747                                         PAGE_CACHE_SIZE);
 748         p_offset = p_offset ? roundup(p_offset, len) : PAGE_CACHE_SIZE;
 749         page_dirty = p_offset / len;
 750
 751         /*
 752          * The moment we find a buffer that doesn't match our current type
 753          * specification or can't be written, abort the loop and start
 754          * writeback. As per the above xfs_imap_valid() check, only
 755          * xfs_vm_writepage() can handle partial page writeback fully - we are
 756          * limited here to the buffers that are contiguous with the current
 757          * ioend, and hence a buffer we can't write breaks that contiguity and
 758          * we have to defer the rest of the IO to xfs_vm_writepage().
 759          */
 760         bh = head = page_buffers(page);
 761         do {
 762                 if (offset >= end_offset)
 763                         break;
 764                 if (!buffer_uptodate(bh))
 765                         uptodate = 0;
 766                 if (!(PageUptodate(page) || buffer_uptodate(bh))) {
 767                         done = 1;
 768                         break;
 769                 }
 770
 771                 if (buffer_unwritten(bh) || buffer_delay(bh) ||
 772                     buffer_mapped(bh)) {
 773                         if (buffer_unwritten(bh))
 774                                 type = XFS_IO_UNWRITTEN;
 775                         else if (buffer_delay(bh))
 776                                 type = XFS_IO_DELALLOC;
 777                         else
 778                                 type = XFS_IO_OVERWRITE;
 779
 780                         /*
 781                          * imap should always be valid because of the above
 782                          * partial page end_offset check on the imap.
 783                          */
 784                         ASSERT(xfs_imap_valid(inode, imap, offset));
 785
 786                         lock_buffer(bh);
 787                         if (type != XFS_IO_OVERWRITE)
 788                                 xfs_map_at_offset(inode, bh, imap, offset);
 789                         xfs_add_to_ioend(inode, bh, offset, type,
 790                                          ioendp, done);
 791
 792                         page_dirty--;
 793                         count++;
 794                 } else {
 795                         done = 1;
 796                         break;
 797                 }
 798         } while (offset += len, (bh = bh->b_this_page) != head);
 799
 800         if (uptodate && bh == head)
 801                 SetPageUptodate(page);
 802
 803         if (count) {
 804                 if (--wbc->nr_to_write <= 0 &&
 805                     wbc->sync_mode == WB_SYNC_NONE)
 806                         done = 1;
 807         }
 808         xfs_start_page_writeback(page, !page_dirty, count);
 809
 810         return done;
 811  fail_unlock_page:
 812         unlock_page(page);
 813  fail:
 814         return 1;
 815 }
 816
 817 /*
 818  * Convert & write out a cluster of pages in the same extent as defined
 819  * by mp and following the start page.
 820  */
 821 STATIC void
 822 xfs_cluster_write(
 823         struct inode            *inode,
 824         pgoff_t                 tindex,
 825         struct xfs_bmbt_irec    *imap,
 826         xfs_ioend_t             **ioendp,
 827         struct writeback_control *wbc,
 828         pgoff_t                 tlast)
 829 {
 830         struct pagevec          pvec;
 831         int                     done = 0, i;
 832
 833         pagevec_init(&pvec, 0);
 834         while (!done && tindex <= tlast) {
 835                 unsigned len = min_t(pgoff_t, PAGEVEC_SIZE, tlast - tindex + 1);
 836
 837                 if (!pagevec_lookup(&pvec, inode->i_mapping, tindex, len))
 838                         break;
 839
 840                 for (i = 0; i < pagevec_count(&pvec); i++) {
 841                         done = xfs_convert_page(inode, pvec.pages[i], tindex++,
 842                                         imap, ioendp, wbc);
 843                         if (done)
 844                                 break;
 845                 }
 846
 847                 pagevec_release(&pvec);
 848                 cond_resched();
 849         }
 850 }
 851
 852 STATIC void
 853 xfs_vm_invalidatepage(
 854         struct page             *page,
 855         unsigned int            offset,
 856         unsigned int            length)
 857 {
 858         trace_xfs_invalidatepage(page->mapping->host, page, offset,
 859                                  length);
 860         block_invalidatepage(page, offset, length);
 861 }
 862
 863 /*
 864  * If the page has delalloc buffers on it, we need to punch them out before we
 865  * invalidate the page. If we don't, we leave a stale delalloc mapping on the
 866  * inode that can trip a BUG() in xfs_get_blocks() later on if a direct IO read
 867  * is done on that same region - the delalloc extent is returned when none is
 868  * supposed to be there.
 869  *
 870  * We prevent this by truncating away the delalloc regions on the page before
 871  * invalidating it. Because they are delalloc, we can do this without needing a
 872  * transaction. Indeed - if we get ENOSPC errors, we have to be able to do this
 873  * truncation without a transaction as there is no space left for block
 874  * reservation (typically why we see a ENOSPC in writeback).
 875  *
 876  * This is not a performance critical path, so for now just do the punching a
 877  * buffer head at a time.
 878  */
 879 STATIC void
 880 xfs_aops_discard_page(
 881         struct page             *page)
 882 {
 883         struct inode            *inode = page->mapping->host;
 884         struct xfs_inode        *ip = XFS_I(inode);
 885         struct buffer_head      *bh, *head;
 886         loff_t                  offset = page_offset(page);
 887
 888         if (!xfs_check_page_type(page, XFS_IO_DELALLOC, true))
 889                 goto out_invalidate;
 890
 891         if (XFS_FORCED_SHUTDOWN(ip->i_mount))
 892                 goto out_invalidate;
 893
 894         xfs_alert(ip->i_mount,
 895                 "page discard on page %p, inode 0x%llx, offset %llu.",
 896                         page, ip->i_ino, offset);
 897
 898         xfs_ilock(ip, XFS_ILOCK_EXCL);
 899         bh = head = page_buffers(page);
 900         do {
 901                 int             error;
 902                 xfs_fileoff_t   start_fsb;
 903
 904                 if (!buffer_delay(bh))
 905                         goto next_buffer;
 906
 907                 start_fsb = XFS_B_TO_FSBT(ip->i_mount, offset);
 908                 error = xfs_bmap_punch_delalloc_range(ip, start_fsb, 1);
 909                 if (error) {
 910                         /* something screwed, just bail */
 911                         if (!XFS_FORCED_SHUTDOWN(ip->i_mount)) {
 912                                 xfs_alert(ip->i_mount,
 913                         "page discard unable to remove delalloc mapping.");
 914                         }
 915                         break;
 916                 }
 917 next_buffer:
 918                 offset += 1 << inode->i_blkbits;
 919
 920         } while ((bh = bh->b_this_page) != head);
 921
 922         xfs_iunlock(ip, XFS_ILOCK_EXCL);
 923 out_invalidate:
 924         xfs_vm_invalidatepage(page, 0, PAGE_CACHE_SIZE);
 925         return;
 926 }
 927
 928 /*
 929  * Write out a dirty page.
 930  *
 931  * For delalloc space on the page we need to allocate space and flush it.
 932  * For unwritten space on the page we need to start the conversion to
 933  * regular allocated space.
 934  * For any other dirty buffer heads on the page we should flush them.
 935  */
 936 STATIC int
 937 xfs_vm_writepage(
 938         struct page             *page,
 939         struct writeback_control *wbc)
 940 {
 941         struct inode            *inode = page->mapping->host;
 942         struct buffer_head      *bh, *head;
 943         struct xfs_bmbt_irec    imap;
 944         xfs_ioend_t             *ioend = NULL, *iohead = NULL;
 945         loff_t                  offset;
 946         unsigned int            type;
 947         __uint64_t              end_offset;
 948         pgoff_t                 end_index, last_index;
 949         ssize_t                 len;
 950         int                     err, imap_valid = 0, uptodate = 1;
 951         int                     count = 0;
 952         int                     nonblocking = 0;
 953
 954         trace_xfs_writepage(inode, page, 0, 0);
 955
 956         ASSERT(page_has_buffers(page));
 957
 958         /*
 959          * Refuse to write the page out if we are called from reclaim context.
 960          *
 961          * This avoids stack overflows when called from deeply used stacks in
 962          * random callers for direct reclaim or memcg reclaim.  We explicitly
 963          * allow reclaim from kswapd as the stack usage there is relatively low.
 964          *
 965          * This should never happen except in the case of a VM regression so
 966          * warn about it.
 967          */
 968         if (WARN_ON_ONCE((current->flags & (PF_MEMALLOC|PF_KSWAPD)) ==
 969                         PF_MEMALLOC))
 970                 goto redirty;
 971
 972         /*
 973          * Given that we do not allow direct reclaim to call us, we should
 974          * never be called while in a filesystem transaction.
 975          */
 976         if (WARN_ON_ONCE(current->flags & PF_FSTRANS))
 977                 goto redirty;
 978
 979         /* Is this page beyond the end of the file? */
 980         offset = i_size_read(inode);
 981         end_index = offset >> PAGE_CACHE_SHIFT;
 982         last_index = (offset - 1) >> PAGE_CACHE_SHIFT;
 983
 984         /*
 985          * The page index is less than the end_index, adjust the end_offset
 986          * to the highest offset that this page should represent.
 987          * -----------------------------------------------------
 988          * |                    file mapping           | <EOF> |
 989          * -----------------------------------------------------
 990          * | Page ... | Page N-2 | Page N-1 |  Page N  |       |
 991          * ^--------------------------------^----------|--------
 992          * |     desired writeback range    |      see else    |
 993          * ---------------------------------^------------------|
 994          */
 995         if (page->index < end_index)
 996                 end_offset = (xfs_off_t)(page->index + 1) << PAGE_CACHE_SHIFT;
 997         else {
 998                 /*
 999                  * Check whether the page to write out is beyond or straddles
1000                  * i_size or not.
1001                  * -------------------------------------------------------
1002                  * |            file mapping                    | <EOF>  |
1003                  * -------------------------------------------------------
1004                  * | Page ... | Page N-2 | Page N-1 |  Page N   | Beyond |
1005                  * ^--------------------------------^-----------|---------
1006                  * |                                |      Straddles     |
1007                  * ---------------------------------^-----------|--------|
1008                  */
1009                 unsigned offset_into_page = offset & (PAGE_CACHE_SIZE - 1);
1010
1011                 /*
1012                  * Skip the page if it is fully outside i_size, e.g. due to a
1013                  * truncate operation that is in progress. We must redirty the
1014                  * page so that reclaim stops reclaiming it. Otherwise
1015                  * xfs_vm_releasepage() is called on it and gets confused.
1016                  *
1017                  * Note that the end_index is unsigned long, it would overflow
1018                  * if the given offset is greater than 16TB on 32-bit system
1019                  * and if we do check the page is fully outside i_size or not
1020                  * via "if (page->index >= end_index + 1)" as "end_index + 1"
1021                  * will be evaluated to 0.  Hence this page will be redirtied
1022                  * and be written out repeatedly which would result in an
1023                  * infinite loop, the user program that perform this operation
1024                  * will hang.  Instead, we can verify this situation by checking
1025                  * if the page to write is totally beyond the i_size or if it's
1026                  * offset is just equal to the EOF.
1027                  */
1028                 if (page->index > end_index ||
1029                     (page->index == end_index && offset_into_page == 0))
1030                         goto redirty;
1031
1032                 /*
1033                  * The page straddles i_size.  It must be zeroed out on each
1034                  * and every writepage invocation because it may be mmapped.
1035                  * "A file is mapped in multiples of the page size.  For a file
1036                  * that is not a multiple of the page size, the remaining
1037                  * memory is zeroed when mapped, and writes to that region are
1038                  * not written out to the file."
1039                  */
1040                 zero_user_segment(page, offset_into_page, PAGE_CACHE_SIZE);
1041
1042                 /* Adjust the end_offset to the end of file */
1043                 end_offset = offset;
1044         }
1045
1046         len = 1 << inode->i_blkbits;
1047
1048         bh = head = page_buffers(page);
1049         offset = page_offset(page);
1050         type = XFS_IO_OVERWRITE;
1051
1052         if (wbc->sync_mode == WB_SYNC_NONE)
1053                 nonblocking = 1;
1054
1055         do {
1056                 int new_ioend = 0;
1057
1058                 if (offset >= end_offset)
1059                         break;
1060                 if (!buffer_uptodate(bh))
1061                         uptodate = 0;
1062
1063                 /*
1064                  * set_page_dirty dirties all buffers in a page, independent
1065                  * of their state.  The dirty state however is entirely
1066                  * meaningless for holes (!mapped && uptodate), so skip
1067                  * buffers covering holes here.
1068                  */
1069                 if (!buffer_mapped(bh) && buffer_uptodate(bh)) {
1070                         imap_valid = 0;
1071                         continue;
1072                 }
1073
1074                 if (buffer_unwritten(bh)) {
1075                         if (type != XFS_IO_UNWRITTEN) {
1076                                 type = XFS_IO_UNWRITTEN;
1077                                 imap_valid = 0;
1078                         }
1079                 } else if (buffer_delay(bh)) {
1080                         if (type != XFS_IO_DELALLOC) {
1081                                 type = XFS_IO_DELALLOC;
1082                                 imap_valid = 0;
1083                         }
1084                 } else if (buffer_uptodate(bh)) {
1085                         if (type != XFS_IO_OVERWRITE) {
1086                                 type = XFS_IO_OVERWRITE;
1087                                 imap_valid = 0;
1088                         }
1089                 } else {
1090                         if (PageUptodate(page))
1091                                 ASSERT(buffer_mapped(bh));
1092                         /*
1093                          * This buffer is not uptodate and will not be
1094                          * written to disk.  Ensure that we will put any
1095                          * subsequent writeable buffers into a new
1096                          * ioend.
1097                          */
1098                         imap_valid = 0;
1099                         continue;
1100                 }
1101
1102                 if (imap_valid)
1103                         imap_valid = xfs_imap_valid(inode, &imap, offset);
1104                 if (!imap_valid) {
1105                         /*
1106                          * If we didn't have a valid mapping then we need to
1107                          * put the new mapping into a separate ioend structure.
1108                          * This ensures non-contiguous extents always have
1109                          * separate ioends, which is particularly important
1110                          * for unwritten extent conversion at I/O completion
1111                          * time.
1112                          */
1113                         new_ioend = 1;
1114                         err = xfs_map_blocks(inode, offset, &imap, type,
1115                                              nonblocking);
1116                         if (err)
1117                                 goto error;
1118                         imap_valid = xfs_imap_valid(inode, &imap, offset);
1119                 }
1120                 if (imap_valid) {
1121                         lock_buffer(bh);
1122                         if (type != XFS_IO_OVERWRITE)
1123                                 xfs_map_at_offset(inode, bh, &imap, offset);
1124                         xfs_add_to_ioend(inode, bh, offset, type, &ioend,
1125                                          new_ioend);
1126                         count++;
1127                 }
1128
1129                 if (!iohead)
1130                         iohead = ioend;
1131
1132         } while (offset += len, ((bh = bh->b_this_page) != head));
1133
1134         if (uptodate && bh == head)
1135                 SetPageUptodate(page);
1136
1137         xfs_start_page_writeback(page, 1, count);
1138
1139         /* if there is no IO to be submitted for this page, we are done */
1140         if (!ioend)
1141                 return 0;
1142
1143         ASSERT(iohead);
1144
1145         /*
1146          * Any errors from this point onwards need tobe reported through the IO
1147          * completion path as we have marked the initial page as under writeback
1148          * and unlocked it.
1149          */
1150         if (imap_valid) {
1151                 xfs_off_t               end_index;
1152
1153                 end_index = imap.br_startoff + imap.br_blockcount;
1154
1155                 /* to bytes */
1156                 end_index <<= inode->i_blkbits;
1157
1158                 /* to pages */
1159                 end_index = (end_index - 1) >> PAGE_CACHE_SHIFT;
1160
1161                 /* check against file size */
1162                 if (end_index > last_index)
1163                         end_index = last_index;
1164
1165                 xfs_cluster_write(inode, page->index + 1, &imap, &ioend,
1166                                   wbc, end_index);
1167         }
1168
1169
1170         /*
1171          * Reserve log space if we might write beyond the on-disk inode size.
1172          */
1173         err = 0;
1174         if (ioend->io_type != XFS_IO_UNWRITTEN && xfs_ioend_is_append(ioend))
1175                 err = xfs_setfilesize_trans_alloc(ioend);
1176
1177         xfs_submit_ioend(wbc, iohead, err);
1178
1179         return 0;
1180
1181 error:
1182         if (iohead)
1183                 xfs_cancel_ioend(iohead);
1184
1185         if (err == -EAGAIN)
1186                 goto redirty;
1187
1188         xfs_aops_discard_page(page);
1189         ClearPageUptodate(page);
1190         unlock_page(page);
1191         return err;
1192
1193 redirty:
1194         redirty_page_for_writepage(wbc, page);
1195         unlock_page(page);
1196         return 0;
1197 }
1198
1199 STATIC int
1200 xfs_vm_writepages(
1201         struct address_space    *mapping,
1202         struct writeback_control *wbc)
1203 {
1204         xfs_iflags_clear(XFS_I(mapping->host), XFS_ITRUNCATED);
1205         return generic_writepages(mapping, wbc);
1206 }
1207
1208 /*
1209  * Called to move a page into cleanable state - and from there
1210  * to be released. The page should already be clean. We always
1211  * have buffer heads in this call.
1212  *
1213  * Returns 1 if the page is ok to release, 0 otherwise.
1214  */
1215 STATIC int
1216 xfs_vm_releasepage(
1217         struct page             *page,
1218         gfp_t                   gfp_mask)
1219 {
1220         int                     delalloc, unwritten;
1221
1222         trace_xfs_releasepage(page->mapping->host, page, 0, 0);
1223
1224         xfs_count_page_state(page, &delalloc, &unwritten);
1225
1226         if (WARN_ON_ONCE(delalloc))
1227                 return 0;
1228         if (WARN_ON_ONCE(unwritten))
1229                 return 0;
1230
1231         return try_to_free_buffers(page);
1232 }
1233
1234 /*
1235  * When we map a DIO buffer, we may need to attach an ioend that describes the
1236  * type of write IO we are doing. This passes to the completion function the
1237  * operations it needs to perform. If the mapping is for an overwrite wholly
1238  * within the EOF then we don't need an ioend and so we don't allocate one.
1239  * This avoids the unnecessary overhead of allocating and freeing ioends for
1240  * workloads that don't require transactions on IO completion.
1241  *
1242  * If we get multiple mappings in a single IO, we might be mapping different
1243  * types. But because the direct IO can only have a single private pointer, we
1244  * need to ensure that:
1245  *
1246  * a) i) the ioend spans the entire region of unwritten mappings; or
1247  *    ii) the ioend spans all the mappings that cross or are beyond EOF; and
1248  * b) if it contains unwritten extents, it is *permanently* marked as such
1249  *
1250  * We could do this by chaining ioends like buffered IO does, but we only
1251  * actually get one IO completion callback from the direct IO, and that spans
1252  * the entire IO regardless of how many mappings and IOs are needed to complete
1253  * the DIO. There is only going to be one reference to the ioend and its life
1254  * cycle is constrained by the DIO completion code. hence we don't need
1255  * reference counting here.
1256  */
1257 static void
1258 xfs_map_direct(
1259         struct inode            *inode,
1260         struct buffer_head      *bh_result,
1261         struct xfs_bmbt_irec    *imap,
1262         xfs_off_t               offset)
1263 {
1264         struct xfs_ioend        *ioend;
1265         xfs_off_t               size = bh_result->b_size;
1266         int                     type;
1267
1268         if (ISUNWRITTEN(imap))
1269                 type = XFS_IO_UNWRITTEN;
1270         else
1271                 type = XFS_IO_OVERWRITE;
1272
1273         trace_xfs_gbmap_direct(XFS_I(inode), offset, size, type, imap);
1274
1275         if (bh_result->b_private) {
1276                 ioend = bh_result->b_private;
1277                 ASSERT(ioend->io_size > 0);
1278                 ASSERT(offset >= ioend->io_offset);
1279                 if (offset + size > ioend->io_offset + ioend->io_size)
1280                         ioend->io_size = offset - ioend->io_offset + size;
1281
1282                 if (type == XFS_IO_UNWRITTEN && type != ioend->io_type)
1283                         ioend->io_type = XFS_IO_UNWRITTEN;
1284
1285                 trace_xfs_gbmap_direct_update(XFS_I(inode), ioend->io_offset,
1286                                               ioend->io_size, ioend->io_type,
1287                                               imap);
1288         } else if (type == XFS_IO_UNWRITTEN ||
1289                    offset + size > i_size_read(inode)) {
1290                 ioend = xfs_alloc_ioend(inode, type);
1291                 ioend->io_offset = offset;
1292                 ioend->io_size = size;
1293
1294                 bh_result->b_private = ioend;
1295                 set_buffer_defer_completion(bh_result);
1296
1297                 trace_xfs_gbmap_direct_new(XFS_I(inode), offset, size, type,
1298                                            imap);
1299         } else {
1300                 trace_xfs_gbmap_direct_none(XFS_I(inode), offset, size, type,
1301                                             imap);
1302         }
1303 }
1304
1305 /*
1306  * If this is O_DIRECT or the mpage code calling tell them how large the mapping
1307  * is, so that we can avoid repeated get_blocks calls.
1308  *
1309  * If the mapping spans EOF, then we have to break the mapping up as the mapping
1310  * for blocks beyond EOF must be marked new so that sub block regions can be
1311  * correctly zeroed. We can't do this for mappings within EOF unless the mapping
1312  * was just allocated or is unwritten, otherwise the callers would overwrite
1313  * existing data with zeros. Hence we have to split the mapping into a range up
1314  * to and including EOF, and a second mapping for beyond EOF.
1315  */
1316 static void
1317 xfs_map_trim_size(
1318         struct inode            *inode,
1319         sector_t                iblock,
1320         struct buffer_head      *bh_result,
1321         struct xfs_bmbt_irec    *imap,
1322         xfs_off_t               offset,
1323         ssize_t                 size)
1324 {
1325         xfs_off_t               mapping_size;
1326
1327         mapping_size = imap->br_startoff + imap->br_blockcount - iblock;
1328         mapping_size <<= inode->i_blkbits;
1329
1330         ASSERT(mapping_size > 0);
1331         if (mapping_size > size)
1332                 mapping_size = size;
1333         if (offset < i_size_read(inode) &&
1334             offset + mapping_size >= i_size_read(inode)) {
1335                 /* limit mapping to block that spans EOF */
1336                 mapping_size = roundup_64(i_size_read(inode) - offset,
1337                                           1 << inode->i_blkbits);
1338         }
1339         if (mapping_size > LONG_MAX)
1340                 mapping_size = LONG_MAX;
1341
1342         bh_result->b_size = mapping_size;
1343 }
1344
1345 STATIC int
1346 __xfs_get_blocks(
1347         struct inode            *inode,
1348         sector_t                iblock,
1349         struct buffer_head      *bh_result,
1350         int                     create,
1351         int                     direct)
1352 {
1353         struct xfs_inode        *ip = XFS_I(inode);
1354         struct xfs_mount        *mp = ip->i_mount;
1355         xfs_fileoff_t           offset_fsb, end_fsb;
1356         int                     error = 0;
1357         int                     lockmode = 0;
1358         struct xfs_bmbt_irec    imap;
1359         int                     nimaps = 1;
1360         xfs_off_t               offset;
1361         ssize_t                 size;
1362         int                     new = 0;
1363
1364         if (XFS_FORCED_SHUTDOWN(mp))
1365                 return -EIO;
1366
1367         offset = (xfs_off_t)iblock << inode->i_blkbits;
1368         ASSERT(bh_result->b_size >= (1 << inode->i_blkbits));
1369         size = bh_result->b_size;
1370
1371         if (!create && direct && offset >= i_size_read(inode))
1372                 return 0;
1373
1374         /*
1375          * Direct I/O is usually done on preallocated files, so try getting
1376          * a block mapping without an exclusive lock first.  For buffered
1377          * writes we already have the exclusive iolock anyway, so avoiding
1378          * a lock roundtrip here by taking the ilock exclusive from the
1379          * beginning is a useful micro optimization.
1380          */
1381         if (create && !direct) {
1382                 lockmode = XFS_ILOCK_EXCL;
1383                 xfs_ilock(ip, lockmode);
1384         } else {
1385                 lockmode = xfs_ilock_data_map_shared(ip);
1386         }
1387
1388         ASSERT(offset <= mp->m_super->s_maxbytes);
1389         if (offset + size > mp->m_super->s_maxbytes)
1390                 size = mp->m_super->s_maxbytes - offset;
1391         end_fsb = XFS_B_TO_FSB(mp, (xfs_ufsize_t)offset + size);
1392         offset_fsb = XFS_B_TO_FSBT(mp, offset);
1393
1394         error = xfs_bmapi_read(ip, offset_fsb, end_fsb - offset_fsb,
1395                                 &imap, &nimaps, XFS_BMAPI_ENTIRE);
1396         if (error)
1397                 goto out_unlock;
1398
1399         if (create &&
1400             (!nimaps ||
1401              (imap.br_startblock == HOLESTARTBLOCK ||
1402               imap.br_startblock == DELAYSTARTBLOCK))) {
1403                 if (direct || xfs_get_extsz_hint(ip)) {
1404                         /*
1405                          * Drop the ilock in preparation for starting the block
1406                          * allocation transaction.  It will be retaken
1407                          * exclusively inside xfs_iomap_write_direct for the
1408                          * actual allocation.
1409                          */
1410                         xfs_iunlock(ip, lockmode);
1411                         error = xfs_iomap_write_direct(ip, offset, size,
1412                                                        &imap, nimaps);
1413                         if (error)
1414                                 return error;
1415                         new = 1;
1416                 } else {
1417                         /*
1418                          * Delalloc reservations do not require a transaction,
1419                          * we can go on without dropping the lock here. If we
1420                          * are allocating a new delalloc block, make sure that
1421                          * we set the new flag so that we mark the buffer new so
1422                          * that we know that it is newly allocated if the write
1423                          * fails.
1424                          */
1425                         if (nimaps && imap.br_startblock == HOLESTARTBLOCK)
1426                                 new = 1;
1427                         error = xfs_iomap_write_delay(ip, offset, size, &imap);
1428                         if (error)
1429                                 goto out_unlock;
1430
1431                         xfs_iunlock(ip, lockmode);
1432                 }
1433                 trace_xfs_get_blocks_alloc(ip, offset, size,
1434                                 ISUNWRITTEN(&imap) ? XFS_IO_UNWRITTEN
1435                                                    : XFS_IO_DELALLOC, &imap);
1436         } else if (nimaps) {
1437                 trace_xfs_get_blocks_found(ip, offset, size,
1438                                 ISUNWRITTEN(&imap) ? XFS_IO_UNWRITTEN
1439                                                    : XFS_IO_OVERWRITE, &imap);
1440                 xfs_iunlock(ip, lockmode);
1441         } else {
1442                 trace_xfs_get_blocks_notfound(ip, offset, size);
1443                 goto out_unlock;
1444         }
1445
1446         /* trim mapping down to size requested */
1447         if (direct || size > (1 << inode->i_blkbits))
1448                 xfs_map_trim_size(inode, iblock, bh_result,
1449                                   &imap, offset, size);
1450
1451         /*
1452          * For unwritten extents do not report a disk address in the buffered
1453          * read case (treat as if we're reading into a hole).
1454          */
1455         if (imap.br_startblock != HOLESTARTBLOCK &&
1456             imap.br_startblock != DELAYSTARTBLOCK &&
1457             (create || !ISUNWRITTEN(&imap))) {
1458                 xfs_map_buffer(inode, bh_result, &imap, offset);
1459                 if (ISUNWRITTEN(&imap))
1460                         set_buffer_unwritten(bh_result);
1461                 /* direct IO needs special help */
1462                 if (create && direct)
1463                         xfs_map_direct(inode, bh_result, &imap, offset);
1464         }
1465
1466         /*
1467          * If this is a realtime file, data may be on a different device.
1468          * to that pointed to from the buffer_head b_bdev currently.
1469          */
1470         bh_result->b_bdev = xfs_find_bdev_for_inode(inode);
1471
1472         /*
1473          * If we previously allocated a block out beyond eof and we are now
1474          * coming back to use it then we will need to flag it as new even if it
1475          * has a disk address.
1476          *
1477          * With sub-block writes into unwritten extents we also need to mark
1478          * the buffer as new so that the unwritten parts of the buffer gets
1479          * correctly zeroed.
1480          */
1481         if (create &&
1482             ((!buffer_mapped(bh_result) && !buffer_uptodate(bh_result)) ||
1483              (offset >= i_size_read(inode)) ||
1484              (new || ISUNWRITTEN(&imap))))
1485                 set_buffer_new(bh_result);
1486
1487         if (imap.br_startblock == DELAYSTARTBLOCK) {
1488                 BUG_ON(direct);
1489                 if (create) {
1490                         set_buffer_uptodate(bh_result);
1491                         set_buffer_mapped(bh_result);
1492                         set_buffer_delay(bh_result);
1493                 }
1494         }
1495
1496         return 0;
1497
1498 out_unlock:
1499         xfs_iunlock(ip, lockmode);
1500         return error;
1501 }
1502
1503 int
1504 xfs_get_blocks(
1505         struct inode            *inode,
1506         sector_t                iblock,
1507         struct buffer_head      *bh_result,
1508         int                     create)
1509 {
1510         return __xfs_get_blocks(inode, iblock, bh_result, create, 0);
1511 }
1512
1513 STATIC int
1514 xfs_get_blocks_direct(
1515         struct inode            *inode,
1516         sector_t                iblock,
1517         struct buffer_head      *bh_result,
1518         int                     create)
1519 {
1520         return __xfs_get_blocks(inode, iblock, bh_result, create, 1);
1521 }
1522
1523 /*
1524  * Complete a direct I/O write request.
1525  *
1526  * The ioend structure is passed from __xfs_get_blocks() to tell us what to do.
1527  * If no ioend exists (i.e. @private == NULL) then the write IO is an overwrite
1528  * wholly within the EOF and so there is nothing for us to do. Note that in this
1529  * case the completion can be called in interrupt context, whereas if we have an
1530  * ioend we will always be called in task context (i.e. from a workqueue).
1531  */
1532 STATIC void
1533 xfs_end_io_direct_write(
1534         struct kiocb            *iocb,
1535         loff_t                  offset,
1536         ssize_t                 size,
1537         void                    *private)
1538 {
1539         struct inode            *inode = file_inode(iocb->ki_filp);
1540         struct xfs_inode        *ip = XFS_I(inode);
1541         struct xfs_mount        *mp = ip->i_mount;
1542         struct xfs_ioend        *ioend = private;
1543
1544         trace_xfs_gbmap_direct_endio(ip, offset, size,
1545                                      ioend ? ioend->io_type : 0, NULL);
1546
1547         if (!ioend) {
1548                 ASSERT(offset + size <= i_size_read(inode));
1549                 return;
1550         }
1551
1552         if (XFS_FORCED_SHUTDOWN(mp))
1553                 goto out_end_io;
1554
1555         /*
1556          * dio completion end_io functions are only called on writes if more
1557          * than 0 bytes was written.
1558          */
1559         ASSERT(size > 0);
1560
1561         /*
1562          * The ioend only maps whole blocks, while the IO may be sector aligned.
1563          * Hence the ioend offset/size may not match the IO offset/size exactly.
1564          * Because we don't map overwrites within EOF into the ioend, the offset
1565          * may not match, but only if the endio spans EOF.  Either way, write
1566          * the IO sizes into the ioend so that completion processing does the
1567          * right thing.
1568          */
1569         ASSERT(offset + size <= ioend->io_offset + ioend->io_size);
1570         ioend->io_size = size;
1571         ioend->io_offset = offset;
1572
1573         /*
1574          * The ioend tells us whether we are doing unwritten extent conversion
1575          * or an append transaction that updates the on-disk file size. These
1576          * cases are the only cases where we should *potentially* be needing
1577          * to update the VFS inode size.
1578          *
1579          * We need to update the in-core inode size here so that we don't end up
1580          * with the on-disk inode size being outside the in-core inode size. We
1581          * have no other method of updating EOF for AIO, so always do it here
1582          * if necessary.
1583          *
1584          * We need to lock the test/set EOF update as we can be racing with
1585          * other IO completions here to update the EOF. Failing to serialise
1586          * here can result in EOF moving backwards and Bad Things Happen when
1587          * that occurs.
1588          */
1589         spin_lock(&ip->i_flags_lock);
1590         if (offset + size > i_size_read(inode))
1591                 i_size_write(inode, offset + size);
1592         spin_unlock(&ip->i_flags_lock);
1593
1594         /*
1595          * If we are doing an append IO that needs to update the EOF on disk,
1596          * do the transaction reserve now so we can use common end io
1597          * processing. Stashing the error (if there is one) in the ioend will
1598          * result in the ioend processing passing on the error if it is
1599          * possible as we can't return it from here.
1600          */
1601         if (ioend->io_type == XFS_IO_OVERWRITE)
1602                 ioend->io_error = xfs_setfilesize_trans_alloc(ioend);
1603
1604 out_end_io:
1605         xfs_end_io(&ioend->io_work);
1606         return;
1607 }
1608
1609 STATIC ssize_t
1610 xfs_vm_direct_IO(
1611         struct kiocb            *iocb,
1612         struct iov_iter         *iter,
1613         loff_t                  offset)
1614 {
1615         struct inode            *inode = iocb->ki_filp->f_mapping->host;
1616         struct block_device     *bdev = xfs_find_bdev_for_inode(inode);
1617
1618         if (iov_iter_rw(iter) == WRITE) {
1619                 return __blockdev_direct_IO(iocb, inode, bdev, iter, offset,
1620                                             xfs_get_blocks_direct,
1621                                             xfs_end_io_direct_write, NULL,
1622                                             DIO_ASYNC_EXTEND);
1623         }
1624         return __blockdev_direct_IO(iocb, inode, bdev, iter, offset,
1625                                     xfs_get_blocks_direct, NULL, NULL, 0);
1626 }
1627
1628 /*
1629  * Punch out the delalloc blocks we have already allocated.
1630  *
1631  * Don't bother with xfs_setattr given that nothing can have made it to disk yet
1632  * as the page is still locked at this point.
1633  */
1634 STATIC void
1635 xfs_vm_kill_delalloc_range(
1636         struct inode            *inode,
1637         loff_t                  start,
1638         loff_t                  end)
1639 {
1640         struct xfs_inode        *ip = XFS_I(inode);
1641         xfs_fileoff_t           start_fsb;
1642         xfs_fileoff_t           end_fsb;
1643         int                     error;
1644
1645         start_fsb = XFS_B_TO_FSB(ip->i_mount, start);
1646         end_fsb = XFS_B_TO_FSB(ip->i_mount, end);
1647         if (end_fsb <= start_fsb)
1648                 return;
1649
1650         xfs_ilock(ip, XFS_ILOCK_EXCL);
1651         error = xfs_bmap_punch_delalloc_range(ip, start_fsb,
1652                                                 end_fsb - start_fsb);
1653         if (error) {
1654                 /* something screwed, just bail */
1655                 if (!XFS_FORCED_SHUTDOWN(ip->i_mount)) {
1656                         xfs_alert(ip->i_mount,
1657                 "xfs_vm_write_failed: unable to clean up ino %lld",
1658                                         ip->i_ino);
1659                 }
1660         }
1661         xfs_iunlock(ip, XFS_ILOCK_EXCL);
1662 }
1663
1664 STATIC void
1665 xfs_vm_write_failed(
1666         struct inode            *inode,
1667         struct page             *page,
1668         loff_t                  pos,
1669         unsigned                len)
1670 {
1671         loff_t                  block_offset;
1672         loff_t                  block_start;
1673         loff_t                  block_end;
1674         loff_t                  from = pos & (PAGE_CACHE_SIZE - 1);
1675         loff_t                  to = from + len;
1676         struct buffer_head      *bh, *head;
1677
1678         /*
1679          * The request pos offset might be 32 or 64 bit, this is all fine
1680          * on 64-bit platform.  However, for 64-bit pos request on 32-bit
1681          * platform, the high 32-bit will be masked off if we evaluate the
1682          * block_offset via (pos & PAGE_MASK) because the PAGE_MASK is
1683          * 0xfffff000 as an unsigned long, hence the result is incorrect
1684          * which could cause the following ASSERT failed in most cases.
1685          * In order to avoid this, we can evaluate the block_offset of the
1686          * start of the page by using shifts rather than masks the mismatch
1687          * problem.
1688          */
1689         block_offset = (pos >> PAGE_CACHE_SHIFT) << PAGE_CACHE_SHIFT;
1690
1691         ASSERT(block_offset + from == pos);
1692
1693         head = page_buffers(page);
1694         block_start = 0;
1695         for (bh = head; bh != head || !block_start;
1696              bh = bh->b_this_page, block_start = block_end,
1697                                    block_offset += bh->b_size) {
1698                 block_end = block_start + bh->b_size;
1699
1700                 /* skip buffers before the write */
1701                 if (block_end <= from)
1702                         continue;
1703
1704                 /* if the buffer is after the write, we're done */
1705                 if (block_start >= to)
1706                         break;
1707
1708                 if (!buffer_delay(bh))
1709                         continue;
1710
1711                 if (!buffer_new(bh) && block_offset < i_size_read(inode))
1712                         continue;
1713
1714                 xfs_vm_kill_delalloc_range(inode, block_offset,
1715                                            block_offset + bh->b_size);
1716
1717                 /*
1718                  * This buffer does not contain data anymore. make sure anyone
1719                  * who finds it knows that for certain.
1720                  */
1721                 clear_buffer_delay(bh);
1722                 clear_buffer_uptodate(bh);
1723                 clear_buffer_mapped(bh);
1724                 clear_buffer_new(bh);
1725                 clear_buffer_dirty(bh);
1726         }
1727
1728 }
1729
1730 /*
1731  * This used to call block_write_begin(), but it unlocks and releases the page
1732  * on error, and we need that page to be able to punch stale delalloc blocks out
1733  * on failure. hence we copy-n-waste it here and call xfs_vm_write_failed() at
1734  * the appropriate point.
1735  */
1736 STATIC int
1737 xfs_vm_write_begin(
1738         struct file             *file,
1739         struct address_space    *mapping,
1740         loff_t                  pos,
1741         unsigned                len,
1742         unsigned                flags,
1743         struct page             **pagep,
1744         void                    **fsdata)
1745 {
1746         pgoff_t                 index = pos >> PAGE_CACHE_SHIFT;
1747         struct page             *page;
1748         int                     status;
1749
1750         ASSERT(len <= PAGE_CACHE_SIZE);
1751
1752         page = grab_cache_page_write_begin(mapping, index, flags);
1753         if (!page)
1754                 return -ENOMEM;
1755
1756         status = __block_write_begin(page, pos, len, xfs_get_blocks);
1757         if (unlikely(status)) {
1758                 struct inode    *inode = mapping->host;
1759                 size_t          isize = i_size_read(inode);
1760
1761                 xfs_vm_write_failed(inode, page, pos, len);
1762                 unlock_page(page);
1763
1764                 /*
1765                  * If the write is beyond EOF, we only want to kill blocks
1766                  * allocated in this write, not blocks that were previously
1767                  * written successfully.
1768                  */
1769                 if (pos + len > isize) {
1770                         ssize_t start = max_t(ssize_t, pos, isize);
1771
1772                         truncate_pagecache_range(inode, start, pos + len);
1773                 }
1774
1775                 page_cache_release(page);
1776                 page = NULL;
1777         }
1778
1779         *pagep = page;
1780         return status;
1781 }
1782
1783 /*
1784  * On failure, we only need to kill delalloc blocks beyond EOF in the range of
1785  * this specific write because they will never be written. Previous writes
1786  * beyond EOF where block allocation succeeded do not need to be trashed, so
1787  * only new blocks from this write should be trashed. For blocks within
1788  * EOF, generic_write_end() zeros them so they are safe to leave alone and be
1789  * written with all the other valid data.
1790  */
1791 STATIC int
1792 xfs_vm_write_end(
1793         struct file             *file,
1794         struct address_space    *mapping,
1795         loff_t                  pos,
1796         unsigned                len,
1797         unsigned                copied,
1798         struct page             *page,
1799         void                    *fsdata)
1800 {
1801         int                     ret;
1802
1803         ASSERT(len <= PAGE_CACHE_SIZE);
1804
1805         ret = generic_write_end(file, mapping, pos, len, copied, page, fsdata);
1806         if (unlikely(ret < len)) {
1807                 struct inode    *inode = mapping->host;
1808                 size_t          isize = i_size_read(inode);
1809                 loff_t          to = pos + len;
1810
1811                 if (to > isize) {
1812                         /* only kill blocks in this write beyond EOF */
1813                         if (pos > isize)
1814                                 isize = pos;
1815                         xfs_vm_kill_delalloc_range(inode, isize, to);
1816                         truncate_pagecache_range(inode, isize, to);
1817                 }
1818         }
1819         return ret;
1820 }
1821
1822 STATIC sector_t
1823 xfs_vm_bmap(
1824         struct address_space    *mapping,
1825         sector_t                block)
1826 {
1827         struct inode            *inode = (struct inode *)mapping->host;
1828         struct xfs_inode        *ip = XFS_I(inode);
1829
1830         trace_xfs_vm_bmap(XFS_I(inode));
1831         xfs_ilock(ip, XFS_IOLOCK_SHARED);
1832         filemap_write_and_wait(mapping);
1833         xfs_iunlock(ip, XFS_IOLOCK_SHARED);
1834         return generic_block_bmap(mapping, block, xfs_get_blocks);
1835 }
1836
1837 STATIC int
1838 xfs_vm_readpage(
1839         struct file             *unused,
1840         struct page             *page)
1841 {
1842         return mpage_readpage(page, xfs_get_blocks);
1843 }
1844
1845 STATIC int
1846 xfs_vm_readpages(
1847         struct file             *unused,
1848         struct address_space    *mapping,
1849         struct list_head        *pages,
1850         unsigned                nr_pages)
1851 {
1852         return mpage_readpages(mapping, pages, nr_pages, xfs_get_blocks);
1853 }
1854
1855 /*
1856  * This is basically a copy of __set_page_dirty_buffers() with one
1857  * small tweak: buffers beyond EOF do not get marked dirty. If we mark them
1858  * dirty, we'll never be able to clean them because we don't write buffers
1859  * beyond EOF, and that means we can't invalidate pages that span EOF
1860  * that have been marked dirty. Further, the dirty state can leak into
1861  * the file interior if the file is extended, resulting in all sorts of
1862  * bad things happening as the state does not match the underlying data.
1863  *
1864  * XXX: this really indicates that bufferheads in XFS need to die. Warts like
1865  * this only exist because of bufferheads and how the generic code manages them.
1866  */
1867 STATIC int
1868 xfs_vm_set_page_dirty(
1869         struct page             *page)
1870 {
1871         struct address_space    *mapping = page->mapping;
1872         struct inode            *inode = mapping->host;
1873         loff_t                  end_offset;
1874         loff_t                  offset;
1875         int                     newly_dirty;
1876         struct mem_cgroup       *memcg;
1877
1878         if (unlikely(!mapping))
1879                 return !TestSetPageDirty(page);
1880
1881         end_offset = i_size_read(inode);
1882         offset = page_offset(page);
1883
1884         spin_lock(&mapping->private_lock);
1885         if (page_has_buffers(page)) {
1886                 struct buffer_head *head = page_buffers(page);
1887                 struct buffer_head *bh = head;
1888
1889                 do {
1890                         if (offset < end_offset)
1891                                 set_buffer_dirty(bh);
1892                         bh = bh->b_this_page;
1893                         offset += 1 << inode->i_blkbits;
1894                 } while (bh != head);
1895         }
1896         /*
1897          * Use mem_group_begin_page_stat() to keep PageDirty synchronized with
1898          * per-memcg dirty page counters.
1899          */
1900         memcg = mem_cgroup_begin_page_stat(page);
1901         newly_dirty = !TestSetPageDirty(page);
1902         spin_unlock(&mapping->private_lock);
1903
1904         if (newly_dirty) {
1905                 /* sigh - __set_page_dirty() is static, so copy it here, too */
1906                 unsigned long flags;
1907
1908                 spin_lock_irqsave(&mapping->tree_lock, flags);
1909                 if (page->mapping) {    /* Race with truncate? */
1910                         WARN_ON_ONCE(!PageUptodate(page));
1911                         account_page_dirtied(page, mapping, memcg);
1912                         radix_tree_tag_set(&mapping->page_tree,
1913                                         page_index(page), PAGECACHE_TAG_DIRTY);
1914                 }
1915                 spin_unlock_irqrestore(&mapping->tree_lock, flags);
1916         }
1917         mem_cgroup_end_page_stat(memcg);
1918         if (newly_dirty)
1919                 __mark_inode_dirty(mapping->host, I_DIRTY_PAGES);
1920         return newly_dirty;
1921 }
1922
1923 const struct address_space_operations xfs_address_space_operations = {
1924         .readpage               = xfs_vm_readpage,
1925         .readpages              = xfs_vm_readpages,
1926         .writepage              = xfs_vm_writepage,
1927         .writepages             = xfs_vm_writepages,
1928         .set_page_dirty         = xfs_vm_set_page_dirty,
1929         .releasepage            = xfs_vm_releasepage,
1930         .invalidatepage         = xfs_vm_invalidatepage,
1931         .write_begin            = xfs_vm_write_begin,
1932         .write_end              = xfs_vm_write_end,
1933         .bmap                   = xfs_vm_bmap,
1934         .direct_IO              = xfs_vm_direct_IO,
1935         .migratepage            = buffer_migrate_page,
1936         .is_partially_uptodate  = block_is_partially_uptodate,
1937         .error_remove_page      = generic_error_remove_page,
1938 };