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