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