Blame view
fs/xfs/xfs_aops.c
46.9 KB
1da177e4c Linux-2.6.12-rc2 |
1 |
/* |
7b7187698 [XFS] Update lice... |
2 3 |
* Copyright (c) 2000-2005 Silicon Graphics, Inc. * All Rights Reserved. |
1da177e4c Linux-2.6.12-rc2 |
4 |
* |
7b7187698 [XFS] Update lice... |
5 6 |
* This program is free software; you can redistribute it and/or * modify it under the terms of the GNU General Public License as |
1da177e4c Linux-2.6.12-rc2 |
7 8 |
* published by the Free Software Foundation. * |
7b7187698 [XFS] Update lice... |
9 10 11 12 |
* This program is distributed in the hope that it would be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. |
1da177e4c Linux-2.6.12-rc2 |
13 |
* |
7b7187698 [XFS] Update lice... |
14 15 16 |
* You should have received a copy of the GNU General Public License * along with this program; if not, write the Free Software Foundation, * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA |
1da177e4c Linux-2.6.12-rc2 |
17 |
*/ |
1da177e4c Linux-2.6.12-rc2 |
18 |
#include "xfs.h" |
70a9883c5 xfs: create a sha... |
19 |
#include "xfs_shared.h" |
239880ef6 xfs: decouple log... |
20 21 22 |
#include "xfs_format.h" #include "xfs_log_format.h" #include "xfs_trans_resv.h" |
1da177e4c Linux-2.6.12-rc2 |
23 |
#include "xfs_mount.h" |
1da177e4c Linux-2.6.12-rc2 |
24 |
#include "xfs_inode.h" |
239880ef6 xfs: decouple log... |
25 |
#include "xfs_trans.h" |
281627df3 xfs: log file siz... |
26 |
#include "xfs_inode_item.h" |
a844f4510 [XFS] Remove xfs_... |
27 |
#include "xfs_alloc.h" |
1da177e4c Linux-2.6.12-rc2 |
28 |
#include "xfs_error.h" |
1da177e4c Linux-2.6.12-rc2 |
29 |
#include "xfs_iomap.h" |
0b1b213fc xfs: event tracin... |
30 |
#include "xfs_trace.h" |
3ed3a4343 xfs: truncate del... |
31 |
#include "xfs_bmap.h" |
689881145 xfs: create xfs_b... |
32 |
#include "xfs_bmap_util.h" |
a4fbe6ab1 xfs: decouple ino... |
33 |
#include "xfs_bmap_btree.h" |
ef4736678 xfs: allocate del... |
34 |
#include "xfs_reflink.h" |
5a0e3ad6a include cleanup: ... |
35 |
#include <linux/gfp.h> |
1da177e4c Linux-2.6.12-rc2 |
36 |
#include <linux/mpage.h> |
10ce44442 [XFS] use pagevec... |
37 |
#include <linux/pagevec.h> |
1da177e4c Linux-2.6.12-rc2 |
38 |
#include <linux/writeback.h> |
273dda76f xfs: don't use io... |
39 40 41 |
/* flags for direct write completions */ #define XFS_DIO_FLAG_UNWRITTEN (1 << 0) #define XFS_DIO_FLAG_APPEND (1 << 1) |
0613f16cd xfs: implement Co... |
42 |
#define XFS_DIO_FLAG_COW (1 << 2) |
273dda76f xfs: don't use io... |
43 |
|
fbcc02561 xfs: Introduce wr... |
44 45 46 47 48 49 50 |
/* * structure owned by writepages passed to individual writepage calls */ struct xfs_writepage_ctx { struct xfs_bmbt_irec imap; bool imap_valid; unsigned int io_type; |
fbcc02561 xfs: Introduce wr... |
51 52 53 |
struct xfs_ioend *ioend; sector_t last_block; }; |
0b1b213fc xfs: event tracin... |
54 |
void |
f51623b21 [XFS] Move some c... |
55 56 57 |
xfs_count_page_state( struct page *page, int *delalloc, |
f51623b21 [XFS] Move some c... |
58 59 60 |
int *unwritten) { struct buffer_head *bh, *head; |
20cb52ebd xfs: simplify xfs... |
61 |
*delalloc = *unwritten = 0; |
f51623b21 [XFS] Move some c... |
62 63 64 |
bh = head = page_buffers(page); do { |
20cb52ebd xfs: simplify xfs... |
65 |
if (buffer_unwritten(bh)) |
f51623b21 [XFS] Move some c... |
66 67 68 69 70 |
(*unwritten) = 1; else if (buffer_delay(bh)) (*delalloc) = 1; } while ((bh = bh->b_this_page) != head); } |
20a90f589 dax: give DAX cle... |
71 |
struct block_device * |
6214ed446 [XFS] kill BMAPI_... |
72 |
xfs_find_bdev_for_inode( |
046f1685b xfs: remove iomap... |
73 |
struct inode *inode) |
6214ed446 [XFS] kill BMAPI_... |
74 |
{ |
046f1685b xfs: remove iomap... |
75 |
struct xfs_inode *ip = XFS_I(inode); |
6214ed446 [XFS] kill BMAPI_... |
76 |
struct xfs_mount *mp = ip->i_mount; |
71ddabb94 [XFS] optimize XF... |
77 |
if (XFS_IS_REALTIME_INODE(ip)) |
6214ed446 [XFS] kill BMAPI_... |
78 79 80 81 |
return mp->m_rtdev_targp->bt_bdev; else return mp->m_ddev_targp->bt_bdev; } |
0829c3602 [XFS] Add infrast... |
82 |
/* |
37992c18b xfs: don't releas... |
83 84 85 |
* We're now finished for good with this page. Update the page state via the * associated buffer_heads, paying attention to the start and end offsets that * we need to process on the page. |
28b783e47 xfs: bufferhead c... |
86 87 88 89 90 91 |
* * Landmine Warning: bh->b_end_io() will call end_page_writeback() on the last * buffer in the IO. Once it does this, it is unsafe to access the bufferhead or * the page at all, as we may be racing with memory reclaim and it can free both * the bufferhead chain and the page as it will see the page as clean and * unused. |
37992c18b xfs: don't releas... |
92 93 94 95 96 97 98 |
*/ static void xfs_finish_page_writeback( struct inode *inode, struct bio_vec *bvec, int error) { |
37992c18b xfs: don't releas... |
99 |
unsigned int end = bvec->bv_offset + bvec->bv_len - 1; |
28b783e47 xfs: bufferhead c... |
100 |
struct buffer_head *head, *bh, *next; |
37992c18b xfs: don't releas... |
101 |
unsigned int off = 0; |
28b783e47 xfs: bufferhead c... |
102 |
unsigned int bsize; |
37992c18b xfs: don't releas... |
103 104 |
ASSERT(bvec->bv_offset < PAGE_SIZE); |
690a78712 xfs: fix warning ... |
105 |
ASSERT((bvec->bv_offset & ((1 << inode->i_blkbits) - 1)) == 0); |
37992c18b xfs: don't releas... |
106 |
ASSERT(end < PAGE_SIZE); |
690a78712 xfs: fix warning ... |
107 |
ASSERT((bvec->bv_len & ((1 << inode->i_blkbits) - 1)) == 0); |
37992c18b xfs: don't releas... |
108 109 |
bh = head = page_buffers(bvec->bv_page); |
28b783e47 xfs: bufferhead c... |
110 |
bsize = bh->b_size; |
37992c18b xfs: don't releas... |
111 |
do { |
28b783e47 xfs: bufferhead c... |
112 |
next = bh->b_this_page; |
37992c18b xfs: don't releas... |
113 114 115 116 117 118 |
if (off < bvec->bv_offset) goto next_bh; if (off > end) break; bh->b_end_io(bh, !error); next_bh: |
28b783e47 xfs: bufferhead c... |
119 120 |
off += bsize; } while ((bh = next) != head); |
37992c18b xfs: don't releas... |
121 122 123 124 125 126 |
} /* * We're now finished for good with this ioend structure. Update the page * state, release holds on bios, and finally free up memory. Do not use the * ioend after this. |
f6d6d4fcd [XFS] Initial pas... |
127 |
*/ |
0829c3602 [XFS] Add infrast... |
128 129 |
STATIC void xfs_destroy_ioend( |
0e51a8e19 xfs: optimize bio... |
130 131 |
struct xfs_ioend *ioend, int error) |
0829c3602 [XFS] Add infrast... |
132 |
{ |
37992c18b xfs: don't releas... |
133 |
struct inode *inode = ioend->io_inode; |
0e51a8e19 xfs: optimize bio... |
134 |
struct bio *last = ioend->io_bio; |
37992c18b xfs: don't releas... |
135 |
struct bio *bio, *next; |
f6d6d4fcd [XFS] Initial pas... |
136 |
|
0e51a8e19 xfs: optimize bio... |
137 |
for (bio = &ioend->io_inline_bio; bio; bio = next) { |
37992c18b xfs: don't releas... |
138 139 |
struct bio_vec *bvec; int i; |
0e51a8e19 xfs: optimize bio... |
140 141 142 143 144 145 146 147 |
/* * For the last bio, bi_private points to the ioend, so we * need to explicitly end the iteration here. */ if (bio == last) next = NULL; else next = bio->bi_private; |
583fa586f kill vn_ioerror |
148 |
|
37992c18b xfs: don't releas... |
149 150 151 152 153 |
/* walk each page on bio, ending page IO on them */ bio_for_each_segment_all(bvec, bio, i) xfs_finish_page_writeback(inode, bvec, error); bio_put(bio); |
f6d6d4fcd [XFS] Initial pas... |
154 |
} |
0829c3602 [XFS] Add infrast... |
155 156 157 |
} /* |
fc0063c44 xfs: reduce ioend... |
158 159 160 161 162 163 164 |
* Fast and loose check if this write could update the on-disk inode size. */ static inline bool xfs_ioend_is_append(struct xfs_ioend *ioend) { return ioend->io_offset + ioend->io_size > XFS_I(ioend->io_inode)->i_d.di_size; } |
281627df3 xfs: log file siz... |
165 166 167 168 169 170 171 |
STATIC int xfs_setfilesize_trans_alloc( struct xfs_ioend *ioend) { struct xfs_mount *mp = XFS_I(ioend->io_inode)->i_mount; struct xfs_trans *tp; int error; |
253f4911f xfs: better xfs_t... |
172 173 |
error = xfs_trans_alloc(mp, &M_RES(mp)->tr_fsyncts, 0, 0, 0, &tp); if (error) |
281627df3 xfs: log file siz... |
174 |
return error; |
281627df3 xfs: log file siz... |
175 176 177 178 |
ioend->io_append_trans = tp; /* |
437a255aa xfs: fix direct I... |
179 |
* We may pass freeze protection with a transaction. So tell lockdep |
d9457dc05 xfs: Convert to n... |
180 181 |
* we released it. */ |
bee9182d9 introduce __sb_wr... |
182 |
__sb_writers_release(ioend->io_inode->i_sb, SB_FREEZE_FS); |
d9457dc05 xfs: Convert to n... |
183 |
/* |
281627df3 xfs: log file siz... |
184 185 186 187 188 189 |
* We hand off the transaction to the completion thread now, so * clear the flag here. */ current_restore_flags_nested(&tp->t_pflags, PF_FSTRANS); return 0; } |
fc0063c44 xfs: reduce ioend... |
190 |
/* |
2813d682e xfs: remove the i... |
191 |
* Update on-disk file size now that data has been written to disk. |
ba87ea699 [XFS] Fix to prev... |
192 |
*/ |
281627df3 xfs: log file siz... |
193 |
STATIC int |
e372843a4 xfs: refactor xfs... |
194 |
__xfs_setfilesize( |
2ba662370 xfs: don't alloca... |
195 196 197 198 |
struct xfs_inode *ip, struct xfs_trans *tp, xfs_off_t offset, size_t size) |
ba87ea699 [XFS] Fix to prev... |
199 |
{ |
ba87ea699 [XFS] Fix to prev... |
200 |
xfs_fsize_t isize; |
ba87ea699 [XFS] Fix to prev... |
201 |
|
aa6bf01d3 xfs: use per-file... |
202 |
xfs_ilock(ip, XFS_ILOCK_EXCL); |
2ba662370 xfs: don't alloca... |
203 |
isize = xfs_new_eof(ip, offset + size); |
281627df3 xfs: log file siz... |
204 205 |
if (!isize) { xfs_iunlock(ip, XFS_ILOCK_EXCL); |
4906e2154 xfs: remove the f... |
206 |
xfs_trans_cancel(tp); |
281627df3 xfs: log file siz... |
207 |
return 0; |
ba87ea699 [XFS] Fix to prev... |
208 |
} |
2ba662370 xfs: don't alloca... |
209 |
trace_xfs_setfilesize(ip, offset, size); |
281627df3 xfs: log file siz... |
210 211 212 213 |
ip->i_d.di_size = isize; xfs_trans_ijoin(tp, ip, XFS_ILOCK_EXCL); xfs_trans_log_inode(tp, ip, XFS_ILOG_CORE); |
70393313d xfs: saner xfs_tr... |
214 |
return xfs_trans_commit(tp); |
77d7a0c2e xfs: Non-blocking... |
215 |
} |
e372843a4 xfs: refactor xfs... |
216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 |
int xfs_setfilesize( struct xfs_inode *ip, xfs_off_t offset, size_t size) { struct xfs_mount *mp = ip->i_mount; struct xfs_trans *tp; int error; error = xfs_trans_alloc(mp, &M_RES(mp)->tr_fsyncts, 0, 0, 0, &tp); if (error) return error; return __xfs_setfilesize(ip, tp, offset, size); } |
2ba662370 xfs: don't alloca... |
232 233 |
STATIC int xfs_setfilesize_ioend( |
0e51a8e19 xfs: optimize bio... |
234 235 |
struct xfs_ioend *ioend, int error) |
2ba662370 xfs: don't alloca... |
236 237 238 239 240 241 242 243 244 245 |
{ struct xfs_inode *ip = XFS_I(ioend->io_inode); struct xfs_trans *tp = ioend->io_append_trans; /* * The transaction may have been allocated in the I/O submission thread, * thus we need to mark ourselves as being in a transaction manually. * Similarly for freeze protection. */ current_set_flags_nested(&tp->t_pflags, PF_FSTRANS); |
bee9182d9 introduce __sb_wr... |
246 |
__sb_writers_acquired(VFS_I(ip)->i_sb, SB_FREEZE_FS); |
2ba662370 xfs: don't alloca... |
247 |
|
5cb13dcd0 cancel the setfil... |
248 |
/* we abort the update if there was an IO error */ |
0e51a8e19 xfs: optimize bio... |
249 |
if (error) { |
5cb13dcd0 cancel the setfil... |
250 |
xfs_trans_cancel(tp); |
0e51a8e19 xfs: optimize bio... |
251 |
return error; |
5cb13dcd0 cancel the setfil... |
252 |
} |
e372843a4 xfs: refactor xfs... |
253 |
return __xfs_setfilesize(ip, tp, ioend->io_offset, ioend->io_size); |
2ba662370 xfs: don't alloca... |
254 |
} |
77d7a0c2e xfs: Non-blocking... |
255 |
/* |
5ec4fabb0 xfs: cleanup data... |
256 |
* IO write completion. |
f6d6d4fcd [XFS] Initial pas... |
257 258 |
*/ STATIC void |
5ec4fabb0 xfs: cleanup data... |
259 |
xfs_end_io( |
77d7a0c2e xfs: Non-blocking... |
260 |
struct work_struct *work) |
0829c3602 [XFS] Add infrast... |
261 |
{ |
0e51a8e19 xfs: optimize bio... |
262 263 264 265 |
struct xfs_ioend *ioend = container_of(work, struct xfs_ioend, io_work); struct xfs_inode *ip = XFS_I(ioend->io_inode); int error = ioend->io_bio->bi_error; |
ba87ea699 [XFS] Fix to prev... |
266 |
|
af055e37a xfs: fix xfs_log_... |
267 268 269 270 271 |
/* * Set an error if the mount has shut down and proceed with end I/O * processing so it can perform whatever cleanups are necessary. */ if (XFS_FORCED_SHUTDOWN(ip->i_mount)) |
0e51a8e19 xfs: optimize bio... |
272 |
error = -EIO; |
04f658ee2 xfs: improve ioen... |
273 |
|
5ec4fabb0 xfs: cleanup data... |
274 |
/* |
43caeb187 xfs: move mapping... |
275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 |
* For a CoW extent, we need to move the mapping from the CoW fork * to the data fork. If instead an error happened, just dump the * new blocks. */ if (ioend->io_type == XFS_IO_COW) { if (error) goto done; if (ioend->io_bio->bi_error) { error = xfs_reflink_cancel_cow_range(ip, ioend->io_offset, ioend->io_size); goto done; } error = xfs_reflink_end_cow(ip, ioend->io_offset, ioend->io_size); if (error) goto done; } /* |
5ec4fabb0 xfs: cleanup data... |
294 295 |
* For unwritten extents we need to issue transactions to convert a * range to normal written extens after the data I/O has finished. |
5cb13dcd0 cancel the setfil... |
296 297 298 |
* Detecting and handling completion IO errors is done individually * for each case as different cleanup operations need to be performed * on error. |
5ec4fabb0 xfs: cleanup data... |
299 |
*/ |
0d882a360 Prefix IO_XX flag... |
300 |
if (ioend->io_type == XFS_IO_UNWRITTEN) { |
0e51a8e19 xfs: optimize bio... |
301 |
if (error) |
5cb13dcd0 cancel the setfil... |
302 |
goto done; |
437a255aa xfs: fix direct I... |
303 304 |
error = xfs_iomap_write_unwritten(ip, ioend->io_offset, ioend->io_size); |
281627df3 xfs: log file siz... |
305 |
} else if (ioend->io_append_trans) { |
0e51a8e19 xfs: optimize bio... |
306 |
error = xfs_setfilesize_ioend(ioend, error); |
84803fb78 xfs: log file siz... |
307 |
} else { |
43caeb187 xfs: move mapping... |
308 309 |
ASSERT(!xfs_ioend_is_append(ioend) || ioend->io_type == XFS_IO_COW); |
5ec4fabb0 xfs: cleanup data... |
310 |
} |
ba87ea699 [XFS] Fix to prev... |
311 |
|
04f658ee2 xfs: improve ioen... |
312 |
done: |
0e51a8e19 xfs: optimize bio... |
313 |
xfs_destroy_ioend(ioend, error); |
c626d174c xfs: prevent unwr... |
314 |
} |
0e51a8e19 xfs: optimize bio... |
315 316 317 |
STATIC void xfs_end_bio( struct bio *bio) |
0829c3602 [XFS] Add infrast... |
318 |
{ |
0e51a8e19 xfs: optimize bio... |
319 320 |
struct xfs_ioend *ioend = bio->bi_private; struct xfs_mount *mp = XFS_I(ioend->io_inode)->i_mount; |
0829c3602 [XFS] Add infrast... |
321 |
|
43caeb187 xfs: move mapping... |
322 |
if (ioend->io_type == XFS_IO_UNWRITTEN || ioend->io_type == XFS_IO_COW) |
0e51a8e19 xfs: optimize bio... |
323 324 325 326 327 |
queue_work(mp->m_unwritten_workqueue, &ioend->io_work); else if (ioend->io_append_trans) queue_work(mp->m_data_workqueue, &ioend->io_work); else xfs_destroy_ioend(ioend, bio->bi_error); |
0829c3602 [XFS] Add infrast... |
328 |
} |
1da177e4c Linux-2.6.12-rc2 |
329 330 331 332 |
STATIC int xfs_map_blocks( struct inode *inode, loff_t offset, |
207d04160 xfs: kill struct ... |
333 |
struct xfs_bmbt_irec *imap, |
988ef9279 xfs: remove nonbl... |
334 |
int type) |
1da177e4c Linux-2.6.12-rc2 |
335 |
{ |
a206c817c xfs: kill xfs_iomap |
336 337 |
struct xfs_inode *ip = XFS_I(inode); struct xfs_mount *mp = ip->i_mount; |
ed1e7b7e4 xfs: remove xfs_p... |
338 |
ssize_t count = 1 << inode->i_blkbits; |
a206c817c xfs: kill xfs_iomap |
339 340 |
xfs_fileoff_t offset_fsb, end_fsb; int error = 0; |
a206c817c xfs: kill xfs_iomap |
341 342 343 344 |
int bmapi_flags = XFS_BMAPI_ENTIRE; int nimaps = 1; if (XFS_FORCED_SHUTDOWN(mp)) |
b474c7ae4 xfs: Nuke XFS_ERR... |
345 |
return -EIO; |
a206c817c xfs: kill xfs_iomap |
346 |
|
ef4736678 xfs: allocate del... |
347 |
ASSERT(type != XFS_IO_COW); |
0d882a360 Prefix IO_XX flag... |
348 |
if (type == XFS_IO_UNWRITTEN) |
a206c817c xfs: kill xfs_iomap |
349 |
bmapi_flags |= XFS_BMAPI_IGSTATE; |
8ff2957d5 xfs: simplify xfs... |
350 |
|
988ef9279 xfs: remove nonbl... |
351 |
xfs_ilock(ip, XFS_ILOCK_SHARED); |
8ff2957d5 xfs: simplify xfs... |
352 353 |
ASSERT(ip->i_d.di_format != XFS_DINODE_FMT_BTREE || (ip->i_df.if_flags & XFS_IFEXTENTS)); |
d2c281911 xfs: m_maxioffset... |
354 |
ASSERT(offset <= mp->m_super->s_maxbytes); |
8ff2957d5 xfs: simplify xfs... |
355 |
|
d2c281911 xfs: m_maxioffset... |
356 357 |
if (offset + count > mp->m_super->s_maxbytes) count = mp->m_super->s_maxbytes - offset; |
a206c817c xfs: kill xfs_iomap |
358 359 |
end_fsb = XFS_B_TO_FSB(mp, (xfs_ufsize_t)offset + count); offset_fsb = XFS_B_TO_FSBT(mp, offset); |
5c8ed2021 xfs: introduce xf... |
360 361 |
error = xfs_bmapi_read(ip, offset_fsb, end_fsb - offset_fsb, imap, &nimaps, bmapi_flags); |
ef4736678 xfs: allocate del... |
362 363 364 365 366 367 368 |
/* * Truncate an overwrite extent if there's a pending CoW * reservation before the end of this extent. This forces us * to come back to writepage to take care of the CoW. */ if (nimaps && type == XFS_IO_OVERWRITE) xfs_reflink_trim_irec_to_next_cow(ip, offset_fsb, imap); |
8ff2957d5 xfs: simplify xfs... |
369 |
xfs_iunlock(ip, XFS_ILOCK_SHARED); |
a206c817c xfs: kill xfs_iomap |
370 |
|
8ff2957d5 xfs: simplify xfs... |
371 |
if (error) |
2451337dd xfs: global error... |
372 |
return error; |
a206c817c xfs: kill xfs_iomap |
373 |
|
0d882a360 Prefix IO_XX flag... |
374 |
if (type == XFS_IO_DELALLOC && |
8ff2957d5 xfs: simplify xfs... |
375 |
(!nimaps || isnullstartblock(imap->br_startblock))) { |
60b4984fc xfs: support allo... |
376 377 |
error = xfs_iomap_write_allocate(ip, XFS_DATA_FORK, offset, imap); |
a206c817c xfs: kill xfs_iomap |
378 |
if (!error) |
ef4736678 xfs: allocate del... |
379 |
trace_xfs_map_blocks_alloc(ip, offset, count, type, imap); |
2451337dd xfs: global error... |
380 |
return error; |
a206c817c xfs: kill xfs_iomap |
381 |
} |
8ff2957d5 xfs: simplify xfs... |
382 |
#ifdef DEBUG |
0d882a360 Prefix IO_XX flag... |
383 |
if (type == XFS_IO_UNWRITTEN) { |
8ff2957d5 xfs: simplify xfs... |
384 385 386 387 388 389 390 391 |
ASSERT(nimaps); ASSERT(imap->br_startblock != HOLESTARTBLOCK); ASSERT(imap->br_startblock != DELAYSTARTBLOCK); } #endif if (nimaps) trace_xfs_map_blocks_found(ip, offset, count, type, imap); return 0; |
1da177e4c Linux-2.6.12-rc2 |
392 |
} |
fbcc02561 xfs: Introduce wr... |
393 |
STATIC bool |
558e68916 xfs: clean up xfs... |
394 |
xfs_imap_valid( |
8699bb0a4 xfs: report iomap... |
395 |
struct inode *inode, |
207d04160 xfs: kill struct ... |
396 |
struct xfs_bmbt_irec *imap, |
558e68916 xfs: clean up xfs... |
397 |
xfs_off_t offset) |
1da177e4c Linux-2.6.12-rc2 |
398 |
{ |
558e68916 xfs: clean up xfs... |
399 |
offset >>= inode->i_blkbits; |
8699bb0a4 xfs: report iomap... |
400 |
|
558e68916 xfs: clean up xfs... |
401 402 |
return offset >= imap->br_startoff && offset < imap->br_startoff + imap->br_blockcount; |
1da177e4c Linux-2.6.12-rc2 |
403 |
} |
f6d6d4fcd [XFS] Initial pas... |
404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 |
STATIC void xfs_start_buffer_writeback( struct buffer_head *bh) { ASSERT(buffer_mapped(bh)); ASSERT(buffer_locked(bh)); ASSERT(!buffer_delay(bh)); ASSERT(!buffer_unwritten(bh)); mark_buffer_async_write(bh); set_buffer_uptodate(bh); clear_buffer_dirty(bh); } STATIC void xfs_start_page_writeback( struct page *page, |
e10de3723 xfs: don't chain ... |
421 |
int clear_dirty) |
f6d6d4fcd [XFS] Initial pas... |
422 423 424 |
{ ASSERT(PageLocked(page)); ASSERT(!PageWriteback(page)); |
0d085a529 xfs: ensure WB_SY... |
425 426 427 428 429 430 431 432 433 |
/* * if the page was not fully cleaned, we need to ensure that the higher * layers come back to it correctly. That means we need to keep the page * dirty, and for WB_SYNC_ALL writeback we need to ensure the * PAGECACHE_TAG_TOWRITE index mark is not removed so another attempt to * write this page in this writeback sweep will be made. */ if (clear_dirty) { |
921320210 [PATCH] Fix XFS a... |
434 |
clear_page_dirty_for_io(page); |
0d085a529 xfs: ensure WB_SY... |
435 436 437 |
set_page_writeback(page); } else set_page_writeback_keepwrite(page); |
f6d6d4fcd [XFS] Initial pas... |
438 |
unlock_page(page); |
f6d6d4fcd [XFS] Initial pas... |
439 |
} |
c7c1a7d8b xfs: rename bio_a... |
440 |
static inline int xfs_bio_add_buffer(struct bio *bio, struct buffer_head *bh) |
f6d6d4fcd [XFS] Initial pas... |
441 442 443 444 445 |
{ return bio_add_page(bio, bh->b_page, bh->b_size, bh_offset(bh)); } /* |
bb18782aa xfs: build bios d... |
446 447 448 449 450 451 |
* Submit the bio for an ioend. We are passed an ioend with a bio attached to * it, and we submit that bio. The ioend may be used for multiple bio * submissions, so we only want to allocate an append transaction for the ioend * once. In the case of multiple bio submission, each bio will take an IO * reference to the ioend to ensure that the ioend completion is only done once * all bios have been submitted and the ioend is really done. |
7bf7f3521 xfs: fix broken e... |
452 453 454 |
* * If @fail is non-zero, it means that we have a situation where some part of * the submission process has failed after we have marked paged for writeback |
bb18782aa xfs: build bios d... |
455 456 457 |
* and unlocked them. In this situation, we need to fail the bio and ioend * rather than submit it to IO. This typically only happens on a filesystem * shutdown. |
f6d6d4fcd [XFS] Initial pas... |
458 |
*/ |
e10de3723 xfs: don't chain ... |
459 |
STATIC int |
f6d6d4fcd [XFS] Initial pas... |
460 |
xfs_submit_ioend( |
06342cf8a xfs: use WRITE_SY... |
461 |
struct writeback_control *wbc, |
0e51a8e19 xfs: optimize bio... |
462 |
struct xfs_ioend *ioend, |
e10de3723 xfs: don't chain ... |
463 |
int status) |
f6d6d4fcd [XFS] Initial pas... |
464 |
{ |
e10de3723 xfs: don't chain ... |
465 466 |
/* Reserve log space if we might write beyond the on-disk inode size. */ if (!status && |
0e51a8e19 xfs: optimize bio... |
467 |
ioend->io_type != XFS_IO_UNWRITTEN && |
bb18782aa xfs: build bios d... |
468 469 |
xfs_ioend_is_append(ioend) && !ioend->io_append_trans) |
e10de3723 xfs: don't chain ... |
470 |
status = xfs_setfilesize_trans_alloc(ioend); |
bb18782aa xfs: build bios d... |
471 |
|
0e51a8e19 xfs: optimize bio... |
472 473 |
ioend->io_bio->bi_private = ioend; ioend->io_bio->bi_end_io = xfs_end_bio; |
50bfcd0cb xfs: use bio op a... |
474 475 |
bio_set_op_attrs(ioend->io_bio, REQ_OP_WRITE, (wbc->sync_mode == WB_SYNC_ALL) ? WRITE_SYNC : 0); |
e10de3723 xfs: don't chain ... |
476 477 478 479 480 481 482 |
/* * If we are failing the IO now, just mark the ioend with an * error and finish it. This will run IO completion immediately * as there is only one reference to the ioend at this point in * time. */ if (status) { |
0e51a8e19 xfs: optimize bio... |
483 484 |
ioend->io_bio->bi_error = status; bio_endio(ioend->io_bio); |
e10de3723 xfs: don't chain ... |
485 486 |
return status; } |
d88992f66 [XFS] Fix a race ... |
487 |
|
4e49ea4a3 block/fs/drivers:... |
488 |
submit_bio(ioend->io_bio); |
e10de3723 xfs: don't chain ... |
489 |
return 0; |
f6d6d4fcd [XFS] Initial pas... |
490 |
} |
f6d6d4fcd [XFS] Initial pas... |
491 |
|
0e51a8e19 xfs: optimize bio... |
492 493 494 495 496 497 498 499 |
static void xfs_init_bio_from_bh( struct bio *bio, struct buffer_head *bh) { bio->bi_iter.bi_sector = bh->b_blocknr * (bh->b_size >> 9); bio->bi_bdev = bh->b_bdev; } |
7bf7f3521 xfs: fix broken e... |
500 |
|
0e51a8e19 xfs: optimize bio... |
501 502 503 504 505 506 507 508 509 |
static struct xfs_ioend * xfs_alloc_ioend( struct inode *inode, unsigned int type, xfs_off_t offset, struct buffer_head *bh) { struct xfs_ioend *ioend; struct bio *bio; |
f6d6d4fcd [XFS] Initial pas... |
510 |
|
0e51a8e19 xfs: optimize bio... |
511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 |
bio = bio_alloc_bioset(GFP_NOFS, BIO_MAX_PAGES, xfs_ioend_bioset); xfs_init_bio_from_bh(bio, bh); ioend = container_of(bio, struct xfs_ioend, io_inline_bio); INIT_LIST_HEAD(&ioend->io_list); ioend->io_type = type; ioend->io_inode = inode; ioend->io_size = 0; ioend->io_offset = offset; INIT_WORK(&ioend->io_work, xfs_end_io); ioend->io_append_trans = NULL; ioend->io_bio = bio; return ioend; } /* * Allocate a new bio, and chain the old bio to the new one. * * Note that we have to do perform the chaining in this unintuitive order * so that the bi_private linkage is set up in the right direction for the * traversal in xfs_destroy_ioend(). */ static void xfs_chain_bio( struct xfs_ioend *ioend, struct writeback_control *wbc, struct buffer_head *bh) { struct bio *new; new = bio_alloc(GFP_NOFS, BIO_MAX_PAGES); xfs_init_bio_from_bh(new, bh); bio_chain(ioend->io_bio, new); bio_get(ioend->io_bio); /* for xfs_destroy_ioend */ |
50bfcd0cb xfs: use bio op a... |
546 547 |
bio_set_op_attrs(ioend->io_bio, REQ_OP_WRITE, (wbc->sync_mode == WB_SYNC_ALL) ? WRITE_SYNC : 0); |
4e49ea4a3 block/fs/drivers:... |
548 |
submit_bio(ioend->io_bio); |
0e51a8e19 xfs: optimize bio... |
549 |
ioend->io_bio = new; |
f6d6d4fcd [XFS] Initial pas... |
550 551 552 553 554 555 |
} /* * Test to see if we've been building up a completion structure for * earlier buffers -- if so, we try to append to this ioend if we * can, otherwise we finish off any current ioend and start another. |
e10de3723 xfs: don't chain ... |
556 557 |
* Return the ioend we finished off so that the caller can submit it * once it has finished processing the dirty page. |
f6d6d4fcd [XFS] Initial pas... |
558 559 560 561 562 |
*/ STATIC void xfs_add_to_ioend( struct inode *inode, struct buffer_head *bh, |
7336cea8c [XFS] pass full 6... |
563 |
xfs_off_t offset, |
e10de3723 xfs: don't chain ... |
564 |
struct xfs_writepage_ctx *wpc, |
bb18782aa xfs: build bios d... |
565 |
struct writeback_control *wbc, |
e10de3723 xfs: don't chain ... |
566 |
struct list_head *iolist) |
f6d6d4fcd [XFS] Initial pas... |
567 |
{ |
fbcc02561 xfs: Introduce wr... |
568 |
if (!wpc->ioend || wpc->io_type != wpc->ioend->io_type || |
0df61da8a xfs: ioends requi... |
569 570 |
bh->b_blocknr != wpc->last_block + 1 || offset != wpc->ioend->io_offset + wpc->ioend->io_size) { |
e10de3723 xfs: don't chain ... |
571 572 |
if (wpc->ioend) list_add(&wpc->ioend->io_list, iolist); |
0e51a8e19 xfs: optimize bio... |
573 |
wpc->ioend = xfs_alloc_ioend(inode, wpc->io_type, offset, bh); |
f6d6d4fcd [XFS] Initial pas... |
574 |
} |
0e51a8e19 xfs: optimize bio... |
575 576 577 578 579 580 |
/* * If the buffer doesn't fit into the bio we need to allocate a new * one. This shouldn't happen more than once for a given buffer. */ while (xfs_bio_add_buffer(wpc->ioend->io_bio, bh) != bh->b_size) xfs_chain_bio(wpc->ioend, wbc, bh); |
bb18782aa xfs: build bios d... |
581 |
|
fbcc02561 xfs: Introduce wr... |
582 583 |
wpc->ioend->io_size += bh->b_size; wpc->last_block = bh->b_blocknr; |
e10de3723 xfs: don't chain ... |
584 |
xfs_start_buffer_writeback(bh); |
f6d6d4fcd [XFS] Initial pas... |
585 |
} |
1da177e4c Linux-2.6.12-rc2 |
586 |
STATIC void |
87cbc49cd [XFS] Add xfs_map... |
587 |
xfs_map_buffer( |
046f1685b xfs: remove iomap... |
588 |
struct inode *inode, |
87cbc49cd [XFS] Add xfs_map... |
589 |
struct buffer_head *bh, |
207d04160 xfs: kill struct ... |
590 |
struct xfs_bmbt_irec *imap, |
046f1685b xfs: remove iomap... |
591 |
xfs_off_t offset) |
87cbc49cd [XFS] Add xfs_map... |
592 593 |
{ sector_t bn; |
8699bb0a4 xfs: report iomap... |
594 |
struct xfs_mount *m = XFS_I(inode)->i_mount; |
207d04160 xfs: kill struct ... |
595 596 |
xfs_off_t iomap_offset = XFS_FSB_TO_B(m, imap->br_startoff); xfs_daddr_t iomap_bn = xfs_fsb_to_db(XFS_I(inode), imap->br_startblock); |
87cbc49cd [XFS] Add xfs_map... |
597 |
|
207d04160 xfs: kill struct ... |
598 599 |
ASSERT(imap->br_startblock != HOLESTARTBLOCK); ASSERT(imap->br_startblock != DELAYSTARTBLOCK); |
87cbc49cd [XFS] Add xfs_map... |
600 |
|
e513182d4 xfs: report iomap... |
601 |
bn = (iomap_bn >> (inode->i_blkbits - BBSHIFT)) + |
8699bb0a4 xfs: report iomap... |
602 |
((offset - iomap_offset) >> inode->i_blkbits); |
87cbc49cd [XFS] Add xfs_map... |
603 |
|
046f1685b xfs: remove iomap... |
604 |
ASSERT(bn || XFS_IS_REALTIME_INODE(XFS_I(inode))); |
87cbc49cd [XFS] Add xfs_map... |
605 606 607 608 609 610 |
bh->b_blocknr = bn; set_buffer_mapped(bh); } STATIC void |
1da177e4c Linux-2.6.12-rc2 |
611 |
xfs_map_at_offset( |
046f1685b xfs: remove iomap... |
612 |
struct inode *inode, |
1da177e4c Linux-2.6.12-rc2 |
613 |
struct buffer_head *bh, |
207d04160 xfs: kill struct ... |
614 |
struct xfs_bmbt_irec *imap, |
046f1685b xfs: remove iomap... |
615 |
xfs_off_t offset) |
1da177e4c Linux-2.6.12-rc2 |
616 |
{ |
207d04160 xfs: kill struct ... |
617 618 |
ASSERT(imap->br_startblock != HOLESTARTBLOCK); ASSERT(imap->br_startblock != DELAYSTARTBLOCK); |
1da177e4c Linux-2.6.12-rc2 |
619 |
|
207d04160 xfs: kill struct ... |
620 |
xfs_map_buffer(inode, bh, imap, offset); |
1da177e4c Linux-2.6.12-rc2 |
621 622 |
set_buffer_mapped(bh); clear_buffer_delay(bh); |
f6d6d4fcd [XFS] Initial pas... |
623 |
clear_buffer_unwritten(bh); |
1da177e4c Linux-2.6.12-rc2 |
624 625 626 |
} /* |
a49935f20 xfs: xfs_check_pa... |
627 628 629 630 |
* Test if a given page contains at least one buffer of a given @type. * If @check_all_buffers is true, then we walk all the buffers in the page to * try to find one of the type passed in. If it is not set, then the caller only * needs to check the first buffer on the page for a match. |
1da177e4c Linux-2.6.12-rc2 |
631 |
*/ |
a49935f20 xfs: xfs_check_pa... |
632 |
STATIC bool |
6ffc4db5d xfs: page type ch... |
633 |
xfs_check_page_type( |
10ce44442 [XFS] use pagevec... |
634 |
struct page *page, |
a49935f20 xfs: xfs_check_pa... |
635 636 |
unsigned int type, bool check_all_buffers) |
1da177e4c Linux-2.6.12-rc2 |
637 |
{ |
a49935f20 xfs: xfs_check_pa... |
638 639 |
struct buffer_head *bh; struct buffer_head *head; |
1da177e4c Linux-2.6.12-rc2 |
640 |
|
a49935f20 xfs: xfs_check_pa... |
641 642 643 644 645 646 |
if (PageWriteback(page)) return false; if (!page->mapping) return false; if (!page_has_buffers(page)) return false; |
1da177e4c Linux-2.6.12-rc2 |
647 |
|
a49935f20 xfs: xfs_check_pa... |
648 649 650 651 652 653 |
bh = head = page_buffers(page); do { if (buffer_unwritten(bh)) { if (type == XFS_IO_UNWRITTEN) return true; } else if (buffer_delay(bh)) { |
805eeb8e0 xfs: extra semi-c... |
654 |
if (type == XFS_IO_DELALLOC) |
a49935f20 xfs: xfs_check_pa... |
655 656 |
return true; } else if (buffer_dirty(bh) && buffer_mapped(bh)) { |
805eeb8e0 xfs: extra semi-c... |
657 |
if (type == XFS_IO_OVERWRITE) |
a49935f20 xfs: xfs_check_pa... |
658 659 |
return true; } |
1da177e4c Linux-2.6.12-rc2 |
660 |
|
a49935f20 xfs: xfs_check_pa... |
661 662 663 664 |
/* If we are only checking the first buffer, we are done now. */ if (!check_all_buffers) break; } while ((bh = bh->b_this_page) != head); |
1da177e4c Linux-2.6.12-rc2 |
665 |
|
a49935f20 xfs: xfs_check_pa... |
666 |
return false; |
1da177e4c Linux-2.6.12-rc2 |
667 |
} |
3ed3a4343 xfs: truncate del... |
668 669 670 |
STATIC void xfs_vm_invalidatepage( struct page *page, |
d47992f86 mm: change invali... |
671 672 |
unsigned int offset, unsigned int length) |
3ed3a4343 xfs: truncate del... |
673 |
{ |
34097dfe8 xfs: use ->invali... |
674 675 676 |
trace_xfs_invalidatepage(page->mapping->host, page, offset, length); block_invalidatepage(page, offset, length); |
3ed3a4343 xfs: truncate del... |
677 678 679 680 681 682 683 684 685 686 687 688 689 690 691 692 693 694 695 696 697 698 699 700 701 702 |
} /* * If the page has delalloc buffers on it, we need to punch them out before we * invalidate the page. If we don't, we leave a stale delalloc mapping on the * inode that can trip a BUG() in xfs_get_blocks() later on if a direct IO read * is done on that same region - the delalloc extent is returned when none is * supposed to be there. * * We prevent this by truncating away the delalloc regions on the page before * invalidating it. Because they are delalloc, we can do this without needing a * transaction. Indeed - if we get ENOSPC errors, we have to be able to do this * truncation without a transaction as there is no space left for block * reservation (typically why we see a ENOSPC in writeback). * * This is not a performance critical path, so for now just do the punching a * buffer head at a time. */ STATIC void xfs_aops_discard_page( struct page *page) { struct inode *inode = page->mapping->host; struct xfs_inode *ip = XFS_I(inode); struct buffer_head *bh, *head; loff_t offset = page_offset(page); |
3ed3a4343 xfs: truncate del... |
703 |
|
a49935f20 xfs: xfs_check_pa... |
704 |
if (!xfs_check_page_type(page, XFS_IO_DELALLOC, true)) |
3ed3a4343 xfs: truncate del... |
705 |
goto out_invalidate; |
e8c3753ce xfs: don't warn a... |
706 707 |
if (XFS_FORCED_SHUTDOWN(ip->i_mount)) goto out_invalidate; |
4f10700a2 xfs: Convert linu... |
708 |
xfs_alert(ip->i_mount, |
3ed3a4343 xfs: truncate del... |
709 710 711 712 713 714 |
"page discard on page %p, inode 0x%llx, offset %llu.", page, ip->i_ino, offset); xfs_ilock(ip, XFS_ILOCK_EXCL); bh = head = page_buffers(page); do { |
3ed3a4343 xfs: truncate del... |
715 |
int error; |
c726de440 xfs: fix failed w... |
716 |
xfs_fileoff_t start_fsb; |
3ed3a4343 xfs: truncate del... |
717 718 719 |
if (!buffer_delay(bh)) goto next_buffer; |
c726de440 xfs: fix failed w... |
720 721 |
start_fsb = XFS_B_TO_FSBT(ip->i_mount, offset); error = xfs_bmap_punch_delalloc_range(ip, start_fsb, 1); |
3ed3a4343 xfs: truncate del... |
722 723 |
if (error) { /* something screwed, just bail */ |
e8c3753ce xfs: don't warn a... |
724 |
if (!XFS_FORCED_SHUTDOWN(ip->i_mount)) { |
4f10700a2 xfs: Convert linu... |
725 |
xfs_alert(ip->i_mount, |
3ed3a4343 xfs: truncate del... |
726 |
"page discard unable to remove delalloc mapping."); |
e8c3753ce xfs: don't warn a... |
727 |
} |
3ed3a4343 xfs: truncate del... |
728 729 730 |
break; } next_buffer: |
c726de440 xfs: fix failed w... |
731 |
offset += 1 << inode->i_blkbits; |
3ed3a4343 xfs: truncate del... |
732 733 734 735 736 |
} while ((bh = bh->b_this_page) != head); xfs_iunlock(ip, XFS_ILOCK_EXCL); out_invalidate: |
09cbfeaf1 mm, fs: get rid o... |
737 |
xfs_vm_invalidatepage(page, 0, PAGE_SIZE); |
3ed3a4343 xfs: truncate del... |
738 739 |
return; } |
ef4736678 xfs: allocate del... |
740 741 742 743 744 745 746 747 748 749 750 751 752 753 754 755 756 757 758 759 760 761 762 763 764 765 766 767 768 769 770 771 772 773 774 775 776 777 778 779 780 781 782 783 784 785 786 787 788 |
static int xfs_map_cow( struct xfs_writepage_ctx *wpc, struct inode *inode, loff_t offset, unsigned int *new_type) { struct xfs_inode *ip = XFS_I(inode); struct xfs_bmbt_irec imap; bool is_cow = false, need_alloc = false; int error; /* * If we already have a valid COW mapping keep using it. */ if (wpc->io_type == XFS_IO_COW) { wpc->imap_valid = xfs_imap_valid(inode, &wpc->imap, offset); if (wpc->imap_valid) { *new_type = XFS_IO_COW; return 0; } } /* * Else we need to check if there is a COW mapping at this offset. */ xfs_ilock(ip, XFS_ILOCK_SHARED); is_cow = xfs_reflink_find_cow_mapping(ip, offset, &imap, &need_alloc); xfs_iunlock(ip, XFS_ILOCK_SHARED); if (!is_cow) return 0; /* * And if the COW mapping has a delayed extent here we need to * allocate real space for it now. */ if (need_alloc) { error = xfs_iomap_write_allocate(ip, XFS_COW_FORK, offset, &imap); if (error) return error; } wpc->io_type = *new_type = XFS_IO_COW; wpc->imap_valid = true; wpc->imap = imap; return 0; } |
1da177e4c Linux-2.6.12-rc2 |
789 |
/* |
e10de3723 xfs: don't chain ... |
790 791 792 793 794 795 796 797 798 799 800 801 802 803 804 |
* We implement an immediate ioend submission policy here to avoid needing to * chain multiple ioends and hence nest mempool allocations which can violate * forward progress guarantees we need to provide. The current ioend we are * adding buffers to is cached on the writepage context, and if the new buffer * does not append to the cached ioend it will create a new ioend and cache that * instead. * * If a new ioend is created and cached, the old ioend is returned and queued * locally for submission once the entire page is processed or an error has been * detected. While ioends are submitted immediately after they are completed, * batching optimisations are provided by higher level block plugging. * * At the end of a writeback pass, there will be a cached ioend remaining on the * writepage context that the caller will need to submit. */ |
bfce7d2e2 xfs: factor mappi... |
805 806 807 |
static int xfs_writepage_map( struct xfs_writepage_ctx *wpc, |
e10de3723 xfs: don't chain ... |
808 |
struct writeback_control *wbc, |
bfce7d2e2 xfs: factor mappi... |
809 810 811 812 813 |
struct inode *inode, struct page *page, loff_t offset, __uint64_t end_offset) { |
e10de3723 xfs: don't chain ... |
814 815 |
LIST_HEAD(submit_list); struct xfs_ioend *ioend, *next; |
bfce7d2e2 xfs: factor mappi... |
816 817 818 |
struct buffer_head *bh, *head; ssize_t len = 1 << inode->i_blkbits; int error = 0; |
bfce7d2e2 xfs: factor mappi... |
819 |
int count = 0; |
e10de3723 xfs: don't chain ... |
820 |
int uptodate = 1; |
ef4736678 xfs: allocate del... |
821 |
unsigned int new_type; |
bfce7d2e2 xfs: factor mappi... |
822 823 824 |
bh = head = page_buffers(page); offset = page_offset(page); |
bfce7d2e2 xfs: factor mappi... |
825 826 827 828 829 830 831 832 833 834 835 836 837 838 839 840 |
do { if (offset >= end_offset) break; if (!buffer_uptodate(bh)) uptodate = 0; /* * set_page_dirty dirties all buffers in a page, independent * of their state. The dirty state however is entirely * meaningless for holes (!mapped && uptodate), so skip * buffers covering holes here. */ if (!buffer_mapped(bh) && buffer_uptodate(bh)) { wpc->imap_valid = false; continue; } |
ef4736678 xfs: allocate del... |
841 842 843 844 845 846 847 |
if (buffer_unwritten(bh)) new_type = XFS_IO_UNWRITTEN; else if (buffer_delay(bh)) new_type = XFS_IO_DELALLOC; else if (buffer_uptodate(bh)) new_type = XFS_IO_OVERWRITE; else { |
bfce7d2e2 xfs: factor mappi... |
848 849 850 851 852 853 854 855 856 857 858 |
if (PageUptodate(page)) ASSERT(buffer_mapped(bh)); /* * This buffer is not uptodate and will not be * written to disk. Ensure that we will put any * subsequent writeable buffers into a new * ioend. */ wpc->imap_valid = false; continue; } |
ef4736678 xfs: allocate del... |
859 860 861 862 863 864 865 866 867 868 |
if (xfs_is_reflink_inode(XFS_I(inode))) { error = xfs_map_cow(wpc, inode, offset, &new_type); if (error) goto out; } if (wpc->io_type != new_type) { wpc->io_type = new_type; wpc->imap_valid = false; } |
bfce7d2e2 xfs: factor mappi... |
869 870 871 872 873 874 875 |
if (wpc->imap_valid) wpc->imap_valid = xfs_imap_valid(inode, &wpc->imap, offset); if (!wpc->imap_valid) { error = xfs_map_blocks(inode, offset, &wpc->imap, wpc->io_type); if (error) |
e10de3723 xfs: don't chain ... |
876 |
goto out; |
bfce7d2e2 xfs: factor mappi... |
877 878 879 880 881 882 883 |
wpc->imap_valid = xfs_imap_valid(inode, &wpc->imap, offset); } if (wpc->imap_valid) { lock_buffer(bh); if (wpc->io_type != XFS_IO_OVERWRITE) xfs_map_at_offset(inode, bh, &wpc->imap, offset); |
bb18782aa xfs: build bios d... |
884 |
xfs_add_to_ioend(inode, bh, offset, wpc, wbc, &submit_list); |
bfce7d2e2 xfs: factor mappi... |
885 886 |
count++; } |
bfce7d2e2 xfs: factor mappi... |
887 888 889 890 |
} while (offset += len, ((bh = bh->b_this_page) != head)); if (uptodate && bh == head) SetPageUptodate(page); |
e10de3723 xfs: don't chain ... |
891 |
ASSERT(wpc->ioend || list_empty(&submit_list)); |
bfce7d2e2 xfs: factor mappi... |
892 |
|
e10de3723 xfs: don't chain ... |
893 |
out: |
bfce7d2e2 xfs: factor mappi... |
894 |
/* |
e10de3723 xfs: don't chain ... |
895 896 897 898 899 900 901 902 903 |
* On error, we have to fail the ioend here because we have locked * buffers in the ioend. If we don't do this, we'll deadlock * invalidating the page as that tries to lock the buffers on the page. * Also, because we may have set pages under writeback, we have to make * sure we run IO completion to mark the error state of the IO * appropriately, so we can't cancel the ioend directly here. That means * we have to mark this page as under writeback if we included any * buffers from it in the ioend chain so that completion treats it * correctly. |
bfce7d2e2 xfs: factor mappi... |
904 |
* |
e10de3723 xfs: don't chain ... |
905 906 907 908 909 |
* If we didn't include the page in the ioend, the on error we can * simply discard and unlock it as there are no other users of the page * or it's buffers right now. The caller will still need to trigger * submission of outstanding ioends on the writepage context so they are * treated correctly on error. |
bfce7d2e2 xfs: factor mappi... |
910 |
*/ |
e10de3723 xfs: don't chain ... |
911 912 913 914 915 916 917 918 919 920 921 922 923 924 925 926 927 |
if (count) { xfs_start_page_writeback(page, !error); /* * Preserve the original error if there was one, otherwise catch * submission errors here and propagate into subsequent ioend * submissions. */ list_for_each_entry_safe(ioend, next, &submit_list, io_list) { int error2; list_del_init(&ioend->io_list); error2 = xfs_submit_ioend(wbc, ioend, error); if (error2 && !error) error = error2; } } else if (error) { |
bfce7d2e2 xfs: factor mappi... |
928 929 930 |
xfs_aops_discard_page(page); ClearPageUptodate(page); unlock_page(page); |
e10de3723 xfs: don't chain ... |
931 932 933 934 935 936 937 938 |
} else { /* * We can end up here with no error and nothing to write if we * race with a partial page truncate on a sub-page block sized * filesystem. In that case we need to mark the page clean. */ xfs_start_page_writeback(page, 1); end_page_writeback(page); |
bfce7d2e2 xfs: factor mappi... |
939 |
} |
e10de3723 xfs: don't chain ... |
940 |
|
bfce7d2e2 xfs: factor mappi... |
941 942 943 |
mapping_set_error(page->mapping, error); return error; } |
1da177e4c Linux-2.6.12-rc2 |
944 |
/* |
89f3b3639 xfs: simplify xfs... |
945 946 947 948 949 |
* Write out a dirty page. * * For delalloc space on the page we need to allocate space and flush it. * For unwritten space on the page we need to start the conversion to * regular allocated space. |
89f3b3639 xfs: simplify xfs... |
950 |
* For any other dirty buffer heads on the page we should flush them. |
1da177e4c Linux-2.6.12-rc2 |
951 |
*/ |
1da177e4c Linux-2.6.12-rc2 |
952 |
STATIC int |
fbcc02561 xfs: Introduce wr... |
953 |
xfs_do_writepage( |
89f3b3639 xfs: simplify xfs... |
954 |
struct page *page, |
fbcc02561 xfs: Introduce wr... |
955 956 |
struct writeback_control *wbc, void *data) |
1da177e4c Linux-2.6.12-rc2 |
957 |
{ |
fbcc02561 xfs: Introduce wr... |
958 |
struct xfs_writepage_ctx *wpc = data; |
89f3b3639 xfs: simplify xfs... |
959 |
struct inode *inode = page->mapping->host; |
1da177e4c Linux-2.6.12-rc2 |
960 |
loff_t offset; |
1da177e4c Linux-2.6.12-rc2 |
961 |
__uint64_t end_offset; |
ad68972ac xfs: xfs_cluster_... |
962 |
pgoff_t end_index; |
89f3b3639 xfs: simplify xfs... |
963 |
|
34097dfe8 xfs: use ->invali... |
964 |
trace_xfs_writepage(inode, page, 0, 0); |
89f3b3639 xfs: simplify xfs... |
965 |
|
20cb52ebd xfs: simplify xfs... |
966 |
ASSERT(page_has_buffers(page)); |
89f3b3639 xfs: simplify xfs... |
967 968 969 |
/* * Refuse to write the page out if we are called from reclaim context. * |
d4f7a5cbd xfs: allow writeb... |
970 971 972 |
* This avoids stack overflows when called from deeply used stacks in * random callers for direct reclaim or memcg reclaim. We explicitly * allow reclaim from kswapd as the stack usage there is relatively low. |
89f3b3639 xfs: simplify xfs... |
973 |
* |
94054fa3f xfs: warn if dire... |
974 975 |
* This should never happen except in the case of a VM regression so * warn about it. |
89f3b3639 xfs: simplify xfs... |
976 |
*/ |
94054fa3f xfs: warn if dire... |
977 978 |
if (WARN_ON_ONCE((current->flags & (PF_MEMALLOC|PF_KSWAPD)) == PF_MEMALLOC)) |
b5420f235 xfs: do not disca... |
979 |
goto redirty; |
1da177e4c Linux-2.6.12-rc2 |
980 |
|
89f3b3639 xfs: simplify xfs... |
981 |
/* |
680a647b4 xfs: PF_FSTRANS s... |
982 983 |
* Given that we do not allow direct reclaim to call us, we should * never be called while in a filesystem transaction. |
89f3b3639 xfs: simplify xfs... |
984 |
*/ |
448011e2a xfs: tone down wr... |
985 |
if (WARN_ON_ONCE(current->flags & PF_FSTRANS)) |
b5420f235 xfs: do not disca... |
986 |
goto redirty; |
89f3b3639 xfs: simplify xfs... |
987 |
|
8695d27ec xfs: fix infinite... |
988 |
/* |
ad68972ac xfs: xfs_cluster_... |
989 990 |
* Is this page beyond the end of the file? * |
8695d27ec xfs: fix infinite... |
991 992 993 994 995 996 997 998 999 1000 |
* The page index is less than the end_index, adjust the end_offset * to the highest offset that this page should represent. * ----------------------------------------------------- * | file mapping | <EOF> | * ----------------------------------------------------- * | Page ... | Page N-2 | Page N-1 | Page N | | * ^--------------------------------^----------|-------- * | desired writeback range | see else | * ---------------------------------^------------------| */ |
ad68972ac xfs: xfs_cluster_... |
1001 |
offset = i_size_read(inode); |
09cbfeaf1 mm, fs: get rid o... |
1002 |
end_index = offset >> PAGE_SHIFT; |
8695d27ec xfs: fix infinite... |
1003 |
if (page->index < end_index) |
09cbfeaf1 mm, fs: get rid o... |
1004 |
end_offset = (xfs_off_t)(page->index + 1) << PAGE_SHIFT; |
8695d27ec xfs: fix infinite... |
1005 1006 1007 1008 1009 1010 1011 1012 1013 1014 1015 1016 |
else { /* * Check whether the page to write out is beyond or straddles * i_size or not. * ------------------------------------------------------- * | file mapping | <EOF> | * ------------------------------------------------------- * | Page ... | Page N-2 | Page N-1 | Page N | Beyond | * ^--------------------------------^-----------|--------- * | | Straddles | * ---------------------------------^-----------|--------| */ |
09cbfeaf1 mm, fs: get rid o... |
1017 |
unsigned offset_into_page = offset & (PAGE_SIZE - 1); |
6b7a03f03 xfs: handle EOF c... |
1018 1019 |
/* |
ff9a28f6c xfs: Fix WARN_ON(... |
1020 1021 1022 1023 |
* Skip the page if it is fully outside i_size, e.g. due to a * truncate operation that is in progress. We must redirty the * page so that reclaim stops reclaiming it. Otherwise * xfs_vm_releasepage() is called on it and gets confused. |
8695d27ec xfs: fix infinite... |
1024 1025 1026 1027 1028 1029 1030 1031 1032 1033 1034 |
* * Note that the end_index is unsigned long, it would overflow * if the given offset is greater than 16TB on 32-bit system * and if we do check the page is fully outside i_size or not * via "if (page->index >= end_index + 1)" as "end_index + 1" * will be evaluated to 0. Hence this page will be redirtied * and be written out repeatedly which would result in an * infinite loop, the user program that perform this operation * will hang. Instead, we can verify this situation by checking * if the page to write is totally beyond the i_size or if it's * offset is just equal to the EOF. |
6b7a03f03 xfs: handle EOF c... |
1035 |
*/ |
8695d27ec xfs: fix infinite... |
1036 1037 |
if (page->index > end_index || (page->index == end_index && offset_into_page == 0)) |
ff9a28f6c xfs: Fix WARN_ON(... |
1038 |
goto redirty; |
6b7a03f03 xfs: handle EOF c... |
1039 1040 1041 1042 1043 |
/* * The page straddles i_size. It must be zeroed out on each * and every writepage invocation because it may be mmapped. * "A file is mapped in multiples of the page size. For a file |
8695d27ec xfs: fix infinite... |
1044 |
* that is not a multiple of the page size, the remaining |
6b7a03f03 xfs: handle EOF c... |
1045 1046 1047 |
* memory is zeroed when mapped, and writes to that region are * not written out to the file." */ |
09cbfeaf1 mm, fs: get rid o... |
1048 |
zero_user_segment(page, offset_into_page, PAGE_SIZE); |
8695d27ec xfs: fix infinite... |
1049 1050 1051 |
/* Adjust the end_offset to the end of file */ end_offset = offset; |
1da177e4c Linux-2.6.12-rc2 |
1052 |
} |
e10de3723 xfs: don't chain ... |
1053 |
return xfs_writepage_map(wpc, wbc, inode, page, offset, end_offset); |
f51623b21 [XFS] Move some c... |
1054 |
|
b5420f235 xfs: do not disca... |
1055 |
redirty: |
f51623b21 [XFS] Move some c... |
1056 1057 1058 |
redirty_page_for_writepage(wbc, page); unlock_page(page); return 0; |
f51623b21 [XFS] Move some c... |
1059 |
} |
7d4fb40ad [XFS] Start write... |
1060 |
STATIC int |
fbcc02561 xfs: Introduce wr... |
1061 1062 1063 1064 1065 1066 1067 1068 1069 1070 |
xfs_vm_writepage( struct page *page, struct writeback_control *wbc) { struct xfs_writepage_ctx wpc = { .io_type = XFS_IO_INVALID, }; int ret; ret = xfs_do_writepage(page, wbc, &wpc); |
e10de3723 xfs: don't chain ... |
1071 1072 1073 |
if (wpc.ioend) ret = xfs_submit_ioend(wbc, wpc.ioend, ret); return ret; |
fbcc02561 xfs: Introduce wr... |
1074 1075 1076 |
} STATIC int |
7d4fb40ad [XFS] Start write... |
1077 1078 1079 1080 |
xfs_vm_writepages( struct address_space *mapping, struct writeback_control *wbc) { |
fbcc02561 xfs: Introduce wr... |
1081 1082 1083 1084 |
struct xfs_writepage_ctx wpc = { .io_type = XFS_IO_INVALID, }; int ret; |
b3aea4edc [XFS] kill the v_... |
1085 |
xfs_iflags_clear(XFS_I(mapping->host), XFS_ITRUNCATED); |
7f6d5b529 dax: move writeba... |
1086 1087 1088 |
if (dax_mapping(mapping)) return dax_writeback_mapping_range(mapping, xfs_find_bdev_for_inode(mapping->host), wbc); |
fbcc02561 xfs: Introduce wr... |
1089 |
ret = write_cache_pages(mapping, wbc, xfs_do_writepage, &wpc); |
e10de3723 xfs: don't chain ... |
1090 1091 1092 |
if (wpc.ioend) ret = xfs_submit_ioend(wbc, wpc.ioend, ret); return ret; |
7d4fb40ad [XFS] Start write... |
1093 |
} |
f51623b21 [XFS] Move some c... |
1094 1095 |
/* * Called to move a page into cleanable state - and from there |
89f3b3639 xfs: simplify xfs... |
1096 |
* to be released. The page should already be clean. We always |
f51623b21 [XFS] Move some c... |
1097 1098 |
* have buffer heads in this call. * |
89f3b3639 xfs: simplify xfs... |
1099 |
* Returns 1 if the page is ok to release, 0 otherwise. |
f51623b21 [XFS] Move some c... |
1100 1101 |
*/ STATIC int |
238f4c546 [XFS] Make couple... |
1102 |
xfs_vm_releasepage( |
f51623b21 [XFS] Move some c... |
1103 1104 1105 |
struct page *page, gfp_t gfp_mask) { |
20cb52ebd xfs: simplify xfs... |
1106 |
int delalloc, unwritten; |
f51623b21 [XFS] Move some c... |
1107 |
|
34097dfe8 xfs: use ->invali... |
1108 |
trace_xfs_releasepage(page->mapping->host, page, 0, 0); |
238f4c546 [XFS] Make couple... |
1109 |
|
99579ccec xfs: skip dirty p... |
1110 1111 1112 1113 1114 1115 1116 |
/* * mm accommodates an old ext3 case where clean pages might not have had * the dirty bit cleared. Thus, it can send actual dirty pages to * ->releasepage() via shrink_active_list(). Conversely, * block_invalidatepage() can send pages that are still marked dirty * but otherwise have invalidated buffers. * |
6ba35da69 xfs: Timely free ... |
1117 1118 1119 1120 1121 |
* We want to release the latter to avoid unnecessary buildup of the * LRU, skip the former and warn if we've left any lingering * delalloc/unwritten buffers on clean pages. Skip pages with delalloc * or unwritten buffers and warn if the page is not dirty. Otherwise * try to release the buffers. |
99579ccec xfs: skip dirty p... |
1122 |
*/ |
20cb52ebd xfs: simplify xfs... |
1123 |
xfs_count_page_state(page, &delalloc, &unwritten); |
f51623b21 [XFS] Move some c... |
1124 |
|
6ba35da69 xfs: Timely free ... |
1125 1126 |
if (delalloc) { WARN_ON_ONCE(!PageDirty(page)); |
f51623b21 [XFS] Move some c... |
1127 |
return 0; |
6ba35da69 xfs: Timely free ... |
1128 1129 1130 |
} if (unwritten) { WARN_ON_ONCE(!PageDirty(page)); |
f51623b21 [XFS] Move some c... |
1131 |
return 0; |
6ba35da69 xfs: Timely free ... |
1132 |
} |
f51623b21 [XFS] Move some c... |
1133 |
|
f51623b21 [XFS] Move some c... |
1134 1135 |
return try_to_free_buffers(page); } |
a719370be xfs: factor DIO w... |
1136 |
/* |
273dda76f xfs: don't use io... |
1137 1138 |
* When we map a DIO buffer, we may need to pass flags to * xfs_end_io_direct_write to tell it what kind of write IO we are doing. |
3e12dbbdb xfs: fix inode si... |
1139 1140 1141 1142 1143 1144 1145 |
* * Note that for DIO, an IO to the highest supported file block offset (i.e. * 2^63 - 1FSB bytes) will result in the offset + count overflowing a signed 64 * bit variable. Hence if we see this overflow, we have to assume that the IO is * extending the file size. We won't know for sure until IO completion is run * and the actual max write offset is communicated to the IO completion * routine. |
a719370be xfs: factor DIO w... |
1146 1147 1148 1149 1150 1151 |
*/ static void xfs_map_direct( struct inode *inode, struct buffer_head *bh_result, struct xfs_bmbt_irec *imap, |
0613f16cd xfs: implement Co... |
1152 1153 |
xfs_off_t offset, bool is_cow) |
a719370be xfs: factor DIO w... |
1154 |
{ |
273dda76f xfs: don't use io... |
1155 |
uintptr_t *flags = (uintptr_t *)&bh_result->b_private; |
d5cc2e3f9 xfs: DIO needs an... |
1156 |
xfs_off_t size = bh_result->b_size; |
d5cc2e3f9 xfs: DIO needs an... |
1157 |
|
273dda76f xfs: don't use io... |
1158 |
trace_xfs_get_blocks_map_direct(XFS_I(inode), offset, size, |
0613f16cd xfs: implement Co... |
1159 1160 |
ISUNWRITTEN(imap) ? XFS_IO_UNWRITTEN : is_cow ? XFS_IO_COW : XFS_IO_OVERWRITE, imap); |
d5cc2e3f9 xfs: DIO needs an... |
1161 |
|
273dda76f xfs: don't use io... |
1162 1163 1164 |
if (ISUNWRITTEN(imap)) { *flags |= XFS_DIO_FLAG_UNWRITTEN; set_buffer_defer_completion(bh_result); |
0613f16cd xfs: implement Co... |
1165 1166 1167 1168 1169 |
} else if (is_cow) { *flags |= XFS_DIO_FLAG_COW; set_buffer_defer_completion(bh_result); } if (offset + size > i_size_read(inode) || offset + size < 0) { |
273dda76f xfs: don't use io... |
1170 |
*flags |= XFS_DIO_FLAG_APPEND; |
a06c277a1 xfs: DIO writes w... |
1171 |
set_buffer_defer_completion(bh_result); |
a719370be xfs: factor DIO w... |
1172 1173 |
} } |
1fdca9c21 xfs: move DIO map... |
1174 1175 1176 1177 1178 1179 1180 1181 1182 1183 1184 1185 1186 1187 1188 1189 1190 1191 1192 1193 1194 1195 1196 1197 1198 1199 1200 1201 1202 1203 1204 1205 1206 1207 1208 1209 1210 1211 1212 |
/* * If this is O_DIRECT or the mpage code calling tell them how large the mapping * is, so that we can avoid repeated get_blocks calls. * * If the mapping spans EOF, then we have to break the mapping up as the mapping * for blocks beyond EOF must be marked new so that sub block regions can be * correctly zeroed. We can't do this for mappings within EOF unless the mapping * was just allocated or is unwritten, otherwise the callers would overwrite * existing data with zeros. Hence we have to split the mapping into a range up * to and including EOF, and a second mapping for beyond EOF. */ static void xfs_map_trim_size( struct inode *inode, sector_t iblock, struct buffer_head *bh_result, struct xfs_bmbt_irec *imap, xfs_off_t offset, ssize_t size) { xfs_off_t mapping_size; mapping_size = imap->br_startoff + imap->br_blockcount - iblock; mapping_size <<= inode->i_blkbits; ASSERT(mapping_size > 0); if (mapping_size > size) mapping_size = size; if (offset < i_size_read(inode) && offset + mapping_size >= i_size_read(inode)) { /* limit mapping to block that spans EOF */ mapping_size = roundup_64(i_size_read(inode) - offset, 1 << inode->i_blkbits); } if (mapping_size > LONG_MAX) mapping_size = LONG_MAX; bh_result->b_size = mapping_size; } |
0613f16cd xfs: implement Co... |
1213 1214 1215 1216 1217 1218 1219 1220 1221 1222 1223 1224 1225 1226 1227 1228 1229 1230 1231 1232 1233 1234 1235 1236 1237 1238 1239 1240 1241 1242 1243 1244 1245 1246 1247 1248 1249 |
/* Bounce unaligned directio writes to the page cache. */ static int xfs_bounce_unaligned_dio_write( struct xfs_inode *ip, xfs_fileoff_t offset_fsb, struct xfs_bmbt_irec *imap) { struct xfs_bmbt_irec irec; xfs_fileoff_t delta; bool shared; bool x; int error; irec = *imap; if (offset_fsb > irec.br_startoff) { delta = offset_fsb - irec.br_startoff; irec.br_blockcount -= delta; irec.br_startblock += delta; irec.br_startoff = offset_fsb; } error = xfs_reflink_trim_around_shared(ip, &irec, &shared, &x); if (error) return error; /* * We're here because we're trying to do a directio write to a * region that isn't aligned to a filesystem block. If any part * of the extent is shared, fall back to buffered mode to handle * the RMW. This is done by returning -EREMCHG ("remote addr * changed"), which is caught further up the call stack. */ if (shared) { trace_xfs_reflink_bounce_dio_write(ip, imap); return -EREMCHG; } return 0; } |
1da177e4c Linux-2.6.12-rc2 |
1250 |
STATIC int |
c25366680 [XFS] Cleanup in ... |
1251 |
__xfs_get_blocks( |
1da177e4c Linux-2.6.12-rc2 |
1252 1253 |
struct inode *inode, sector_t iblock, |
1da177e4c Linux-2.6.12-rc2 |
1254 1255 |
struct buffer_head *bh_result, int create, |
3e12dbbdb xfs: fix inode si... |
1256 1257 |
bool direct, bool dax_fault) |
1da177e4c Linux-2.6.12-rc2 |
1258 |
{ |
a206c817c xfs: kill xfs_iomap |
1259 1260 1261 1262 1263 |
struct xfs_inode *ip = XFS_I(inode); struct xfs_mount *mp = ip->i_mount; xfs_fileoff_t offset_fsb, end_fsb; int error = 0; int lockmode = 0; |
207d04160 xfs: kill struct ... |
1264 |
struct xfs_bmbt_irec imap; |
a206c817c xfs: kill xfs_iomap |
1265 |
int nimaps = 1; |
fdc7ed75c [XFS] Fix boundar... |
1266 1267 |
xfs_off_t offset; ssize_t size; |
207d04160 xfs: kill struct ... |
1268 |
int new = 0; |
0613f16cd xfs: implement Co... |
1269 1270 |
bool is_cow = false; bool need_alloc = false; |
a206c817c xfs: kill xfs_iomap |
1271 |
|
6e8a27a81 xfs: remove buffe... |
1272 |
BUG_ON(create && !direct); |
a206c817c xfs: kill xfs_iomap |
1273 |
if (XFS_FORCED_SHUTDOWN(mp)) |
b474c7ae4 xfs: Nuke XFS_ERR... |
1274 |
return -EIO; |
1da177e4c Linux-2.6.12-rc2 |
1275 |
|
fdc7ed75c [XFS] Fix boundar... |
1276 |
offset = (xfs_off_t)iblock << inode->i_blkbits; |
c25366680 [XFS] Cleanup in ... |
1277 1278 |
ASSERT(bh_result->b_size >= (1 << inode->i_blkbits)); size = bh_result->b_size; |
364f358a7 [XFS] Prevent dir... |
1279 |
|
6e8a27a81 xfs: remove buffe... |
1280 |
if (!create && offset >= i_size_read(inode)) |
364f358a7 [XFS] Prevent dir... |
1281 |
return 0; |
507630b29 xfs: use shared i... |
1282 1283 |
/* * Direct I/O is usually done on preallocated files, so try getting |
6e8a27a81 xfs: remove buffe... |
1284 |
* a block mapping without an exclusive lock first. |
507630b29 xfs: use shared i... |
1285 |
*/ |
6e8a27a81 xfs: remove buffe... |
1286 |
lockmode = xfs_ilock_data_map_shared(ip); |
f2bde9b89 xfs: small cleanu... |
1287 |
|
d2c281911 xfs: m_maxioffset... |
1288 1289 1290 |
ASSERT(offset <= mp->m_super->s_maxbytes); if (offset + size > mp->m_super->s_maxbytes) size = mp->m_super->s_maxbytes - offset; |
a206c817c xfs: kill xfs_iomap |
1291 1292 |
end_fsb = XFS_B_TO_FSB(mp, (xfs_ufsize_t)offset + size); offset_fsb = XFS_B_TO_FSBT(mp, offset); |
0613f16cd xfs: implement Co... |
1293 1294 1295 1296 1297 1298 1299 1300 1301 1302 1303 1304 1305 1306 1307 1308 1309 1310 1311 1312 |
if (create && direct && xfs_is_reflink_inode(ip)) is_cow = xfs_reflink_find_cow_mapping(ip, offset, &imap, &need_alloc); if (!is_cow) { error = xfs_bmapi_read(ip, offset_fsb, end_fsb - offset_fsb, &imap, &nimaps, XFS_BMAPI_ENTIRE); /* * Truncate an overwrite extent if there's a pending CoW * reservation before the end of this extent. This * forces us to come back to get_blocks to take care of * the CoW. */ if (create && direct && nimaps && imap.br_startblock != HOLESTARTBLOCK && imap.br_startblock != DELAYSTARTBLOCK && !ISUNWRITTEN(&imap)) xfs_reflink_trim_irec_to_next_cow(ip, offset_fsb, &imap); } ASSERT(!need_alloc); |
1da177e4c Linux-2.6.12-rc2 |
1313 |
if (error) |
a206c817c xfs: kill xfs_iomap |
1314 |
goto out_unlock; |
3978c5bb0 xfs: don't BUG() ... |
1315 1316 1317 1318 1319 1320 1321 1322 1323 1324 1325 1326 1327 1328 1329 1330 1331 1332 1333 |
/* * The only time we can ever safely find delalloc blocks on direct I/O * is a dio write to post-eof speculative preallocation. All other * scenarios are indicative of a problem or misuse (such as mixing * direct and mapped I/O). * * The file may be unmapped by the time we get here so we cannot * reliably fail the I/O based on mapping. Instead, fail the I/O if this * is a read or a write within eof. Otherwise, carry on but warn as a * precuation if the file happens to be mapped. */ if (direct && imap.br_startblock == DELAYSTARTBLOCK) { if (!create || offset < i_size_read(VFS_I(ip))) { WARN_ON_ONCE(1); error = -EIO; goto out_unlock; } WARN_ON_ONCE(mapping_mapped(VFS_I(ip)->i_mapping)); } |
1ca191576 xfs: Don't use un... |
1334 |
/* for DAX, we convert unwritten extents directly */ |
a206c817c xfs: kill xfs_iomap |
1335 1336 1337 |
if (create && (!nimaps || (imap.br_startblock == HOLESTARTBLOCK || |
1ca191576 xfs: Don't use un... |
1338 1339 |
imap.br_startblock == DELAYSTARTBLOCK) || (IS_DAX(inode) && ISUNWRITTEN(&imap)))) { |
6e8a27a81 xfs: remove buffe... |
1340 1341 1342 1343 1344 1345 |
/* * xfs_iomap_write_direct() expects the shared lock. It * is unlocked on return. */ if (lockmode == XFS_ILOCK_EXCL) xfs_ilock_demote(ip, lockmode); |
6b698edee xfs: add DAX file... |
1346 |
|
6e8a27a81 xfs: remove buffe... |
1347 1348 1349 1350 1351 |
error = xfs_iomap_write_direct(ip, offset, size, &imap, nimaps); if (error) return error; new = 1; |
507630b29 xfs: use shared i... |
1352 |
|
d5cc2e3f9 xfs: DIO needs an... |
1353 1354 1355 |
trace_xfs_get_blocks_alloc(ip, offset, size, ISUNWRITTEN(&imap) ? XFS_IO_UNWRITTEN : XFS_IO_DELALLOC, &imap); |
a206c817c xfs: kill xfs_iomap |
1356 |
} else if (nimaps) { |
d5cc2e3f9 xfs: DIO needs an... |
1357 1358 1359 |
trace_xfs_get_blocks_found(ip, offset, size, ISUNWRITTEN(&imap) ? XFS_IO_UNWRITTEN : XFS_IO_OVERWRITE, &imap); |
507630b29 xfs: use shared i... |
1360 |
xfs_iunlock(ip, lockmode); |
a206c817c xfs: kill xfs_iomap |
1361 1362 1363 1364 |
} else { trace_xfs_get_blocks_notfound(ip, offset, size); goto out_unlock; } |
1da177e4c Linux-2.6.12-rc2 |
1365 |
|
1ca191576 xfs: Don't use un... |
1366 1367 1368 1369 1370 |
if (IS_DAX(inode) && create) { ASSERT(!ISUNWRITTEN(&imap)); /* zeroing is not needed at a higher layer */ new = 0; } |
1fdca9c21 xfs: move DIO map... |
1371 |
/* trim mapping down to size requested */ |
6e8a27a81 xfs: remove buffe... |
1372 |
xfs_map_trim_size(inode, iblock, bh_result, &imap, offset, size); |
1fdca9c21 xfs: move DIO map... |
1373 |
|
a719370be xfs: factor DIO w... |
1374 1375 1376 1377 |
/* * For unwritten extents do not report a disk address in the buffered * read case (treat as if we're reading into a hole). */ |
207d04160 xfs: kill struct ... |
1378 |
if (imap.br_startblock != HOLESTARTBLOCK && |
a719370be xfs: factor DIO w... |
1379 1380 |
imap.br_startblock != DELAYSTARTBLOCK && (create || !ISUNWRITTEN(&imap))) { |
0613f16cd xfs: implement Co... |
1381 1382 1383 1384 1385 1386 |
if (create && direct && !is_cow) { error = xfs_bounce_unaligned_dio_write(ip, offset_fsb, &imap); if (error) return error; } |
a719370be xfs: factor DIO w... |
1387 1388 |
xfs_map_buffer(inode, bh_result, &imap, offset); if (ISUNWRITTEN(&imap)) |
1da177e4c Linux-2.6.12-rc2 |
1389 |
set_buffer_unwritten(bh_result); |
a719370be xfs: factor DIO w... |
1390 |
/* direct IO needs special help */ |
6e8a27a81 xfs: remove buffe... |
1391 |
if (create) { |
273dda76f xfs: don't use io... |
1392 1393 1394 |
if (dax_fault) ASSERT(!ISUNWRITTEN(&imap)); else |
0613f16cd xfs: implement Co... |
1395 1396 |
xfs_map_direct(inode, bh_result, &imap, offset, is_cow); |
273dda76f xfs: don't use io... |
1397 |
} |
1da177e4c Linux-2.6.12-rc2 |
1398 |
} |
c25366680 [XFS] Cleanup in ... |
1399 1400 1401 1402 |
/* * If this is a realtime file, data may be on a different device. * to that pointed to from the buffer_head b_bdev currently. */ |
046f1685b xfs: remove iomap... |
1403 |
bh_result->b_bdev = xfs_find_bdev_for_inode(inode); |
1da177e4c Linux-2.6.12-rc2 |
1404 |
|
c25366680 [XFS] Cleanup in ... |
1405 |
/* |
549054afa [XFS] Fix sub-blo... |
1406 1407 1408 1409 1410 1411 1412 |
* If we previously allocated a block out beyond eof and we are now * coming back to use it then we will need to flag it as new even if it * has a disk address. * * With sub-block writes into unwritten extents we also need to mark * the buffer as new so that the unwritten parts of the buffer gets * correctly zeroed. |
1da177e4c Linux-2.6.12-rc2 |
1413 1414 1415 |
*/ if (create && ((!buffer_mapped(bh_result) && !buffer_uptodate(bh_result)) || |
549054afa [XFS] Fix sub-blo... |
1416 |
(offset >= i_size_read(inode)) || |
207d04160 xfs: kill struct ... |
1417 |
(new || ISUNWRITTEN(&imap)))) |
1da177e4c Linux-2.6.12-rc2 |
1418 |
set_buffer_new(bh_result); |
1da177e4c Linux-2.6.12-rc2 |
1419 |
|
1da177e4c Linux-2.6.12-rc2 |
1420 |
return 0; |
a206c817c xfs: kill xfs_iomap |
1421 1422 1423 |
out_unlock: xfs_iunlock(ip, lockmode); |
2451337dd xfs: global error... |
1424 |
return error; |
1da177e4c Linux-2.6.12-rc2 |
1425 1426 1427 |
} int |
c25366680 [XFS] Cleanup in ... |
1428 |
xfs_get_blocks( |
1da177e4c Linux-2.6.12-rc2 |
1429 1430 1431 1432 1433 |
struct inode *inode, sector_t iblock, struct buffer_head *bh_result, int create) { |
3e12dbbdb xfs: fix inode si... |
1434 |
return __xfs_get_blocks(inode, iblock, bh_result, create, false, false); |
1da177e4c Linux-2.6.12-rc2 |
1435 |
} |
6b698edee xfs: add DAX file... |
1436 |
int |
e4c573bb6 [XFS] Switch over... |
1437 |
xfs_get_blocks_direct( |
1da177e4c Linux-2.6.12-rc2 |
1438 1439 |
struct inode *inode, sector_t iblock, |
1da177e4c Linux-2.6.12-rc2 |
1440 1441 1442 |
struct buffer_head *bh_result, int create) { |
3e12dbbdb xfs: fix inode si... |
1443 1444 1445 1446 1447 1448 1449 1450 1451 1452 1453 |
return __xfs_get_blocks(inode, iblock, bh_result, create, true, false); } int xfs_get_blocks_dax_fault( struct inode *inode, sector_t iblock, struct buffer_head *bh_result, int create) { return __xfs_get_blocks(inode, iblock, bh_result, create, true, true); |
1da177e4c Linux-2.6.12-rc2 |
1454 |
} |
273dda76f xfs: don't use io... |
1455 1456 1457 1458 1459 1460 1461 1462 1463 1464 1465 |
/* * Complete a direct I/O write request. * * xfs_map_direct passes us some flags in the private data to tell us what to * do. If no flags are set, then the write IO is an overwrite wholly within * the existing allocated file size and so there is nothing for us to do. * * Note that in this case the completion can be called in interrupt context, * whereas if we have flags set we will always be called in task context * (i.e. from a workqueue). */ |
fa8d972d0 xfs: direct calls... |
1466 |
int |
273dda76f xfs: don't use io... |
1467 1468 |
xfs_end_io_direct_write( struct kiocb *iocb, |
209fb87a2 xfs simplify and ... |
1469 |
loff_t offset, |
273dda76f xfs: don't use io... |
1470 1471 |
ssize_t size, void *private) |
f09738638 [XFS] Delay direc... |
1472 |
{ |
273dda76f xfs: don't use io... |
1473 1474 |
struct inode *inode = file_inode(iocb->ki_filp); struct xfs_inode *ip = XFS_I(inode); |
273dda76f xfs: don't use io... |
1475 1476 |
uintptr_t flags = (uintptr_t)private; int error = 0; |
a06c277a1 xfs: DIO writes w... |
1477 |
|
273dda76f xfs: don't use io... |
1478 |
trace_xfs_end_io_direct_write(ip, offset, size); |
f09738638 [XFS] Delay direc... |
1479 |
|
e372843a4 xfs: refactor xfs... |
1480 |
if (XFS_FORCED_SHUTDOWN(ip->i_mount)) |
273dda76f xfs: don't use io... |
1481 |
return -EIO; |
d5cc2e3f9 xfs: DIO needs an... |
1482 |
|
273dda76f xfs: don't use io... |
1483 1484 |
if (size <= 0) return size; |
f09738638 [XFS] Delay direc... |
1485 1486 |
/* |
273dda76f xfs: don't use io... |
1487 |
* The flags tell us whether we are doing unwritten extent conversions |
6dfa1b67e xfs: handle DIO o... |
1488 1489 |
* or an append transaction that updates the on-disk file size. These * cases are the only cases where we should *potentially* be needing |
a06c277a1 xfs: DIO writes w... |
1490 |
* to update the VFS inode size. |
273dda76f xfs: don't use io... |
1491 1492 1493 1494 1495 1496 1497 |
*/ if (flags == 0) { ASSERT(offset + size <= i_size_read(inode)); return 0; } /* |
6dfa1b67e xfs: handle DIO o... |
1498 |
* We need to update the in-core inode size here so that we don't end up |
a06c277a1 xfs: DIO writes w... |
1499 1500 1501 |
* with the on-disk inode size being outside the in-core inode size. We * have no other method of updating EOF for AIO, so always do it here * if necessary. |
b9d59846f xfs: DIO write co... |
1502 1503 1504 1505 1506 |
* * We need to lock the test/set EOF update as we can be racing with * other IO completions here to update the EOF. Failing to serialise * here can result in EOF moving backwards and Bad Things Happen when * that occurs. |
2813d682e xfs: remove the i... |
1507 |
*/ |
273dda76f xfs: don't use io... |
1508 |
spin_lock(&ip->i_flags_lock); |
2ba662370 xfs: don't alloca... |
1509 1510 |
if (offset + size > i_size_read(inode)) i_size_write(inode, offset + size); |
273dda76f xfs: don't use io... |
1511 |
spin_unlock(&ip->i_flags_lock); |
2813d682e xfs: remove the i... |
1512 |
|
feac470e3 xfs: convert COW ... |
1513 1514 |
if (flags & XFS_DIO_FLAG_COW) error = xfs_reflink_end_cow(ip, offset, size); |
273dda76f xfs: don't use io... |
1515 1516 |
if (flags & XFS_DIO_FLAG_UNWRITTEN) { trace_xfs_end_io_direct_write_unwritten(ip, offset, size); |
209fb87a2 xfs simplify and ... |
1517 |
|
273dda76f xfs: don't use io... |
1518 |
error = xfs_iomap_write_unwritten(ip, offset, size); |
0613f16cd xfs: implement Co... |
1519 |
} |
0613f16cd xfs: implement Co... |
1520 |
if (flags & XFS_DIO_FLAG_APPEND) { |
273dda76f xfs: don't use io... |
1521 |
trace_xfs_end_io_direct_write_append(ip, offset, size); |
6b698edee xfs: add DAX file... |
1522 |
|
e372843a4 xfs: refactor xfs... |
1523 |
error = xfs_setfilesize(ip, offset, size); |
6b698edee xfs: add DAX file... |
1524 |
} |
273dda76f xfs: don't use io... |
1525 |
return error; |
6b698edee xfs: add DAX file... |
1526 |
} |
c19b104a6 xfs: fold xfs_vm_... |
1527 1528 |
STATIC ssize_t xfs_vm_direct_IO( |
6e1ba0bcb xfs: add DAX IO p... |
1529 |
struct kiocb *iocb, |
c8b8e32d7 direct-io: elimin... |
1530 |
struct iov_iter *iter) |
6e1ba0bcb xfs: add DAX IO p... |
1531 |
{ |
58e59854a xfs: fix assertio... |
1532 |
/* |
fa8d972d0 xfs: direct calls... |
1533 |
* We just need the method present so that open/fcntl allow direct I/O. |
58e59854a xfs: fix assertio... |
1534 |
*/ |
fa8d972d0 xfs: direct calls... |
1535 |
return -EINVAL; |
f51623b21 [XFS] Move some c... |
1536 |
} |
1da177e4c Linux-2.6.12-rc2 |
1537 1538 |
STATIC sector_t |
e4c573bb6 [XFS] Switch over... |
1539 |
xfs_vm_bmap( |
1da177e4c Linux-2.6.12-rc2 |
1540 1541 1542 1543 |
struct address_space *mapping, sector_t block) { struct inode *inode = (struct inode *)mapping->host; |
739bfb2a7 [XFS] call common... |
1544 |
struct xfs_inode *ip = XFS_I(inode); |
1da177e4c Linux-2.6.12-rc2 |
1545 |
|
cca28fb83 xfs: split xfs_it... |
1546 |
trace_xfs_vm_bmap(XFS_I(inode)); |
126468b11 [XFS] kill xfs_rw... |
1547 |
xfs_ilock(ip, XFS_IOLOCK_SHARED); |
db1327b16 xfs: report share... |
1548 1549 1550 1551 1552 1553 1554 1555 1556 1557 1558 |
/* * The swap code (ab-)uses ->bmap to get a block mapping and then * bypasseѕ the file system for actual I/O. We really can't allow * that on reflinks inodes, so we have to skip out here. And yes, * 0 is the magic code for a bmap error.. */ if (xfs_is_reflink_inode(ip)) { xfs_iunlock(ip, XFS_IOLOCK_SHARED); return 0; } |
4bc1ea6b8 xfs: remove xfs_f... |
1559 |
filemap_write_and_wait(mapping); |
126468b11 [XFS] kill xfs_rw... |
1560 |
xfs_iunlock(ip, XFS_IOLOCK_SHARED); |
c25366680 [XFS] Cleanup in ... |
1561 |
return generic_block_bmap(mapping, block, xfs_get_blocks); |
1da177e4c Linux-2.6.12-rc2 |
1562 1563 1564 |
} STATIC int |
e4c573bb6 [XFS] Switch over... |
1565 |
xfs_vm_readpage( |
1da177e4c Linux-2.6.12-rc2 |
1566 1567 1568 |
struct file *unused, struct page *page) { |
121e213ea xfs: add tracepoi... |
1569 |
trace_xfs_vm_readpage(page->mapping->host, 1); |
c25366680 [XFS] Cleanup in ... |
1570 |
return mpage_readpage(page, xfs_get_blocks); |
1da177e4c Linux-2.6.12-rc2 |
1571 1572 1573 |
} STATIC int |
e4c573bb6 [XFS] Switch over... |
1574 |
xfs_vm_readpages( |
1da177e4c Linux-2.6.12-rc2 |
1575 1576 1577 1578 1579 |
struct file *unused, struct address_space *mapping, struct list_head *pages, unsigned nr_pages) { |
121e213ea xfs: add tracepoi... |
1580 |
trace_xfs_vm_readpages(mapping->host, nr_pages); |
c25366680 [XFS] Cleanup in ... |
1581 |
return mpage_readpages(mapping, pages, nr_pages, xfs_get_blocks); |
1da177e4c Linux-2.6.12-rc2 |
1582 |
} |
22e757a49 xfs: don't dirty ... |
1583 1584 1585 1586 1587 1588 1589 1590 1591 1592 1593 1594 1595 1596 1597 1598 1599 1600 1601 1602 1603 1604 1605 1606 1607 1608 1609 1610 1611 1612 1613 1614 1615 1616 1617 1618 1619 1620 1621 1622 |
/* * This is basically a copy of __set_page_dirty_buffers() with one * small tweak: buffers beyond EOF do not get marked dirty. If we mark them * dirty, we'll never be able to clean them because we don't write buffers * beyond EOF, and that means we can't invalidate pages that span EOF * that have been marked dirty. Further, the dirty state can leak into * the file interior if the file is extended, resulting in all sorts of * bad things happening as the state does not match the underlying data. * * XXX: this really indicates that bufferheads in XFS need to die. Warts like * this only exist because of bufferheads and how the generic code manages them. */ STATIC int xfs_vm_set_page_dirty( struct page *page) { struct address_space *mapping = page->mapping; struct inode *inode = mapping->host; loff_t end_offset; loff_t offset; int newly_dirty; if (unlikely(!mapping)) return !TestSetPageDirty(page); end_offset = i_size_read(inode); offset = page_offset(page); spin_lock(&mapping->private_lock); if (page_has_buffers(page)) { struct buffer_head *head = page_buffers(page); struct buffer_head *bh = head; do { if (offset < end_offset) set_buffer_dirty(bh); bh = bh->b_this_page; offset += 1 << inode->i_blkbits; } while (bh != head); } |
c4843a759 memcg: add per cg... |
1623 |
/* |
81f8c3a46 mm: memcontrol: g... |
1624 1625 |
* Lock out page->mem_cgroup migration to keep PageDirty * synchronized with per-memcg dirty page counters. |
c4843a759 memcg: add per cg... |
1626 |
*/ |
62cccb8c8 mm: simplify lock... |
1627 |
lock_page_memcg(page); |
22e757a49 xfs: don't dirty ... |
1628 1629 1630 1631 1632 1633 1634 1635 1636 1637 |
newly_dirty = !TestSetPageDirty(page); spin_unlock(&mapping->private_lock); if (newly_dirty) { /* sigh - __set_page_dirty() is static, so copy it here, too */ unsigned long flags; spin_lock_irqsave(&mapping->tree_lock, flags); if (page->mapping) { /* Race with truncate? */ WARN_ON_ONCE(!PageUptodate(page)); |
62cccb8c8 mm: simplify lock... |
1638 |
account_page_dirtied(page, mapping); |
22e757a49 xfs: don't dirty ... |
1639 1640 1641 1642 |
radix_tree_tag_set(&mapping->page_tree, page_index(page), PAGECACHE_TAG_DIRTY); } spin_unlock_irqrestore(&mapping->tree_lock, flags); |
22e757a49 xfs: don't dirty ... |
1643 |
} |
62cccb8c8 mm: simplify lock... |
1644 |
unlock_page_memcg(page); |
c4843a759 memcg: add per cg... |
1645 1646 |
if (newly_dirty) __mark_inode_dirty(mapping->host, I_DIRTY_PAGES); |
22e757a49 xfs: don't dirty ... |
1647 1648 |
return newly_dirty; } |
f5e54d6e5 [PATCH] mark addr... |
1649 |
const struct address_space_operations xfs_address_space_operations = { |
e4c573bb6 [XFS] Switch over... |
1650 1651 1652 |
.readpage = xfs_vm_readpage, .readpages = xfs_vm_readpages, .writepage = xfs_vm_writepage, |
7d4fb40ad [XFS] Start write... |
1653 |
.writepages = xfs_vm_writepages, |
22e757a49 xfs: don't dirty ... |
1654 |
.set_page_dirty = xfs_vm_set_page_dirty, |
238f4c546 [XFS] Make couple... |
1655 1656 |
.releasepage = xfs_vm_releasepage, .invalidatepage = xfs_vm_invalidatepage, |
e4c573bb6 [XFS] Switch over... |
1657 1658 |
.bmap = xfs_vm_bmap, .direct_IO = xfs_vm_direct_IO, |
e965f9630 [PATCH] Direct Mi... |
1659 |
.migratepage = buffer_migrate_page, |
bddaafa11 xfs: pagecache us... |
1660 |
.is_partially_uptodate = block_is_partially_uptodate, |
aa261f549 HWPOISON: Enable ... |
1661 |
.error_remove_page = generic_error_remove_page, |
1da177e4c Linux-2.6.12-rc2 |
1662 |
}; |