c9af48fffcd77fc559f73d5d97317e22ec4d3413
[pandora-kernel.git] / 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_trans.h"
25 #include "xfs_mount.h"
26 #include "xfs_bmap_btree.h"
27 #include "xfs_dinode.h"
28 #include "xfs_inode.h"
29 #include "xfs_alloc.h"
30 #include "xfs_error.h"
31 #include "xfs_rw.h"
32 #include "xfs_iomap.h"
33 #include "xfs_vnodeops.h"
34 #include "xfs_trace.h"
35 #include "xfs_bmap.h"
36 #include <linux/gfp.h>
37 #include <linux/mpage.h>
38 #include <linux/pagevec.h>
39 #include <linux/writeback.h>
40
41 /*
42  * Types of I/O for bmap clustering and I/O completion tracking.
43  */
44 enum {
45         IO_READ,        /* mapping for a read */
46         IO_DELAY,       /* mapping covers delalloc region */
47         IO_UNWRITTEN,   /* mapping covers allocated but uninitialized data */
48         IO_NEW          /* just allocated */
49 };
50
51 /*
52  * Prime number of hash buckets since address is used as the key.
53  */
54 #define NVSYNC          37
55 #define to_ioend_wq(v)  (&xfs_ioend_wq[((unsigned long)v) % NVSYNC])
56 static wait_queue_head_t xfs_ioend_wq[NVSYNC];
57
58 void __init
59 xfs_ioend_init(void)
60 {
61         int i;
62
63         for (i = 0; i < NVSYNC; i++)
64                 init_waitqueue_head(&xfs_ioend_wq[i]);
65 }
66
67 void
68 xfs_ioend_wait(
69         xfs_inode_t     *ip)
70 {
71         wait_queue_head_t *wq = to_ioend_wq(ip);
72
73         wait_event(*wq, (atomic_read(&ip->i_iocount) == 0));
74 }
75
76 STATIC void
77 xfs_ioend_wake(
78         xfs_inode_t     *ip)
79 {
80         if (atomic_dec_and_test(&ip->i_iocount))
81                 wake_up(to_ioend_wq(ip));
82 }
83
84 void
85 xfs_count_page_state(
86         struct page             *page,
87         int                     *delalloc,
88         int                     *unwritten)
89 {
90         struct buffer_head      *bh, *head;
91
92         *delalloc = *unwritten = 0;
93
94         bh = head = page_buffers(page);
95         do {
96                 if (buffer_unwritten(bh))
97                         (*unwritten) = 1;
98                 else if (buffer_delay(bh))
99                         (*delalloc) = 1;
100         } while ((bh = bh->b_this_page) != head);
101 }
102
103 STATIC struct block_device *
104 xfs_find_bdev_for_inode(
105         struct inode            *inode)
106 {
107         struct xfs_inode        *ip = XFS_I(inode);
108         struct xfs_mount        *mp = ip->i_mount;
109
110         if (XFS_IS_REALTIME_INODE(ip))
111                 return mp->m_rtdev_targp->bt_bdev;
112         else
113                 return mp->m_ddev_targp->bt_bdev;
114 }
115
116 /*
117  * We're now finished for good with this ioend structure.
118  * Update the page state via the associated buffer_heads,
119  * release holds on the inode and bio, and finally free
120  * up memory.  Do not use the ioend after this.
121  */
122 STATIC void
123 xfs_destroy_ioend(
124         xfs_ioend_t             *ioend)
125 {
126         struct buffer_head      *bh, *next;
127         struct xfs_inode        *ip = XFS_I(ioend->io_inode);
128
129         for (bh = ioend->io_buffer_head; bh; bh = next) {
130                 next = bh->b_private;
131                 bh->b_end_io(bh, !ioend->io_error);
132         }
133
134         /*
135          * Volume managers supporting multiple paths can send back ENODEV
136          * when the final path disappears.  In this case continuing to fill
137          * the page cache with dirty data which cannot be written out is
138          * evil, so prevent that.
139          */
140         if (unlikely(ioend->io_error == -ENODEV)) {
141                 xfs_do_force_shutdown(ip->i_mount, SHUTDOWN_DEVICE_REQ,
142                                       __FILE__, __LINE__);
143         }
144
145         xfs_ioend_wake(ip);
146         mempool_free(ioend, xfs_ioend_pool);
147 }
148
149 /*
150  * If the end of the current ioend is beyond the current EOF,
151  * return the new EOF value, otherwise zero.
152  */
153 STATIC xfs_fsize_t
154 xfs_ioend_new_eof(
155         xfs_ioend_t             *ioend)
156 {
157         xfs_inode_t             *ip = XFS_I(ioend->io_inode);
158         xfs_fsize_t             isize;
159         xfs_fsize_t             bsize;
160
161         bsize = ioend->io_offset + ioend->io_size;
162         isize = MAX(ip->i_size, ip->i_new_size);
163         isize = MIN(isize, bsize);
164         return isize > ip->i_d.di_size ? isize : 0;
165 }
166
167 /*
168  * Update on-disk file size now that data has been written to disk.  The
169  * current in-memory file size is i_size.  If a write is beyond eof i_new_size
170  * will be the intended file size until i_size is updated.  If this write does
171  * not extend all the way to the valid file size then restrict this update to
172  * the end of the write.
173  *
174  * This function does not block as blocking on the inode lock in IO completion
175  * can lead to IO completion order dependency deadlocks.. If it can't get the
176  * inode ilock it will return EAGAIN. Callers must handle this.
177  */
178 STATIC int
179 xfs_setfilesize(
180         xfs_ioend_t             *ioend)
181 {
182         xfs_inode_t             *ip = XFS_I(ioend->io_inode);
183         xfs_fsize_t             isize;
184
185         ASSERT((ip->i_d.di_mode & S_IFMT) == S_IFREG);
186         ASSERT(ioend->io_type != IO_READ);
187
188         if (unlikely(ioend->io_error))
189                 return 0;
190
191         if (!xfs_ilock_nowait(ip, XFS_ILOCK_EXCL))
192                 return EAGAIN;
193
194         isize = xfs_ioend_new_eof(ioend);
195         if (isize) {
196                 ip->i_d.di_size = isize;
197                 xfs_mark_inode_dirty(ip);
198         }
199
200         xfs_iunlock(ip, XFS_ILOCK_EXCL);
201         return 0;
202 }
203
204 /*
205  * Schedule IO completion handling on the final put of an ioend.
206  */
207 STATIC void
208 xfs_finish_ioend(
209         struct xfs_ioend        *ioend)
210 {
211         if (atomic_dec_and_test(&ioend->io_remaining)) {
212                 if (ioend->io_type == IO_UNWRITTEN)
213                         queue_work(xfsconvertd_workqueue, &ioend->io_work);
214                 else
215                         queue_work(xfsdatad_workqueue, &ioend->io_work);
216         }
217 }
218
219 /*
220  * IO write completion.
221  */
222 STATIC void
223 xfs_end_io(
224         struct work_struct *work)
225 {
226         xfs_ioend_t     *ioend = container_of(work, xfs_ioend_t, io_work);
227         struct xfs_inode *ip = XFS_I(ioend->io_inode);
228         int             error = 0;
229
230         /*
231          * For unwritten extents we need to issue transactions to convert a
232          * range to normal written extens after the data I/O has finished.
233          */
234         if (ioend->io_type == IO_UNWRITTEN &&
235             likely(!ioend->io_error && !XFS_FORCED_SHUTDOWN(ip->i_mount))) {
236
237                 error = xfs_iomap_write_unwritten(ip, ioend->io_offset,
238                                                  ioend->io_size);
239                 if (error)
240                         ioend->io_error = error;
241         }
242
243         /*
244          * We might have to update the on-disk file size after extending
245          * writes.
246          */
247         if (ioend->io_type != IO_READ) {
248                 error = xfs_setfilesize(ioend);
249                 ASSERT(!error || error == EAGAIN);
250         }
251
252         /*
253          * If we didn't complete processing of the ioend, requeue it to the
254          * tail of the workqueue for another attempt later. Otherwise destroy
255          * it.
256          */
257         if (error == EAGAIN) {
258                 atomic_inc(&ioend->io_remaining);
259                 xfs_finish_ioend(ioend);
260                 /* ensure we don't spin on blocked ioends */
261                 delay(1);
262         } else {
263                 if (ioend->io_iocb)
264                         aio_complete(ioend->io_iocb, ioend->io_result, 0);
265                 xfs_destroy_ioend(ioend);
266         }
267 }
268
269 /*
270  * Call IO completion handling in caller context on the final put of an ioend.
271  */
272 STATIC void
273 xfs_finish_ioend_sync(
274         struct xfs_ioend        *ioend)
275 {
276         if (atomic_dec_and_test(&ioend->io_remaining))
277                 xfs_end_io(&ioend->io_work);
278 }
279
280 /*
281  * Allocate and initialise an IO completion structure.
282  * We need to track unwritten extent write completion here initially.
283  * We'll need to extend this for updating the ondisk inode size later
284  * (vs. incore size).
285  */
286 STATIC xfs_ioend_t *
287 xfs_alloc_ioend(
288         struct inode            *inode,
289         unsigned int            type)
290 {
291         xfs_ioend_t             *ioend;
292
293         ioend = mempool_alloc(xfs_ioend_pool, GFP_NOFS);
294
295         /*
296          * Set the count to 1 initially, which will prevent an I/O
297          * completion callback from happening before we have started
298          * all the I/O from calling the completion routine too early.
299          */
300         atomic_set(&ioend->io_remaining, 1);
301         ioend->io_error = 0;
302         ioend->io_list = NULL;
303         ioend->io_type = type;
304         ioend->io_inode = inode;
305         ioend->io_buffer_head = NULL;
306         ioend->io_buffer_tail = NULL;
307         atomic_inc(&XFS_I(ioend->io_inode)->i_iocount);
308         ioend->io_offset = 0;
309         ioend->io_size = 0;
310         ioend->io_iocb = NULL;
311         ioend->io_result = 0;
312
313         INIT_WORK(&ioend->io_work, xfs_end_io);
314         return ioend;
315 }
316
317 STATIC int
318 xfs_map_blocks(
319         struct inode            *inode,
320         loff_t                  offset,
321         ssize_t                 count,
322         struct xfs_bmbt_irec    *imap,
323         int                     flags)
324 {
325         int                     nmaps = 1;
326         int                     new = 0;
327
328         return -xfs_iomap(XFS_I(inode), offset, count, flags, imap, &nmaps, &new);
329 }
330
331 STATIC int
332 xfs_imap_valid(
333         struct inode            *inode,
334         struct xfs_bmbt_irec    *imap,
335         xfs_off_t               offset)
336 {
337         offset >>= inode->i_blkbits;
338
339         return offset >= imap->br_startoff &&
340                 offset < imap->br_startoff + imap->br_blockcount;
341 }
342
343 /*
344  * BIO completion handler for buffered IO.
345  */
346 STATIC void
347 xfs_end_bio(
348         struct bio              *bio,
349         int                     error)
350 {
351         xfs_ioend_t             *ioend = bio->bi_private;
352
353         ASSERT(atomic_read(&bio->bi_cnt) >= 1);
354         ioend->io_error = test_bit(BIO_UPTODATE, &bio->bi_flags) ? 0 : error;
355
356         /* Toss bio and pass work off to an xfsdatad thread */
357         bio->bi_private = NULL;
358         bio->bi_end_io = NULL;
359         bio_put(bio);
360
361         xfs_finish_ioend(ioend);
362 }
363
364 STATIC void
365 xfs_submit_ioend_bio(
366         struct writeback_control *wbc,
367         xfs_ioend_t             *ioend,
368         struct bio              *bio)
369 {
370         atomic_inc(&ioend->io_remaining);
371         bio->bi_private = ioend;
372         bio->bi_end_io = xfs_end_bio;
373
374         /*
375          * If the I/O is beyond EOF we mark the inode dirty immediately
376          * but don't update the inode size until I/O completion.
377          */
378         if (xfs_ioend_new_eof(ioend))
379                 xfs_mark_inode_dirty(XFS_I(ioend->io_inode));
380
381         submit_bio(wbc->sync_mode == WB_SYNC_ALL ?
382                    WRITE_SYNC_PLUG : WRITE, bio);
383         ASSERT(!bio_flagged(bio, BIO_EOPNOTSUPP));
384         bio_put(bio);
385 }
386
387 STATIC struct bio *
388 xfs_alloc_ioend_bio(
389         struct buffer_head      *bh)
390 {
391         struct bio              *bio;
392         int                     nvecs = bio_get_nr_vecs(bh->b_bdev);
393
394         do {
395                 bio = bio_alloc(GFP_NOIO, nvecs);
396                 nvecs >>= 1;
397         } while (!bio);
398
399         ASSERT(bio->bi_private == NULL);
400         bio->bi_sector = bh->b_blocknr * (bh->b_size >> 9);
401         bio->bi_bdev = bh->b_bdev;
402         bio_get(bio);
403         return bio;
404 }
405
406 STATIC void
407 xfs_start_buffer_writeback(
408         struct buffer_head      *bh)
409 {
410         ASSERT(buffer_mapped(bh));
411         ASSERT(buffer_locked(bh));
412         ASSERT(!buffer_delay(bh));
413         ASSERT(!buffer_unwritten(bh));
414
415         mark_buffer_async_write(bh);
416         set_buffer_uptodate(bh);
417         clear_buffer_dirty(bh);
418 }
419
420 STATIC void
421 xfs_start_page_writeback(
422         struct page             *page,
423         int                     clear_dirty,
424         int                     buffers)
425 {
426         ASSERT(PageLocked(page));
427         ASSERT(!PageWriteback(page));
428         if (clear_dirty)
429                 clear_page_dirty_for_io(page);
430         set_page_writeback(page);
431         unlock_page(page);
432         /* If no buffers on the page are to be written, finish it here */
433         if (!buffers)
434                 end_page_writeback(page);
435 }
436
437 static inline int bio_add_buffer(struct bio *bio, struct buffer_head *bh)
438 {
439         return bio_add_page(bio, bh->b_page, bh->b_size, bh_offset(bh));
440 }
441
442 /*
443  * Submit all of the bios for all of the ioends we have saved up, covering the
444  * initial writepage page and also any probed pages.
445  *
446  * Because we may have multiple ioends spanning a page, we need to start
447  * writeback on all the buffers before we submit them for I/O. If we mark the
448  * buffers as we got, then we can end up with a page that only has buffers
449  * marked async write and I/O complete on can occur before we mark the other
450  * buffers async write.
451  *
452  * The end result of this is that we trip a bug in end_page_writeback() because
453  * we call it twice for the one page as the code in end_buffer_async_write()
454  * assumes that all buffers on the page are started at the same time.
455  *
456  * The fix is two passes across the ioend list - one to start writeback on the
457  * buffer_heads, and then submit them for I/O on the second pass.
458  */
459 STATIC void
460 xfs_submit_ioend(
461         struct writeback_control *wbc,
462         xfs_ioend_t             *ioend)
463 {
464         xfs_ioend_t             *head = ioend;
465         xfs_ioend_t             *next;
466         struct buffer_head      *bh;
467         struct bio              *bio;
468         sector_t                lastblock = 0;
469
470         /* Pass 1 - start writeback */
471         do {
472                 next = ioend->io_list;
473                 for (bh = ioend->io_buffer_head; bh; bh = bh->b_private) {
474                         xfs_start_buffer_writeback(bh);
475                 }
476         } while ((ioend = next) != NULL);
477
478         /* Pass 2 - submit I/O */
479         ioend = head;
480         do {
481                 next = ioend->io_list;
482                 bio = NULL;
483
484                 for (bh = ioend->io_buffer_head; bh; bh = bh->b_private) {
485
486                         if (!bio) {
487  retry:
488                                 bio = xfs_alloc_ioend_bio(bh);
489                         } else if (bh->b_blocknr != lastblock + 1) {
490                                 xfs_submit_ioend_bio(wbc, ioend, bio);
491                                 goto retry;
492                         }
493
494                         if (bio_add_buffer(bio, bh) != bh->b_size) {
495                                 xfs_submit_ioend_bio(wbc, ioend, bio);
496                                 goto retry;
497                         }
498
499                         lastblock = bh->b_blocknr;
500                 }
501                 if (bio)
502                         xfs_submit_ioend_bio(wbc, ioend, bio);
503                 xfs_finish_ioend(ioend);
504         } while ((ioend = next) != NULL);
505 }
506
507 /*
508  * Cancel submission of all buffer_heads so far in this endio.
509  * Toss the endio too.  Only ever called for the initial page
510  * in a writepage request, so only ever one page.
511  */
512 STATIC void
513 xfs_cancel_ioend(
514         xfs_ioend_t             *ioend)
515 {
516         xfs_ioend_t             *next;
517         struct buffer_head      *bh, *next_bh;
518
519         do {
520                 next = ioend->io_list;
521                 bh = ioend->io_buffer_head;
522                 do {
523                         next_bh = bh->b_private;
524                         clear_buffer_async_write(bh);
525                         unlock_buffer(bh);
526                 } while ((bh = next_bh) != NULL);
527
528                 xfs_ioend_wake(XFS_I(ioend->io_inode));
529                 mempool_free(ioend, xfs_ioend_pool);
530         } while ((ioend = next) != NULL);
531 }
532
533 /*
534  * Test to see if we've been building up a completion structure for
535  * earlier buffers -- if so, we try to append to this ioend if we
536  * can, otherwise we finish off any current ioend and start another.
537  * Return true if we've finished the given ioend.
538  */
539 STATIC void
540 xfs_add_to_ioend(
541         struct inode            *inode,
542         struct buffer_head      *bh,
543         xfs_off_t               offset,
544         unsigned int            type,
545         xfs_ioend_t             **result,
546         int                     need_ioend)
547 {
548         xfs_ioend_t             *ioend = *result;
549
550         if (!ioend || need_ioend || type != ioend->io_type) {
551                 xfs_ioend_t     *previous = *result;
552
553                 ioend = xfs_alloc_ioend(inode, type);
554                 ioend->io_offset = offset;
555                 ioend->io_buffer_head = bh;
556                 ioend->io_buffer_tail = bh;
557                 if (previous)
558                         previous->io_list = ioend;
559                 *result = ioend;
560         } else {
561                 ioend->io_buffer_tail->b_private = bh;
562                 ioend->io_buffer_tail = bh;
563         }
564
565         bh->b_private = NULL;
566         ioend->io_size += bh->b_size;
567 }
568
569 STATIC void
570 xfs_map_buffer(
571         struct inode            *inode,
572         struct buffer_head      *bh,
573         struct xfs_bmbt_irec    *imap,
574         xfs_off_t               offset)
575 {
576         sector_t                bn;
577         struct xfs_mount        *m = XFS_I(inode)->i_mount;
578         xfs_off_t               iomap_offset = XFS_FSB_TO_B(m, imap->br_startoff);
579         xfs_daddr_t             iomap_bn = xfs_fsb_to_db(XFS_I(inode), imap->br_startblock);
580
581         ASSERT(imap->br_startblock != HOLESTARTBLOCK);
582         ASSERT(imap->br_startblock != DELAYSTARTBLOCK);
583
584         bn = (iomap_bn >> (inode->i_blkbits - BBSHIFT)) +
585               ((offset - iomap_offset) >> inode->i_blkbits);
586
587         ASSERT(bn || XFS_IS_REALTIME_INODE(XFS_I(inode)));
588
589         bh->b_blocknr = bn;
590         set_buffer_mapped(bh);
591 }
592
593 STATIC void
594 xfs_map_at_offset(
595         struct inode            *inode,
596         struct buffer_head      *bh,
597         struct xfs_bmbt_irec    *imap,
598         xfs_off_t               offset)
599 {
600         ASSERT(imap->br_startblock != HOLESTARTBLOCK);
601         ASSERT(imap->br_startblock != DELAYSTARTBLOCK);
602
603         lock_buffer(bh);
604         xfs_map_buffer(inode, bh, imap, offset);
605         bh->b_bdev = xfs_find_bdev_for_inode(inode);
606         set_buffer_mapped(bh);
607         clear_buffer_delay(bh);
608         clear_buffer_unwritten(bh);
609 }
610
611 /*
612  * Look for a page at index that is suitable for clustering.
613  */
614 STATIC unsigned int
615 xfs_probe_page(
616         struct page             *page,
617         unsigned int            pg_offset)
618 {
619         struct buffer_head      *bh, *head;
620         int                     ret = 0;
621
622         if (PageWriteback(page))
623                 return 0;
624         if (!PageDirty(page))
625                 return 0;
626         if (!page->mapping)
627                 return 0;
628         if (!page_has_buffers(page))
629                 return 0;
630
631         bh = head = page_buffers(page);
632         do {
633                 if (!buffer_uptodate(bh))
634                         break;
635                 if (!buffer_mapped(bh))
636                         break;
637                 ret += bh->b_size;
638                 if (ret >= pg_offset)
639                         break;
640         } while ((bh = bh->b_this_page) != head);
641
642         return ret;
643 }
644
645 STATIC size_t
646 xfs_probe_cluster(
647         struct inode            *inode,
648         struct page             *startpage,
649         struct buffer_head      *bh,
650         struct buffer_head      *head)
651 {
652         struct pagevec          pvec;
653         pgoff_t                 tindex, tlast, tloff;
654         size_t                  total = 0;
655         int                     done = 0, i;
656
657         /* First sum forwards in this page */
658         do {
659                 if (!buffer_uptodate(bh) || !buffer_mapped(bh))
660                         return total;
661                 total += bh->b_size;
662         } while ((bh = bh->b_this_page) != head);
663
664         /* if we reached the end of the page, sum forwards in following pages */
665         tlast = i_size_read(inode) >> PAGE_CACHE_SHIFT;
666         tindex = startpage->index + 1;
667
668         /* Prune this back to avoid pathological behavior */
669         tloff = min(tlast, startpage->index + 64);
670
671         pagevec_init(&pvec, 0);
672         while (!done && tindex <= tloff) {
673                 unsigned len = min_t(pgoff_t, PAGEVEC_SIZE, tlast - tindex + 1);
674
675                 if (!pagevec_lookup(&pvec, inode->i_mapping, tindex, len))
676                         break;
677
678                 for (i = 0; i < pagevec_count(&pvec); i++) {
679                         struct page *page = pvec.pages[i];
680                         size_t pg_offset, pg_len = 0;
681
682                         if (tindex == tlast) {
683                                 pg_offset =
684                                     i_size_read(inode) & (PAGE_CACHE_SIZE - 1);
685                                 if (!pg_offset) {
686                                         done = 1;
687                                         break;
688                                 }
689                         } else
690                                 pg_offset = PAGE_CACHE_SIZE;
691
692                         if (page->index == tindex && trylock_page(page)) {
693                                 pg_len = xfs_probe_page(page, pg_offset);
694                                 unlock_page(page);
695                         }
696
697                         if (!pg_len) {
698                                 done = 1;
699                                 break;
700                         }
701
702                         total += pg_len;
703                         tindex++;
704                 }
705
706                 pagevec_release(&pvec);
707                 cond_resched();
708         }
709
710         return total;
711 }
712
713 /*
714  * Test if a given page is suitable for writing as part of an unwritten
715  * or delayed allocate extent.
716  */
717 STATIC int
718 xfs_is_delayed_page(
719         struct page             *page,
720         unsigned int            type)
721 {
722         if (PageWriteback(page))
723                 return 0;
724
725         if (page->mapping && page_has_buffers(page)) {
726                 struct buffer_head      *bh, *head;
727                 int                     acceptable = 0;
728
729                 bh = head = page_buffers(page);
730                 do {
731                         if (buffer_unwritten(bh))
732                                 acceptable = (type == IO_UNWRITTEN);
733                         else if (buffer_delay(bh))
734                                 acceptable = (type == IO_DELAY);
735                         else if (buffer_dirty(bh) && buffer_mapped(bh))
736                                 acceptable = (type == IO_NEW);
737                         else
738                                 break;
739                 } while ((bh = bh->b_this_page) != head);
740
741                 if (acceptable)
742                         return 1;
743         }
744
745         return 0;
746 }
747
748 /*
749  * Allocate & map buffers for page given the extent map. Write it out.
750  * except for the original page of a writepage, this is called on
751  * delalloc/unwritten pages only, for the original page it is possible
752  * that the page has no mapping at all.
753  */
754 STATIC int
755 xfs_convert_page(
756         struct inode            *inode,
757         struct page             *page,
758         loff_t                  tindex,
759         struct xfs_bmbt_irec    *imap,
760         xfs_ioend_t             **ioendp,
761         struct writeback_control *wbc,
762         int                     all_bh)
763 {
764         struct buffer_head      *bh, *head;
765         xfs_off_t               end_offset;
766         unsigned long           p_offset;
767         unsigned int            type;
768         int                     len, page_dirty;
769         int                     count = 0, done = 0, uptodate = 1;
770         xfs_off_t               offset = page_offset(page);
771
772         if (page->index != tindex)
773                 goto fail;
774         if (!trylock_page(page))
775                 goto fail;
776         if (PageWriteback(page))
777                 goto fail_unlock_page;
778         if (page->mapping != inode->i_mapping)
779                 goto fail_unlock_page;
780         if (!xfs_is_delayed_page(page, (*ioendp)->io_type))
781                 goto fail_unlock_page;
782
783         /*
784          * page_dirty is initially a count of buffers on the page before
785          * EOF and is decremented as we move each into a cleanable state.
786          *
787          * Derivation:
788          *
789          * End offset is the highest offset that this page should represent.
790          * If we are on the last page, (end_offset & (PAGE_CACHE_SIZE - 1))
791          * will evaluate non-zero and be less than PAGE_CACHE_SIZE and
792          * hence give us the correct page_dirty count. On any other page,
793          * it will be zero and in that case we need page_dirty to be the
794          * count of buffers on the page.
795          */
796         end_offset = min_t(unsigned long long,
797                         (xfs_off_t)(page->index + 1) << PAGE_CACHE_SHIFT,
798                         i_size_read(inode));
799
800         len = 1 << inode->i_blkbits;
801         p_offset = min_t(unsigned long, end_offset & (PAGE_CACHE_SIZE - 1),
802                                         PAGE_CACHE_SIZE);
803         p_offset = p_offset ? roundup(p_offset, len) : PAGE_CACHE_SIZE;
804         page_dirty = p_offset / len;
805
806         bh = head = page_buffers(page);
807         do {
808                 if (offset >= end_offset)
809                         break;
810                 if (!buffer_uptodate(bh))
811                         uptodate = 0;
812                 if (!(PageUptodate(page) || buffer_uptodate(bh))) {
813                         done = 1;
814                         continue;
815                 }
816
817                 if (buffer_unwritten(bh) || buffer_delay(bh)) {
818                         if (buffer_unwritten(bh))
819                                 type = IO_UNWRITTEN;
820                         else
821                                 type = IO_DELAY;
822
823                         if (!xfs_imap_valid(inode, imap, offset)) {
824                                 done = 1;
825                                 continue;
826                         }
827
828                         ASSERT(imap->br_startblock != HOLESTARTBLOCK);
829                         ASSERT(imap->br_startblock != DELAYSTARTBLOCK);
830
831                         xfs_map_at_offset(inode, bh, imap, offset);
832                         xfs_add_to_ioend(inode, bh, offset, type,
833                                          ioendp, done);
834
835                         page_dirty--;
836                         count++;
837                 } else {
838                         type = IO_NEW;
839                         if (buffer_mapped(bh) && all_bh) {
840                                 lock_buffer(bh);
841                                 xfs_add_to_ioend(inode, bh, offset,
842                                                 type, ioendp, done);
843                                 count++;
844                                 page_dirty--;
845                         } else {
846                                 done = 1;
847                         }
848                 }
849         } while (offset += len, (bh = bh->b_this_page) != head);
850
851         if (uptodate && bh == head)
852                 SetPageUptodate(page);
853
854         if (count) {
855                 if (--wbc->nr_to_write <= 0 &&
856                     wbc->sync_mode == WB_SYNC_NONE)
857                         done = 1;
858         }
859         xfs_start_page_writeback(page, !page_dirty, count);
860
861         return done;
862  fail_unlock_page:
863         unlock_page(page);
864  fail:
865         return 1;
866 }
867
868 /*
869  * Convert & write out a cluster of pages in the same extent as defined
870  * by mp and following the start page.
871  */
872 STATIC void
873 xfs_cluster_write(
874         struct inode            *inode,
875         pgoff_t                 tindex,
876         struct xfs_bmbt_irec    *imap,
877         xfs_ioend_t             **ioendp,
878         struct writeback_control *wbc,
879         int                     all_bh,
880         pgoff_t                 tlast)
881 {
882         struct pagevec          pvec;
883         int                     done = 0, i;
884
885         pagevec_init(&pvec, 0);
886         while (!done && tindex <= tlast) {
887                 unsigned len = min_t(pgoff_t, PAGEVEC_SIZE, tlast - tindex + 1);
888
889                 if (!pagevec_lookup(&pvec, inode->i_mapping, tindex, len))
890                         break;
891
892                 for (i = 0; i < pagevec_count(&pvec); i++) {
893                         done = xfs_convert_page(inode, pvec.pages[i], tindex++,
894                                         imap, ioendp, wbc, all_bh);
895                         if (done)
896                                 break;
897                 }
898
899                 pagevec_release(&pvec);
900                 cond_resched();
901         }
902 }
903
904 STATIC void
905 xfs_vm_invalidatepage(
906         struct page             *page,
907         unsigned long           offset)
908 {
909         trace_xfs_invalidatepage(page->mapping->host, page, offset);
910         block_invalidatepage(page, offset);
911 }
912
913 /*
914  * If the page has delalloc buffers on it, we need to punch them out before we
915  * invalidate the page. If we don't, we leave a stale delalloc mapping on the
916  * inode that can trip a BUG() in xfs_get_blocks() later on if a direct IO read
917  * is done on that same region - the delalloc extent is returned when none is
918  * supposed to be there.
919  *
920  * We prevent this by truncating away the delalloc regions on the page before
921  * invalidating it. Because they are delalloc, we can do this without needing a
922  * transaction. Indeed - if we get ENOSPC errors, we have to be able to do this
923  * truncation without a transaction as there is no space left for block
924  * reservation (typically why we see a ENOSPC in writeback).
925  *
926  * This is not a performance critical path, so for now just do the punching a
927  * buffer head at a time.
928  */
929 STATIC void
930 xfs_aops_discard_page(
931         struct page             *page)
932 {
933         struct inode            *inode = page->mapping->host;
934         struct xfs_inode        *ip = XFS_I(inode);
935         struct buffer_head      *bh, *head;
936         loff_t                  offset = page_offset(page);
937         ssize_t                 len = 1 << inode->i_blkbits;
938
939         if (!xfs_is_delayed_page(page, IO_DELAY))
940                 goto out_invalidate;
941
942         if (XFS_FORCED_SHUTDOWN(ip->i_mount))
943                 goto out_invalidate;
944
945         xfs_fs_cmn_err(CE_ALERT, ip->i_mount,
946                 "page discard on page %p, inode 0x%llx, offset %llu.",
947                         page, ip->i_ino, offset);
948
949         xfs_ilock(ip, XFS_ILOCK_EXCL);
950         bh = head = page_buffers(page);
951         do {
952                 int             done;
953                 xfs_fileoff_t   offset_fsb;
954                 xfs_bmbt_irec_t imap;
955                 int             nimaps = 1;
956                 int             error;
957                 xfs_fsblock_t   firstblock;
958                 xfs_bmap_free_t flist;
959
960                 if (!buffer_delay(bh))
961                         goto next_buffer;
962
963                 offset_fsb = XFS_B_TO_FSBT(ip->i_mount, offset);
964
965                 /*
966                  * Map the range first and check that it is a delalloc extent
967                  * before trying to unmap the range. Otherwise we will be
968                  * trying to remove a real extent (which requires a
969                  * transaction) or a hole, which is probably a bad idea...
970                  */
971                 error = xfs_bmapi(NULL, ip, offset_fsb, 1,
972                                 XFS_BMAPI_ENTIRE,  NULL, 0, &imap,
973                                 &nimaps, NULL);
974
975                 if (error) {
976                         /* something screwed, just bail */
977                         if (!XFS_FORCED_SHUTDOWN(ip->i_mount)) {
978                                 xfs_fs_cmn_err(CE_ALERT, ip->i_mount,
979                                 "page discard failed delalloc mapping lookup.");
980                         }
981                         break;
982                 }
983                 if (!nimaps) {
984                         /* nothing there */
985                         goto next_buffer;
986                 }
987                 if (imap.br_startblock != DELAYSTARTBLOCK) {
988                         /* been converted, ignore */
989                         goto next_buffer;
990                 }
991                 WARN_ON(imap.br_blockcount == 0);
992
993                 /*
994                  * Note: while we initialise the firstblock/flist pair, they
995                  * should never be used because blocks should never be
996                  * allocated or freed for a delalloc extent and hence we need
997                  * don't cancel or finish them after the xfs_bunmapi() call.
998                  */
999                 xfs_bmap_init(&flist, &firstblock);
1000                 error = xfs_bunmapi(NULL, ip, offset_fsb, 1, 0, 1, &firstblock,
1001                                         &flist, &done);
1002
1003                 ASSERT(!flist.xbf_count && !flist.xbf_first);
1004                 if (error) {
1005                         /* something screwed, just bail */
1006                         if (!XFS_FORCED_SHUTDOWN(ip->i_mount)) {
1007                                 xfs_fs_cmn_err(CE_ALERT, ip->i_mount,
1008                         "page discard unable to remove delalloc mapping.");
1009                         }
1010                         break;
1011                 }
1012 next_buffer:
1013                 offset += len;
1014
1015         } while ((bh = bh->b_this_page) != head);
1016
1017         xfs_iunlock(ip, XFS_ILOCK_EXCL);
1018 out_invalidate:
1019         xfs_vm_invalidatepage(page, 0);
1020         return;
1021 }
1022
1023 /*
1024  * Write out a dirty page.
1025  *
1026  * For delalloc space on the page we need to allocate space and flush it.
1027  * For unwritten space on the page we need to start the conversion to
1028  * regular allocated space.
1029  * For any other dirty buffer heads on the page we should flush them.
1030  *
1031  * If we detect that a transaction would be required to flush the page, we
1032  * have to check the process flags first, if we are already in a transaction
1033  * or disk I/O during allocations is off, we need to fail the writepage and
1034  * redirty the page.
1035  */
1036 STATIC int
1037 xfs_vm_writepage(
1038         struct page             *page,
1039         struct writeback_control *wbc)
1040 {
1041         struct inode            *inode = page->mapping->host;
1042         int                     delalloc, unwritten;
1043         struct buffer_head      *bh, *head;
1044         struct xfs_bmbt_irec    imap;
1045         xfs_ioend_t             *ioend = NULL, *iohead = NULL;
1046         loff_t                  offset;
1047         unsigned int            type;
1048         __uint64_t              end_offset;
1049         pgoff_t                 end_index, last_index;
1050         ssize_t                 size, len;
1051         int                     flags, err, imap_valid = 0, uptodate = 1;
1052         int                     count = 0;
1053         int                     all_bh = 0;
1054
1055         trace_xfs_writepage(inode, page, 0);
1056
1057         ASSERT(page_has_buffers(page));
1058
1059         /*
1060          * Refuse to write the page out if we are called from reclaim context.
1061          *
1062          * This avoids stack overflows when called from deeply used stacks in
1063          * random callers for direct reclaim or memcg reclaim.  We explicitly
1064          * allow reclaim from kswapd as the stack usage there is relatively low.
1065          *
1066          * This should really be done by the core VM, but until that happens
1067          * filesystems like XFS, btrfs and ext4 have to take care of this
1068          * by themselves.
1069          */
1070         if ((current->flags & (PF_MEMALLOC|PF_KSWAPD)) == PF_MEMALLOC)
1071                 goto redirty;
1072
1073         /*
1074          * We need a transaction if there are delalloc or unwritten buffers
1075          * on the page.
1076          *
1077          * If we need a transaction and the process flags say we are already
1078          * in a transaction, or no IO is allowed then mark the page dirty
1079          * again and leave the page as is.
1080          */
1081         xfs_count_page_state(page, &delalloc, &unwritten);
1082         if ((current->flags & PF_FSTRANS) && (delalloc || unwritten))
1083                 goto redirty;
1084
1085         /* Is this page beyond the end of the file? */
1086         offset = i_size_read(inode);
1087         end_index = offset >> PAGE_CACHE_SHIFT;
1088         last_index = (offset - 1) >> PAGE_CACHE_SHIFT;
1089         if (page->index >= end_index) {
1090                 if ((page->index >= end_index + 1) ||
1091                     !(i_size_read(inode) & (PAGE_CACHE_SIZE - 1))) {
1092                         unlock_page(page);
1093                         return 0;
1094                 }
1095         }
1096
1097         end_offset = min_t(unsigned long long,
1098                         (xfs_off_t)(page->index + 1) << PAGE_CACHE_SHIFT,
1099                         offset);
1100         len = 1 << inode->i_blkbits;
1101
1102         bh = head = page_buffers(page);
1103         offset = page_offset(page);
1104         flags = BMAPI_READ;
1105         type = IO_NEW;
1106
1107         do {
1108                 if (offset >= end_offset)
1109                         break;
1110                 if (!buffer_uptodate(bh))
1111                         uptodate = 0;
1112
1113                 /*
1114                  * A hole may still be marked uptodate because discard_buffer
1115                  * leaves the flag set.
1116                  */
1117                 if (!buffer_mapped(bh) && buffer_uptodate(bh)) {
1118                         ASSERT(!buffer_dirty(bh));
1119                         imap_valid = 0;
1120                         continue;
1121                 }
1122
1123                 if (imap_valid)
1124                         imap_valid = xfs_imap_valid(inode, &imap, offset);
1125
1126                 if (buffer_unwritten(bh) || buffer_delay(bh)) {
1127                         int new_ioend = 0;
1128
1129                         /*
1130                          * Make sure we don't use a read-only iomap
1131                          */
1132                         if (flags == BMAPI_READ)
1133                                 imap_valid = 0;
1134
1135                         if (buffer_unwritten(bh)) {
1136                                 type = IO_UNWRITTEN;
1137                                 flags = BMAPI_WRITE | BMAPI_IGNSTATE;
1138                         } else if (buffer_delay(bh)) {
1139                                 type = IO_DELAY;
1140                                 flags = BMAPI_ALLOCATE;
1141
1142                                 if (wbc->sync_mode == WB_SYNC_NONE)
1143                                         flags |= BMAPI_TRYLOCK;
1144                         }
1145
1146                         if (!imap_valid) {
1147                                 /*
1148                                  * If we didn't have a valid mapping then we
1149                                  * need to ensure that we put the new mapping
1150                                  * in a new ioend structure. This needs to be
1151                                  * done to ensure that the ioends correctly
1152                                  * reflect the block mappings at io completion
1153                                  * for unwritten extent conversion.
1154                                  */
1155                                 new_ioend = 1;
1156                                 err = xfs_map_blocks(inode, offset, len,
1157                                                 &imap, flags);
1158                                 if (err)
1159                                         goto error;
1160                                 imap_valid = xfs_imap_valid(inode, &imap,
1161                                                             offset);
1162                         }
1163                         if (imap_valid) {
1164                                 xfs_map_at_offset(inode, bh, &imap, offset);
1165                                 xfs_add_to_ioend(inode, bh, offset, type,
1166                                                  &ioend, new_ioend);
1167                                 count++;
1168                         }
1169                 } else if (buffer_uptodate(bh)) {
1170                         /*
1171                          * we got here because the buffer is already mapped.
1172                          * That means it must already have extents allocated
1173                          * underneath it. Map the extent by reading it.
1174                          */
1175                         if (!imap_valid || flags != BMAPI_READ) {
1176                                 flags = BMAPI_READ;
1177                                 size = xfs_probe_cluster(inode, page, bh, head);
1178                                 err = xfs_map_blocks(inode, offset, size,
1179                                                 &imap, flags);
1180                                 if (err)
1181                                         goto error;
1182                                 imap_valid = xfs_imap_valid(inode, &imap,
1183                                                             offset);
1184                         }
1185
1186                         /*
1187                          * We set the type to IO_NEW in case we are doing a
1188                          * small write at EOF that is extending the file but
1189                          * without needing an allocation. We need to update the
1190                          * file size on I/O completion in this case so it is
1191                          * the same case as having just allocated a new extent
1192                          * that we are writing into for the first time.
1193                          */
1194                         type = IO_NEW;
1195                         if (trylock_buffer(bh)) {
1196                                 if (imap_valid)
1197                                         all_bh = 1;
1198                                 xfs_add_to_ioend(inode, bh, offset, type,
1199                                                 &ioend, !imap_valid);
1200                                 count++;
1201                         } else {
1202                                 imap_valid = 0;
1203                         }
1204                 } else if (PageUptodate(page)) {
1205                         ASSERT(buffer_mapped(bh));
1206                         imap_valid = 0;
1207                 }
1208
1209                 if (!iohead)
1210                         iohead = ioend;
1211
1212         } while (offset += len, ((bh = bh->b_this_page) != head));
1213
1214         if (uptodate && bh == head)
1215                 SetPageUptodate(page);
1216
1217         xfs_start_page_writeback(page, 1, count);
1218
1219         if (ioend && imap_valid) {
1220                 xfs_off_t               end_index;
1221
1222                 end_index = imap.br_startoff + imap.br_blockcount;
1223
1224                 /* to bytes */
1225                 end_index <<= inode->i_blkbits;
1226
1227                 /* to pages */
1228                 end_index = (end_index - 1) >> PAGE_CACHE_SHIFT;
1229
1230                 /* check against file size */
1231                 if (end_index > last_index)
1232                         end_index = last_index;
1233
1234                 xfs_cluster_write(inode, page->index + 1, &imap, &ioend,
1235                                         wbc, all_bh, end_index);
1236         }
1237
1238         if (iohead)
1239                 xfs_submit_ioend(wbc, iohead);
1240
1241         return 0;
1242
1243 error:
1244         if (iohead)
1245                 xfs_cancel_ioend(iohead);
1246
1247         if (err == -EAGAIN)
1248                 goto redirty;
1249
1250         xfs_aops_discard_page(page);
1251         ClearPageUptodate(page);
1252         unlock_page(page);
1253         return err;
1254
1255 redirty:
1256         redirty_page_for_writepage(wbc, page);
1257         unlock_page(page);
1258         return 0;
1259 }
1260
1261 STATIC int
1262 xfs_vm_writepages(
1263         struct address_space    *mapping,
1264         struct writeback_control *wbc)
1265 {
1266         xfs_iflags_clear(XFS_I(mapping->host), XFS_ITRUNCATED);
1267         return generic_writepages(mapping, wbc);
1268 }
1269
1270 /*
1271  * Called to move a page into cleanable state - and from there
1272  * to be released. The page should already be clean. We always
1273  * have buffer heads in this call.
1274  *
1275  * Returns 1 if the page is ok to release, 0 otherwise.
1276  */
1277 STATIC int
1278 xfs_vm_releasepage(
1279         struct page             *page,
1280         gfp_t                   gfp_mask)
1281 {
1282         int                     delalloc, unwritten;
1283
1284         trace_xfs_releasepage(page->mapping->host, page, 0);
1285
1286         xfs_count_page_state(page, &delalloc, &unwritten);
1287
1288         if (WARN_ON(delalloc))
1289                 return 0;
1290         if (WARN_ON(unwritten))
1291                 return 0;
1292
1293         return try_to_free_buffers(page);
1294 }
1295
1296 STATIC int
1297 __xfs_get_blocks(
1298         struct inode            *inode,
1299         sector_t                iblock,
1300         struct buffer_head      *bh_result,
1301         int                     create,
1302         int                     direct)
1303 {
1304         int                     flags = create ? BMAPI_WRITE : BMAPI_READ;
1305         struct xfs_bmbt_irec    imap;
1306         xfs_off_t               offset;
1307         ssize_t                 size;
1308         int                     nimap = 1;
1309         int                     new = 0;
1310         int                     error;
1311
1312         offset = (xfs_off_t)iblock << inode->i_blkbits;
1313         ASSERT(bh_result->b_size >= (1 << inode->i_blkbits));
1314         size = bh_result->b_size;
1315
1316         if (!create && direct && offset >= i_size_read(inode))
1317                 return 0;
1318
1319         if (direct && create)
1320                 flags |= BMAPI_DIRECT;
1321
1322         error = xfs_iomap(XFS_I(inode), offset, size, flags, &imap, &nimap,
1323                           &new);
1324         if (error)
1325                 return -error;
1326         if (nimap == 0)
1327                 return 0;
1328
1329         if (imap.br_startblock != HOLESTARTBLOCK &&
1330             imap.br_startblock != DELAYSTARTBLOCK) {
1331                 /*
1332                  * For unwritten extents do not report a disk address on
1333                  * the read case (treat as if we're reading into a hole).
1334                  */
1335                 if (create || !ISUNWRITTEN(&imap))
1336                         xfs_map_buffer(inode, bh_result, &imap, offset);
1337                 if (create && ISUNWRITTEN(&imap)) {
1338                         if (direct)
1339                                 bh_result->b_private = inode;
1340                         set_buffer_unwritten(bh_result);
1341                 }
1342         }
1343
1344         /*
1345          * If this is a realtime file, data may be on a different device.
1346          * to that pointed to from the buffer_head b_bdev currently.
1347          */
1348         bh_result->b_bdev = xfs_find_bdev_for_inode(inode);
1349
1350         /*
1351          * If we previously allocated a block out beyond eof and we are now
1352          * coming back to use it then we will need to flag it as new even if it
1353          * has a disk address.
1354          *
1355          * With sub-block writes into unwritten extents we also need to mark
1356          * the buffer as new so that the unwritten parts of the buffer gets
1357          * correctly zeroed.
1358          */
1359         if (create &&
1360             ((!buffer_mapped(bh_result) && !buffer_uptodate(bh_result)) ||
1361              (offset >= i_size_read(inode)) ||
1362              (new || ISUNWRITTEN(&imap))))
1363                 set_buffer_new(bh_result);
1364
1365         if (imap.br_startblock == DELAYSTARTBLOCK) {
1366                 BUG_ON(direct);
1367                 if (create) {
1368                         set_buffer_uptodate(bh_result);
1369                         set_buffer_mapped(bh_result);
1370                         set_buffer_delay(bh_result);
1371                 }
1372         }
1373
1374         /*
1375          * If this is O_DIRECT or the mpage code calling tell them how large
1376          * the mapping is, so that we can avoid repeated get_blocks calls.
1377          */
1378         if (direct || size > (1 << inode->i_blkbits)) {
1379                 xfs_off_t               mapping_size;
1380
1381                 mapping_size = imap.br_startoff + imap.br_blockcount - iblock;
1382                 mapping_size <<= inode->i_blkbits;
1383
1384                 ASSERT(mapping_size > 0);
1385                 if (mapping_size > size)
1386                         mapping_size = size;
1387                 if (mapping_size > LONG_MAX)
1388                         mapping_size = LONG_MAX;
1389
1390                 bh_result->b_size = mapping_size;
1391         }
1392
1393         return 0;
1394 }
1395
1396 int
1397 xfs_get_blocks(
1398         struct inode            *inode,
1399         sector_t                iblock,
1400         struct buffer_head      *bh_result,
1401         int                     create)
1402 {
1403         return __xfs_get_blocks(inode, iblock, bh_result, create, 0);
1404 }
1405
1406 STATIC int
1407 xfs_get_blocks_direct(
1408         struct inode            *inode,
1409         sector_t                iblock,
1410         struct buffer_head      *bh_result,
1411         int                     create)
1412 {
1413         return __xfs_get_blocks(inode, iblock, bh_result, create, 1);
1414 }
1415
1416 /*
1417  * Complete a direct I/O write request.
1418  *
1419  * If the private argument is non-NULL __xfs_get_blocks signals us that we
1420  * need to issue a transaction to convert the range from unwritten to written
1421  * extents.  In case this is regular synchronous I/O we just call xfs_end_io
1422  * to do this and we are done.  But in case this was a successfull AIO
1423  * request this handler is called from interrupt context, from which we
1424  * can't start transactions.  In that case offload the I/O completion to
1425  * the workqueues we also use for buffered I/O completion.
1426  */
1427 STATIC void
1428 xfs_end_io_direct_write(
1429         struct kiocb            *iocb,
1430         loff_t                  offset,
1431         ssize_t                 size,
1432         void                    *private,
1433         int                     ret,
1434         bool                    is_async)
1435 {
1436         struct xfs_ioend        *ioend = iocb->private;
1437
1438         /*
1439          * blockdev_direct_IO can return an error even after the I/O
1440          * completion handler was called.  Thus we need to protect
1441          * against double-freeing.
1442          */
1443         iocb->private = NULL;
1444
1445         ioend->io_offset = offset;
1446         ioend->io_size = size;
1447         if (private && size > 0)
1448                 ioend->io_type = IO_UNWRITTEN;
1449
1450         if (is_async) {
1451                 /*
1452                  * If we are converting an unwritten extent we need to delay
1453                  * the AIO completion until after the unwrittent extent
1454                  * conversion has completed, otherwise do it ASAP.
1455                  */
1456                 if (ioend->io_type == IO_UNWRITTEN) {
1457                         ioend->io_iocb = iocb;
1458                         ioend->io_result = ret;
1459                 } else {
1460                         aio_complete(iocb, ret, 0);
1461                 }
1462                 xfs_finish_ioend(ioend);
1463         } else {
1464                 xfs_finish_ioend_sync(ioend);
1465         }
1466 }
1467
1468 STATIC ssize_t
1469 xfs_vm_direct_IO(
1470         int                     rw,
1471         struct kiocb            *iocb,
1472         const struct iovec      *iov,
1473         loff_t                  offset,
1474         unsigned long           nr_segs)
1475 {
1476         struct inode            *inode = iocb->ki_filp->f_mapping->host;
1477         struct block_device     *bdev = xfs_find_bdev_for_inode(inode);
1478         ssize_t                 ret;
1479
1480         if (rw & WRITE) {
1481                 iocb->private = xfs_alloc_ioend(inode, IO_NEW);
1482
1483                 ret = __blockdev_direct_IO(rw, iocb, inode, bdev, iov,
1484                                             offset, nr_segs,
1485                                             xfs_get_blocks_direct,
1486                                             xfs_end_io_direct_write, NULL, 0);
1487                 if (ret != -EIOCBQUEUED && iocb->private)
1488                         xfs_destroy_ioend(iocb->private);
1489         } else {
1490                 ret = __blockdev_direct_IO(rw, iocb, inode, bdev, iov,
1491                                             offset, nr_segs,
1492                                             xfs_get_blocks_direct,
1493                                             NULL, NULL, 0);
1494         }
1495
1496         return ret;
1497 }
1498
1499 STATIC void
1500 xfs_vm_write_failed(
1501         struct address_space    *mapping,
1502         loff_t                  to)
1503 {
1504         struct inode            *inode = mapping->host;
1505
1506         if (to > inode->i_size) {
1507                 struct iattr    ia = {
1508                         .ia_valid       = ATTR_SIZE | ATTR_FORCE,
1509                         .ia_size        = inode->i_size,
1510                 };
1511                 xfs_setattr(XFS_I(inode), &ia, XFS_ATTR_NOLOCK);
1512         }
1513 }
1514
1515 STATIC int
1516 xfs_vm_write_begin(
1517         struct file             *file,
1518         struct address_space    *mapping,
1519         loff_t                  pos,
1520         unsigned                len,
1521         unsigned                flags,
1522         struct page             **pagep,
1523         void                    **fsdata)
1524 {
1525         int                     ret;
1526
1527         ret = block_write_begin(mapping, pos, len, flags | AOP_FLAG_NOFS,
1528                                 pagep, xfs_get_blocks);
1529         if (unlikely(ret))
1530                 xfs_vm_write_failed(mapping, pos + len);
1531         return ret;
1532 }
1533
1534 STATIC int
1535 xfs_vm_write_end(
1536         struct file             *file,
1537         struct address_space    *mapping,
1538         loff_t                  pos,
1539         unsigned                len,
1540         unsigned                copied,
1541         struct page             *page,
1542         void                    *fsdata)
1543 {
1544         int                     ret;
1545
1546         ret = generic_write_end(file, mapping, pos, len, copied, page, fsdata);
1547         if (unlikely(ret < len))
1548                 xfs_vm_write_failed(mapping, pos + len);
1549         return ret;
1550 }
1551
1552 STATIC sector_t
1553 xfs_vm_bmap(
1554         struct address_space    *mapping,
1555         sector_t                block)
1556 {
1557         struct inode            *inode = (struct inode *)mapping->host;
1558         struct xfs_inode        *ip = XFS_I(inode);
1559
1560         trace_xfs_vm_bmap(XFS_I(inode));
1561         xfs_ilock(ip, XFS_IOLOCK_SHARED);
1562         xfs_flush_pages(ip, (xfs_off_t)0, -1, 0, FI_REMAPF);
1563         xfs_iunlock(ip, XFS_IOLOCK_SHARED);
1564         return generic_block_bmap(mapping, block, xfs_get_blocks);
1565 }
1566
1567 STATIC int
1568 xfs_vm_readpage(
1569         struct file             *unused,
1570         struct page             *page)
1571 {
1572         return mpage_readpage(page, xfs_get_blocks);
1573 }
1574
1575 STATIC int
1576 xfs_vm_readpages(
1577         struct file             *unused,
1578         struct address_space    *mapping,
1579         struct list_head        *pages,
1580         unsigned                nr_pages)
1581 {
1582         return mpage_readpages(mapping, pages, nr_pages, xfs_get_blocks);
1583 }
1584
1585 const struct address_space_operations xfs_address_space_operations = {
1586         .readpage               = xfs_vm_readpage,
1587         .readpages              = xfs_vm_readpages,
1588         .writepage              = xfs_vm_writepage,
1589         .writepages             = xfs_vm_writepages,
1590         .sync_page              = block_sync_page,
1591         .releasepage            = xfs_vm_releasepage,
1592         .invalidatepage         = xfs_vm_invalidatepage,
1593         .write_begin            = xfs_vm_write_begin,
1594         .write_end              = xfs_vm_write_end,
1595         .bmap                   = xfs_vm_bmap,
1596         .direct_IO              = xfs_vm_direct_IO,
1597         .migratepage            = buffer_migrate_page,
1598         .is_partially_uptodate  = block_is_partially_uptodate,
1599         .error_remove_page      = generic_error_remove_page,
1600 };