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