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