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