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);
 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);
 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);
 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         bool                    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
1417                 } else {
1418                         /*
1419                          * Delalloc reservations do not require a transaction,
1420                          * we can go on without dropping the lock here. If we
1421                          * are allocating a new delalloc block, make sure that
1422                          * we set the new flag so that we mark the buffer new so
1423                          * that we know that it is newly allocated if the write
1424                          * fails.
1425                          */
1426                         if (nimaps && imap.br_startblock == HOLESTARTBLOCK)
1427                                 new = 1;
1428                         error = xfs_iomap_write_delay(ip, offset, size, &imap);
1429                         if (error)
1430                                 goto out_unlock;
1431
1432                         xfs_iunlock(ip, lockmode);
1433                 }
1434                 trace_xfs_get_blocks_alloc(ip, offset, size,
1435                                 ISUNWRITTEN(&imap) ? XFS_IO_UNWRITTEN
1436                                                    : XFS_IO_DELALLOC, &imap);
1437         } else if (nimaps) {
1438                 trace_xfs_get_blocks_found(ip, offset, size,
1439                                 ISUNWRITTEN(&imap) ? XFS_IO_UNWRITTEN
1440                                                    : XFS_IO_OVERWRITE, &imap);
1441                 xfs_iunlock(ip, lockmode);
1442         } else {
1443                 trace_xfs_get_blocks_notfound(ip, offset, size);
1444                 goto out_unlock;
1445         }
1446
1447         /* trim mapping down to size requested */
1448         if (direct || size > (1 << inode->i_blkbits))
1449                 xfs_map_trim_size(inode, iblock, bh_result,
1450                                   &imap, offset, size);
1451
1452         /*
1453          * For unwritten extents do not report a disk address in the buffered
1454          * read case (treat as if we're reading into a hole).
1455          */
1456         if (imap.br_startblock != HOLESTARTBLOCK &&
1457             imap.br_startblock != DELAYSTARTBLOCK &&
1458             (create || !ISUNWRITTEN(&imap))) {
1459                 xfs_map_buffer(inode, bh_result, &imap, offset);
1460                 if (ISUNWRITTEN(&imap))
1461                         set_buffer_unwritten(bh_result);
1462                 /* direct IO needs special help */
1463                 if (create && direct)
1464                         xfs_map_direct(inode, bh_result, &imap, offset);
1465         }
1466
1467         /*
1468          * If this is a realtime file, data may be on a different device.
1469          * to that pointed to from the buffer_head b_bdev currently.
1470          */
1471         bh_result->b_bdev = xfs_find_bdev_for_inode(inode);
1472
1473         /*
1474          * If we previously allocated a block out beyond eof and we are now
1475          * coming back to use it then we will need to flag it as new even if it
1476          * has a disk address.
1477          *
1478          * With sub-block writes into unwritten extents we also need to mark
1479          * the buffer as new so that the unwritten parts of the buffer gets
1480          * correctly zeroed.
1481          */
1482         if (create &&
1483             ((!buffer_mapped(bh_result) && !buffer_uptodate(bh_result)) ||
1484              (offset >= i_size_read(inode)) ||
1485              (new || ISUNWRITTEN(&imap))))
1486                 set_buffer_new(bh_result);
1487
1488         if (imap.br_startblock == DELAYSTARTBLOCK) {
1489                 BUG_ON(direct);
1490                 if (create) {
1491                         set_buffer_uptodate(bh_result);
1492                         set_buffer_mapped(bh_result);
1493                         set_buffer_delay(bh_result);
1494                 }
1495         }
1496
1497         return 0;
1498
1499 out_unlock:
1500         xfs_iunlock(ip, lockmode);
1501         return error;
1502 }
1503
1504 int
1505 xfs_get_blocks(
1506         struct inode            *inode,
1507         sector_t                iblock,
1508         struct buffer_head      *bh_result,
1509         int                     create)
1510 {
1511         return __xfs_get_blocks(inode, iblock, bh_result, create, false);
1512 }
1513
1514 int
1515 xfs_get_blocks_direct(
1516         struct inode            *inode,
1517         sector_t                iblock,
1518         struct buffer_head      *bh_result,
1519         int                     create)
1520 {
1521         return __xfs_get_blocks(inode, iblock, bh_result, create, true);
1522 }
1523
1524 static void
1525 __xfs_end_io_direct_write(
1526         struct inode            *inode,
1527         struct xfs_ioend        *ioend,
1528         loff_t                  offset,
1529         ssize_t                 size)
1530 {
1531         struct xfs_mount        *mp = XFS_I(inode)->i_mount;
1532
1533         if (XFS_FORCED_SHUTDOWN(mp) || ioend->io_error)
1534                 goto out_end_io;
1535
1536         /*
1537          * dio completion end_io functions are only called on writes if more
1538          * than 0 bytes was written.
1539          */
1540         ASSERT(size > 0);
1541
1542         /*
1543          * The ioend only maps whole blocks, while the IO may be sector aligned.
1544          * Hence the ioend offset/size may not match the IO offset/size exactly.
1545          * Because we don't map overwrites within EOF into the ioend, the offset
1546          * may not match, but only if the endio spans EOF.  Either way, write
1547          * the IO sizes into the ioend so that completion processing does the
1548          * right thing.
1549          */
1550         ASSERT(offset + size <= ioend->io_offset + ioend->io_size);
1551         ioend->io_size = size;
1552         ioend->io_offset = offset;
1553
1554         /*
1555          * The ioend tells us whether we are doing unwritten extent conversion
1556          * or an append transaction that updates the on-disk file size. These
1557          * cases are the only cases where we should *potentially* be needing
1558          * to update the VFS inode size.
1559          *
1560          * We need to update the in-core inode size here so that we don't end up
1561          * with the on-disk inode size being outside the in-core inode size. We
1562          * have no other method of updating EOF for AIO, so always do it here
1563          * if necessary.
1564          *
1565          * We need to lock the test/set EOF update as we can be racing with
1566          * other IO completions here to update the EOF. Failing to serialise
1567          * here can result in EOF moving backwards and Bad Things Happen when
1568          * that occurs.
1569          */
1570         spin_lock(&XFS_I(inode)->i_flags_lock);
1571         if (offset + size > i_size_read(inode))
1572                 i_size_write(inode, offset + size);
1573         spin_unlock(&XFS_I(inode)->i_flags_lock);
1574
1575         /*
1576          * If we are doing an append IO that needs to update the EOF on disk,
1577          * do the transaction reserve now so we can use common end io
1578          * processing. Stashing the error (if there is one) in the ioend will
1579          * result in the ioend processing passing on the error if it is
1580          * possible as we can't return it from here.
1581          */
1582         if (ioend->io_type == XFS_IO_OVERWRITE)
1583                 ioend->io_error = xfs_setfilesize_trans_alloc(ioend);
1584
1585 out_end_io:
1586         xfs_end_io(&ioend->io_work);
1587         return;
1588 }
1589
1590 /*
1591  * Complete a direct I/O write request.
1592  *
1593  * The ioend structure is passed from __xfs_get_blocks() to tell us what to do.
1594  * If no ioend exists (i.e. @private == NULL) then the write IO is an overwrite
1595  * wholly within the EOF and so there is nothing for us to do. Note that in this
1596  * case the completion can be called in interrupt context, whereas if we have an
1597  * ioend we will always be called in task context (i.e. from a workqueue).
1598  */
1599 STATIC void
1600 xfs_end_io_direct_write(
1601         struct kiocb            *iocb,
1602         loff_t                  offset,
1603         ssize_t                 size,
1604         void                    *private)
1605 {
1606         struct inode            *inode = file_inode(iocb->ki_filp);
1607         struct xfs_ioend        *ioend = private;
1608
1609         trace_xfs_gbmap_direct_endio(XFS_I(inode), offset, size,
1610                                      ioend ? ioend->io_type : 0, NULL);
1611
1612         if (!ioend) {
1613                 ASSERT(offset + size <= i_size_read(inode));
1614                 return;
1615         }
1616
1617         __xfs_end_io_direct_write(inode, ioend, offset, size);
1618 }
1619
1620 /*
1621  * For DAX we need a mapping buffer callback for unwritten extent conversion
1622  * when page faults allocate blocks and then zero them. Note that in this
1623  * case the mapping indicated by the ioend may extend beyond EOF. We most
1624  * definitely do not want to extend EOF here, so we trim back the ioend size to
1625  * EOF.
1626  */
1627 #ifdef CONFIG_FS_DAX
1628 void
1629 xfs_end_io_dax_write(
1630         struct buffer_head      *bh,
1631         int                     uptodate)
1632 {
1633         struct xfs_ioend        *ioend = bh->b_private;
1634         struct inode            *inode = ioend->io_inode;
1635         ssize_t                 size = ioend->io_size;
1636
1637         ASSERT(IS_DAX(ioend->io_inode));
1638
1639         /* if there was an error zeroing, then don't convert it */
1640         if (!uptodate)
1641                 ioend->io_error = -EIO;
1642
1643         /*
1644          * Trim update to EOF, so we don't extend EOF during unwritten extent
1645          * conversion of partial EOF blocks.
1646          */
1647         spin_lock(&XFS_I(inode)->i_flags_lock);
1648         if (ioend->io_offset + size > i_size_read(inode))
1649                 size = i_size_read(inode) - ioend->io_offset;
1650         spin_unlock(&XFS_I(inode)->i_flags_lock);
1651
1652         __xfs_end_io_direct_write(inode, ioend, ioend->io_offset, size);
1653
1654 }
1655 #else
1656 void xfs_end_io_dax_write(struct buffer_head *bh, int uptodate) { }
1657 #endif
1658
1659 static inline ssize_t
1660 xfs_vm_do_dio(
1661         struct inode            *inode,
1662         struct kiocb            *iocb,
1663         struct iov_iter         *iter,
1664         loff_t                  offset,
1665         void                    (*endio)(struct kiocb   *iocb,
1666                                          loff_t         offset,
1667                                          ssize_t        size,
1668                                          void           *private),
1669         int                     flags)
1670 {
1671         struct block_device     *bdev;
1672
1673         if (IS_DAX(inode))
1674                 return dax_do_io(iocb, inode, iter, offset,
1675                                  xfs_get_blocks_direct, endio, 0);
1676
1677         bdev = xfs_find_bdev_for_inode(inode);
1678         return  __blockdev_direct_IO(iocb, inode, bdev, iter, offset,
1679                                      xfs_get_blocks_direct, endio, NULL, flags);
1680 }
1681
1682 STATIC ssize_t
1683 xfs_vm_direct_IO(
1684         struct kiocb            *iocb,
1685         struct iov_iter         *iter,
1686         loff_t                  offset)
1687 {
1688         struct inode            *inode = iocb->ki_filp->f_mapping->host;
1689
1690         if (iov_iter_rw(iter) == WRITE)
1691                 return xfs_vm_do_dio(inode, iocb, iter, offset,
1692                                      xfs_end_io_direct_write, DIO_ASYNC_EXTEND);
1693         return xfs_vm_do_dio(inode, iocb, iter, offset, NULL, 0);
1694 }
1695
1696 /*
1697  * Punch out the delalloc blocks we have already allocated.
1698  *
1699  * Don't bother with xfs_setattr given that nothing can have made it to disk yet
1700  * as the page is still locked at this point.
1701  */
1702 STATIC void
1703 xfs_vm_kill_delalloc_range(
1704         struct inode            *inode,
1705         loff_t                  start,
1706         loff_t                  end)
1707 {
1708         struct xfs_inode        *ip = XFS_I(inode);
1709         xfs_fileoff_t           start_fsb;
1710         xfs_fileoff_t           end_fsb;
1711         int                     error;
1712
1713         start_fsb = XFS_B_TO_FSB(ip->i_mount, start);
1714         end_fsb = XFS_B_TO_FSB(ip->i_mount, end);
1715         if (end_fsb <= start_fsb)
1716                 return;
1717
1718         xfs_ilock(ip, XFS_ILOCK_EXCL);
1719         error = xfs_bmap_punch_delalloc_range(ip, start_fsb,
1720                                                 end_fsb - start_fsb);
1721         if (error) {
1722                 /* something screwed, just bail */
1723                 if (!XFS_FORCED_SHUTDOWN(ip->i_mount)) {
1724                         xfs_alert(ip->i_mount,
1725                 "xfs_vm_write_failed: unable to clean up ino %lld",
1726                                         ip->i_ino);
1727                 }
1728         }
1729         xfs_iunlock(ip, XFS_ILOCK_EXCL);
1730 }
1731
1732 STATIC void
1733 xfs_vm_write_failed(
1734         struct inode            *inode,
1735         struct page             *page,
1736         loff_t                  pos,
1737         unsigned                len)
1738 {
1739         loff_t                  block_offset;
1740         loff_t                  block_start;
1741         loff_t                  block_end;
1742         loff_t                  from = pos & (PAGE_CACHE_SIZE - 1);
1743         loff_t                  to = from + len;
1744         struct buffer_head      *bh, *head;
1745
1746         /*
1747          * The request pos offset might be 32 or 64 bit, this is all fine
1748          * on 64-bit platform.  However, for 64-bit pos request on 32-bit
1749          * platform, the high 32-bit will be masked off if we evaluate the
1750          * block_offset via (pos & PAGE_MASK) because the PAGE_MASK is
1751          * 0xfffff000 as an unsigned long, hence the result is incorrect
1752          * which could cause the following ASSERT failed in most cases.
1753          * In order to avoid this, we can evaluate the block_offset of the
1754          * start of the page by using shifts rather than masks the mismatch
1755          * problem.
1756          */
1757         block_offset = (pos >> PAGE_CACHE_SHIFT) << PAGE_CACHE_SHIFT;
1758
1759         ASSERT(block_offset + from == pos);
1760
1761         head = page_buffers(page);
1762         block_start = 0;
1763         for (bh = head; bh != head || !block_start;
1764              bh = bh->b_this_page, block_start = block_end,
1765                                    block_offset += bh->b_size) {
1766                 block_end = block_start + bh->b_size;
1767
1768                 /* skip buffers before the write */
1769                 if (block_end <= from)
1770                         continue;
1771
1772                 /* if the buffer is after the write, we're done */
1773                 if (block_start >= to)
1774                         break;
1775
1776                 if (!buffer_delay(bh))
1777                         continue;
1778
1779                 if (!buffer_new(bh) && block_offset < i_size_read(inode))
1780                         continue;
1781
1782                 xfs_vm_kill_delalloc_range(inode, block_offset,
1783                                            block_offset + bh->b_size);
1784
1785                 /*
1786                  * This buffer does not contain data anymore. make sure anyone
1787                  * who finds it knows that for certain.
1788                  */
1789                 clear_buffer_delay(bh);
1790                 clear_buffer_uptodate(bh);
1791                 clear_buffer_mapped(bh);
1792                 clear_buffer_new(bh);
1793                 clear_buffer_dirty(bh);
1794         }
1795
1796 }
1797
1798 /*
1799  * This used to call block_write_begin(), but it unlocks and releases the page
1800  * on error, and we need that page to be able to punch stale delalloc blocks out
1801  * on failure. hence we copy-n-waste it here and call xfs_vm_write_failed() at
1802  * the appropriate point.
1803  */
1804 STATIC int
1805 xfs_vm_write_begin(
1806         struct file             *file,
1807         struct address_space    *mapping,
1808         loff_t                  pos,
1809         unsigned                len,
1810         unsigned                flags,
1811         struct page             **pagep,
1812         void                    **fsdata)
1813 {
1814         pgoff_t                 index = pos >> PAGE_CACHE_SHIFT;
1815         struct page             *page;
1816         int                     status;
1817
1818         ASSERT(len <= PAGE_CACHE_SIZE);
1819
1820         page = grab_cache_page_write_begin(mapping, index, flags);
1821         if (!page)
1822                 return -ENOMEM;
1823
1824         status = __block_write_begin(page, pos, len, xfs_get_blocks);
1825         if (unlikely(status)) {
1826                 struct inode    *inode = mapping->host;
1827                 size_t          isize = i_size_read(inode);
1828
1829                 xfs_vm_write_failed(inode, page, pos, len);
1830                 unlock_page(page);
1831
1832                 /*
1833                  * If the write is beyond EOF, we only want to kill blocks
1834                  * allocated in this write, not blocks that were previously
1835                  * written successfully.
1836                  */
1837                 if (pos + len > isize) {
1838                         ssize_t start = max_t(ssize_t, pos, isize);
1839
1840                         truncate_pagecache_range(inode, start, pos + len);
1841                 }
1842
1843                 page_cache_release(page);
1844                 page = NULL;
1845         }
1846
1847         *pagep = page;
1848         return status;
1849 }
1850
1851 /*
1852  * On failure, we only need to kill delalloc blocks beyond EOF in the range of
1853  * this specific write because they will never be written. Previous writes
1854  * beyond EOF where block allocation succeeded do not need to be trashed, so
1855  * only new blocks from this write should be trashed. For blocks within
1856  * EOF, generic_write_end() zeros them so they are safe to leave alone and be
1857  * written with all the other valid data.
1858  */
1859 STATIC int
1860 xfs_vm_write_end(
1861         struct file             *file,
1862         struct address_space    *mapping,
1863         loff_t                  pos,
1864         unsigned                len,
1865         unsigned                copied,
1866         struct page             *page,
1867         void                    *fsdata)
1868 {
1869         int                     ret;
1870
1871         ASSERT(len <= PAGE_CACHE_SIZE);
1872
1873         ret = generic_write_end(file, mapping, pos, len, copied, page, fsdata);
1874         if (unlikely(ret < len)) {
1875                 struct inode    *inode = mapping->host;
1876                 size_t          isize = i_size_read(inode);
1877                 loff_t          to = pos + len;
1878
1879                 if (to > isize) {
1880                         /* only kill blocks in this write beyond EOF */
1881                         if (pos > isize)
1882                                 isize = pos;
1883                         xfs_vm_kill_delalloc_range(inode, isize, to);
1884                         truncate_pagecache_range(inode, isize, to);
1885                 }
1886         }
1887         return ret;
1888 }
1889
1890 STATIC sector_t
1891 xfs_vm_bmap(
1892         struct address_space    *mapping,
1893         sector_t                block)
1894 {
1895         struct inode            *inode = (struct inode *)mapping->host;
1896         struct xfs_inode        *ip = XFS_I(inode);
1897
1898         trace_xfs_vm_bmap(XFS_I(inode));
1899         xfs_ilock(ip, XFS_IOLOCK_SHARED);
1900         filemap_write_and_wait(mapping);
1901         xfs_iunlock(ip, XFS_IOLOCK_SHARED);
1902         return generic_block_bmap(mapping, block, xfs_get_blocks);
1903 }
1904
1905 STATIC int
1906 xfs_vm_readpage(
1907         struct file             *unused,
1908         struct page             *page)
1909 {
1910         return mpage_readpage(page, xfs_get_blocks);
1911 }
1912
1913 STATIC int
1914 xfs_vm_readpages(
1915         struct file             *unused,
1916         struct address_space    *mapping,
1917         struct list_head        *pages,
1918         unsigned                nr_pages)
1919 {
1920         return mpage_readpages(mapping, pages, nr_pages, xfs_get_blocks);
1921 }
1922
1923 /*
1924  * This is basically a copy of __set_page_dirty_buffers() with one
1925  * small tweak: buffers beyond EOF do not get marked dirty. If we mark them
1926  * dirty, we'll never be able to clean them because we don't write buffers
1927  * beyond EOF, and that means we can't invalidate pages that span EOF
1928  * that have been marked dirty. Further, the dirty state can leak into
1929  * the file interior if the file is extended, resulting in all sorts of
1930  * bad things happening as the state does not match the underlying data.
1931  *
1932  * XXX: this really indicates that bufferheads in XFS need to die. Warts like
1933  * this only exist because of bufferheads and how the generic code manages them.
1934  */
1935 STATIC int
1936 xfs_vm_set_page_dirty(
1937         struct page             *page)
1938 {
1939         struct address_space    *mapping = page->mapping;
1940         struct inode            *inode = mapping->host;
1941         loff_t                  end_offset;
1942         loff_t                  offset;
1943         int                     newly_dirty;
1944         struct mem_cgroup       *memcg;
1945
1946         if (unlikely(!mapping))
1947                 return !TestSetPageDirty(page);
1948
1949         end_offset = i_size_read(inode);
1950         offset = page_offset(page);
1951
1952         spin_lock(&mapping->private_lock);
1953         if (page_has_buffers(page)) {
1954                 struct buffer_head *head = page_buffers(page);
1955                 struct buffer_head *bh = head;
1956
1957                 do {
1958                         if (offset < end_offset)
1959                                 set_buffer_dirty(bh);
1960                         bh = bh->b_this_page;
1961                         offset += 1 << inode->i_blkbits;
1962                 } while (bh != head);
1963         }
1964         /*
1965          * Use mem_group_begin_page_stat() to keep PageDirty synchronized with
1966          * per-memcg dirty page counters.
1967          */
1968         memcg = mem_cgroup_begin_page_stat(page);
1969         newly_dirty = !TestSetPageDirty(page);
1970         spin_unlock(&mapping->private_lock);
1971
1972         if (newly_dirty) {
1973                 /* sigh - __set_page_dirty() is static, so copy it here, too */
1974                 unsigned long flags;
1975
1976                 spin_lock_irqsave(&mapping->tree_lock, flags);
1977                 if (page->mapping) {    /* Race with truncate? */
1978                         WARN_ON_ONCE(!PageUptodate(page));
1979                         account_page_dirtied(page, mapping, memcg);
1980                         radix_tree_tag_set(&mapping->page_tree,
1981                                         page_index(page), PAGECACHE_TAG_DIRTY);
1982                 }
1983                 spin_unlock_irqrestore(&mapping->tree_lock, flags);
1984         }
1985         mem_cgroup_end_page_stat(memcg);
1986         if (newly_dirty)
1987                 __mark_inode_dirty(mapping->host, I_DIRTY_PAGES);
1988         return newly_dirty;
1989 }
1990
1991 const struct address_space_operations xfs_address_space_operations = {
1992         .readpage               = xfs_vm_readpage,
1993         .readpages              = xfs_vm_readpages,
1994         .writepage              = xfs_vm_writepage,
1995         .writepages             = xfs_vm_writepages,
1996         .set_page_dirty         = xfs_vm_set_page_dirty,
1997         .releasepage            = xfs_vm_releasepage,
1998         .invalidatepage         = xfs_vm_invalidatepage,
1999         .write_begin            = xfs_vm_write_begin,
2000         .write_end              = xfs_vm_write_end,
2001         .bmap                   = xfs_vm_bmap,
2002         .direct_IO              = xfs_vm_direct_IO,
2003         .migratepage            = buffer_migrate_page,
2004         .is_partially_uptodate  = block_is_partially_uptodate,
2005         .error_remove_page      = generic_error_remove_page,
2006 };