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