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