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