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_bit.h"
  20 #include "xfs_log.h"
  21 #include "xfs_inum.h"
  22 #include "xfs_sb.h"
  23 #include "xfs_ag.h"
  24 #include "xfs_trans.h"
  25 #include "xfs_mount.h"
  26 #include "xfs_bmap_btree.h"
  27 #include "xfs_dinode.h"
  28 #include "xfs_inode.h"
  29 #include "xfs_alloc.h"
  30 #include "xfs_error.h"
  31 #include "xfs_rw.h"
  32 #include "xfs_iomap.h"
  33 #include "xfs_vnodeops.h"
  34 #include "xfs_trace.h"
  35 #include "xfs_bmap.h"
  36 #include <linux/gfp.h>
  37 #include <linux/mpage.h>
  38 #include <linux/pagevec.h>
  39 #include <linux/writeback.h>
  40
  41 void
  42 xfs_count_page_state(
  43         struct page             *page,
  44         int                     *delalloc,
  45         int                     *unwritten)
  46 {
  47         struct buffer_head      *bh, *head;
  48
  49         *delalloc = *unwritten = 0;
  50
  51         bh = head = page_buffers(page);
  52         do {
  53                 if (buffer_unwritten(bh))
  54                         (*unwritten) = 1;
  55                 else if (buffer_delay(bh))
  56                         (*delalloc) = 1;
  57         } while ((bh = bh->b_this_page) != head);
  58 }
  59
  60 STATIC struct block_device *
  61 xfs_find_bdev_for_inode(
  62         struct inode            *inode)
  63 {
  64         struct xfs_inode        *ip = XFS_I(inode);
  65         struct xfs_mount        *mp = ip->i_mount;
  66
  67         if (XFS_IS_REALTIME_INODE(ip))
  68                 return mp->m_rtdev_targp->bt_bdev;
  69         else
  70                 return mp->m_ddev_targp->bt_bdev;
  71 }
  72
  73 /*
  74  * We're now finished for good with this ioend structure.
  75  * Update the page state via the associated buffer_heads,
  76  * release holds on the inode and bio, and finally free
  77  * up memory.  Do not use the ioend after this.
  78  */
  79 STATIC void
  80 xfs_destroy_ioend(
  81         xfs_ioend_t             *ioend)
  82 {
  83         struct buffer_head      *bh, *next;
  84
  85         for (bh = ioend->io_buffer_head; bh; bh = next) {
  86                 next = bh->b_private;
  87                 bh->b_end_io(bh, !ioend->io_error);
  88         }
  89
  90         if (ioend->io_iocb) {
  91                 if (ioend->io_isasync) {
  92                         aio_complete(ioend->io_iocb, ioend->io_error ?
  93                                         ioend->io_error : ioend->io_result, 0);
  94                 }
  95                 inode_dio_done(ioend->io_inode);
  96         }
  97
  98         mempool_free(ioend, xfs_ioend_pool);
  99 }
 100
 101 /*
 102  * If the end of the current ioend is beyond the current EOF,
 103  * return the new EOF value, otherwise zero.
 104  */
 105 STATIC xfs_fsize_t
 106 xfs_ioend_new_eof(
 107         xfs_ioend_t             *ioend)
 108 {
 109         xfs_inode_t             *ip = XFS_I(ioend->io_inode);
 110         xfs_fsize_t             isize;
 111         xfs_fsize_t             bsize;
 112
 113         bsize = ioend->io_offset + ioend->io_size;
 114         isize = MIN(i_size_read(VFS_I(ip)), bsize);
 115         return isize > ip->i_d.di_size ? isize : 0;
 116 }
 117
 118 /*
 119  * Fast and loose check if this write could update the on-disk inode size.
 120  */
 121 static inline bool xfs_ioend_is_append(struct xfs_ioend *ioend)
 122 {
 123         return ioend->io_offset + ioend->io_size >
 124                 XFS_I(ioend->io_inode)->i_d.di_size;
 125 }
 126
 127 /*
 128  * Update on-disk file size now that data has been written to disk.
 129  *
 130  * This function does not block as blocking on the inode lock in IO completion
 131  * can lead to IO completion order dependency deadlocks.. If it can't get the
 132  * inode ilock it will return EAGAIN. Callers must handle this.
 133  */
 134 STATIC int
 135 xfs_setfilesize(
 136         xfs_ioend_t             *ioend)
 137 {
 138         xfs_inode_t             *ip = XFS_I(ioend->io_inode);
 139         xfs_fsize_t             isize;
 140
 141         if (!xfs_ilock_nowait(ip, XFS_ILOCK_EXCL))
 142                 return EAGAIN;
 143
 144         isize = xfs_ioend_new_eof(ioend);
 145         if (isize) {
 146                 trace_xfs_setfilesize(ip, ioend->io_offset, ioend->io_size);
 147                 ip->i_d.di_size = isize;
 148                 xfs_mark_inode_dirty(ip);
 149         }
 150
 151         xfs_iunlock(ip, XFS_ILOCK_EXCL);
 152         return 0;
 153 }
 154
 155 /*
 156  * Schedule IO completion handling on the final put of an ioend.
 157  *
 158  * If there is no work to do we might as well call it a day and free the
 159  * ioend right now.
 160  */
 161 STATIC void
 162 xfs_finish_ioend(
 163         struct xfs_ioend        *ioend)
 164 {
 165         if (atomic_dec_and_test(&ioend->io_remaining)) {
 166                 if (ioend->io_type == IO_UNWRITTEN)
 167                         queue_work(xfsconvertd_workqueue, &ioend->io_work);
 168                 else if (xfs_ioend_is_append(ioend))
 169                         queue_work(xfsdatad_workqueue, &ioend->io_work);
 170                 else
 171                         xfs_destroy_ioend(ioend);
 172         }
 173 }
 174
 175 /*
 176  * IO write completion.
 177  */
 178 STATIC void
 179 xfs_end_io(
 180         struct work_struct *work)
 181 {
 182         xfs_ioend_t     *ioend = container_of(work, xfs_ioend_t, io_work);
 183         struct xfs_inode *ip = XFS_I(ioend->io_inode);
 184         int             error = 0;
 185
 186         if (XFS_FORCED_SHUTDOWN(ip->i_mount)) {
 187                 ioend->io_error = -EIO;
 188                 goto done;
 189         }
 190         if (ioend->io_error)
 191                 goto done;
 192
 193         /*
 194          * For unwritten extents we need to issue transactions to convert a
 195          * range to normal written extens after the data I/O has finished.
 196          */
 197         if (ioend->io_type == IO_UNWRITTEN) {
 198                 error = xfs_iomap_write_unwritten(ip, ioend->io_offset,
 199                                                  ioend->io_size);
 200                 if (error) {
 201                         ioend->io_error = -error;
 202                         goto done;
 203                 }
 204         }
 205
 206         /*
 207          * We might have to update the on-disk file size after extending
 208          * writes.
 209          */
 210         error = xfs_setfilesize(ioend);
 211         ASSERT(!error || error == EAGAIN);
 212
 213 done:
 214         /*
 215          * If we didn't complete processing of the ioend, requeue it to the
 216          * tail of the workqueue for another attempt later. Otherwise destroy
 217          * it.
 218          */
 219         if (error == EAGAIN) {
 220                 atomic_inc(&ioend->io_remaining);
 221                 xfs_finish_ioend(ioend);
 222                 /* ensure we don't spin on blocked ioends */
 223                 delay(1);
 224         } else {
 225                 xfs_destroy_ioend(ioend);
 226         }
 227 }
 228
 229 /*
 230  * Call IO completion handling in caller context on the final put of an ioend.
 231  */
 232 STATIC void
 233 xfs_finish_ioend_sync(
 234         struct xfs_ioend        *ioend)
 235 {
 236         if (atomic_dec_and_test(&ioend->io_remaining))
 237                 xfs_end_io(&ioend->io_work);
 238 }
 239
 240 /*
 241  * Allocate and initialise an IO completion structure.
 242  * We need to track unwritten extent write completion here initially.
 243  * We'll need to extend this for updating the ondisk inode size later
 244  * (vs. incore size).
 245  */
 246 STATIC xfs_ioend_t *
 247 xfs_alloc_ioend(
 248         struct inode            *inode,
 249         unsigned int            type)
 250 {
 251         xfs_ioend_t             *ioend;
 252
 253         ioend = mempool_alloc(xfs_ioend_pool, GFP_NOFS);
 254
 255         /*
 256          * Set the count to 1 initially, which will prevent an I/O
 257          * completion callback from happening before we have started
 258          * all the I/O from calling the completion routine too early.
 259          */
 260         atomic_set(&ioend->io_remaining, 1);
 261         ioend->io_isasync = 0;
 262         ioend->io_error = 0;
 263         ioend->io_list = NULL;
 264         ioend->io_type = type;
 265         ioend->io_inode = inode;
 266         ioend->io_buffer_head = NULL;
 267         ioend->io_buffer_tail = NULL;
 268         ioend->io_offset = 0;
 269         ioend->io_size = 0;
 270         ioend->io_iocb = NULL;
 271         ioend->io_result = 0;
 272
 273         INIT_WORK(&ioend->io_work, xfs_end_io);
 274         return ioend;
 275 }
 276
 277 STATIC int
 278 xfs_map_blocks(
 279         struct inode            *inode,
 280         loff_t                  offset,
 281         struct xfs_bmbt_irec    *imap,
 282         int                     type,
 283         int                     nonblocking)
 284 {
 285         struct xfs_inode        *ip = XFS_I(inode);
 286         struct xfs_mount        *mp = ip->i_mount;
 287         ssize_t                 count = 1 << inode->i_blkbits;
 288         xfs_fileoff_t           offset_fsb, end_fsb;
 289         int                     error = 0;
 290         int                     bmapi_flags = XFS_BMAPI_ENTIRE;
 291         int                     nimaps = 1;
 292
 293         if (XFS_FORCED_SHUTDOWN(mp))
 294                 return -XFS_ERROR(EIO);
 295
 296         if (type == IO_UNWRITTEN)
 297                 bmapi_flags |= XFS_BMAPI_IGSTATE;
 298
 299         if (!xfs_ilock_nowait(ip, XFS_ILOCK_SHARED)) {
 300                 if (nonblocking)
 301                         return -XFS_ERROR(EAGAIN);
 302                 xfs_ilock(ip, XFS_ILOCK_SHARED);
 303         }
 304
 305         ASSERT(ip->i_d.di_format != XFS_DINODE_FMT_BTREE ||
 306                (ip->i_df.if_flags & XFS_IFEXTENTS));
 307         ASSERT(offset <= mp->m_maxioffset);
 308
 309         if (offset + count > mp->m_maxioffset)
 310                 count = mp->m_maxioffset - offset;
 311         end_fsb = XFS_B_TO_FSB(mp, (xfs_ufsize_t)offset + count);
 312         offset_fsb = XFS_B_TO_FSBT(mp, offset);
 313         error = xfs_bmapi_read(ip, offset_fsb, end_fsb - offset_fsb,
 314                                 imap, &nimaps, bmapi_flags);
 315         xfs_iunlock(ip, XFS_ILOCK_SHARED);
 316
 317         if (error)
 318                 return -XFS_ERROR(error);
 319
 320         if (type == IO_DELALLOC &&
 321             (!nimaps || isnullstartblock(imap->br_startblock))) {
 322                 error = xfs_iomap_write_allocate(ip, offset, count, imap);
 323                 if (!error)
 324                         trace_xfs_map_blocks_alloc(ip, offset, count, type, imap);
 325                 return -XFS_ERROR(error);
 326         }
 327
 328 #ifdef DEBUG
 329         if (type == IO_UNWRITTEN) {
 330                 ASSERT(nimaps);
 331                 ASSERT(imap->br_startblock != HOLESTARTBLOCK);
 332                 ASSERT(imap->br_startblock != DELAYSTARTBLOCK);
 333         }
 334 #endif
 335         if (nimaps)
 336                 trace_xfs_map_blocks_found(ip, offset, count, type, imap);
 337         return 0;
 338 }
 339
 340 STATIC int
 341 xfs_imap_valid(
 342         struct inode            *inode,
 343         struct xfs_bmbt_irec    *imap,
 344         xfs_off_t               offset)
 345 {
 346         offset >>= inode->i_blkbits;
 347
 348         return offset >= imap->br_startoff &&
 349                 offset < imap->br_startoff + imap->br_blockcount;
 350 }
 351
 352 /*
 353  * BIO completion handler for buffered IO.
 354  */
 355 STATIC void
 356 xfs_end_bio(
 357         struct bio              *bio,
 358         int                     error)
 359 {
 360         xfs_ioend_t             *ioend = bio->bi_private;
 361
 362         ASSERT(atomic_read(&bio->bi_cnt) >= 1);
 363         ioend->io_error = test_bit(BIO_UPTODATE, &bio->bi_flags) ? 0 : error;
 364
 365         /* Toss bio and pass work off to an xfsdatad thread */
 366         bio->bi_private = NULL;
 367         bio->bi_end_io = NULL;
 368         bio_put(bio);
 369
 370         xfs_finish_ioend(ioend);
 371 }
 372
 373 STATIC void
 374 xfs_submit_ioend_bio(
 375         struct writeback_control *wbc,
 376         xfs_ioend_t             *ioend,
 377         struct bio              *bio)
 378 {
 379         atomic_inc(&ioend->io_remaining);
 380         bio->bi_private = ioend;
 381         bio->bi_end_io = xfs_end_bio;
 382
 383         /*
 384          * If the I/O is beyond EOF we mark the inode dirty immediately
 385          * but don't update the inode size until I/O completion.
 386          */
 387         if (xfs_ioend_new_eof(ioend))
 388                 xfs_mark_inode_dirty(XFS_I(ioend->io_inode));
 389
 390         submit_bio(wbc->sync_mode == WB_SYNC_ALL ? WRITE_SYNC : WRITE, bio);
 391 }
 392
 393 STATIC struct bio *
 394 xfs_alloc_ioend_bio(
 395         struct buffer_head      *bh)
 396 {
 397         int                     nvecs = bio_get_nr_vecs(bh->b_bdev);
 398         struct bio              *bio = bio_alloc(GFP_NOIO, nvecs);
 399
 400         ASSERT(bio->bi_private == NULL);
 401         bio->bi_sector = bh->b_blocknr * (bh->b_size >> 9);
 402         bio->bi_bdev = bh->b_bdev;
 403         return bio;
 404 }
 405
 406 STATIC void
 407 xfs_start_buffer_writeback(
 408         struct buffer_head      *bh)
 409 {
 410         ASSERT(buffer_mapped(bh));
 411         ASSERT(buffer_locked(bh));
 412         ASSERT(!buffer_delay(bh));
 413         ASSERT(!buffer_unwritten(bh));
 414
 415         mark_buffer_async_write(bh);
 416         set_buffer_uptodate(bh);
 417         clear_buffer_dirty(bh);
 418 }
 419
 420 STATIC void
 421 xfs_start_page_writeback(
 422         struct page             *page,
 423         int                     clear_dirty,
 424         int                     buffers)
 425 {
 426         ASSERT(PageLocked(page));
 427         ASSERT(!PageWriteback(page));
 428         if (clear_dirty)
 429                 clear_page_dirty_for_io(page);
 430         set_page_writeback(page);
 431         unlock_page(page);
 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 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 STATIC void
 460 xfs_submit_ioend(
 461         struct writeback_control *wbc,
 462         xfs_ioend_t             *ioend)
 463 {
 464         xfs_ioend_t             *head = ioend;
 465         xfs_ioend_t             *next;
 466         struct buffer_head      *bh;
 467         struct bio              *bio;
 468         sector_t                lastblock = 0;
 469
 470         /* Pass 1 - start writeback */
 471         do {
 472                 next = ioend->io_list;
 473                 for (bh = ioend->io_buffer_head; bh; bh = bh->b_private)
 474                         xfs_start_buffer_writeback(bh);
 475         } while ((ioend = next) != NULL);
 476
 477         /* Pass 2 - submit I/O */
 478         ioend = head;
 479         do {
 480                 next = ioend->io_list;
 481                 bio = NULL;
 482
 483                 for (bh = ioend->io_buffer_head; bh; bh = bh->b_private) {
 484
 485                         if (!bio) {
 486  retry:
 487                                 bio = xfs_alloc_ioend_bio(bh);
 488                         } else if (bh->b_blocknr != lastblock + 1) {
 489                                 xfs_submit_ioend_bio(wbc, ioend, bio);
 490                                 goto retry;
 491                         }
 492
 493                         if (bio_add_buffer(bio, bh) != bh->b_size) {
 494                                 xfs_submit_ioend_bio(wbc, ioend, bio);
 495                                 goto retry;
 496                         }
 497
 498                         lastblock = bh->b_blocknr;
 499                 }
 500                 if (bio)
 501                         xfs_submit_ioend_bio(wbc, ioend, bio);
 502                 xfs_finish_ioend(ioend);
 503         } while ((ioend = next) != NULL);
 504 }
 505
 506 /*
 507  * Cancel submission of all buffer_heads so far in this endio.
 508  * Toss the endio too.  Only ever called for the initial page
 509  * in a writepage request, so only ever one page.
 510  */
 511 STATIC void
 512 xfs_cancel_ioend(
 513         xfs_ioend_t             *ioend)
 514 {
 515         xfs_ioend_t             *next;
 516         struct buffer_head      *bh, *next_bh;
 517
 518         do {
 519                 next = ioend->io_list;
 520                 bh = ioend->io_buffer_head;
 521                 do {
 522                         next_bh = bh->b_private;
 523                         clear_buffer_async_write(bh);
 524                         unlock_buffer(bh);
 525                 } while ((bh = next_bh) != NULL);
 526
 527                 mempool_free(ioend, xfs_ioend_pool);
 528         } while ((ioend = next) != NULL);
 529 }
 530
 531 /*
 532  * Test to see if we've been building up a completion structure for
 533  * earlier buffers -- if so, we try to append to this ioend if we
 534  * can, otherwise we finish off any current ioend and start another.
 535  * Return true if we've finished the given ioend.
 536  */
 537 STATIC void
 538 xfs_add_to_ioend(
 539         struct inode            *inode,
 540         struct buffer_head      *bh,
 541         xfs_off_t               offset,
 542         unsigned int            type,
 543         xfs_ioend_t             **result,
 544         int                     need_ioend)
 545 {
 546         xfs_ioend_t             *ioend = *result;
 547
 548         if (!ioend || need_ioend || type != ioend->io_type) {
 549                 xfs_ioend_t     *previous = *result;
 550
 551                 ioend = xfs_alloc_ioend(inode, type);
 552                 ioend->io_offset = offset;
 553                 ioend->io_buffer_head = bh;
 554                 ioend->io_buffer_tail = bh;
 555                 if (previous)
 556                         previous->io_list = ioend;
 557                 *result = ioend;
 558         } else {
 559                 ioend->io_buffer_tail->b_private = bh;
 560                 ioend->io_buffer_tail = bh;
 561         }
 562
 563         bh->b_private = NULL;
 564         ioend->io_size += bh->b_size;
 565 }
 566
 567 STATIC void
 568 xfs_map_buffer(
 569         struct inode            *inode,
 570         struct buffer_head      *bh,
 571         struct xfs_bmbt_irec    *imap,
 572         xfs_off_t               offset)
 573 {
 574         sector_t                bn;
 575         struct xfs_mount        *m = XFS_I(inode)->i_mount;
 576         xfs_off_t               iomap_offset = XFS_FSB_TO_B(m, imap->br_startoff);
 577         xfs_daddr_t             iomap_bn = xfs_fsb_to_db(XFS_I(inode), imap->br_startblock);
 578
 579         ASSERT(imap->br_startblock != HOLESTARTBLOCK);
 580         ASSERT(imap->br_startblock != DELAYSTARTBLOCK);
 581
 582         bn = (iomap_bn >> (inode->i_blkbits - BBSHIFT)) +
 583               ((offset - iomap_offset) >> inode->i_blkbits);
 584
 585         ASSERT(bn || XFS_IS_REALTIME_INODE(XFS_I(inode)));
 586
 587         bh->b_blocknr = bn;
 588         set_buffer_mapped(bh);
 589 }
 590
 591 STATIC void
 592 xfs_map_at_offset(
 593         struct inode            *inode,
 594         struct buffer_head      *bh,
 595         struct xfs_bmbt_irec    *imap,
 596         xfs_off_t               offset)
 597 {
 598         ASSERT(imap->br_startblock != HOLESTARTBLOCK);
 599         ASSERT(imap->br_startblock != DELAYSTARTBLOCK);
 600
 601         xfs_map_buffer(inode, bh, imap, offset);
 602         set_buffer_mapped(bh);
 603         clear_buffer_delay(bh);
 604         clear_buffer_unwritten(bh);
 605 }
 606
 607 /*
 608  * Test if a given page is suitable for writing as part of an unwritten
 609  * or delayed allocate extent.
 610  */
 611 STATIC int
 612 xfs_is_delayed_page(
 613         struct page             *page,
 614         unsigned int            type)
 615 {
 616         if (PageWriteback(page))
 617                 return 0;
 618
 619         if (page->mapping && page_has_buffers(page)) {
 620                 struct buffer_head      *bh, *head;
 621                 int                     acceptable = 0;
 622
 623                 bh = head = page_buffers(page);
 624                 do {
 625                         if (buffer_unwritten(bh))
 626                                 acceptable = (type == IO_UNWRITTEN);
 627                         else if (buffer_delay(bh))
 628                                 acceptable = (type == IO_DELALLOC);
 629                         else if (buffer_dirty(bh) && buffer_mapped(bh))
 630                                 acceptable = (type == IO_OVERWRITE);
 631                         else
 632                                 break;
 633                 } while ((bh = bh->b_this_page) != head);
 634
 635                 if (acceptable)
 636                         return 1;
 637         }
 638
 639         return 0;
 640 }
 641
 642 /*
 643  * Allocate & map buffers for page given the extent map. Write it out.
 644  * except for the original page of a writepage, this is called on
 645  * delalloc/unwritten pages only, for the original page it is possible
 646  * that the page has no mapping at all.
 647  */
 648 STATIC int
 649 xfs_convert_page(
 650         struct inode            *inode,
 651         struct page             *page,
 652         loff_t                  tindex,
 653         struct xfs_bmbt_irec    *imap,
 654         xfs_ioend_t             **ioendp,
 655         struct writeback_control *wbc)
 656 {
 657         struct buffer_head      *bh, *head;
 658         xfs_off_t               end_offset;
 659         unsigned long           p_offset;
 660         unsigned int            type;
 661         int                     len, page_dirty;
 662         int                     count = 0, done = 0, uptodate = 1;
 663         xfs_off_t               offset = page_offset(page);
 664
 665         if (page->index != tindex)
 666                 goto fail;
 667         if (!trylock_page(page))
 668                 goto fail;
 669         if (PageWriteback(page))
 670                 goto fail_unlock_page;
 671         if (page->mapping != inode->i_mapping)
 672                 goto fail_unlock_page;
 673         if (!xfs_is_delayed_page(page, (*ioendp)->io_type))
 674                 goto fail_unlock_page;
 675
 676         /*
 677          * page_dirty is initially a count of buffers on the page before
 678          * EOF and is decremented as we move each into a cleanable state.
 679          *
 680          * Derivation:
 681          *
 682          * End offset is the highest offset that this page should represent.
 683          * If we are on the last page, (end_offset & (PAGE_CACHE_SIZE - 1))
 684          * will evaluate non-zero and be less than PAGE_CACHE_SIZE and
 685          * hence give us the correct page_dirty count. On any other page,
 686          * it will be zero and in that case we need page_dirty to be the
 687          * count of buffers on the page.
 688          */
 689         end_offset = min_t(unsigned long long,
 690                         (xfs_off_t)(page->index + 1) << PAGE_CACHE_SHIFT,
 691                         i_size_read(inode));
 692
 693         len = 1 << inode->i_blkbits;
 694         p_offset = min_t(unsigned long, end_offset & (PAGE_CACHE_SIZE - 1),
 695                                         PAGE_CACHE_SIZE);
 696         p_offset = p_offset ? roundup(p_offset, len) : PAGE_CACHE_SIZE;
 697         page_dirty = p_offset / len;
 698
 699         bh = head = page_buffers(page);
 700         do {
 701                 if (offset >= end_offset)
 702                         break;
 703                 if (!buffer_uptodate(bh))
 704                         uptodate = 0;
 705                 if (!(PageUptodate(page) || buffer_uptodate(bh))) {
 706                         done = 1;
 707                         continue;
 708                 }
 709
 710                 if (buffer_unwritten(bh) || buffer_delay(bh) ||
 711                     buffer_mapped(bh)) {
 712                         if (buffer_unwritten(bh))
 713                                 type = IO_UNWRITTEN;
 714                         else if (buffer_delay(bh))
 715                                 type = IO_DELALLOC;
 716                         else
 717                                 type = IO_OVERWRITE;
 718
 719                         if (!xfs_imap_valid(inode, imap, offset)) {
 720                                 done = 1;
 721                                 continue;
 722                         }
 723
 724                         lock_buffer(bh);
 725                         if (type != IO_OVERWRITE)
 726                                 xfs_map_at_offset(inode, bh, imap, offset);
 727                         xfs_add_to_ioend(inode, bh, offset, type,
 728                                          ioendp, done);
 729
 730                         page_dirty--;
 731                         count++;
 732                 } else {
 733                         done = 1;
 734                 }
 735         } while (offset += len, (bh = bh->b_this_page) != head);
 736
 737         if (uptodate && bh == head)
 738                 SetPageUptodate(page);
 739
 740         if (count) {
 741                 if (--wbc->nr_to_write <= 0 &&
 742                     wbc->sync_mode == WB_SYNC_NONE)
 743                         done = 1;
 744         }
 745         xfs_start_page_writeback(page, !page_dirty, count);
 746
 747         return done;
 748  fail_unlock_page:
 749         unlock_page(page);
 750  fail:
 751         return 1;
 752 }
 753
 754 /*
 755  * Convert & write out a cluster of pages in the same extent as defined
 756  * by mp and following the start page.
 757  */
 758 STATIC void
 759 xfs_cluster_write(
 760         struct inode            *inode,
 761         pgoff_t                 tindex,
 762         struct xfs_bmbt_irec    *imap,
 763         xfs_ioend_t             **ioendp,
 764         struct writeback_control *wbc,
 765         pgoff_t                 tlast)
 766 {
 767         struct pagevec          pvec;
 768         int                     done = 0, i;
 769
 770         pagevec_init(&pvec, 0);
 771         while (!done && tindex <= tlast) {
 772                 unsigned len = min_t(pgoff_t, PAGEVEC_SIZE, tlast - tindex + 1);
 773
 774                 if (!pagevec_lookup(&pvec, inode->i_mapping, tindex, len))
 775                         break;
 776
 777                 for (i = 0; i < pagevec_count(&pvec); i++) {
 778                         done = xfs_convert_page(inode, pvec.pages[i], tindex++,
 779                                         imap, ioendp, wbc);
 780                         if (done)
 781                                 break;
 782                 }
 783
 784                 pagevec_release(&pvec);
 785                 cond_resched();
 786         }
 787 }
 788
 789 STATIC void
 790 xfs_vm_invalidatepage(
 791         struct page             *page,
 792         unsigned long           offset)
 793 {
 794         trace_xfs_invalidatepage(page->mapping->host, page, offset);
 795         block_invalidatepage(page, offset);
 796 }
 797
 798 /*
 799  * If the page has delalloc buffers on it, we need to punch them out before we
 800  * invalidate the page. If we don't, we leave a stale delalloc mapping on the
 801  * inode that can trip a BUG() in xfs_get_blocks() later on if a direct IO read
 802  * is done on that same region - the delalloc extent is returned when none is
 803  * supposed to be there.
 804  *
 805  * We prevent this by truncating away the delalloc regions on the page before
 806  * invalidating it. Because they are delalloc, we can do this without needing a
 807  * transaction. Indeed - if we get ENOSPC errors, we have to be able to do this
 808  * truncation without a transaction as there is no space left for block
 809  * reservation (typically why we see a ENOSPC in writeback).
 810  *
 811  * This is not a performance critical path, so for now just do the punching a
 812  * buffer head at a time.
 813  */
 814 STATIC void
 815 xfs_aops_discard_page(
 816         struct page             *page)
 817 {
 818         struct inode            *inode = page->mapping->host;
 819         struct xfs_inode        *ip = XFS_I(inode);
 820         struct buffer_head      *bh, *head;
 821         loff_t                  offset = page_offset(page);
 822
 823         if (!xfs_is_delayed_page(page, IO_DELALLOC))
 824                 goto out_invalidate;
 825
 826         if (XFS_FORCED_SHUTDOWN(ip->i_mount))
 827                 goto out_invalidate;
 828
 829         xfs_alert(ip->i_mount,
 830                 "page discard on page %p, inode 0x%llx, offset %llu.",
 831                         page, ip->i_ino, offset);
 832
 833         xfs_ilock(ip, XFS_ILOCK_EXCL);
 834         bh = head = page_buffers(page);
 835         do {
 836                 int             error;
 837                 xfs_fileoff_t   start_fsb;
 838
 839                 if (!buffer_delay(bh))
 840                         goto next_buffer;
 841
 842                 start_fsb = XFS_B_TO_FSBT(ip->i_mount, offset);
 843                 error = xfs_bmap_punch_delalloc_range(ip, start_fsb, 1);
 844                 if (error) {
 845                         /* something screwed, just bail */
 846                         if (!XFS_FORCED_SHUTDOWN(ip->i_mount)) {
 847                                 xfs_alert(ip->i_mount,
 848                         "page discard unable to remove delalloc mapping.");
 849                         }
 850                         break;
 851                 }
 852 next_buffer:
 853                 offset += 1 << inode->i_blkbits;
 854
 855         } while ((bh = bh->b_this_page) != head);
 856
 857         xfs_iunlock(ip, XFS_ILOCK_EXCL);
 858 out_invalidate:
 859         xfs_vm_invalidatepage(page, 0);
 860         return;
 861 }
 862
 863 /*
 864  * Write out a dirty page.
 865  *
 866  * For delalloc space on the page we need to allocate space and flush it.
 867  * For unwritten space on the page we need to start the conversion to
 868  * regular allocated space.
 869  * For any other dirty buffer heads on the page we should flush them.
 870  */
 871 STATIC int
 872 xfs_vm_writepage(
 873         struct page             *page,
 874         struct writeback_control *wbc)
 875 {
 876         struct inode            *inode = page->mapping->host;
 877         struct buffer_head      *bh, *head;
 878         struct xfs_bmbt_irec    imap;
 879         xfs_ioend_t             *ioend = NULL, *iohead = NULL;
 880         loff_t                  offset;
 881         unsigned int            type;
 882         __uint64_t              end_offset;
 883         pgoff_t                 end_index, last_index;
 884         ssize_t                 len;
 885         int                     err, imap_valid = 0, uptodate = 1;
 886         int                     count = 0;
 887         int                     nonblocking = 0;
 888
 889         trace_xfs_writepage(inode, page, 0);
 890
 891         ASSERT(page_has_buffers(page));
 892
 893         /*
 894          * Refuse to write the page out if we are called from reclaim context.
 895          *
 896          * This avoids stack overflows when called from deeply used stacks in
 897          * random callers for direct reclaim or memcg reclaim.  We explicitly
 898          * allow reclaim from kswapd as the stack usage there is relatively low.
 899          *
 900          * This should never happen except in the case of a VM regression so
 901          * warn about it.
 902          */
 903         if (WARN_ON_ONCE((current->flags & (PF_MEMALLOC|PF_KSWAPD)) ==
 904                         PF_MEMALLOC))
 905                 goto redirty;
 906
 907         /*
 908          * Given that we do not allow direct reclaim to call us, we should
 909          * never be called while in a filesystem transaction.
 910          */
 911         if (WARN_ON(current->flags & PF_FSTRANS))
 912                 goto redirty;
 913
 914         /* Is this page beyond the end of the file? */
 915         offset = i_size_read(inode);
 916         end_index = offset >> PAGE_CACHE_SHIFT;
 917         last_index = (offset - 1) >> PAGE_CACHE_SHIFT;
 918         if (page->index >= end_index) {
 919                 if ((page->index >= end_index + 1) ||
 920                     !(i_size_read(inode) & (PAGE_CACHE_SIZE - 1))) {
 921                         unlock_page(page);
 922                         return 0;
 923                 }
 924         }
 925
 926         end_offset = min_t(unsigned long long,
 927                         (xfs_off_t)(page->index + 1) << PAGE_CACHE_SHIFT,
 928                         offset);
 929         len = 1 << inode->i_blkbits;
 930
 931         bh = head = page_buffers(page);
 932         offset = page_offset(page);
 933         type = IO_OVERWRITE;
 934
 935         if (wbc->sync_mode == WB_SYNC_NONE)
 936                 nonblocking = 1;
 937
 938         do {
 939                 int new_ioend = 0;
 940
 941                 if (offset >= end_offset)
 942                         break;
 943                 if (!buffer_uptodate(bh))
 944                         uptodate = 0;
 945
 946                 /*
 947                  * set_page_dirty dirties all buffers in a page, independent
 948                  * of their state.  The dirty state however is entirely
 949                  * meaningless for holes (!mapped && uptodate), so skip
 950                  * buffers covering holes here.
 951                  */
 952                 if (!buffer_mapped(bh) && buffer_uptodate(bh)) {
 953                         imap_valid = 0;
 954                         continue;
 955                 }
 956
 957                 if (buffer_unwritten(bh)) {
 958                         if (type != IO_UNWRITTEN) {
 959                                 type = IO_UNWRITTEN;
 960                                 imap_valid = 0;
 961                         }
 962                 } else if (buffer_delay(bh)) {
 963                         if (type != IO_DELALLOC) {
 964                                 type = IO_DELALLOC;
 965                                 imap_valid = 0;
 966                         }
 967                 } else if (buffer_uptodate(bh)) {
 968                         if (type != IO_OVERWRITE) {
 969                                 type = IO_OVERWRITE;
 970                                 imap_valid = 0;
 971                         }
 972                 } else {
 973                         if (PageUptodate(page)) {
 974                                 ASSERT(buffer_mapped(bh));
 975                                 imap_valid = 0;
 976                         }
 977                         continue;
 978                 }
 979
 980                 if (imap_valid)
 981                         imap_valid = xfs_imap_valid(inode, &imap, offset);
 982                 if (!imap_valid) {
 983                         /*
 984                          * If we didn't have a valid mapping then we need to
 985                          * put the new mapping into a separate ioend structure.
 986                          * This ensures non-contiguous extents always have
 987                          * separate ioends, which is particularly important
 988                          * for unwritten extent conversion at I/O completion
 989                          * time.
 990                          */
 991                         new_ioend = 1;
 992                         err = xfs_map_blocks(inode, offset, &imap, type,
 993                                              nonblocking);
 994                         if (err)
 995                                 goto error;
 996                         imap_valid = xfs_imap_valid(inode, &imap, offset);
 997                 }
 998                 if (imap_valid) {
 999                         lock_buffer(bh);
1000                         if (type != IO_OVERWRITE)
1001                                 xfs_map_at_offset(inode, bh, &imap, offset);
1002                         xfs_add_to_ioend(inode, bh, offset, type, &ioend,
1003                                          new_ioend);
1004                         count++;
1005                 }
1006
1007                 if (!iohead)
1008                         iohead = ioend;
1009
1010         } while (offset += len, ((bh = bh->b_this_page) != head));
1011
1012         if (uptodate && bh == head)
1013                 SetPageUptodate(page);
1014
1015         xfs_start_page_writeback(page, 1, count);
1016
1017         if (ioend && imap_valid) {
1018                 xfs_off_t               end_index;
1019
1020                 end_index = imap.br_startoff + imap.br_blockcount;
1021
1022                 /* to bytes */
1023                 end_index <<= inode->i_blkbits;
1024
1025                 /* to pages */
1026                 end_index = (end_index - 1) >> PAGE_CACHE_SHIFT;
1027
1028                 /* check against file size */
1029                 if (end_index > last_index)
1030                         end_index = last_index;
1031
1032                 xfs_cluster_write(inode, page->index + 1, &imap, &ioend,
1033                                   wbc, end_index);
1034         }
1035
1036         if (iohead)
1037                 xfs_submit_ioend(wbc, iohead);
1038
1039         return 0;
1040
1041 error:
1042         if (iohead)
1043                 xfs_cancel_ioend(iohead);
1044
1045         if (err == -EAGAIN)
1046                 goto redirty;
1047
1048         xfs_aops_discard_page(page);
1049         ClearPageUptodate(page);
1050         unlock_page(page);
1051         return err;
1052
1053 redirty:
1054         redirty_page_for_writepage(wbc, page);
1055         unlock_page(page);
1056         return 0;
1057 }
1058
1059 STATIC int
1060 xfs_vm_writepages(
1061         struct address_space    *mapping,
1062         struct writeback_control *wbc)
1063 {
1064         xfs_iflags_clear(XFS_I(mapping->host), XFS_ITRUNCATED);
1065         return generic_writepages(mapping, wbc);
1066 }
1067
1068 /*
1069  * Called to move a page into cleanable state - and from there
1070  * to be released. The page should already be clean. We always
1071  * have buffer heads in this call.
1072  *
1073  * Returns 1 if the page is ok to release, 0 otherwise.
1074  */
1075 STATIC int
1076 xfs_vm_releasepage(
1077         struct page             *page,
1078         gfp_t                   gfp_mask)
1079 {
1080         int                     delalloc, unwritten;
1081
1082         trace_xfs_releasepage(page->mapping->host, page, 0);
1083
1084         xfs_count_page_state(page, &delalloc, &unwritten);
1085
1086         if (WARN_ON(delalloc))
1087                 return 0;
1088         if (WARN_ON(unwritten))
1089                 return 0;
1090
1091         return try_to_free_buffers(page);
1092 }
1093
1094 STATIC int
1095 __xfs_get_blocks(
1096         struct inode            *inode,
1097         sector_t                iblock,
1098         struct buffer_head      *bh_result,
1099         int                     create,
1100         int                     direct)
1101 {
1102         struct xfs_inode        *ip = XFS_I(inode);
1103         struct xfs_mount        *mp = ip->i_mount;
1104         xfs_fileoff_t           offset_fsb, end_fsb;
1105         int                     error = 0;
1106         int                     lockmode = 0;
1107         struct xfs_bmbt_irec    imap;
1108         int                     nimaps = 1;
1109         xfs_off_t               offset;
1110         ssize_t                 size;
1111         int                     new = 0;
1112
1113         if (XFS_FORCED_SHUTDOWN(mp))
1114                 return -XFS_ERROR(EIO);
1115
1116         offset = (xfs_off_t)iblock << inode->i_blkbits;
1117         ASSERT(bh_result->b_size >= (1 << inode->i_blkbits));
1118         size = bh_result->b_size;
1119
1120         if (!create && direct && offset >= i_size_read(inode))
1121                 return 0;
1122
1123         if (create) {
1124                 lockmode = XFS_ILOCK_EXCL;
1125                 xfs_ilock(ip, lockmode);
1126         } else {
1127                 lockmode = xfs_ilock_map_shared(ip);
1128         }
1129
1130         ASSERT(offset <= mp->m_maxioffset);
1131         if (offset + size > mp->m_maxioffset)
1132                 size = mp->m_maxioffset - offset;
1133         end_fsb = XFS_B_TO_FSB(mp, (xfs_ufsize_t)offset + size);
1134         offset_fsb = XFS_B_TO_FSBT(mp, offset);
1135
1136         error = xfs_bmapi_read(ip, offset_fsb, end_fsb - offset_fsb,
1137                                 &imap, &nimaps, XFS_BMAPI_ENTIRE);
1138         if (error)
1139                 goto out_unlock;
1140
1141         if (create &&
1142             (!nimaps ||
1143              (imap.br_startblock == HOLESTARTBLOCK ||
1144               imap.br_startblock == DELAYSTARTBLOCK))) {
1145                 if (direct) {
1146                         error = xfs_iomap_write_direct(ip, offset, size,
1147                                                        &imap, nimaps);
1148                 } else {
1149                         error = xfs_iomap_write_delay(ip, offset, size, &imap);
1150                 }
1151                 if (error)
1152                         goto out_unlock;
1153
1154                 trace_xfs_get_blocks_alloc(ip, offset, size, 0, &imap);
1155         } else if (nimaps) {
1156                 trace_xfs_get_blocks_found(ip, offset, size, 0, &imap);
1157         } else {
1158                 trace_xfs_get_blocks_notfound(ip, offset, size);
1159                 goto out_unlock;
1160         }
1161         xfs_iunlock(ip, lockmode);
1162
1163         if (imap.br_startblock != HOLESTARTBLOCK &&
1164             imap.br_startblock != DELAYSTARTBLOCK) {
1165                 /*
1166                  * For unwritten extents do not report a disk address on
1167                  * the read case (treat as if we're reading into a hole).
1168                  */
1169                 if (create || !ISUNWRITTEN(&imap))
1170                         xfs_map_buffer(inode, bh_result, &imap, offset);
1171                 if (create && ISUNWRITTEN(&imap)) {
1172                         if (direct)
1173                                 bh_result->b_private = inode;
1174                         set_buffer_unwritten(bh_result);
1175                 }
1176         }
1177
1178         /*
1179          * If this is a realtime file, data may be on a different device.
1180          * to that pointed to from the buffer_head b_bdev currently.
1181          */
1182         bh_result->b_bdev = xfs_find_bdev_for_inode(inode);
1183
1184         /*
1185          * If we previously allocated a block out beyond eof and we are now
1186          * coming back to use it then we will need to flag it as new even if it
1187          * has a disk address.
1188          *
1189          * With sub-block writes into unwritten extents we also need to mark
1190          * the buffer as new so that the unwritten parts of the buffer gets
1191          * correctly zeroed.
1192          */
1193         if (create &&
1194             ((!buffer_mapped(bh_result) && !buffer_uptodate(bh_result)) ||
1195              (offset >= i_size_read(inode)) ||
1196              (new || ISUNWRITTEN(&imap))))
1197                 set_buffer_new(bh_result);
1198
1199         if (imap.br_startblock == DELAYSTARTBLOCK) {
1200                 BUG_ON(direct);
1201                 if (create) {
1202                         set_buffer_uptodate(bh_result);
1203                         set_buffer_mapped(bh_result);
1204                         set_buffer_delay(bh_result);
1205                 }
1206         }
1207
1208         /*
1209          * If this is O_DIRECT or the mpage code calling tell them how large
1210          * the mapping is, so that we can avoid repeated get_blocks calls.
1211          */
1212         if (direct || size > (1 << inode->i_blkbits)) {
1213                 xfs_off_t               mapping_size;
1214
1215                 mapping_size = imap.br_startoff + imap.br_blockcount - iblock;
1216                 mapping_size <<= inode->i_blkbits;
1217
1218                 ASSERT(mapping_size > 0);
1219                 if (mapping_size > size)
1220                         mapping_size = size;
1221                 if (mapping_size > LONG_MAX)
1222                         mapping_size = LONG_MAX;
1223
1224                 bh_result->b_size = mapping_size;
1225         }
1226
1227         return 0;
1228
1229 out_unlock:
1230         xfs_iunlock(ip, lockmode);
1231         return -error;
1232 }
1233
1234 int
1235 xfs_get_blocks(
1236         struct inode            *inode,
1237         sector_t                iblock,
1238         struct buffer_head      *bh_result,
1239         int                     create)
1240 {
1241         return __xfs_get_blocks(inode, iblock, bh_result, create, 0);
1242 }
1243
1244 STATIC int
1245 xfs_get_blocks_direct(
1246         struct inode            *inode,
1247         sector_t                iblock,
1248         struct buffer_head      *bh_result,
1249         int                     create)
1250 {
1251         return __xfs_get_blocks(inode, iblock, bh_result, create, 1);
1252 }
1253
1254 /*
1255  * Complete a direct I/O write request.
1256  *
1257  * If the private argument is non-NULL __xfs_get_blocks signals us that we
1258  * need to issue a transaction to convert the range from unwritten to written
1259  * extents.  In case this is regular synchronous I/O we just call xfs_end_io
1260  * to do this and we are done.  But in case this was a successful AIO
1261  * request this handler is called from interrupt context, from which we
1262  * can't start transactions.  In that case offload the I/O completion to
1263  * the workqueues we also use for buffered I/O completion.
1264  */
1265 STATIC void
1266 xfs_end_io_direct_write(
1267         struct kiocb            *iocb,
1268         loff_t                  offset,
1269         ssize_t                 size,
1270         void                    *private,
1271         int                     ret,
1272         bool                    is_async)
1273 {
1274         struct xfs_ioend        *ioend = iocb->private;
1275
1276         /*
1277          * While the generic direct I/O code updates the inode size, it does
1278          * so only after the end_io handler is called, which means our
1279          * end_io handler thinks the on-disk size is outside the in-core
1280          * size.  To prevent this just update it a little bit earlier here.
1281          */
1282         if (offset + size > i_size_read(ioend->io_inode))
1283                 i_size_write(ioend->io_inode, offset + size);
1284
1285         /*
1286          * blockdev_direct_IO can return an error even after the I/O
1287          * completion handler was called.  Thus we need to protect
1288          * against double-freeing.
1289          */
1290         iocb->private = NULL;
1291
1292         ioend->io_offset = offset;
1293         ioend->io_size = size;
1294         ioend->io_iocb = iocb;
1295         ioend->io_result = ret;
1296         if (private && size > 0)
1297                 ioend->io_type = IO_UNWRITTEN;
1298
1299         if (is_async) {
1300                 ioend->io_isasync = 1;
1301                 xfs_finish_ioend(ioend);
1302         } else {
1303                 xfs_finish_ioend_sync(ioend);
1304         }
1305 }
1306
1307 STATIC ssize_t
1308 xfs_vm_direct_IO(
1309         int                     rw,
1310         struct kiocb            *iocb,
1311         const struct iovec      *iov,
1312         loff_t                  offset,
1313         unsigned long           nr_segs)
1314 {
1315         struct inode            *inode = iocb->ki_filp->f_mapping->host;
1316         struct block_device     *bdev = xfs_find_bdev_for_inode(inode);
1317         ssize_t                 ret;
1318
1319         if (rw & WRITE) {
1320                 iocb->private = xfs_alloc_ioend(inode, IO_DIRECT);
1321
1322                 ret = __blockdev_direct_IO(rw, iocb, inode, bdev, iov,
1323                                             offset, nr_segs,
1324                                             xfs_get_blocks_direct,
1325                                             xfs_end_io_direct_write, NULL, 0);
1326                 if (ret != -EIOCBQUEUED && iocb->private)
1327                         xfs_destroy_ioend(iocb->private);
1328         } else {
1329                 ret = __blockdev_direct_IO(rw, iocb, inode, bdev, iov,
1330                                             offset, nr_segs,
1331                                             xfs_get_blocks_direct,
1332                                             NULL, NULL, 0);
1333         }
1334
1335         return ret;
1336 }
1337
1338 STATIC void
1339 xfs_vm_write_failed(
1340         struct address_space    *mapping,
1341         loff_t                  to)
1342 {
1343         struct inode            *inode = mapping->host;
1344
1345         if (to > inode->i_size) {
1346                 /*
1347                  * Punch out the delalloc blocks we have already allocated.
1348                  *
1349                  * Don't bother with xfs_setattr given that nothing can have
1350                  * made it to disk yet as the page is still locked at this
1351                  * point.
1352                  */
1353                 struct xfs_inode        *ip = XFS_I(inode);
1354                 xfs_fileoff_t           start_fsb;
1355                 xfs_fileoff_t           end_fsb;
1356                 int                     error;
1357
1358                 truncate_pagecache(inode, to, inode->i_size);
1359
1360                 /*
1361                  * Check if there are any blocks that are outside of i_size
1362                  * that need to be trimmed back.
1363                  */
1364                 start_fsb = XFS_B_TO_FSB(ip->i_mount, inode->i_size) + 1;
1365                 end_fsb = XFS_B_TO_FSB(ip->i_mount, to);
1366                 if (end_fsb <= start_fsb)
1367                         return;
1368
1369                 xfs_ilock(ip, XFS_ILOCK_EXCL);
1370                 error = xfs_bmap_punch_delalloc_range(ip, start_fsb,
1371                                                         end_fsb - start_fsb);
1372                 if (error) {
1373                         /* something screwed, just bail */
1374                         if (!XFS_FORCED_SHUTDOWN(ip->i_mount)) {
1375                                 xfs_alert(ip->i_mount,
1376                         "xfs_vm_write_failed: unable to clean up ino %lld",
1377                                                 ip->i_ino);
1378                         }
1379                 }
1380                 xfs_iunlock(ip, XFS_ILOCK_EXCL);
1381         }
1382 }
1383
1384 STATIC int
1385 xfs_vm_write_begin(
1386         struct file             *file,
1387         struct address_space    *mapping,
1388         loff_t                  pos,
1389         unsigned                len,
1390         unsigned                flags,
1391         struct page             **pagep,
1392         void                    **fsdata)
1393 {
1394         int                     ret;
1395
1396         ret = block_write_begin(mapping, pos, len, flags | AOP_FLAG_NOFS,
1397                                 pagep, xfs_get_blocks);
1398         if (unlikely(ret))
1399                 xfs_vm_write_failed(mapping, pos + len);
1400         return ret;
1401 }
1402
1403 STATIC int
1404 xfs_vm_write_end(
1405         struct file             *file,
1406         struct address_space    *mapping,
1407         loff_t                  pos,
1408         unsigned                len,
1409         unsigned                copied,
1410         struct page             *page,
1411         void                    *fsdata)
1412 {
1413         int                     ret;
1414
1415         ret = generic_write_end(file, mapping, pos, len, copied, page, fsdata);
1416         if (unlikely(ret < len))
1417                 xfs_vm_write_failed(mapping, pos + len);
1418         return ret;
1419 }
1420
1421 STATIC sector_t
1422 xfs_vm_bmap(
1423         struct address_space    *mapping,
1424         sector_t                block)
1425 {
1426         struct inode            *inode = (struct inode *)mapping->host;
1427         struct xfs_inode        *ip = XFS_I(inode);
1428
1429         trace_xfs_vm_bmap(XFS_I(inode));
1430         xfs_ilock(ip, XFS_IOLOCK_SHARED);
1431         xfs_flush_pages(ip, (xfs_off_t)0, -1, 0, FI_REMAPF);
1432         xfs_iunlock(ip, XFS_IOLOCK_SHARED);
1433         return generic_block_bmap(mapping, block, xfs_get_blocks);
1434 }
1435
1436 STATIC int
1437 xfs_vm_readpage(
1438         struct file             *unused,
1439         struct page             *page)
1440 {
1441         return mpage_readpage(page, xfs_get_blocks);
1442 }
1443
1444 STATIC int
1445 xfs_vm_readpages(
1446         struct file             *unused,
1447         struct address_space    *mapping,
1448         struct list_head        *pages,
1449         unsigned                nr_pages)
1450 {
1451         return mpage_readpages(mapping, pages, nr_pages, xfs_get_blocks);
1452 }
1453
1454 const struct address_space_operations xfs_address_space_operations = {
1455         .readpage               = xfs_vm_readpage,
1456         .readpages              = xfs_vm_readpages,
1457         .writepage              = xfs_vm_writepage,
1458         .writepages             = xfs_vm_writepages,
1459         .releasepage            = xfs_vm_releasepage,
1460         .invalidatepage         = xfs_vm_invalidatepage,
1461         .write_begin            = xfs_vm_write_begin,
1462         .write_end              = xfs_vm_write_end,
1463         .bmap                   = xfs_vm_bmap,
1464         .direct_IO              = xfs_vm_direct_IO,
1465         .migratepage            = buffer_migrate_page,
1466         .is_partially_uptodate  = block_is_partially_uptodate,
1467         .error_remove_page      = generic_error_remove_page,
1468 };