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