aboutsummaryrefslogtreecommitdiffstats
path: root/fs/xfs
diff options
context:
space:
mode:
Diffstat (limited to 'fs/xfs')
-rw-r--r--fs/xfs/xfs_alloc.c4
-rw-r--r--fs/xfs/xfs_aops.c119
-rw-r--r--fs/xfs/xfs_aops.h4
-rw-r--r--fs/xfs/xfs_attr.c89
-rw-r--r--fs/xfs/xfs_attr_leaf.c7
-rw-r--r--fs/xfs/xfs_bmap.c2531
-rw-r--r--fs/xfs/xfs_bmap.h318
-rw-r--r--fs/xfs/xfs_btree.c11
-rw-r--r--fs/xfs/xfs_buf.c244
-rw-r--r--fs/xfs/xfs_buf.h51
-rw-r--r--fs/xfs/xfs_buf_item.c12
-rw-r--r--fs/xfs/xfs_da_btree.c54
-rw-r--r--fs/xfs/xfs_dfrag.c6
-rw-r--r--fs/xfs/xfs_dir2_leaf.c6
-rw-r--r--fs/xfs/xfs_discard.c20
-rw-r--r--fs/xfs/xfs_dquot.c32
-rw-r--r--fs/xfs/xfs_export.c12
-rw-r--r--fs/xfs/xfs_file.c168
-rw-r--r--fs/xfs/xfs_filestream.c4
-rw-r--r--fs/xfs/xfs_fsops.c60
-rw-r--r--fs/xfs/xfs_ialloc.c15
-rw-r--r--fs/xfs/xfs_iget.c2
-rw-r--r--fs/xfs/xfs_inode.c43
-rw-r--r--fs/xfs/xfs_inode.h1
-rw-r--r--fs/xfs/xfs_inode_item.c4
-rw-r--r--fs/xfs/xfs_ioctl.c2
-rw-r--r--fs/xfs/xfs_iomap.c39
-rw-r--r--fs/xfs/xfs_iops.c14
-rw-r--r--fs/xfs/xfs_log.c20
-rw-r--r--fs/xfs/xfs_log_recover.c43
-rw-r--r--fs/xfs/xfs_mount.c36
-rw-r--r--fs/xfs/xfs_qm.c12
-rw-r--r--fs/xfs/xfs_qm_syscalls.c2
-rw-r--r--fs/xfs/xfs_rename.c8
-rw-r--r--fs/xfs/xfs_rtalloc.c48
-rw-r--r--fs/xfs/xfs_rw.c23
-rw-r--r--fs/xfs/xfs_rw.h2
-rw-r--r--fs/xfs/xfs_super.c13
-rw-r--r--fs/xfs/xfs_sync.c16
-rw-r--r--fs/xfs/xfs_trace.h39
-rw-r--r--fs/xfs/xfs_trans.c13
-rw-r--r--fs/xfs/xfs_trans.h8
-rw-r--r--fs/xfs/xfs_trans_ail.c43
-rw-r--r--fs/xfs/xfs_trans_buf.c24
-rw-r--r--fs/xfs/xfs_trans_inode.c25
-rw-r--r--fs/xfs/xfs_trans_priv.h1
-rw-r--r--fs/xfs/xfs_vnodeops.c109
47 files changed, 2033 insertions, 2324 deletions
diff --git a/fs/xfs/xfs_alloc.c b/fs/xfs/xfs_alloc.c
index bdd9cb54d63b..ce84ffd0264c 100644
--- a/fs/xfs/xfs_alloc.c
+++ b/fs/xfs/xfs_alloc.c
@@ -452,7 +452,7 @@ xfs_alloc_read_agfl(
452 if (error) 452 if (error)
453 return error; 453 return error;
454 ASSERT(!xfs_buf_geterror(bp)); 454 ASSERT(!xfs_buf_geterror(bp));
455 XFS_BUF_SET_VTYPE_REF(bp, B_FS_AGFL, XFS_AGFL_REF); 455 xfs_buf_set_ref(bp, XFS_AGFL_REF);
456 *bpp = bp; 456 *bpp = bp;
457 return 0; 457 return 0;
458} 458}
@@ -2139,7 +2139,7 @@ xfs_read_agf(
2139 xfs_trans_brelse(tp, *bpp); 2139 xfs_trans_brelse(tp, *bpp);
2140 return XFS_ERROR(EFSCORRUPTED); 2140 return XFS_ERROR(EFSCORRUPTED);
2141 } 2141 }
2142 XFS_BUF_SET_VTYPE_REF(*bpp, B_FS_AGF, XFS_AGF_REF); 2142 xfs_buf_set_ref(*bpp, XFS_AGF_REF);
2143 return 0; 2143 return 0;
2144} 2144}
2145 2145
diff --git a/fs/xfs/xfs_aops.c b/fs/xfs/xfs_aops.c
index 8c37dde4c521..11b2aad982d4 100644
--- a/fs/xfs/xfs_aops.c
+++ b/fs/xfs/xfs_aops.c
@@ -38,40 +38,6 @@
38#include <linux/pagevec.h> 38#include <linux/pagevec.h>
39#include <linux/writeback.h> 39#include <linux/writeback.h>
40 40
41
42/*
43 * Prime number of hash buckets since address is used as the key.
44 */
45#define NVSYNC 37
46#define to_ioend_wq(v) (&xfs_ioend_wq[((unsigned long)v) % NVSYNC])
47static wait_queue_head_t xfs_ioend_wq[NVSYNC];
48
49void __init
50xfs_ioend_init(void)
51{
52 int i;
53
54 for (i = 0; i < NVSYNC; i++)
55 init_waitqueue_head(&xfs_ioend_wq[i]);
56}
57
58void
59xfs_ioend_wait(
60 xfs_inode_t *ip)
61{
62 wait_queue_head_t *wq = to_ioend_wq(ip);
63
64 wait_event(*wq, (atomic_read(&ip->i_iocount) == 0));
65}
66
67STATIC void
68xfs_ioend_wake(
69 xfs_inode_t *ip)
70{
71 if (atomic_dec_and_test(&ip->i_iocount))
72 wake_up(to_ioend_wq(ip));
73}
74
75void 41void
76xfs_count_page_state( 42xfs_count_page_state(
77 struct page *page, 43 struct page *page,
@@ -115,25 +81,20 @@ xfs_destroy_ioend(
115 xfs_ioend_t *ioend) 81 xfs_ioend_t *ioend)
116{ 82{
117 struct buffer_head *bh, *next; 83 struct buffer_head *bh, *next;
118 struct xfs_inode *ip = XFS_I(ioend->io_inode);
119 84
120 for (bh = ioend->io_buffer_head; bh; bh = next) { 85 for (bh = ioend->io_buffer_head; bh; bh = next) {
121 next = bh->b_private; 86 next = bh->b_private;
122 bh->b_end_io(bh, !ioend->io_error); 87 bh->b_end_io(bh, !ioend->io_error);
123 } 88 }
124 89
125 /* 90 if (ioend->io_iocb) {
126 * Volume managers supporting multiple paths can send back ENODEV 91 if (ioend->io_isasync) {
127 * when the final path disappears. In this case continuing to fill 92 aio_complete(ioend->io_iocb, ioend->io_error ?
128 * the page cache with dirty data which cannot be written out is 93 ioend->io_error : ioend->io_result, 0);
129 * evil, so prevent that. 94 }
130 */ 95 inode_dio_done(ioend->io_inode);
131 if (unlikely(ioend->io_error == -ENODEV)) {
132 xfs_do_force_shutdown(ip->i_mount, SHUTDOWN_DEVICE_REQ,
133 __FILE__, __LINE__);
134 } 96 }
135 97
136 xfs_ioend_wake(ip);
137 mempool_free(ioend, xfs_ioend_pool); 98 mempool_free(ioend, xfs_ioend_pool);
138} 99}
139 100
@@ -156,6 +117,15 @@ xfs_ioend_new_eof(
156} 117}
157 118
158/* 119/*
120 * Fast and loose check if this write could update the on-disk inode size.
121 */
122static inline bool xfs_ioend_is_append(struct xfs_ioend *ioend)
123{
124 return ioend->io_offset + ioend->io_size >
125 XFS_I(ioend->io_inode)->i_d.di_size;
126}
127
128/*
159 * Update on-disk file size now that data has been written to disk. The 129 * Update on-disk file size now that data has been written to disk. The
160 * current in-memory file size is i_size. If a write is beyond eof i_new_size 130 * current in-memory file size is i_size. If a write is beyond eof i_new_size
161 * will be the intended file size until i_size is updated. If this write does 131 * will be the intended file size until i_size is updated. If this write does
@@ -173,9 +143,6 @@ xfs_setfilesize(
173 xfs_inode_t *ip = XFS_I(ioend->io_inode); 143 xfs_inode_t *ip = XFS_I(ioend->io_inode);
174 xfs_fsize_t isize; 144 xfs_fsize_t isize;
175 145
176 if (unlikely(ioend->io_error))
177 return 0;
178
179 if (!xfs_ilock_nowait(ip, XFS_ILOCK_EXCL)) 146 if (!xfs_ilock_nowait(ip, XFS_ILOCK_EXCL))
180 return EAGAIN; 147 return EAGAIN;
181 148
@@ -192,6 +159,9 @@ xfs_setfilesize(
192 159
193/* 160/*
194 * Schedule IO completion handling on the final put of an ioend. 161 * Schedule IO completion handling on the final put of an ioend.
162 *
163 * If there is no work to do we might as well call it a day and free the
164 * ioend right now.
195 */ 165 */
196STATIC void 166STATIC void
197xfs_finish_ioend( 167xfs_finish_ioend(
@@ -200,8 +170,10 @@ xfs_finish_ioend(
200 if (atomic_dec_and_test(&ioend->io_remaining)) { 170 if (atomic_dec_and_test(&ioend->io_remaining)) {
201 if (ioend->io_type == IO_UNWRITTEN) 171 if (ioend->io_type == IO_UNWRITTEN)
202 queue_work(xfsconvertd_workqueue, &ioend->io_work); 172 queue_work(xfsconvertd_workqueue, &ioend->io_work);
203 else 173 else if (xfs_ioend_is_append(ioend))
204 queue_work(xfsdatad_workqueue, &ioend->io_work); 174 queue_work(xfsdatad_workqueue, &ioend->io_work);
175 else
176 xfs_destroy_ioend(ioend);
205 } 177 }
206} 178}
207 179
@@ -216,17 +188,24 @@ xfs_end_io(
216 struct xfs_inode *ip = XFS_I(ioend->io_inode); 188 struct xfs_inode *ip = XFS_I(ioend->io_inode);
217 int error = 0; 189 int error = 0;
218 190
191 if (XFS_FORCED_SHUTDOWN(ip->i_mount)) {
192 error = -EIO;
193 goto done;
194 }
195 if (ioend->io_error)
196 goto done;
197
219 /* 198 /*
220 * For unwritten extents we need to issue transactions to convert a 199 * For unwritten extents we need to issue transactions to convert a
221 * range to normal written extens after the data I/O has finished. 200 * range to normal written extens after the data I/O has finished.
222 */ 201 */
223 if (ioend->io_type == IO_UNWRITTEN && 202 if (ioend->io_type == IO_UNWRITTEN) {
224 likely(!ioend->io_error && !XFS_FORCED_SHUTDOWN(ip->i_mount))) {
225
226 error = xfs_iomap_write_unwritten(ip, ioend->io_offset, 203 error = xfs_iomap_write_unwritten(ip, ioend->io_offset,
227 ioend->io_size); 204 ioend->io_size);
228 if (error) 205 if (error) {
229 ioend->io_error = error; 206 ioend->io_error = -error;
207 goto done;
208 }
230 } 209 }
231 210
232 /* 211 /*
@@ -236,6 +215,7 @@ xfs_end_io(
236 error = xfs_setfilesize(ioend); 215 error = xfs_setfilesize(ioend);
237 ASSERT(!error || error == EAGAIN); 216 ASSERT(!error || error == EAGAIN);
238 217
218done:
239 /* 219 /*
240 * If we didn't complete processing of the ioend, requeue it to the 220 * If we didn't complete processing of the ioend, requeue it to the
241 * tail of the workqueue for another attempt later. Otherwise destroy 221 * tail of the workqueue for another attempt later. Otherwise destroy
@@ -247,8 +227,6 @@ xfs_end_io(
247 /* ensure we don't spin on blocked ioends */ 227 /* ensure we don't spin on blocked ioends */
248 delay(1); 228 delay(1);
249 } else { 229 } else {
250 if (ioend->io_iocb)
251 aio_complete(ioend->io_iocb, ioend->io_result, 0);
252 xfs_destroy_ioend(ioend); 230 xfs_destroy_ioend(ioend);
253 } 231 }
254} 232}
@@ -285,13 +263,13 @@ xfs_alloc_ioend(
285 * all the I/O from calling the completion routine too early. 263 * all the I/O from calling the completion routine too early.
286 */ 264 */
287 atomic_set(&ioend->io_remaining, 1); 265 atomic_set(&ioend->io_remaining, 1);
266 ioend->io_isasync = 0;
288 ioend->io_error = 0; 267 ioend->io_error = 0;
289 ioend->io_list = NULL; 268 ioend->io_list = NULL;
290 ioend->io_type = type; 269 ioend->io_type = type;
291 ioend->io_inode = inode; 270 ioend->io_inode = inode;
292 ioend->io_buffer_head = NULL; 271 ioend->io_buffer_head = NULL;
293 ioend->io_buffer_tail = NULL; 272 ioend->io_buffer_tail = NULL;
294 atomic_inc(&XFS_I(ioend->io_inode)->i_iocount);
295 ioend->io_offset = 0; 273 ioend->io_offset = 0;
296 ioend->io_size = 0; 274 ioend->io_size = 0;
297 ioend->io_iocb = NULL; 275 ioend->io_iocb = NULL;
@@ -337,8 +315,8 @@ xfs_map_blocks(
337 count = mp->m_maxioffset - offset; 315 count = mp->m_maxioffset - offset;
338 end_fsb = XFS_B_TO_FSB(mp, (xfs_ufsize_t)offset + count); 316 end_fsb = XFS_B_TO_FSB(mp, (xfs_ufsize_t)offset + count);
339 offset_fsb = XFS_B_TO_FSBT(mp, offset); 317 offset_fsb = XFS_B_TO_FSBT(mp, offset);
340 error = xfs_bmapi(NULL, ip, offset_fsb, end_fsb - offset_fsb, 318 error = xfs_bmapi_read(ip, offset_fsb, end_fsb - offset_fsb,
341 bmapi_flags, NULL, 0, imap, &nimaps, NULL); 319 imap, &nimaps, bmapi_flags);
342 xfs_iunlock(ip, XFS_ILOCK_SHARED); 320 xfs_iunlock(ip, XFS_ILOCK_SHARED);
343 321
344 if (error) 322 if (error)
@@ -551,7 +529,6 @@ xfs_cancel_ioend(
551 unlock_buffer(bh); 529 unlock_buffer(bh);
552 } while ((bh = next_bh) != NULL); 530 } while ((bh = next_bh) != NULL);
553 531
554 xfs_ioend_wake(XFS_I(ioend->io_inode));
555 mempool_free(ioend, xfs_ioend_pool); 532 mempool_free(ioend, xfs_ioend_pool);
556 } while ((ioend = next) != NULL); 533 } while ((ioend = next) != NULL);
557} 534}
@@ -1161,8 +1138,8 @@ __xfs_get_blocks(
1161 end_fsb = XFS_B_TO_FSB(mp, (xfs_ufsize_t)offset + size); 1138 end_fsb = XFS_B_TO_FSB(mp, (xfs_ufsize_t)offset + size);
1162 offset_fsb = XFS_B_TO_FSBT(mp, offset); 1139 offset_fsb = XFS_B_TO_FSBT(mp, offset);
1163 1140
1164 error = xfs_bmapi(NULL, ip, offset_fsb, end_fsb - offset_fsb, 1141 error = xfs_bmapi_read(ip, offset_fsb, end_fsb - offset_fsb,
1165 XFS_BMAPI_ENTIRE, NULL, 0, &imap, &nimaps, NULL); 1142 &imap, &nimaps, XFS_BMAPI_ENTIRE);
1166 if (error) 1143 if (error)
1167 goto out_unlock; 1144 goto out_unlock;
1168 1145
@@ -1300,7 +1277,6 @@ xfs_end_io_direct_write(
1300 bool is_async) 1277 bool is_async)
1301{ 1278{
1302 struct xfs_ioend *ioend = iocb->private; 1279 struct xfs_ioend *ioend = iocb->private;
1303 struct inode *inode = ioend->io_inode;
1304 1280
1305 /* 1281 /*
1306 * blockdev_direct_IO can return an error even after the I/O 1282 * blockdev_direct_IO can return an error even after the I/O
@@ -1311,28 +1287,17 @@ xfs_end_io_direct_write(
1311 1287
1312 ioend->io_offset = offset; 1288 ioend->io_offset = offset;
1313 ioend->io_size = size; 1289 ioend->io_size = size;
1290 ioend->io_iocb = iocb;
1291 ioend->io_result = ret;
1314 if (private && size > 0) 1292 if (private && size > 0)
1315 ioend->io_type = IO_UNWRITTEN; 1293 ioend->io_type = IO_UNWRITTEN;
1316 1294
1317 if (is_async) { 1295 if (is_async) {
1318 /* 1296 ioend->io_isasync = 1;
1319 * If we are converting an unwritten extent we need to delay
1320 * the AIO completion until after the unwrittent extent
1321 * conversion has completed, otherwise do it ASAP.
1322 */
1323 if (ioend->io_type == IO_UNWRITTEN) {
1324 ioend->io_iocb = iocb;
1325 ioend->io_result = ret;
1326 } else {
1327 aio_complete(iocb, ret, 0);
1328 }
1329 xfs_finish_ioend(ioend); 1297 xfs_finish_ioend(ioend);
1330 } else { 1298 } else {
1331 xfs_finish_ioend_sync(ioend); 1299 xfs_finish_ioend_sync(ioend);
1332 } 1300 }
1333
1334 /* XXX: probably should move into the real I/O completion handler */
1335 inode_dio_done(inode);
1336} 1301}
1337 1302
1338STATIC ssize_t 1303STATIC ssize_t
diff --git a/fs/xfs/xfs_aops.h b/fs/xfs/xfs_aops.h
index 71f721e1a71f..116dd5c37034 100644
--- a/fs/xfs/xfs_aops.h
+++ b/fs/xfs/xfs_aops.h
@@ -47,6 +47,7 @@ typedef struct xfs_ioend {
47 unsigned int io_type; /* delalloc / unwritten */ 47 unsigned int io_type; /* delalloc / unwritten */
48 int io_error; /* I/O error code */ 48 int io_error; /* I/O error code */
49 atomic_t io_remaining; /* hold count */ 49 atomic_t io_remaining; /* hold count */
50 unsigned int io_isasync : 1; /* needs aio_complete */
50 struct inode *io_inode; /* file being written to */ 51 struct inode *io_inode; /* file being written to */
51 struct buffer_head *io_buffer_head;/* buffer linked list head */ 52 struct buffer_head *io_buffer_head;/* buffer linked list head */
52 struct buffer_head *io_buffer_tail;/* buffer linked list tail */ 53 struct buffer_head *io_buffer_tail;/* buffer linked list tail */
@@ -60,9 +61,6 @@ typedef struct xfs_ioend {
60extern const struct address_space_operations xfs_address_space_operations; 61extern const struct address_space_operations xfs_address_space_operations;
61extern int xfs_get_blocks(struct inode *, sector_t, struct buffer_head *, int); 62extern int xfs_get_blocks(struct inode *, sector_t, struct buffer_head *, int);
62 63
63extern void xfs_ioend_init(void);
64extern void xfs_ioend_wait(struct xfs_inode *);
65
66extern void xfs_count_page_state(struct page *, int *, int *); 64extern void xfs_count_page_state(struct page *, int *, int *);
67 65
68#endif /* __XFS_AOPS_H__ */ 66#endif /* __XFS_AOPS_H__ */
diff --git a/fs/xfs/xfs_attr.c b/fs/xfs/xfs_attr.c
index 160bcdc34a6e..1e5d97f86ea8 100644
--- a/fs/xfs/xfs_attr.c
+++ b/fs/xfs/xfs_attr.c
@@ -319,7 +319,7 @@ xfs_attr_set_int(
319 return (error); 319 return (error);
320 } 320 }
321 321
322 xfs_trans_ijoin(args.trans, dp); 322 xfs_trans_ijoin(args.trans, dp, 0);
323 323
324 /* 324 /*
325 * If the attribute list is non-existent or a shortform list, 325 * If the attribute list is non-existent or a shortform list,
@@ -389,7 +389,7 @@ xfs_attr_set_int(
389 * a new one. We need the inode to be in all transactions. 389 * a new one. We need the inode to be in all transactions.
390 */ 390 */
391 if (committed) 391 if (committed)
392 xfs_trans_ijoin(args.trans, dp); 392 xfs_trans_ijoin(args.trans, dp, 0);
393 393
394 /* 394 /*
395 * Commit the leaf transformation. We'll need another (linked) 395 * Commit the leaf transformation. We'll need another (linked)
@@ -537,7 +537,7 @@ xfs_attr_remove_int(xfs_inode_t *dp, struct xfs_name *name, int flags)
537 * No need to make quota reservations here. We expect to release some 537 * No need to make quota reservations here. We expect to release some
538 * blocks not allocate in the common case. 538 * blocks not allocate in the common case.
539 */ 539 */
540 xfs_trans_ijoin(args.trans, dp); 540 xfs_trans_ijoin(args.trans, dp, 0);
541 541
542 /* 542 /*
543 * Decide on what work routines to call based on the inode size. 543 * Decide on what work routines to call based on the inode size.
@@ -809,7 +809,7 @@ xfs_attr_inactive(xfs_inode_t *dp)
809 * No need to make quota reservations here. We expect to release some 809 * No need to make quota reservations here. We expect to release some
810 * blocks, not allocate, in the common case. 810 * blocks, not allocate, in the common case.
811 */ 811 */
812 xfs_trans_ijoin(trans, dp); 812 xfs_trans_ijoin(trans, dp, 0);
813 813
814 /* 814 /*
815 * Decide on what work routines to call based on the inode size. 815 * Decide on what work routines to call based on the inode size.
@@ -823,18 +823,6 @@ xfs_attr_inactive(xfs_inode_t *dp)
823 if (error) 823 if (error)
824 goto out; 824 goto out;
825 825
826 /*
827 * Signal synchronous inactive transactions unless this is a
828 * synchronous mount filesystem in which case we know that we're here
829 * because we've been called out of xfs_inactive which means that the
830 * last reference is gone and the unlink transaction has already hit
831 * the disk so async inactive transactions are safe.
832 */
833 if (!(mp->m_flags & XFS_MOUNT_WSYNC)) {
834 if (dp->i_d.di_anextents > 0)
835 xfs_trans_set_sync(trans);
836 }
837
838 error = xfs_itruncate_extents(&trans, dp, XFS_ATTR_FORK, 0); 826 error = xfs_itruncate_extents(&trans, dp, XFS_ATTR_FORK, 0);
839 if (error) 827 if (error)
840 goto out; 828 goto out;
@@ -973,7 +961,7 @@ xfs_attr_leaf_addname(xfs_da_args_t *args)
973 * a new one. We need the inode to be in all transactions. 961 * a new one. We need the inode to be in all transactions.
974 */ 962 */
975 if (committed) 963 if (committed)
976 xfs_trans_ijoin(args->trans, dp); 964 xfs_trans_ijoin(args->trans, dp, 0);
977 965
978 /* 966 /*
979 * Commit the current trans (including the inode) and start 967 * Commit the current trans (including the inode) and start
@@ -1075,7 +1063,7 @@ xfs_attr_leaf_addname(xfs_da_args_t *args)
1075 * in all transactions. 1063 * in all transactions.
1076 */ 1064 */
1077 if (committed) 1065 if (committed)
1078 xfs_trans_ijoin(args->trans, dp); 1066 xfs_trans_ijoin(args->trans, dp, 0);
1079 } else 1067 } else
1080 xfs_da_buf_done(bp); 1068 xfs_da_buf_done(bp);
1081 1069
@@ -1149,7 +1137,7 @@ xfs_attr_leaf_removename(xfs_da_args_t *args)
1149 * a new one. We need the inode to be in all transactions. 1137 * a new one. We need the inode to be in all transactions.
1150 */ 1138 */
1151 if (committed) 1139 if (committed)
1152 xfs_trans_ijoin(args->trans, dp); 1140 xfs_trans_ijoin(args->trans, dp, 0);
1153 } else 1141 } else
1154 xfs_da_buf_done(bp); 1142 xfs_da_buf_done(bp);
1155 return(0); 1143 return(0);
@@ -1303,7 +1291,7 @@ restart:
1303 * in all transactions. 1291 * in all transactions.
1304 */ 1292 */
1305 if (committed) 1293 if (committed)
1306 xfs_trans_ijoin(args->trans, dp); 1294 xfs_trans_ijoin(args->trans, dp, 0);
1307 1295
1308 /* 1296 /*
1309 * Commit the node conversion and start the next 1297 * Commit the node conversion and start the next
@@ -1340,7 +1328,7 @@ restart:
1340 * a new one. We need the inode to be in all transactions. 1328 * a new one. We need the inode to be in all transactions.
1341 */ 1329 */
1342 if (committed) 1330 if (committed)
1343 xfs_trans_ijoin(args->trans, dp); 1331 xfs_trans_ijoin(args->trans, dp, 0);
1344 } else { 1332 } else {
1345 /* 1333 /*
1346 * Addition succeeded, update Btree hashvals. 1334 * Addition succeeded, update Btree hashvals.
@@ -1452,7 +1440,7 @@ restart:
1452 * in all transactions. 1440 * in all transactions.
1453 */ 1441 */
1454 if (committed) 1442 if (committed)
1455 xfs_trans_ijoin(args->trans, dp); 1443 xfs_trans_ijoin(args->trans, dp, 0);
1456 } 1444 }
1457 1445
1458 /* 1446 /*
@@ -1584,7 +1572,7 @@ xfs_attr_node_removename(xfs_da_args_t *args)
1584 * a new one. We need the inode to be in all transactions. 1572 * a new one. We need the inode to be in all transactions.
1585 */ 1573 */
1586 if (committed) 1574 if (committed)
1587 xfs_trans_ijoin(args->trans, dp); 1575 xfs_trans_ijoin(args->trans, dp, 0);
1588 1576
1589 /* 1577 /*
1590 * Commit the Btree join operation and start a new trans. 1578 * Commit the Btree join operation and start a new trans.
@@ -1635,7 +1623,7 @@ xfs_attr_node_removename(xfs_da_args_t *args)
1635 * in all transactions. 1623 * in all transactions.
1636 */ 1624 */
1637 if (committed) 1625 if (committed)
1638 xfs_trans_ijoin(args->trans, dp); 1626 xfs_trans_ijoin(args->trans, dp, 0);
1639 } else 1627 } else
1640 xfs_da_brelse(args->trans, bp); 1628 xfs_da_brelse(args->trans, bp);
1641 } 1629 }
@@ -1975,10 +1963,9 @@ xfs_attr_rmtval_get(xfs_da_args_t *args)
1975 lblkno = args->rmtblkno; 1963 lblkno = args->rmtblkno;
1976 while (valuelen > 0) { 1964 while (valuelen > 0) {
1977 nmap = ATTR_RMTVALUE_MAPSIZE; 1965 nmap = ATTR_RMTVALUE_MAPSIZE;
1978 error = xfs_bmapi(args->trans, args->dp, (xfs_fileoff_t)lblkno, 1966 error = xfs_bmapi_read(args->dp, (xfs_fileoff_t)lblkno,
1979 args->rmtblkcnt, 1967 args->rmtblkcnt, map, &nmap,
1980 XFS_BMAPI_ATTRFORK | XFS_BMAPI_METADATA, 1968 XFS_BMAPI_ATTRFORK);
1981 NULL, 0, map, &nmap, NULL);
1982 if (error) 1969 if (error)
1983 return(error); 1970 return(error);
1984 ASSERT(nmap >= 1); 1971 ASSERT(nmap >= 1);
@@ -2052,10 +2039,9 @@ xfs_attr_rmtval_set(xfs_da_args_t *args)
2052 */ 2039 */
2053 xfs_bmap_init(args->flist, args->firstblock); 2040 xfs_bmap_init(args->flist, args->firstblock);
2054 nmap = 1; 2041 nmap = 1;
2055 error = xfs_bmapi(args->trans, dp, (xfs_fileoff_t)lblkno, 2042 error = xfs_bmapi_write(args->trans, dp, (xfs_fileoff_t)lblkno,
2056 blkcnt, 2043 blkcnt,
2057 XFS_BMAPI_ATTRFORK | XFS_BMAPI_METADATA | 2044 XFS_BMAPI_ATTRFORK | XFS_BMAPI_METADATA,
2058 XFS_BMAPI_WRITE,
2059 args->firstblock, args->total, &map, &nmap, 2045 args->firstblock, args->total, &map, &nmap,
2060 args->flist); 2046 args->flist);
2061 if (!error) { 2047 if (!error) {
@@ -2074,7 +2060,7 @@ xfs_attr_rmtval_set(xfs_da_args_t *args)
2074 * a new one. We need the inode to be in all transactions. 2060 * a new one. We need the inode to be in all transactions.
2075 */ 2061 */
2076 if (committed) 2062 if (committed)
2077 xfs_trans_ijoin(args->trans, dp); 2063 xfs_trans_ijoin(args->trans, dp, 0);
2078 2064
2079 ASSERT(nmap == 1); 2065 ASSERT(nmap == 1);
2080 ASSERT((map.br_startblock != DELAYSTARTBLOCK) && 2066 ASSERT((map.br_startblock != DELAYSTARTBLOCK) &&
@@ -2104,14 +2090,11 @@ xfs_attr_rmtval_set(xfs_da_args_t *args)
2104 */ 2090 */
2105 xfs_bmap_init(args->flist, args->firstblock); 2091 xfs_bmap_init(args->flist, args->firstblock);
2106 nmap = 1; 2092 nmap = 1;
2107 error = xfs_bmapi(NULL, dp, (xfs_fileoff_t)lblkno, 2093 error = xfs_bmapi_read(dp, (xfs_fileoff_t)lblkno,
2108 args->rmtblkcnt, 2094 args->rmtblkcnt, &map, &nmap,
2109 XFS_BMAPI_ATTRFORK | XFS_BMAPI_METADATA, 2095 XFS_BMAPI_ATTRFORK);
2110 args->firstblock, 0, &map, &nmap, 2096 if (error)
2111 NULL);
2112 if (error) {
2113 return(error); 2097 return(error);
2114 }
2115 ASSERT(nmap == 1); 2098 ASSERT(nmap == 1);
2116 ASSERT((map.br_startblock != DELAYSTARTBLOCK) && 2099 ASSERT((map.br_startblock != DELAYSTARTBLOCK) &&
2117 (map.br_startblock != HOLESTARTBLOCK)); 2100 (map.br_startblock != HOLESTARTBLOCK));
@@ -2121,16 +2104,17 @@ xfs_attr_rmtval_set(xfs_da_args_t *args)
2121 2104
2122 bp = xfs_buf_get(mp->m_ddev_targp, dblkno, blkcnt, 2105 bp = xfs_buf_get(mp->m_ddev_targp, dblkno, blkcnt,
2123 XBF_LOCK | XBF_DONT_BLOCK); 2106 XBF_LOCK | XBF_DONT_BLOCK);
2124 ASSERT(!xfs_buf_geterror(bp)); 2107 if (!bp)
2125 2108 return ENOMEM;
2126 tmp = (valuelen < XFS_BUF_SIZE(bp)) ? valuelen : 2109 tmp = (valuelen < XFS_BUF_SIZE(bp)) ? valuelen :
2127 XFS_BUF_SIZE(bp); 2110 XFS_BUF_SIZE(bp);
2128 xfs_buf_iomove(bp, 0, tmp, src, XBRW_WRITE); 2111 xfs_buf_iomove(bp, 0, tmp, src, XBRW_WRITE);
2129 if (tmp < XFS_BUF_SIZE(bp)) 2112 if (tmp < XFS_BUF_SIZE(bp))
2130 xfs_buf_zero(bp, tmp, XFS_BUF_SIZE(bp) - tmp); 2113 xfs_buf_zero(bp, tmp, XFS_BUF_SIZE(bp) - tmp);
2131 if ((error = xfs_bwrite(mp, bp))) {/* GROT: NOTE: synchronous write */ 2114 error = xfs_bwrite(bp); /* GROT: NOTE: synchronous write */
2132 return (error); 2115 xfs_buf_relse(bp);
2133 } 2116 if (error)
2117 return error;
2134 src += tmp; 2118 src += tmp;
2135 valuelen -= tmp; 2119 valuelen -= tmp;
2136 2120
@@ -2166,16 +2150,12 @@ xfs_attr_rmtval_remove(xfs_da_args_t *args)
2166 /* 2150 /*
2167 * Try to remember where we decided to put the value. 2151 * Try to remember where we decided to put the value.
2168 */ 2152 */
2169 xfs_bmap_init(args->flist, args->firstblock);
2170 nmap = 1; 2153 nmap = 1;
2171 error = xfs_bmapi(NULL, args->dp, (xfs_fileoff_t)lblkno, 2154 error = xfs_bmapi_read(args->dp, (xfs_fileoff_t)lblkno,
2172 args->rmtblkcnt, 2155 args->rmtblkcnt, &map, &nmap,
2173 XFS_BMAPI_ATTRFORK | XFS_BMAPI_METADATA, 2156 XFS_BMAPI_ATTRFORK);
2174 args->firstblock, 0, &map, &nmap, 2157 if (error)
2175 args->flist);
2176 if (error) {
2177 return(error); 2158 return(error);
2178 }
2179 ASSERT(nmap == 1); 2159 ASSERT(nmap == 1);
2180 ASSERT((map.br_startblock != DELAYSTARTBLOCK) && 2160 ASSERT((map.br_startblock != DELAYSTARTBLOCK) &&
2181 (map.br_startblock != HOLESTARTBLOCK)); 2161 (map.br_startblock != HOLESTARTBLOCK));
@@ -2188,8 +2168,7 @@ xfs_attr_rmtval_remove(xfs_da_args_t *args)
2188 */ 2168 */
2189 bp = xfs_incore(mp->m_ddev_targp, dblkno, blkcnt, XBF_TRYLOCK); 2169 bp = xfs_incore(mp->m_ddev_targp, dblkno, blkcnt, XBF_TRYLOCK);
2190 if (bp) { 2170 if (bp) {
2191 XFS_BUF_STALE(bp); 2171 xfs_buf_stale(bp);
2192 XFS_BUF_UNDELAYWRITE(bp);
2193 xfs_buf_relse(bp); 2172 xfs_buf_relse(bp);
2194 bp = NULL; 2173 bp = NULL;
2195 } 2174 }
@@ -2227,7 +2206,7 @@ xfs_attr_rmtval_remove(xfs_da_args_t *args)
2227 * a new one. We need the inode to be in all transactions. 2206 * a new one. We need the inode to be in all transactions.
2228 */ 2207 */
2229 if (committed) 2208 if (committed)
2230 xfs_trans_ijoin(args->trans, args->dp); 2209 xfs_trans_ijoin(args->trans, args->dp, 0);
2231 2210
2232 /* 2211 /*
2233 * Close out trans and start the next one in the chain. 2212 * Close out trans and start the next one in the chain.
diff --git a/fs/xfs/xfs_attr_leaf.c b/fs/xfs/xfs_attr_leaf.c
index 8fad9602542b..d4906e7c9787 100644
--- a/fs/xfs/xfs_attr_leaf.c
+++ b/fs/xfs/xfs_attr_leaf.c
@@ -2926,9 +2926,8 @@ xfs_attr_leaf_freextent(xfs_trans_t **trans, xfs_inode_t *dp,
2926 * Try to remember where we decided to put the value. 2926 * Try to remember where we decided to put the value.
2927 */ 2927 */
2928 nmap = 1; 2928 nmap = 1;
2929 error = xfs_bmapi(*trans, dp, (xfs_fileoff_t)tblkno, tblkcnt, 2929 error = xfs_bmapi_read(dp, (xfs_fileoff_t)tblkno, tblkcnt,
2930 XFS_BMAPI_ATTRFORK | XFS_BMAPI_METADATA, 2930 &map, &nmap, XFS_BMAPI_ATTRFORK);
2931 NULL, 0, &map, &nmap, NULL);
2932 if (error) { 2931 if (error) {
2933 return(error); 2932 return(error);
2934 } 2933 }
@@ -2948,6 +2947,8 @@ xfs_attr_leaf_freextent(xfs_trans_t **trans, xfs_inode_t *dp,
2948 bp = xfs_trans_get_buf(*trans, 2947 bp = xfs_trans_get_buf(*trans,
2949 dp->i_mount->m_ddev_targp, 2948 dp->i_mount->m_ddev_targp,
2950 dblkno, dblkcnt, XBF_LOCK); 2949 dblkno, dblkcnt, XBF_LOCK);
2950 if (!bp)
2951 return ENOMEM;
2951 xfs_trans_binval(*trans, bp); 2952 xfs_trans_binval(*trans, bp);
2952 /* 2953 /*
2953 * Roll to next transaction. 2954 * Roll to next transaction.
diff --git a/fs/xfs/xfs_bmap.c b/fs/xfs/xfs_bmap.c
index 452a291383ab..c68baeb0974a 100644
--- a/fs/xfs/xfs_bmap.c
+++ b/fs/xfs/xfs_bmap.c
@@ -50,17 +50,22 @@
50#include "xfs_trace.h" 50#include "xfs_trace.h"
51 51
52 52
53#ifdef DEBUG
54STATIC void
55xfs_bmap_check_leaf_extents(xfs_btree_cur_t *cur, xfs_inode_t *ip, int whichfork);
56#endif
57
58kmem_zone_t *xfs_bmap_free_item_zone; 53kmem_zone_t *xfs_bmap_free_item_zone;
59 54
60/* 55/*
61 * Prototypes for internal bmap routines. 56 * Prototypes for internal bmap routines.
62 */ 57 */
63 58
59#ifdef DEBUG
60STATIC void
61xfs_bmap_check_leaf_extents(
62 struct xfs_btree_cur *cur,
63 struct xfs_inode *ip,
64 int whichfork);
65#else
66#define xfs_bmap_check_leaf_extents(cur, ip, whichfork) do { } while (0)
67#endif
68
64 69
65/* 70/*
66 * Called from xfs_bmap_add_attrfork to handle extents format files. 71 * Called from xfs_bmap_add_attrfork to handle extents format files.
@@ -85,58 +90,6 @@ xfs_bmap_add_attrfork_local(
85 int *flags); /* inode logging flags */ 90 int *flags); /* inode logging flags */
86 91
87/* 92/*
88 * Called by xfs_bmap_add_extent to handle cases converting a delayed
89 * allocation to a real allocation.
90 */
91STATIC int /* error */
92xfs_bmap_add_extent_delay_real(
93 struct xfs_trans *tp, /* transaction pointer */
94 xfs_inode_t *ip, /* incore inode pointer */
95 xfs_extnum_t *idx, /* extent number to update/insert */
96 xfs_btree_cur_t **curp, /* if *curp is null, not a btree */
97 xfs_bmbt_irec_t *new, /* new data to add to file extents */
98 xfs_filblks_t *dnew, /* new delayed-alloc indirect blocks */
99 xfs_fsblock_t *first, /* pointer to firstblock variable */
100 xfs_bmap_free_t *flist, /* list of extents to be freed */
101 int *logflagsp); /* inode logging flags */
102
103/*
104 * Called by xfs_bmap_add_extent to handle cases converting a hole
105 * to a delayed allocation.
106 */
107STATIC int /* error */
108xfs_bmap_add_extent_hole_delay(
109 xfs_inode_t *ip, /* incore inode pointer */
110 xfs_extnum_t *idx, /* extent number to update/insert */
111 xfs_bmbt_irec_t *new, /* new data to add to file extents */
112 int *logflagsp); /* inode logging flags */
113
114/*
115 * Called by xfs_bmap_add_extent to handle cases converting a hole
116 * to a real allocation.
117 */
118STATIC int /* error */
119xfs_bmap_add_extent_hole_real(
120 xfs_inode_t *ip, /* incore inode pointer */
121 xfs_extnum_t *idx, /* extent number to update/insert */
122 xfs_btree_cur_t *cur, /* if null, not a btree */
123 xfs_bmbt_irec_t *new, /* new data to add to file extents */
124 int *logflagsp, /* inode logging flags */
125 int whichfork); /* data or attr fork */
126
127/*
128 * Called by xfs_bmap_add_extent to handle cases converting an unwritten
129 * allocation to a real allocation or vice versa.
130 */
131STATIC int /* error */
132xfs_bmap_add_extent_unwritten_real(
133 xfs_inode_t *ip, /* incore inode pointer */
134 xfs_extnum_t *idx, /* extent number to update/insert */
135 xfs_btree_cur_t **curp, /* if *curp is null, not a btree */
136 xfs_bmbt_irec_t *new, /* new data to add to file extents */
137 int *logflagsp); /* inode logging flags */
138
139/*
140 * xfs_bmap_alloc is called by xfs_bmapi to allocate an extent for a file. 93 * xfs_bmap_alloc is called by xfs_bmapi to allocate an extent for a file.
141 * It figures out where to ask the underlying allocator to put the new extent. 94 * It figures out where to ask the underlying allocator to put the new extent.
142 */ 95 */
@@ -215,19 +168,6 @@ xfs_bmap_search_extents(
215 xfs_bmbt_irec_t *prevp); /* out: previous extent entry found */ 168 xfs_bmbt_irec_t *prevp); /* out: previous extent entry found */
216 169
217/* 170/*
218 * Check the last inode extent to determine whether this allocation will result
219 * in blocks being allocated at the end of the file. When we allocate new data
220 * blocks at the end of the file which do not start at the previous data block,
221 * we will try to align the new blocks at stripe unit boundaries.
222 */
223STATIC int /* error */
224xfs_bmap_isaeof(
225 xfs_inode_t *ip, /* incore inode pointer */
226 xfs_fileoff_t off, /* file offset in fsblocks */
227 int whichfork, /* data or attribute fork */
228 char *aeof); /* return value */
229
230/*
231 * Compute the worst-case number of indirect blocks that will be used 171 * Compute the worst-case number of indirect blocks that will be used
232 * for ip's delayed extent of length "len". 172 * for ip's delayed extent of length "len".
233 */ 173 */
@@ -431,188 +371,13 @@ xfs_bmap_add_attrfork_local(
431} 371}
432 372
433/* 373/*
434 * Called by xfs_bmapi to update file extent records and the btree 374 * Convert a delayed allocation to a real allocation.
435 * after allocating space (or doing a delayed allocation).
436 */
437STATIC int /* error */
438xfs_bmap_add_extent(
439 struct xfs_trans *tp, /* transaction pointer */
440 xfs_inode_t *ip, /* incore inode pointer */
441 xfs_extnum_t *idx, /* extent number to update/insert */
442 xfs_btree_cur_t **curp, /* if *curp is null, not a btree */
443 xfs_bmbt_irec_t *new, /* new data to add to file extents */
444 xfs_fsblock_t *first, /* pointer to firstblock variable */
445 xfs_bmap_free_t *flist, /* list of extents to be freed */
446 int *logflagsp, /* inode logging flags */
447 int whichfork) /* data or attr fork */
448{
449 xfs_btree_cur_t *cur; /* btree cursor or null */
450 xfs_filblks_t da_new; /* new count del alloc blocks used */
451 xfs_filblks_t da_old; /* old count del alloc blocks used */
452 int error; /* error return value */
453 xfs_ifork_t *ifp; /* inode fork ptr */
454 int logflags; /* returned value */
455 xfs_extnum_t nextents; /* number of extents in file now */
456
457 XFS_STATS_INC(xs_add_exlist);
458
459 cur = *curp;
460 ifp = XFS_IFORK_PTR(ip, whichfork);
461 nextents = ifp->if_bytes / (uint)sizeof(xfs_bmbt_rec_t);
462 da_old = da_new = 0;
463 error = 0;
464
465 ASSERT(*idx >= 0);
466 ASSERT(*idx <= nextents);
467
468 /*
469 * This is the first extent added to a new/empty file.
470 * Special case this one, so other routines get to assume there are
471 * already extents in the list.
472 */
473 if (nextents == 0) {
474 xfs_iext_insert(ip, *idx, 1, new,
475 whichfork == XFS_ATTR_FORK ? BMAP_ATTRFORK : 0);
476
477 ASSERT(cur == NULL);
478
479 if (!isnullstartblock(new->br_startblock)) {
480 XFS_IFORK_NEXT_SET(ip, whichfork, 1);
481 logflags = XFS_ILOG_CORE | xfs_ilog_fext(whichfork);
482 } else
483 logflags = 0;
484 }
485 /*
486 * Any kind of new delayed allocation goes here.
487 */
488 else if (isnullstartblock(new->br_startblock)) {
489 if (cur)
490 ASSERT((cur->bc_private.b.flags &
491 XFS_BTCUR_BPRV_WASDEL) == 0);
492 error = xfs_bmap_add_extent_hole_delay(ip, idx, new,
493 &logflags);
494 }
495 /*
496 * Real allocation off the end of the file.
497 */
498 else if (*idx == nextents) {
499 if (cur)
500 ASSERT((cur->bc_private.b.flags &
501 XFS_BTCUR_BPRV_WASDEL) == 0);
502 error = xfs_bmap_add_extent_hole_real(ip, idx, cur, new,
503 &logflags, whichfork);
504 } else {
505 xfs_bmbt_irec_t prev; /* old extent at offset idx */
506
507 /*
508 * Get the record referred to by idx.
509 */
510 xfs_bmbt_get_all(xfs_iext_get_ext(ifp, *idx), &prev);
511 /*
512 * If it's a real allocation record, and the new allocation ends
513 * after the start of the referred to record, then we're filling
514 * in a delayed or unwritten allocation with a real one, or
515 * converting real back to unwritten.
516 */
517 if (!isnullstartblock(new->br_startblock) &&
518 new->br_startoff + new->br_blockcount > prev.br_startoff) {
519 if (prev.br_state != XFS_EXT_UNWRITTEN &&
520 isnullstartblock(prev.br_startblock)) {
521 da_old = startblockval(prev.br_startblock);
522 if (cur)
523 ASSERT(cur->bc_private.b.flags &
524 XFS_BTCUR_BPRV_WASDEL);
525 error = xfs_bmap_add_extent_delay_real(tp, ip,
526 idx, &cur, new, &da_new,
527 first, flist, &logflags);
528 } else {
529 ASSERT(new->br_state == XFS_EXT_NORM ||
530 new->br_state == XFS_EXT_UNWRITTEN);
531
532 error = xfs_bmap_add_extent_unwritten_real(ip,
533 idx, &cur, new, &logflags);
534 if (error)
535 goto done;
536 }
537 }
538 /*
539 * Otherwise we're filling in a hole with an allocation.
540 */
541 else {
542 if (cur)
543 ASSERT((cur->bc_private.b.flags &
544 XFS_BTCUR_BPRV_WASDEL) == 0);
545 error = xfs_bmap_add_extent_hole_real(ip, idx, cur,
546 new, &logflags, whichfork);
547 }
548 }
549
550 if (error)
551 goto done;
552 ASSERT(*curp == cur || *curp == NULL);
553
554 /*
555 * Convert to a btree if necessary.
556 */
557 if (XFS_IFORK_FORMAT(ip, whichfork) == XFS_DINODE_FMT_EXTENTS &&
558 XFS_IFORK_NEXTENTS(ip, whichfork) > ifp->if_ext_max) {
559 int tmp_logflags; /* partial log flag return val */
560
561 ASSERT(cur == NULL);
562 error = xfs_bmap_extents_to_btree(tp, ip, first,
563 flist, &cur, da_old > 0, &tmp_logflags, whichfork);
564 logflags |= tmp_logflags;
565 if (error)
566 goto done;
567 }
568 /*
569 * Adjust for changes in reserved delayed indirect blocks.
570 * Nothing to do for disk quotas here.
571 */
572 if (da_old || da_new) {
573 xfs_filblks_t nblks;
574
575 nblks = da_new;
576 if (cur)
577 nblks += cur->bc_private.b.allocated;
578 ASSERT(nblks <= da_old);
579 if (nblks < da_old)
580 xfs_icsb_modify_counters(ip->i_mount, XFS_SBS_FDBLOCKS,
581 (int64_t)(da_old - nblks), 0);
582 }
583 /*
584 * Clear out the allocated field, done with it now in any case.
585 */
586 if (cur) {
587 cur->bc_private.b.allocated = 0;
588 *curp = cur;
589 }
590done:
591#ifdef DEBUG
592 if (!error)
593 xfs_bmap_check_leaf_extents(*curp, ip, whichfork);
594#endif
595 *logflagsp = logflags;
596 return error;
597}
598
599/*
600 * Called by xfs_bmap_add_extent to handle cases converting a delayed
601 * allocation to a real allocation.
602 */ 375 */
603STATIC int /* error */ 376STATIC int /* error */
604xfs_bmap_add_extent_delay_real( 377xfs_bmap_add_extent_delay_real(
605 struct xfs_trans *tp, /* transaction pointer */ 378 struct xfs_bmalloca *bma)
606 xfs_inode_t *ip, /* incore inode pointer */
607 xfs_extnum_t *idx, /* extent number to update/insert */
608 xfs_btree_cur_t **curp, /* if *curp is null, not a btree */
609 xfs_bmbt_irec_t *new, /* new data to add to file extents */
610 xfs_filblks_t *dnew, /* new delayed-alloc indirect blocks */
611 xfs_fsblock_t *first, /* pointer to firstblock variable */
612 xfs_bmap_free_t *flist, /* list of extents to be freed */
613 int *logflagsp) /* inode logging flags */
614{ 379{
615 xfs_btree_cur_t *cur; /* btree cursor */ 380 struct xfs_bmbt_irec *new = &bma->got;
616 int diff; /* temp value */ 381 int diff; /* temp value */
617 xfs_bmbt_rec_host_t *ep; /* extent entry for idx */ 382 xfs_bmbt_rec_host_t *ep; /* extent entry for idx */
618 int error; /* error return value */ 383 int error; /* error return value */
@@ -623,10 +388,22 @@ xfs_bmap_add_extent_delay_real(
623 /* left is 0, right is 1, prev is 2 */ 388 /* left is 0, right is 1, prev is 2 */
624 int rval=0; /* return value (logging flags) */ 389 int rval=0; /* return value (logging flags) */
625 int state = 0;/* state bits, accessed thru macros */ 390 int state = 0;/* state bits, accessed thru macros */
626 xfs_filblks_t temp=0; /* value for dnew calculations */ 391 xfs_filblks_t da_new; /* new count del alloc blocks used */
627 xfs_filblks_t temp2=0;/* value for dnew calculations */ 392 xfs_filblks_t da_old; /* old count del alloc blocks used */
393 xfs_filblks_t temp=0; /* value for da_new calculations */
394 xfs_filblks_t temp2=0;/* value for da_new calculations */
628 int tmp_rval; /* partial logging flags */ 395 int tmp_rval; /* partial logging flags */
629 396
397 ifp = XFS_IFORK_PTR(bma->ip, XFS_DATA_FORK);
398
399 ASSERT(bma->idx >= 0);
400 ASSERT(bma->idx <= ifp->if_bytes / sizeof(struct xfs_bmbt_rec));
401 ASSERT(!isnullstartblock(new->br_startblock));
402 ASSERT(!bma->cur ||
403 (bma->cur->bc_private.b.flags & XFS_BTCUR_BPRV_WASDEL));
404
405 XFS_STATS_INC(xs_add_exlist);
406
630#define LEFT r[0] 407#define LEFT r[0]
631#define RIGHT r[1] 408#define RIGHT r[1]
632#define PREV r[2] 409#define PREV r[2]
@@ -634,14 +411,15 @@ xfs_bmap_add_extent_delay_real(
634 /* 411 /*
635 * Set up a bunch of variables to make the tests simpler. 412 * Set up a bunch of variables to make the tests simpler.
636 */ 413 */
637 cur = *curp; 414 ep = xfs_iext_get_ext(ifp, bma->idx);
638 ifp = XFS_IFORK_PTR(ip, XFS_DATA_FORK);
639 ep = xfs_iext_get_ext(ifp, *idx);
640 xfs_bmbt_get_all(ep, &PREV); 415 xfs_bmbt_get_all(ep, &PREV);
641 new_endoff = new->br_startoff + new->br_blockcount; 416 new_endoff = new->br_startoff + new->br_blockcount;
642 ASSERT(PREV.br_startoff <= new->br_startoff); 417 ASSERT(PREV.br_startoff <= new->br_startoff);
643 ASSERT(PREV.br_startoff + PREV.br_blockcount >= new_endoff); 418 ASSERT(PREV.br_startoff + PREV.br_blockcount >= new_endoff);
644 419
420 da_old = startblockval(PREV.br_startblock);
421 da_new = 0;
422
645 /* 423 /*
646 * Set flags determining what part of the previous delayed allocation 424 * Set flags determining what part of the previous delayed allocation
647 * extent is being replaced by a real allocation. 425 * extent is being replaced by a real allocation.
@@ -655,9 +433,9 @@ xfs_bmap_add_extent_delay_real(
655 * Check and set flags if this segment has a left neighbor. 433 * Check and set flags if this segment has a left neighbor.
656 * Don't set contiguous if the combined extent would be too large. 434 * Don't set contiguous if the combined extent would be too large.
657 */ 435 */
658 if (*idx > 0) { 436 if (bma->idx > 0) {
659 state |= BMAP_LEFT_VALID; 437 state |= BMAP_LEFT_VALID;
660 xfs_bmbt_get_all(xfs_iext_get_ext(ifp, *idx - 1), &LEFT); 438 xfs_bmbt_get_all(xfs_iext_get_ext(ifp, bma->idx - 1), &LEFT);
661 439
662 if (isnullstartblock(LEFT.br_startblock)) 440 if (isnullstartblock(LEFT.br_startblock))
663 state |= BMAP_LEFT_DELAY; 441 state |= BMAP_LEFT_DELAY;
@@ -675,9 +453,9 @@ xfs_bmap_add_extent_delay_real(
675 * Don't set contiguous if the combined extent would be too large. 453 * Don't set contiguous if the combined extent would be too large.
676 * Also check for all-three-contiguous being too large. 454 * Also check for all-three-contiguous being too large.
677 */ 455 */
678 if (*idx < ip->i_df.if_bytes / (uint)sizeof(xfs_bmbt_rec_t) - 1) { 456 if (bma->idx < bma->ip->i_df.if_bytes / (uint)sizeof(xfs_bmbt_rec_t) - 1) {
679 state |= BMAP_RIGHT_VALID; 457 state |= BMAP_RIGHT_VALID;
680 xfs_bmbt_get_all(xfs_iext_get_ext(ifp, *idx + 1), &RIGHT); 458 xfs_bmbt_get_all(xfs_iext_get_ext(ifp, bma->idx + 1), &RIGHT);
681 459
682 if (isnullstartblock(RIGHT.br_startblock)) 460 if (isnullstartblock(RIGHT.br_startblock))
683 state |= BMAP_RIGHT_DELAY; 461 state |= BMAP_RIGHT_DELAY;
@@ -708,38 +486,41 @@ xfs_bmap_add_extent_delay_real(
708 * Filling in all of a previously delayed allocation extent. 486 * Filling in all of a previously delayed allocation extent.
709 * The left and right neighbors are both contiguous with new. 487 * The left and right neighbors are both contiguous with new.
710 */ 488 */
711 --*idx; 489 bma->idx--;
712 trace_xfs_bmap_pre_update(ip, *idx, state, _THIS_IP_); 490 trace_xfs_bmap_pre_update(bma->ip, bma->idx, state, _THIS_IP_);
713 xfs_bmbt_set_blockcount(xfs_iext_get_ext(ifp, *idx), 491 xfs_bmbt_set_blockcount(xfs_iext_get_ext(ifp, bma->idx),
714 LEFT.br_blockcount + PREV.br_blockcount + 492 LEFT.br_blockcount + PREV.br_blockcount +
715 RIGHT.br_blockcount); 493 RIGHT.br_blockcount);
716 trace_xfs_bmap_post_update(ip, *idx, state, _THIS_IP_); 494 trace_xfs_bmap_post_update(bma->ip, bma->idx, state, _THIS_IP_);
717 495
718 xfs_iext_remove(ip, *idx + 1, 2, state); 496 xfs_iext_remove(bma->ip, bma->idx + 1, 2, state);
719 ip->i_d.di_nextents--; 497 bma->ip->i_d.di_nextents--;
720 if (cur == NULL) 498 if (bma->cur == NULL)
721 rval = XFS_ILOG_CORE | XFS_ILOG_DEXT; 499 rval = XFS_ILOG_CORE | XFS_ILOG_DEXT;
722 else { 500 else {
723 rval = XFS_ILOG_CORE; 501 rval = XFS_ILOG_CORE;
724 if ((error = xfs_bmbt_lookup_eq(cur, RIGHT.br_startoff, 502 error = xfs_bmbt_lookup_eq(bma->cur, RIGHT.br_startoff,
725 RIGHT.br_startblock, 503 RIGHT.br_startblock,
726 RIGHT.br_blockcount, &i))) 504 RIGHT.br_blockcount, &i);
505 if (error)
727 goto done; 506 goto done;
728 XFS_WANT_CORRUPTED_GOTO(i == 1, done); 507 XFS_WANT_CORRUPTED_GOTO(i == 1, done);
729 if ((error = xfs_btree_delete(cur, &i))) 508 error = xfs_btree_delete(bma->cur, &i);
509 if (error)
730 goto done; 510 goto done;
731 XFS_WANT_CORRUPTED_GOTO(i == 1, done); 511 XFS_WANT_CORRUPTED_GOTO(i == 1, done);
732 if ((error = xfs_btree_decrement(cur, 0, &i))) 512 error = xfs_btree_decrement(bma->cur, 0, &i);
513 if (error)
733 goto done; 514 goto done;
734 XFS_WANT_CORRUPTED_GOTO(i == 1, done); 515 XFS_WANT_CORRUPTED_GOTO(i == 1, done);
735 if ((error = xfs_bmbt_update(cur, LEFT.br_startoff, 516 error = xfs_bmbt_update(bma->cur, LEFT.br_startoff,
736 LEFT.br_startblock, 517 LEFT.br_startblock,
737 LEFT.br_blockcount + 518 LEFT.br_blockcount +
738 PREV.br_blockcount + 519 PREV.br_blockcount +
739 RIGHT.br_blockcount, LEFT.br_state))) 520 RIGHT.br_blockcount, LEFT.br_state);
521 if (error)
740 goto done; 522 goto done;
741 } 523 }
742 *dnew = 0;
743 break; 524 break;
744 525
745 case BMAP_LEFT_FILLING | BMAP_RIGHT_FILLING | BMAP_LEFT_CONTIG: 526 case BMAP_LEFT_FILLING | BMAP_RIGHT_FILLING | BMAP_LEFT_CONTIG:
@@ -747,30 +528,31 @@ xfs_bmap_add_extent_delay_real(
747 * Filling in all of a previously delayed allocation extent. 528 * Filling in all of a previously delayed allocation extent.
748 * The left neighbor is contiguous, the right is not. 529 * The left neighbor is contiguous, the right is not.
749 */ 530 */
750 --*idx; 531 bma->idx--;
751 532
752 trace_xfs_bmap_pre_update(ip, *idx, state, _THIS_IP_); 533 trace_xfs_bmap_pre_update(bma->ip, bma->idx, state, _THIS_IP_);
753 xfs_bmbt_set_blockcount(xfs_iext_get_ext(ifp, *idx), 534 xfs_bmbt_set_blockcount(xfs_iext_get_ext(ifp, bma->idx),
754 LEFT.br_blockcount + PREV.br_blockcount); 535 LEFT.br_blockcount + PREV.br_blockcount);
755 trace_xfs_bmap_post_update(ip, *idx, state, _THIS_IP_); 536 trace_xfs_bmap_post_update(bma->ip, bma->idx, state, _THIS_IP_);
756 537
757 xfs_iext_remove(ip, *idx + 1, 1, state); 538 xfs_iext_remove(bma->ip, bma->idx + 1, 1, state);
758 if (cur == NULL) 539 if (bma->cur == NULL)
759 rval = XFS_ILOG_DEXT; 540 rval = XFS_ILOG_DEXT;
760 else { 541 else {
761 rval = 0; 542 rval = 0;
762 if ((error = xfs_bmbt_lookup_eq(cur, LEFT.br_startoff, 543 error = xfs_bmbt_lookup_eq(bma->cur, LEFT.br_startoff,
763 LEFT.br_startblock, LEFT.br_blockcount, 544 LEFT.br_startblock, LEFT.br_blockcount,
764 &i))) 545 &i);
546 if (error)
765 goto done; 547 goto done;
766 XFS_WANT_CORRUPTED_GOTO(i == 1, done); 548 XFS_WANT_CORRUPTED_GOTO(i == 1, done);
767 if ((error = xfs_bmbt_update(cur, LEFT.br_startoff, 549 error = xfs_bmbt_update(bma->cur, LEFT.br_startoff,
768 LEFT.br_startblock, 550 LEFT.br_startblock,
769 LEFT.br_blockcount + 551 LEFT.br_blockcount +
770 PREV.br_blockcount, LEFT.br_state))) 552 PREV.br_blockcount, LEFT.br_state);
553 if (error)
771 goto done; 554 goto done;
772 } 555 }
773 *dnew = 0;
774 break; 556 break;
775 557
776 case BMAP_LEFT_FILLING | BMAP_RIGHT_FILLING | BMAP_RIGHT_CONTIG: 558 case BMAP_LEFT_FILLING | BMAP_RIGHT_FILLING | BMAP_RIGHT_CONTIG:
@@ -778,30 +560,30 @@ xfs_bmap_add_extent_delay_real(
778 * Filling in all of a previously delayed allocation extent. 560 * Filling in all of a previously delayed allocation extent.
779 * The right neighbor is contiguous, the left is not. 561 * The right neighbor is contiguous, the left is not.
780 */ 562 */
781 trace_xfs_bmap_pre_update(ip, *idx, state, _THIS_IP_); 563 trace_xfs_bmap_pre_update(bma->ip, bma->idx, state, _THIS_IP_);
782 xfs_bmbt_set_startblock(ep, new->br_startblock); 564 xfs_bmbt_set_startblock(ep, new->br_startblock);
783 xfs_bmbt_set_blockcount(ep, 565 xfs_bmbt_set_blockcount(ep,
784 PREV.br_blockcount + RIGHT.br_blockcount); 566 PREV.br_blockcount + RIGHT.br_blockcount);
785 trace_xfs_bmap_post_update(ip, *idx, state, _THIS_IP_); 567 trace_xfs_bmap_post_update(bma->ip, bma->idx, state, _THIS_IP_);
786 568
787 xfs_iext_remove(ip, *idx + 1, 1, state); 569 xfs_iext_remove(bma->ip, bma->idx + 1, 1, state);
788 if (cur == NULL) 570 if (bma->cur == NULL)
789 rval = XFS_ILOG_DEXT; 571 rval = XFS_ILOG_DEXT;
790 else { 572 else {
791 rval = 0; 573 rval = 0;
792 if ((error = xfs_bmbt_lookup_eq(cur, RIGHT.br_startoff, 574 error = xfs_bmbt_lookup_eq(bma->cur, RIGHT.br_startoff,
793 RIGHT.br_startblock, 575 RIGHT.br_startblock,
794 RIGHT.br_blockcount, &i))) 576 RIGHT.br_blockcount, &i);
577 if (error)
795 goto done; 578 goto done;
796 XFS_WANT_CORRUPTED_GOTO(i == 1, done); 579 XFS_WANT_CORRUPTED_GOTO(i == 1, done);
797 if ((error = xfs_bmbt_update(cur, PREV.br_startoff, 580 error = xfs_bmbt_update(bma->cur, PREV.br_startoff,
798 new->br_startblock, 581 new->br_startblock,
799 PREV.br_blockcount + 582 PREV.br_blockcount +
800 RIGHT.br_blockcount, PREV.br_state))) 583 RIGHT.br_blockcount, PREV.br_state);
584 if (error)
801 goto done; 585 goto done;
802 } 586 }
803
804 *dnew = 0;
805 break; 587 break;
806 588
807 case BMAP_LEFT_FILLING | BMAP_RIGHT_FILLING: 589 case BMAP_LEFT_FILLING | BMAP_RIGHT_FILLING:
@@ -810,27 +592,27 @@ xfs_bmap_add_extent_delay_real(
810 * Neither the left nor right neighbors are contiguous with 592 * Neither the left nor right neighbors are contiguous with
811 * the new one. 593 * the new one.
812 */ 594 */
813 trace_xfs_bmap_pre_update(ip, *idx, state, _THIS_IP_); 595 trace_xfs_bmap_pre_update(bma->ip, bma->idx, state, _THIS_IP_);
814 xfs_bmbt_set_startblock(ep, new->br_startblock); 596 xfs_bmbt_set_startblock(ep, new->br_startblock);
815 trace_xfs_bmap_post_update(ip, *idx, state, _THIS_IP_); 597 trace_xfs_bmap_post_update(bma->ip, bma->idx, state, _THIS_IP_);
816 598
817 ip->i_d.di_nextents++; 599 bma->ip->i_d.di_nextents++;
818 if (cur == NULL) 600 if (bma->cur == NULL)
819 rval = XFS_ILOG_CORE | XFS_ILOG_DEXT; 601 rval = XFS_ILOG_CORE | XFS_ILOG_DEXT;
820 else { 602 else {
821 rval = XFS_ILOG_CORE; 603 rval = XFS_ILOG_CORE;
822 if ((error = xfs_bmbt_lookup_eq(cur, new->br_startoff, 604 error = xfs_bmbt_lookup_eq(bma->cur, new->br_startoff,
823 new->br_startblock, new->br_blockcount, 605 new->br_startblock, new->br_blockcount,
824 &i))) 606 &i);
607 if (error)
825 goto done; 608 goto done;
826 XFS_WANT_CORRUPTED_GOTO(i == 0, done); 609 XFS_WANT_CORRUPTED_GOTO(i == 0, done);
827 cur->bc_rec.b.br_state = XFS_EXT_NORM; 610 bma->cur->bc_rec.b.br_state = XFS_EXT_NORM;
828 if ((error = xfs_btree_insert(cur, &i))) 611 error = xfs_btree_insert(bma->cur, &i);
612 if (error)
829 goto done; 613 goto done;
830 XFS_WANT_CORRUPTED_GOTO(i == 1, done); 614 XFS_WANT_CORRUPTED_GOTO(i == 1, done);
831 } 615 }
832
833 *dnew = 0;
834 break; 616 break;
835 617
836 case BMAP_LEFT_FILLING | BMAP_LEFT_CONTIG: 618 case BMAP_LEFT_FILLING | BMAP_LEFT_CONTIG:
@@ -838,39 +620,40 @@ xfs_bmap_add_extent_delay_real(
838 * Filling in the first part of a previous delayed allocation. 620 * Filling in the first part of a previous delayed allocation.
839 * The left neighbor is contiguous. 621 * The left neighbor is contiguous.
840 */ 622 */
841 trace_xfs_bmap_pre_update(ip, *idx - 1, state, _THIS_IP_); 623 trace_xfs_bmap_pre_update(bma->ip, bma->idx - 1, state, _THIS_IP_);
842 xfs_bmbt_set_blockcount(xfs_iext_get_ext(ifp, *idx - 1), 624 xfs_bmbt_set_blockcount(xfs_iext_get_ext(ifp, bma->idx - 1),
843 LEFT.br_blockcount + new->br_blockcount); 625 LEFT.br_blockcount + new->br_blockcount);
844 xfs_bmbt_set_startoff(ep, 626 xfs_bmbt_set_startoff(ep,
845 PREV.br_startoff + new->br_blockcount); 627 PREV.br_startoff + new->br_blockcount);
846 trace_xfs_bmap_post_update(ip, *idx - 1, state, _THIS_IP_); 628 trace_xfs_bmap_post_update(bma->ip, bma->idx - 1, state, _THIS_IP_);
847 629
848 temp = PREV.br_blockcount - new->br_blockcount; 630 temp = PREV.br_blockcount - new->br_blockcount;
849 trace_xfs_bmap_pre_update(ip, *idx, state, _THIS_IP_); 631 trace_xfs_bmap_pre_update(bma->ip, bma->idx, state, _THIS_IP_);
850 xfs_bmbt_set_blockcount(ep, temp); 632 xfs_bmbt_set_blockcount(ep, temp);
851 if (cur == NULL) 633 if (bma->cur == NULL)
852 rval = XFS_ILOG_DEXT; 634 rval = XFS_ILOG_DEXT;
853 else { 635 else {
854 rval = 0; 636 rval = 0;
855 if ((error = xfs_bmbt_lookup_eq(cur, LEFT.br_startoff, 637 error = xfs_bmbt_lookup_eq(bma->cur, LEFT.br_startoff,
856 LEFT.br_startblock, LEFT.br_blockcount, 638 LEFT.br_startblock, LEFT.br_blockcount,
857 &i))) 639 &i);
640 if (error)
858 goto done; 641 goto done;
859 XFS_WANT_CORRUPTED_GOTO(i == 1, done); 642 XFS_WANT_CORRUPTED_GOTO(i == 1, done);
860 if ((error = xfs_bmbt_update(cur, LEFT.br_startoff, 643 error = xfs_bmbt_update(bma->cur, LEFT.br_startoff,
861 LEFT.br_startblock, 644 LEFT.br_startblock,
862 LEFT.br_blockcount + 645 LEFT.br_blockcount +
863 new->br_blockcount, 646 new->br_blockcount,
864 LEFT.br_state))) 647 LEFT.br_state);
648 if (error)
865 goto done; 649 goto done;
866 } 650 }
867 temp = XFS_FILBLKS_MIN(xfs_bmap_worst_indlen(ip, temp), 651 da_new = XFS_FILBLKS_MIN(xfs_bmap_worst_indlen(bma->ip, temp),
868 startblockval(PREV.br_startblock)); 652 startblockval(PREV.br_startblock));
869 xfs_bmbt_set_startblock(ep, nullstartblock((int)temp)); 653 xfs_bmbt_set_startblock(ep, nullstartblock(da_new));
870 trace_xfs_bmap_post_update(ip, *idx, state, _THIS_IP_); 654 trace_xfs_bmap_post_update(bma->ip, bma->idx, state, _THIS_IP_);
871 655
872 --*idx; 656 bma->idx--;
873 *dnew = temp;
874 break; 657 break;
875 658
876 case BMAP_LEFT_FILLING: 659 case BMAP_LEFT_FILLING:
@@ -878,43 +661,43 @@ xfs_bmap_add_extent_delay_real(
878 * Filling in the first part of a previous delayed allocation. 661 * Filling in the first part of a previous delayed allocation.
879 * The left neighbor is not contiguous. 662 * The left neighbor is not contiguous.
880 */ 663 */
881 trace_xfs_bmap_pre_update(ip, *idx, state, _THIS_IP_); 664 trace_xfs_bmap_pre_update(bma->ip, bma->idx, state, _THIS_IP_);
882 xfs_bmbt_set_startoff(ep, new_endoff); 665 xfs_bmbt_set_startoff(ep, new_endoff);
883 temp = PREV.br_blockcount - new->br_blockcount; 666 temp = PREV.br_blockcount - new->br_blockcount;
884 xfs_bmbt_set_blockcount(ep, temp); 667 xfs_bmbt_set_blockcount(ep, temp);
885 xfs_iext_insert(ip, *idx, 1, new, state); 668 xfs_iext_insert(bma->ip, bma->idx, 1, new, state);
886 ip->i_d.di_nextents++; 669 bma->ip->i_d.di_nextents++;
887 if (cur == NULL) 670 if (bma->cur == NULL)
888 rval = XFS_ILOG_CORE | XFS_ILOG_DEXT; 671 rval = XFS_ILOG_CORE | XFS_ILOG_DEXT;
889 else { 672 else {
890 rval = XFS_ILOG_CORE; 673 rval = XFS_ILOG_CORE;
891 if ((error = xfs_bmbt_lookup_eq(cur, new->br_startoff, 674 error = xfs_bmbt_lookup_eq(bma->cur, new->br_startoff,
892 new->br_startblock, new->br_blockcount, 675 new->br_startblock, new->br_blockcount,
893 &i))) 676 &i);
677 if (error)
894 goto done; 678 goto done;
895 XFS_WANT_CORRUPTED_GOTO(i == 0, done); 679 XFS_WANT_CORRUPTED_GOTO(i == 0, done);
896 cur->bc_rec.b.br_state = XFS_EXT_NORM; 680 bma->cur->bc_rec.b.br_state = XFS_EXT_NORM;
897 if ((error = xfs_btree_insert(cur, &i))) 681 error = xfs_btree_insert(bma->cur, &i);
682 if (error)
898 goto done; 683 goto done;
899 XFS_WANT_CORRUPTED_GOTO(i == 1, done); 684 XFS_WANT_CORRUPTED_GOTO(i == 1, done);
900 } 685 }
901 if (ip->i_d.di_format == XFS_DINODE_FMT_EXTENTS && 686 if (bma->ip->i_d.di_format == XFS_DINODE_FMT_EXTENTS &&
902 ip->i_d.di_nextents > ip->i_df.if_ext_max) { 687 bma->ip->i_d.di_nextents > bma->ip->i_df.if_ext_max) {
903 error = xfs_bmap_extents_to_btree(tp, ip, 688 error = xfs_bmap_extents_to_btree(bma->tp, bma->ip,
904 first, flist, &cur, 1, &tmp_rval, 689 bma->firstblock, bma->flist,
905 XFS_DATA_FORK); 690 &bma->cur, 1, &tmp_rval, XFS_DATA_FORK);
906 rval |= tmp_rval; 691 rval |= tmp_rval;
907 if (error) 692 if (error)
908 goto done; 693 goto done;
909 } 694 }
910 temp = XFS_FILBLKS_MIN(xfs_bmap_worst_indlen(ip, temp), 695 da_new = XFS_FILBLKS_MIN(xfs_bmap_worst_indlen(bma->ip, temp),
911 startblockval(PREV.br_startblock) - 696 startblockval(PREV.br_startblock) -
912 (cur ? cur->bc_private.b.allocated : 0)); 697 (bma->cur ? bma->cur->bc_private.b.allocated : 0));
913 ep = xfs_iext_get_ext(ifp, *idx + 1); 698 ep = xfs_iext_get_ext(ifp, bma->idx + 1);
914 xfs_bmbt_set_startblock(ep, nullstartblock((int)temp)); 699 xfs_bmbt_set_startblock(ep, nullstartblock(da_new));
915 trace_xfs_bmap_post_update(ip, *idx + 1, state, _THIS_IP_); 700 trace_xfs_bmap_post_update(bma->ip, bma->idx + 1, state, _THIS_IP_);
916
917 *dnew = temp;
918 break; 701 break;
919 702
920 case BMAP_RIGHT_FILLING | BMAP_RIGHT_CONTIG: 703 case BMAP_RIGHT_FILLING | BMAP_RIGHT_CONTIG:
@@ -923,38 +706,39 @@ xfs_bmap_add_extent_delay_real(
923 * The right neighbor is contiguous with the new allocation. 706 * The right neighbor is contiguous with the new allocation.
924 */ 707 */
925 temp = PREV.br_blockcount - new->br_blockcount; 708 temp = PREV.br_blockcount - new->br_blockcount;
926 trace_xfs_bmap_pre_update(ip, *idx + 1, state, _THIS_IP_); 709 trace_xfs_bmap_pre_update(bma->ip, bma->idx + 1, state, _THIS_IP_);
927 xfs_bmbt_set_blockcount(ep, temp); 710 xfs_bmbt_set_blockcount(ep, temp);
928 xfs_bmbt_set_allf(xfs_iext_get_ext(ifp, *idx + 1), 711 xfs_bmbt_set_allf(xfs_iext_get_ext(ifp, bma->idx + 1),
929 new->br_startoff, new->br_startblock, 712 new->br_startoff, new->br_startblock,
930 new->br_blockcount + RIGHT.br_blockcount, 713 new->br_blockcount + RIGHT.br_blockcount,
931 RIGHT.br_state); 714 RIGHT.br_state);
932 trace_xfs_bmap_post_update(ip, *idx + 1, state, _THIS_IP_); 715 trace_xfs_bmap_post_update(bma->ip, bma->idx + 1, state, _THIS_IP_);
933 if (cur == NULL) 716 if (bma->cur == NULL)
934 rval = XFS_ILOG_DEXT; 717 rval = XFS_ILOG_DEXT;
935 else { 718 else {
936 rval = 0; 719 rval = 0;
937 if ((error = xfs_bmbt_lookup_eq(cur, RIGHT.br_startoff, 720 error = xfs_bmbt_lookup_eq(bma->cur, RIGHT.br_startoff,
938 RIGHT.br_startblock, 721 RIGHT.br_startblock,
939 RIGHT.br_blockcount, &i))) 722 RIGHT.br_blockcount, &i);
723 if (error)
940 goto done; 724 goto done;
941 XFS_WANT_CORRUPTED_GOTO(i == 1, done); 725 XFS_WANT_CORRUPTED_GOTO(i == 1, done);
942 if ((error = xfs_bmbt_update(cur, new->br_startoff, 726 error = xfs_bmbt_update(bma->cur, new->br_startoff,
943 new->br_startblock, 727 new->br_startblock,
944 new->br_blockcount + 728 new->br_blockcount +
945 RIGHT.br_blockcount, 729 RIGHT.br_blockcount,
946 RIGHT.br_state))) 730 RIGHT.br_state);
731 if (error)
947 goto done; 732 goto done;
948 } 733 }
949 734
950 temp = XFS_FILBLKS_MIN(xfs_bmap_worst_indlen(ip, temp), 735 da_new = XFS_FILBLKS_MIN(xfs_bmap_worst_indlen(bma->ip, temp),
951 startblockval(PREV.br_startblock)); 736 startblockval(PREV.br_startblock));
952 trace_xfs_bmap_pre_update(ip, *idx, state, _THIS_IP_); 737 trace_xfs_bmap_pre_update(bma->ip, bma->idx, state, _THIS_IP_);
953 xfs_bmbt_set_startblock(ep, nullstartblock((int)temp)); 738 xfs_bmbt_set_startblock(ep, nullstartblock(da_new));
954 trace_xfs_bmap_post_update(ip, *idx, state, _THIS_IP_); 739 trace_xfs_bmap_post_update(bma->ip, bma->idx, state, _THIS_IP_);
955 740
956 ++*idx; 741 bma->idx++;
957 *dnew = temp;
958 break; 742 break;
959 743
960 case BMAP_RIGHT_FILLING: 744 case BMAP_RIGHT_FILLING:
@@ -963,42 +747,43 @@ xfs_bmap_add_extent_delay_real(
963 * The right neighbor is not contiguous. 747 * The right neighbor is not contiguous.
964 */ 748 */
965 temp = PREV.br_blockcount - new->br_blockcount; 749 temp = PREV.br_blockcount - new->br_blockcount;
966 trace_xfs_bmap_pre_update(ip, *idx, state, _THIS_IP_); 750 trace_xfs_bmap_pre_update(bma->ip, bma->idx, state, _THIS_IP_);
967 xfs_bmbt_set_blockcount(ep, temp); 751 xfs_bmbt_set_blockcount(ep, temp);
968 xfs_iext_insert(ip, *idx + 1, 1, new, state); 752 xfs_iext_insert(bma->ip, bma->idx + 1, 1, new, state);
969 ip->i_d.di_nextents++; 753 bma->ip->i_d.di_nextents++;
970 if (cur == NULL) 754 if (bma->cur == NULL)
971 rval = XFS_ILOG_CORE | XFS_ILOG_DEXT; 755 rval = XFS_ILOG_CORE | XFS_ILOG_DEXT;
972 else { 756 else {
973 rval = XFS_ILOG_CORE; 757 rval = XFS_ILOG_CORE;
974 if ((error = xfs_bmbt_lookup_eq(cur, new->br_startoff, 758 error = xfs_bmbt_lookup_eq(bma->cur, new->br_startoff,
975 new->br_startblock, new->br_blockcount, 759 new->br_startblock, new->br_blockcount,
976 &i))) 760 &i);
761 if (error)
977 goto done; 762 goto done;
978 XFS_WANT_CORRUPTED_GOTO(i == 0, done); 763 XFS_WANT_CORRUPTED_GOTO(i == 0, done);
979 cur->bc_rec.b.br_state = XFS_EXT_NORM; 764 bma->cur->bc_rec.b.br_state = XFS_EXT_NORM;
980 if ((error = xfs_btree_insert(cur, &i))) 765 error = xfs_btree_insert(bma->cur, &i);
766 if (error)
981 goto done; 767 goto done;
982 XFS_WANT_CORRUPTED_GOTO(i == 1, done); 768 XFS_WANT_CORRUPTED_GOTO(i == 1, done);
983 } 769 }
984 if (ip->i_d.di_format == XFS_DINODE_FMT_EXTENTS && 770 if (bma->ip->i_d.di_format == XFS_DINODE_FMT_EXTENTS &&
985 ip->i_d.di_nextents > ip->i_df.if_ext_max) { 771 bma->ip->i_d.di_nextents > bma->ip->i_df.if_ext_max) {
986 error = xfs_bmap_extents_to_btree(tp, ip, 772 error = xfs_bmap_extents_to_btree(bma->tp, bma->ip,
987 first, flist, &cur, 1, &tmp_rval, 773 bma->firstblock, bma->flist, &bma->cur, 1,
988 XFS_DATA_FORK); 774 &tmp_rval, XFS_DATA_FORK);
989 rval |= tmp_rval; 775 rval |= tmp_rval;
990 if (error) 776 if (error)
991 goto done; 777 goto done;
992 } 778 }
993 temp = XFS_FILBLKS_MIN(xfs_bmap_worst_indlen(ip, temp), 779 da_new = XFS_FILBLKS_MIN(xfs_bmap_worst_indlen(bma->ip, temp),
994 startblockval(PREV.br_startblock) - 780 startblockval(PREV.br_startblock) -
995 (cur ? cur->bc_private.b.allocated : 0)); 781 (bma->cur ? bma->cur->bc_private.b.allocated : 0));
996 ep = xfs_iext_get_ext(ifp, *idx); 782 ep = xfs_iext_get_ext(ifp, bma->idx);
997 xfs_bmbt_set_startblock(ep, nullstartblock((int)temp)); 783 xfs_bmbt_set_startblock(ep, nullstartblock(da_new));
998 trace_xfs_bmap_post_update(ip, *idx, state, _THIS_IP_); 784 trace_xfs_bmap_post_update(bma->ip, bma->idx, state, _THIS_IP_);
999 785
1000 ++*idx; 786 bma->idx++;
1001 *dnew = temp;
1002 break; 787 break;
1003 788
1004 case 0: 789 case 0:
@@ -1024,82 +809,65 @@ xfs_bmap_add_extent_delay_real(
1024 */ 809 */
1025 temp = new->br_startoff - PREV.br_startoff; 810 temp = new->br_startoff - PREV.br_startoff;
1026 temp2 = PREV.br_startoff + PREV.br_blockcount - new_endoff; 811 temp2 = PREV.br_startoff + PREV.br_blockcount - new_endoff;
1027 trace_xfs_bmap_pre_update(ip, *idx, 0, _THIS_IP_); 812 trace_xfs_bmap_pre_update(bma->ip, bma->idx, 0, _THIS_IP_);
1028 xfs_bmbt_set_blockcount(ep, temp); /* truncate PREV */ 813 xfs_bmbt_set_blockcount(ep, temp); /* truncate PREV */
1029 LEFT = *new; 814 LEFT = *new;
1030 RIGHT.br_state = PREV.br_state; 815 RIGHT.br_state = PREV.br_state;
1031 RIGHT.br_startblock = nullstartblock( 816 RIGHT.br_startblock = nullstartblock(
1032 (int)xfs_bmap_worst_indlen(ip, temp2)); 817 (int)xfs_bmap_worst_indlen(bma->ip, temp2));
1033 RIGHT.br_startoff = new_endoff; 818 RIGHT.br_startoff = new_endoff;
1034 RIGHT.br_blockcount = temp2; 819 RIGHT.br_blockcount = temp2;
1035 /* insert LEFT (r[0]) and RIGHT (r[1]) at the same time */ 820 /* insert LEFT (r[0]) and RIGHT (r[1]) at the same time */
1036 xfs_iext_insert(ip, *idx + 1, 2, &LEFT, state); 821 xfs_iext_insert(bma->ip, bma->idx + 1, 2, &LEFT, state);
1037 ip->i_d.di_nextents++; 822 bma->ip->i_d.di_nextents++;
1038 if (cur == NULL) 823 if (bma->cur == NULL)
1039 rval = XFS_ILOG_CORE | XFS_ILOG_DEXT; 824 rval = XFS_ILOG_CORE | XFS_ILOG_DEXT;
1040 else { 825 else {
1041 rval = XFS_ILOG_CORE; 826 rval = XFS_ILOG_CORE;
1042 if ((error = xfs_bmbt_lookup_eq(cur, new->br_startoff, 827 error = xfs_bmbt_lookup_eq(bma->cur, new->br_startoff,
1043 new->br_startblock, new->br_blockcount, 828 new->br_startblock, new->br_blockcount,
1044 &i))) 829 &i);
830 if (error)
1045 goto done; 831 goto done;
1046 XFS_WANT_CORRUPTED_GOTO(i == 0, done); 832 XFS_WANT_CORRUPTED_GOTO(i == 0, done);
1047 cur->bc_rec.b.br_state = XFS_EXT_NORM; 833 bma->cur->bc_rec.b.br_state = XFS_EXT_NORM;
1048 if ((error = xfs_btree_insert(cur, &i))) 834 error = xfs_btree_insert(bma->cur, &i);
835 if (error)
1049 goto done; 836 goto done;
1050 XFS_WANT_CORRUPTED_GOTO(i == 1, done); 837 XFS_WANT_CORRUPTED_GOTO(i == 1, done);
1051 } 838 }
1052 if (ip->i_d.di_format == XFS_DINODE_FMT_EXTENTS && 839 if (bma->ip->i_d.di_format == XFS_DINODE_FMT_EXTENTS &&
1053 ip->i_d.di_nextents > ip->i_df.if_ext_max) { 840 bma->ip->i_d.di_nextents > bma->ip->i_df.if_ext_max) {
1054 error = xfs_bmap_extents_to_btree(tp, ip, 841 error = xfs_bmap_extents_to_btree(bma->tp, bma->ip,
1055 first, flist, &cur, 1, &tmp_rval, 842 bma->firstblock, bma->flist, &bma->cur,
1056 XFS_DATA_FORK); 843 1, &tmp_rval, XFS_DATA_FORK);
1057 rval |= tmp_rval; 844 rval |= tmp_rval;
1058 if (error) 845 if (error)
1059 goto done; 846 goto done;
1060 } 847 }
1061 temp = xfs_bmap_worst_indlen(ip, temp); 848 temp = xfs_bmap_worst_indlen(bma->ip, temp);
1062 temp2 = xfs_bmap_worst_indlen(ip, temp2); 849 temp2 = xfs_bmap_worst_indlen(bma->ip, temp2);
1063 diff = (int)(temp + temp2 - startblockval(PREV.br_startblock) - 850 diff = (int)(temp + temp2 - startblockval(PREV.br_startblock) -
1064 (cur ? cur->bc_private.b.allocated : 0)); 851 (bma->cur ? bma->cur->bc_private.b.allocated : 0));
1065 if (diff > 0 && 852 if (diff > 0) {
1066 xfs_icsb_modify_counters(ip->i_mount, XFS_SBS_FDBLOCKS, 853 error = xfs_icsb_modify_counters(bma->ip->i_mount,
1067 -((int64_t)diff), 0)) { 854 XFS_SBS_FDBLOCKS,
1068 /* 855 -((int64_t)diff), 0);
1069 * Ick gross gag me with a spoon. 856 ASSERT(!error);
1070 */ 857 if (error)
1071 ASSERT(0); /* want to see if this ever happens! */ 858 goto done;
1072 while (diff > 0) {
1073 if (temp) {
1074 temp--;
1075 diff--;
1076 if (!diff ||
1077 !xfs_icsb_modify_counters(ip->i_mount,
1078 XFS_SBS_FDBLOCKS,
1079 -((int64_t)diff), 0))
1080 break;
1081 }
1082 if (temp2) {
1083 temp2--;
1084 diff--;
1085 if (!diff ||
1086 !xfs_icsb_modify_counters(ip->i_mount,
1087 XFS_SBS_FDBLOCKS,
1088 -((int64_t)diff), 0))
1089 break;
1090 }
1091 }
1092 } 859 }
1093 ep = xfs_iext_get_ext(ifp, *idx); 860
861 ep = xfs_iext_get_ext(ifp, bma->idx);
1094 xfs_bmbt_set_startblock(ep, nullstartblock((int)temp)); 862 xfs_bmbt_set_startblock(ep, nullstartblock((int)temp));
1095 trace_xfs_bmap_post_update(ip, *idx, state, _THIS_IP_); 863 trace_xfs_bmap_post_update(bma->ip, bma->idx, state, _THIS_IP_);
1096 trace_xfs_bmap_pre_update(ip, *idx + 2, state, _THIS_IP_); 864 trace_xfs_bmap_pre_update(bma->ip, bma->idx + 2, state, _THIS_IP_);
1097 xfs_bmbt_set_startblock(xfs_iext_get_ext(ifp, *idx + 2), 865 xfs_bmbt_set_startblock(xfs_iext_get_ext(ifp, bma->idx + 2),
1098 nullstartblock((int)temp2)); 866 nullstartblock((int)temp2));
1099 trace_xfs_bmap_post_update(ip, *idx + 2, state, _THIS_IP_); 867 trace_xfs_bmap_post_update(bma->ip, bma->idx + 2, state, _THIS_IP_);
1100 868
1101 ++*idx; 869 bma->idx++;
1102 *dnew = temp + temp2; 870 da_new = temp + temp2;
1103 break; 871 break;
1104 872
1105 case BMAP_LEFT_FILLING | BMAP_LEFT_CONTIG | BMAP_RIGHT_CONTIG: 873 case BMAP_LEFT_FILLING | BMAP_LEFT_CONTIG | BMAP_RIGHT_CONTIG:
@@ -1114,9 +882,40 @@ xfs_bmap_add_extent_delay_real(
1114 */ 882 */
1115 ASSERT(0); 883 ASSERT(0);
1116 } 884 }
1117 *curp = cur; 885
886 /* convert to a btree if necessary */
887 if (XFS_IFORK_FORMAT(bma->ip, XFS_DATA_FORK) == XFS_DINODE_FMT_EXTENTS &&
888 XFS_IFORK_NEXTENTS(bma->ip, XFS_DATA_FORK) > ifp->if_ext_max) {
889 int tmp_logflags; /* partial log flag return val */
890
891 ASSERT(bma->cur == NULL);
892 error = xfs_bmap_extents_to_btree(bma->tp, bma->ip,
893 bma->firstblock, bma->flist, &bma->cur,
894 da_old > 0, &tmp_logflags, XFS_DATA_FORK);
895 bma->logflags |= tmp_logflags;
896 if (error)
897 goto done;
898 }
899
900 /* adjust for changes in reserved delayed indirect blocks */
901 if (da_old || da_new) {
902 temp = da_new;
903 if (bma->cur)
904 temp += bma->cur->bc_private.b.allocated;
905 ASSERT(temp <= da_old);
906 if (temp < da_old)
907 xfs_icsb_modify_counters(bma->ip->i_mount,
908 XFS_SBS_FDBLOCKS,
909 (int64_t)(da_old - temp), 0);
910 }
911
912 /* clear out the allocated field, done with it now in any case. */
913 if (bma->cur)
914 bma->cur->bc_private.b.allocated = 0;
915
916 xfs_bmap_check_leaf_extents(bma->cur, bma->ip, XFS_DATA_FORK);
1118done: 917done:
1119 *logflagsp = rval; 918 bma->logflags |= rval;
1120 return error; 919 return error;
1121#undef LEFT 920#undef LEFT
1122#undef RIGHT 921#undef RIGHT
@@ -1124,15 +923,17 @@ done:
1124} 923}
1125 924
1126/* 925/*
1127 * Called by xfs_bmap_add_extent to handle cases converting an unwritten 926 * Convert an unwritten allocation to a real allocation or vice versa.
1128 * allocation to a real allocation or vice versa.
1129 */ 927 */
1130STATIC int /* error */ 928STATIC int /* error */
1131xfs_bmap_add_extent_unwritten_real( 929xfs_bmap_add_extent_unwritten_real(
930 struct xfs_trans *tp,
1132 xfs_inode_t *ip, /* incore inode pointer */ 931 xfs_inode_t *ip, /* incore inode pointer */
1133 xfs_extnum_t *idx, /* extent number to update/insert */ 932 xfs_extnum_t *idx, /* extent number to update/insert */
1134 xfs_btree_cur_t **curp, /* if *curp is null, not a btree */ 933 xfs_btree_cur_t **curp, /* if *curp is null, not a btree */
1135 xfs_bmbt_irec_t *new, /* new data to add to file extents */ 934 xfs_bmbt_irec_t *new, /* new data to add to file extents */
935 xfs_fsblock_t *first, /* pointer to firstblock variable */
936 xfs_bmap_free_t *flist, /* list of extents to be freed */
1136 int *logflagsp) /* inode logging flags */ 937 int *logflagsp) /* inode logging flags */
1137{ 938{
1138 xfs_btree_cur_t *cur; /* btree cursor */ 939 xfs_btree_cur_t *cur; /* btree cursor */
@@ -1148,15 +949,25 @@ xfs_bmap_add_extent_unwritten_real(
1148 int rval=0; /* return value (logging flags) */ 949 int rval=0; /* return value (logging flags) */
1149 int state = 0;/* state bits, accessed thru macros */ 950 int state = 0;/* state bits, accessed thru macros */
1150 951
952 *logflagsp = 0;
953
954 cur = *curp;
955 ifp = XFS_IFORK_PTR(ip, XFS_DATA_FORK);
956
957 ASSERT(*idx >= 0);
958 ASSERT(*idx <= ifp->if_bytes / sizeof(struct xfs_bmbt_rec));
959 ASSERT(!isnullstartblock(new->br_startblock));
960
961 XFS_STATS_INC(xs_add_exlist);
962
1151#define LEFT r[0] 963#define LEFT r[0]
1152#define RIGHT r[1] 964#define RIGHT r[1]
1153#define PREV r[2] 965#define PREV r[2]
966
1154 /* 967 /*
1155 * Set up a bunch of variables to make the tests simpler. 968 * Set up a bunch of variables to make the tests simpler.
1156 */ 969 */
1157 error = 0; 970 error = 0;
1158 cur = *curp;
1159 ifp = XFS_IFORK_PTR(ip, XFS_DATA_FORK);
1160 ep = xfs_iext_get_ext(ifp, *idx); 971 ep = xfs_iext_get_ext(ifp, *idx);
1161 xfs_bmbt_get_all(ep, &PREV); 972 xfs_bmbt_get_all(ep, &PREV);
1162 newext = new->br_state; 973 newext = new->br_state;
@@ -1406,10 +1217,11 @@ xfs_bmap_add_extent_unwritten_real(
1406 goto done; 1217 goto done;
1407 if ((error = xfs_btree_decrement(cur, 0, &i))) 1218 if ((error = xfs_btree_decrement(cur, 0, &i)))
1408 goto done; 1219 goto done;
1409 if (xfs_bmbt_update(cur, LEFT.br_startoff, 1220 error = xfs_bmbt_update(cur, LEFT.br_startoff,
1410 LEFT.br_startblock, 1221 LEFT.br_startblock,
1411 LEFT.br_blockcount + new->br_blockcount, 1222 LEFT.br_blockcount + new->br_blockcount,
1412 LEFT.br_state)) 1223 LEFT.br_state);
1224 if (error)
1413 goto done; 1225 goto done;
1414 } 1226 }
1415 break; 1227 break;
@@ -1607,9 +1419,29 @@ xfs_bmap_add_extent_unwritten_real(
1607 */ 1419 */
1608 ASSERT(0); 1420 ASSERT(0);
1609 } 1421 }
1610 *curp = cur; 1422
1423 /* convert to a btree if necessary */
1424 if (XFS_IFORK_FORMAT(ip, XFS_DATA_FORK) == XFS_DINODE_FMT_EXTENTS &&
1425 XFS_IFORK_NEXTENTS(ip, XFS_DATA_FORK) > ifp->if_ext_max) {
1426 int tmp_logflags; /* partial log flag return val */
1427
1428 ASSERT(cur == NULL);
1429 error = xfs_bmap_extents_to_btree(tp, ip, first, flist, &cur,
1430 0, &tmp_logflags, XFS_DATA_FORK);
1431 *logflagsp |= tmp_logflags;
1432 if (error)
1433 goto done;
1434 }
1435
1436 /* clear out the allocated field, done with it now in any case. */
1437 if (cur) {
1438 cur->bc_private.b.allocated = 0;
1439 *curp = cur;
1440 }
1441
1442 xfs_bmap_check_leaf_extents(*curp, ip, XFS_DATA_FORK);
1611done: 1443done:
1612 *logflagsp = rval; 1444 *logflagsp |= rval;
1613 return error; 1445 return error;
1614#undef LEFT 1446#undef LEFT
1615#undef RIGHT 1447#undef RIGHT
@@ -1617,16 +1449,13 @@ done:
1617} 1449}
1618 1450
1619/* 1451/*
1620 * Called by xfs_bmap_add_extent to handle cases converting a hole 1452 * Convert a hole to a delayed allocation.
1621 * to a delayed allocation.
1622 */ 1453 */
1623/*ARGSUSED*/ 1454STATIC void
1624STATIC int /* error */
1625xfs_bmap_add_extent_hole_delay( 1455xfs_bmap_add_extent_hole_delay(
1626 xfs_inode_t *ip, /* incore inode pointer */ 1456 xfs_inode_t *ip, /* incore inode pointer */
1627 xfs_extnum_t *idx, /* extent number to update/insert */ 1457 xfs_extnum_t *idx, /* extent number to update/insert */
1628 xfs_bmbt_irec_t *new, /* new data to add to file extents */ 1458 xfs_bmbt_irec_t *new) /* new data to add to file extents */
1629 int *logflagsp) /* inode logging flags */
1630{ 1459{
1631 xfs_ifork_t *ifp; /* inode fork pointer */ 1460 xfs_ifork_t *ifp; /* inode fork pointer */
1632 xfs_bmbt_irec_t left; /* left neighbor extent entry */ 1461 xfs_bmbt_irec_t left; /* left neighbor extent entry */
@@ -1761,23 +1590,17 @@ xfs_bmap_add_extent_hole_delay(
1761 * Nothing to do for disk quota accounting here. 1590 * Nothing to do for disk quota accounting here.
1762 */ 1591 */
1763 } 1592 }
1764 *logflagsp = 0;
1765 return 0;
1766} 1593}
1767 1594
1768/* 1595/*
1769 * Called by xfs_bmap_add_extent to handle cases converting a hole 1596 * Convert a hole to a real allocation.
1770 * to a real allocation.
1771 */ 1597 */
1772STATIC int /* error */ 1598STATIC int /* error */
1773xfs_bmap_add_extent_hole_real( 1599xfs_bmap_add_extent_hole_real(
1774 xfs_inode_t *ip, /* incore inode pointer */ 1600 struct xfs_bmalloca *bma,
1775 xfs_extnum_t *idx, /* extent number to update/insert */ 1601 int whichfork)
1776 xfs_btree_cur_t *cur, /* if null, not a btree */
1777 xfs_bmbt_irec_t *new, /* new data to add to file extents */
1778 int *logflagsp, /* inode logging flags */
1779 int whichfork) /* data or attr fork */
1780{ 1602{
1603 struct xfs_bmbt_irec *new = &bma->got;
1781 int error; /* error return value */ 1604 int error; /* error return value */
1782 int i; /* temp state */ 1605 int i; /* temp state */
1783 xfs_ifork_t *ifp; /* inode fork pointer */ 1606 xfs_ifork_t *ifp; /* inode fork pointer */
@@ -1786,19 +1609,26 @@ xfs_bmap_add_extent_hole_real(
1786 int rval=0; /* return value (logging flags) */ 1609 int rval=0; /* return value (logging flags) */
1787 int state; /* state bits, accessed thru macros */ 1610 int state; /* state bits, accessed thru macros */
1788 1611
1789 ifp = XFS_IFORK_PTR(ip, whichfork); 1612 ifp = XFS_IFORK_PTR(bma->ip, whichfork);
1790 ASSERT(*idx <= ifp->if_bytes / (uint)sizeof(xfs_bmbt_rec_t)); 1613
1791 state = 0; 1614 ASSERT(bma->idx >= 0);
1615 ASSERT(bma->idx <= ifp->if_bytes / sizeof(struct xfs_bmbt_rec));
1616 ASSERT(!isnullstartblock(new->br_startblock));
1617 ASSERT(!bma->cur ||
1618 !(bma->cur->bc_private.b.flags & XFS_BTCUR_BPRV_WASDEL));
1619
1620 XFS_STATS_INC(xs_add_exlist);
1792 1621
1622 state = 0;
1793 if (whichfork == XFS_ATTR_FORK) 1623 if (whichfork == XFS_ATTR_FORK)
1794 state |= BMAP_ATTRFORK; 1624 state |= BMAP_ATTRFORK;
1795 1625
1796 /* 1626 /*
1797 * Check and set flags if this segment has a left neighbor. 1627 * Check and set flags if this segment has a left neighbor.
1798 */ 1628 */
1799 if (*idx > 0) { 1629 if (bma->idx > 0) {
1800 state |= BMAP_LEFT_VALID; 1630 state |= BMAP_LEFT_VALID;
1801 xfs_bmbt_get_all(xfs_iext_get_ext(ifp, *idx - 1), &left); 1631 xfs_bmbt_get_all(xfs_iext_get_ext(ifp, bma->idx - 1), &left);
1802 if (isnullstartblock(left.br_startblock)) 1632 if (isnullstartblock(left.br_startblock))
1803 state |= BMAP_LEFT_DELAY; 1633 state |= BMAP_LEFT_DELAY;
1804 } 1634 }
@@ -1807,9 +1637,9 @@ xfs_bmap_add_extent_hole_real(
1807 * Check and set flags if this segment has a current value. 1637 * Check and set flags if this segment has a current value.
1808 * Not true if we're inserting into the "hole" at eof. 1638 * Not true if we're inserting into the "hole" at eof.
1809 */ 1639 */
1810 if (*idx < ifp->if_bytes / (uint)sizeof(xfs_bmbt_rec_t)) { 1640 if (bma->idx < ifp->if_bytes / (uint)sizeof(xfs_bmbt_rec_t)) {
1811 state |= BMAP_RIGHT_VALID; 1641 state |= BMAP_RIGHT_VALID;
1812 xfs_bmbt_get_all(xfs_iext_get_ext(ifp, *idx), &right); 1642 xfs_bmbt_get_all(xfs_iext_get_ext(ifp, bma->idx), &right);
1813 if (isnullstartblock(right.br_startblock)) 1643 if (isnullstartblock(right.br_startblock))
1814 state |= BMAP_RIGHT_DELAY; 1644 state |= BMAP_RIGHT_DELAY;
1815 } 1645 }
@@ -1846,39 +1676,42 @@ xfs_bmap_add_extent_hole_real(
1846 * left and on the right. 1676 * left and on the right.
1847 * Merge all three into a single extent record. 1677 * Merge all three into a single extent record.
1848 */ 1678 */
1849 --*idx; 1679 --bma->idx;
1850 trace_xfs_bmap_pre_update(ip, *idx, state, _THIS_IP_); 1680 trace_xfs_bmap_pre_update(bma->ip, bma->idx, state, _THIS_IP_);
1851 xfs_bmbt_set_blockcount(xfs_iext_get_ext(ifp, *idx), 1681 xfs_bmbt_set_blockcount(xfs_iext_get_ext(ifp, bma->idx),
1852 left.br_blockcount + new->br_blockcount + 1682 left.br_blockcount + new->br_blockcount +
1853 right.br_blockcount); 1683 right.br_blockcount);
1854 trace_xfs_bmap_post_update(ip, *idx, state, _THIS_IP_); 1684 trace_xfs_bmap_post_update(bma->ip, bma->idx, state, _THIS_IP_);
1855 1685
1856 xfs_iext_remove(ip, *idx + 1, 1, state); 1686 xfs_iext_remove(bma->ip, bma->idx + 1, 1, state);
1857 1687
1858 XFS_IFORK_NEXT_SET(ip, whichfork, 1688 XFS_IFORK_NEXT_SET(bma->ip, whichfork,
1859 XFS_IFORK_NEXTENTS(ip, whichfork) - 1); 1689 XFS_IFORK_NEXTENTS(bma->ip, whichfork) - 1);
1860 if (cur == NULL) { 1690 if (bma->cur == NULL) {
1861 rval = XFS_ILOG_CORE | xfs_ilog_fext(whichfork); 1691 rval = XFS_ILOG_CORE | xfs_ilog_fext(whichfork);
1862 } else { 1692 } else {
1863 rval = XFS_ILOG_CORE; 1693 rval = XFS_ILOG_CORE;
1864 if ((error = xfs_bmbt_lookup_eq(cur, 1694 error = xfs_bmbt_lookup_eq(bma->cur, right.br_startoff,
1865 right.br_startoff, 1695 right.br_startblock, right.br_blockcount,
1866 right.br_startblock, 1696 &i);
1867 right.br_blockcount, &i))) 1697 if (error)
1868 goto done; 1698 goto done;
1869 XFS_WANT_CORRUPTED_GOTO(i == 1, done); 1699 XFS_WANT_CORRUPTED_GOTO(i == 1, done);
1870 if ((error = xfs_btree_delete(cur, &i))) 1700 error = xfs_btree_delete(bma->cur, &i);
1701 if (error)
1871 goto done; 1702 goto done;
1872 XFS_WANT_CORRUPTED_GOTO(i == 1, done); 1703 XFS_WANT_CORRUPTED_GOTO(i == 1, done);
1873 if ((error = xfs_btree_decrement(cur, 0, &i))) 1704 error = xfs_btree_decrement(bma->cur, 0, &i);
1705 if (error)
1874 goto done; 1706 goto done;
1875 XFS_WANT_CORRUPTED_GOTO(i == 1, done); 1707 XFS_WANT_CORRUPTED_GOTO(i == 1, done);
1876 if ((error = xfs_bmbt_update(cur, left.br_startoff, 1708 error = xfs_bmbt_update(bma->cur, left.br_startoff,
1877 left.br_startblock, 1709 left.br_startblock,
1878 left.br_blockcount + 1710 left.br_blockcount +
1879 new->br_blockcount + 1711 new->br_blockcount +
1880 right.br_blockcount, 1712 right.br_blockcount,
1881 left.br_state))) 1713 left.br_state);
1714 if (error)
1882 goto done; 1715 goto done;
1883 } 1716 }
1884 break; 1717 break;
@@ -1889,27 +1722,28 @@ xfs_bmap_add_extent_hole_real(
1889 * on the left. 1722 * on the left.
1890 * Merge the new allocation with the left neighbor. 1723 * Merge the new allocation with the left neighbor.
1891 */ 1724 */
1892 --*idx; 1725 --bma->idx;
1893 trace_xfs_bmap_pre_update(ip, *idx, state, _THIS_IP_); 1726 trace_xfs_bmap_pre_update(bma->ip, bma->idx, state, _THIS_IP_);
1894 xfs_bmbt_set_blockcount(xfs_iext_get_ext(ifp, *idx), 1727 xfs_bmbt_set_blockcount(xfs_iext_get_ext(ifp, bma->idx),
1895 left.br_blockcount + new->br_blockcount); 1728 left.br_blockcount + new->br_blockcount);
1896 trace_xfs_bmap_post_update(ip, *idx, state, _THIS_IP_); 1729 trace_xfs_bmap_post_update(bma->ip, bma->idx, state, _THIS_IP_);
1897 1730
1898 if (cur == NULL) { 1731 if (bma->cur == NULL) {
1899 rval = xfs_ilog_fext(whichfork); 1732 rval = xfs_ilog_fext(whichfork);
1900 } else { 1733 } else {
1901 rval = 0; 1734 rval = 0;
1902 if ((error = xfs_bmbt_lookup_eq(cur, 1735 error = xfs_bmbt_lookup_eq(bma->cur, left.br_startoff,
1903 left.br_startoff, 1736 left.br_startblock, left.br_blockcount,
1904 left.br_startblock, 1737 &i);
1905 left.br_blockcount, &i))) 1738 if (error)
1906 goto done; 1739 goto done;
1907 XFS_WANT_CORRUPTED_GOTO(i == 1, done); 1740 XFS_WANT_CORRUPTED_GOTO(i == 1, done);
1908 if ((error = xfs_bmbt_update(cur, left.br_startoff, 1741 error = xfs_bmbt_update(bma->cur, left.br_startoff,
1909 left.br_startblock, 1742 left.br_startblock,
1910 left.br_blockcount + 1743 left.br_blockcount +
1911 new->br_blockcount, 1744 new->br_blockcount,
1912 left.br_state))) 1745 left.br_state);
1746 if (error)
1913 goto done; 1747 goto done;
1914 } 1748 }
1915 break; 1749 break;
@@ -1920,28 +1754,30 @@ xfs_bmap_add_extent_hole_real(
1920 * on the right. 1754 * on the right.
1921 * Merge the new allocation with the right neighbor. 1755 * Merge the new allocation with the right neighbor.
1922 */ 1756 */
1923 trace_xfs_bmap_pre_update(ip, *idx, state, _THIS_IP_); 1757 trace_xfs_bmap_pre_update(bma->ip, bma->idx, state, _THIS_IP_);
1924 xfs_bmbt_set_allf(xfs_iext_get_ext(ifp, *idx), 1758 xfs_bmbt_set_allf(xfs_iext_get_ext(ifp, bma->idx),
1925 new->br_startoff, new->br_startblock, 1759 new->br_startoff, new->br_startblock,
1926 new->br_blockcount + right.br_blockcount, 1760 new->br_blockcount + right.br_blockcount,
1927 right.br_state); 1761 right.br_state);
1928 trace_xfs_bmap_post_update(ip, *idx, state, _THIS_IP_); 1762 trace_xfs_bmap_post_update(bma->ip, bma->idx, state, _THIS_IP_);
1929 1763
1930 if (cur == NULL) { 1764 if (bma->cur == NULL) {
1931 rval = xfs_ilog_fext(whichfork); 1765 rval = xfs_ilog_fext(whichfork);
1932 } else { 1766 } else {
1933 rval = 0; 1767 rval = 0;
1934 if ((error = xfs_bmbt_lookup_eq(cur, 1768 error = xfs_bmbt_lookup_eq(bma->cur,
1935 right.br_startoff, 1769 right.br_startoff,
1936 right.br_startblock, 1770 right.br_startblock,
1937 right.br_blockcount, &i))) 1771 right.br_blockcount, &i);
1772 if (error)
1938 goto done; 1773 goto done;
1939 XFS_WANT_CORRUPTED_GOTO(i == 1, done); 1774 XFS_WANT_CORRUPTED_GOTO(i == 1, done);
1940 if ((error = xfs_bmbt_update(cur, new->br_startoff, 1775 error = xfs_bmbt_update(bma->cur, new->br_startoff,
1941 new->br_startblock, 1776 new->br_startblock,
1942 new->br_blockcount + 1777 new->br_blockcount +
1943 right.br_blockcount, 1778 right.br_blockcount,
1944 right.br_state))) 1779 right.br_state);
1780 if (error)
1945 goto done; 1781 goto done;
1946 } 1782 }
1947 break; 1783 break;
@@ -1952,28 +1788,50 @@ xfs_bmap_add_extent_hole_real(
1952 * real allocation. 1788 * real allocation.
1953 * Insert a new entry. 1789 * Insert a new entry.
1954 */ 1790 */
1955 xfs_iext_insert(ip, *idx, 1, new, state); 1791 xfs_iext_insert(bma->ip, bma->idx, 1, new, state);
1956 XFS_IFORK_NEXT_SET(ip, whichfork, 1792 XFS_IFORK_NEXT_SET(bma->ip, whichfork,
1957 XFS_IFORK_NEXTENTS(ip, whichfork) + 1); 1793 XFS_IFORK_NEXTENTS(bma->ip, whichfork) + 1);
1958 if (cur == NULL) { 1794 if (bma->cur == NULL) {
1959 rval = XFS_ILOG_CORE | xfs_ilog_fext(whichfork); 1795 rval = XFS_ILOG_CORE | xfs_ilog_fext(whichfork);
1960 } else { 1796 } else {
1961 rval = XFS_ILOG_CORE; 1797 rval = XFS_ILOG_CORE;
1962 if ((error = xfs_bmbt_lookup_eq(cur, 1798 error = xfs_bmbt_lookup_eq(bma->cur,
1963 new->br_startoff, 1799 new->br_startoff,
1964 new->br_startblock, 1800 new->br_startblock,
1965 new->br_blockcount, &i))) 1801 new->br_blockcount, &i);
1802 if (error)
1966 goto done; 1803 goto done;
1967 XFS_WANT_CORRUPTED_GOTO(i == 0, done); 1804 XFS_WANT_CORRUPTED_GOTO(i == 0, done);
1968 cur->bc_rec.b.br_state = new->br_state; 1805 bma->cur->bc_rec.b.br_state = new->br_state;
1969 if ((error = xfs_btree_insert(cur, &i))) 1806 error = xfs_btree_insert(bma->cur, &i);
1807 if (error)
1970 goto done; 1808 goto done;
1971 XFS_WANT_CORRUPTED_GOTO(i == 1, done); 1809 XFS_WANT_CORRUPTED_GOTO(i == 1, done);
1972 } 1810 }
1973 break; 1811 break;
1974 } 1812 }
1813
1814 /* convert to a btree if necessary */
1815 if (XFS_IFORK_FORMAT(bma->ip, whichfork) == XFS_DINODE_FMT_EXTENTS &&
1816 XFS_IFORK_NEXTENTS(bma->ip, whichfork) > ifp->if_ext_max) {
1817 int tmp_logflags; /* partial log flag return val */
1818
1819 ASSERT(bma->cur == NULL);
1820 error = xfs_bmap_extents_to_btree(bma->tp, bma->ip,
1821 bma->firstblock, bma->flist, &bma->cur,
1822 0, &tmp_logflags, whichfork);
1823 bma->logflags |= tmp_logflags;
1824 if (error)
1825 goto done;
1826 }
1827
1828 /* clear out the allocated field, done with it now in any case. */
1829 if (bma->cur)
1830 bma->cur->bc_private.b.allocated = 0;
1831
1832 xfs_bmap_check_leaf_extents(bma->cur, bma->ip, whichfork);
1975done: 1833done:
1976 *logflagsp = rval; 1834 bma->logflags |= rval;
1977 return error; 1835 return error;
1978} 1836}
1979 1837
@@ -2160,26 +2018,26 @@ xfs_bmap_adjacent(
2160 XFS_FSB_TO_AGBNO(mp, x) < mp->m_sb.sb_agblocks) 2018 XFS_FSB_TO_AGBNO(mp, x) < mp->m_sb.sb_agblocks)
2161 2019
2162 mp = ap->ip->i_mount; 2020 mp = ap->ip->i_mount;
2163 nullfb = ap->firstblock == NULLFSBLOCK; 2021 nullfb = *ap->firstblock == NULLFSBLOCK;
2164 rt = XFS_IS_REALTIME_INODE(ap->ip) && ap->userdata; 2022 rt = XFS_IS_REALTIME_INODE(ap->ip) && ap->userdata;
2165 fb_agno = nullfb ? NULLAGNUMBER : XFS_FSB_TO_AGNO(mp, ap->firstblock); 2023 fb_agno = nullfb ? NULLAGNUMBER : XFS_FSB_TO_AGNO(mp, *ap->firstblock);
2166 /* 2024 /*
2167 * If allocating at eof, and there's a previous real block, 2025 * If allocating at eof, and there's a previous real block,
2168 * try to use its last block as our starting point. 2026 * try to use its last block as our starting point.
2169 */ 2027 */
2170 if (ap->eof && ap->prevp->br_startoff != NULLFILEOFF && 2028 if (ap->eof && ap->prev.br_startoff != NULLFILEOFF &&
2171 !isnullstartblock(ap->prevp->br_startblock) && 2029 !isnullstartblock(ap->prev.br_startblock) &&
2172 ISVALID(ap->prevp->br_startblock + ap->prevp->br_blockcount, 2030 ISVALID(ap->prev.br_startblock + ap->prev.br_blockcount,
2173 ap->prevp->br_startblock)) { 2031 ap->prev.br_startblock)) {
2174 ap->rval = ap->prevp->br_startblock + ap->prevp->br_blockcount; 2032 ap->blkno = ap->prev.br_startblock + ap->prev.br_blockcount;
2175 /* 2033 /*
2176 * Adjust for the gap between prevp and us. 2034 * Adjust for the gap between prevp and us.
2177 */ 2035 */
2178 adjust = ap->off - 2036 adjust = ap->offset -
2179 (ap->prevp->br_startoff + ap->prevp->br_blockcount); 2037 (ap->prev.br_startoff + ap->prev.br_blockcount);
2180 if (adjust && 2038 if (adjust &&
2181 ISVALID(ap->rval + adjust, ap->prevp->br_startblock)) 2039 ISVALID(ap->blkno + adjust, ap->prev.br_startblock))
2182 ap->rval += adjust; 2040 ap->blkno += adjust;
2183 } 2041 }
2184 /* 2042 /*
2185 * If not at eof, then compare the two neighbor blocks. 2043 * If not at eof, then compare the two neighbor blocks.
@@ -2196,17 +2054,17 @@ xfs_bmap_adjacent(
2196 * If there's a previous (left) block, select a requested 2054 * If there's a previous (left) block, select a requested
2197 * start block based on it. 2055 * start block based on it.
2198 */ 2056 */
2199 if (ap->prevp->br_startoff != NULLFILEOFF && 2057 if (ap->prev.br_startoff != NULLFILEOFF &&
2200 !isnullstartblock(ap->prevp->br_startblock) && 2058 !isnullstartblock(ap->prev.br_startblock) &&
2201 (prevbno = ap->prevp->br_startblock + 2059 (prevbno = ap->prev.br_startblock +
2202 ap->prevp->br_blockcount) && 2060 ap->prev.br_blockcount) &&
2203 ISVALID(prevbno, ap->prevp->br_startblock)) { 2061 ISVALID(prevbno, ap->prev.br_startblock)) {
2204 /* 2062 /*
2205 * Calculate gap to end of previous block. 2063 * Calculate gap to end of previous block.
2206 */ 2064 */
2207 adjust = prevdiff = ap->off - 2065 adjust = prevdiff = ap->offset -
2208 (ap->prevp->br_startoff + 2066 (ap->prev.br_startoff +
2209 ap->prevp->br_blockcount); 2067 ap->prev.br_blockcount);
2210 /* 2068 /*
2211 * Figure the startblock based on the previous block's 2069 * Figure the startblock based on the previous block's
2212 * end and the gap size. 2070 * end and the gap size.
@@ -2215,9 +2073,9 @@ xfs_bmap_adjacent(
2215 * allocating, or using it gives us an invalid block 2073 * allocating, or using it gives us an invalid block
2216 * number, then just use the end of the previous block. 2074 * number, then just use the end of the previous block.
2217 */ 2075 */
2218 if (prevdiff <= XFS_ALLOC_GAP_UNITS * ap->alen && 2076 if (prevdiff <= XFS_ALLOC_GAP_UNITS * ap->length &&
2219 ISVALID(prevbno + prevdiff, 2077 ISVALID(prevbno + prevdiff,
2220 ap->prevp->br_startblock)) 2078 ap->prev.br_startblock))
2221 prevbno += adjust; 2079 prevbno += adjust;
2222 else 2080 else
2223 prevdiff += adjust; 2081 prevdiff += adjust;
@@ -2238,16 +2096,16 @@ xfs_bmap_adjacent(
2238 * If there's a following (right) block, select a requested 2096 * If there's a following (right) block, select a requested
2239 * start block based on it. 2097 * start block based on it.
2240 */ 2098 */
2241 if (!isnullstartblock(ap->gotp->br_startblock)) { 2099 if (!isnullstartblock(ap->got.br_startblock)) {
2242 /* 2100 /*
2243 * Calculate gap to start of next block. 2101 * Calculate gap to start of next block.
2244 */ 2102 */
2245 adjust = gotdiff = ap->gotp->br_startoff - ap->off; 2103 adjust = gotdiff = ap->got.br_startoff - ap->offset;
2246 /* 2104 /*
2247 * Figure the startblock based on the next block's 2105 * Figure the startblock based on the next block's
2248 * start and the gap size. 2106 * start and the gap size.
2249 */ 2107 */
2250 gotbno = ap->gotp->br_startblock; 2108 gotbno = ap->got.br_startblock;
2251 /* 2109 /*
2252 * Heuristic! 2110 * Heuristic!
2253 * If the gap is large relative to the piece we're 2111 * If the gap is large relative to the piece we're
@@ -2255,12 +2113,12 @@ xfs_bmap_adjacent(
2255 * number, then just use the start of the next block 2113 * number, then just use the start of the next block
2256 * offset by our length. 2114 * offset by our length.
2257 */ 2115 */
2258 if (gotdiff <= XFS_ALLOC_GAP_UNITS * ap->alen && 2116 if (gotdiff <= XFS_ALLOC_GAP_UNITS * ap->length &&
2259 ISVALID(gotbno - gotdiff, gotbno)) 2117 ISVALID(gotbno - gotdiff, gotbno))
2260 gotbno -= adjust; 2118 gotbno -= adjust;
2261 else if (ISVALID(gotbno - ap->alen, gotbno)) { 2119 else if (ISVALID(gotbno - ap->length, gotbno)) {
2262 gotbno -= ap->alen; 2120 gotbno -= ap->length;
2263 gotdiff += adjust - ap->alen; 2121 gotdiff += adjust - ap->length;
2264 } else 2122 } else
2265 gotdiff += adjust; 2123 gotdiff += adjust;
2266 /* 2124 /*
@@ -2278,14 +2136,14 @@ xfs_bmap_adjacent(
2278 gotbno = NULLFSBLOCK; 2136 gotbno = NULLFSBLOCK;
2279 /* 2137 /*
2280 * If both valid, pick the better one, else the only good 2138 * If both valid, pick the better one, else the only good
2281 * one, else ap->rval is already set (to 0 or the inode block). 2139 * one, else ap->blkno is already set (to 0 or the inode block).
2282 */ 2140 */
2283 if (prevbno != NULLFSBLOCK && gotbno != NULLFSBLOCK) 2141 if (prevbno != NULLFSBLOCK && gotbno != NULLFSBLOCK)
2284 ap->rval = prevdiff <= gotdiff ? prevbno : gotbno; 2142 ap->blkno = prevdiff <= gotdiff ? prevbno : gotbno;
2285 else if (prevbno != NULLFSBLOCK) 2143 else if (prevbno != NULLFSBLOCK)
2286 ap->rval = prevbno; 2144 ap->blkno = prevbno;
2287 else if (gotbno != NULLFSBLOCK) 2145 else if (gotbno != NULLFSBLOCK)
2288 ap->rval = gotbno; 2146 ap->blkno = gotbno;
2289 } 2147 }
2290#undef ISVALID 2148#undef ISVALID
2291} 2149}
@@ -2305,24 +2163,24 @@ xfs_bmap_rtalloc(
2305 mp = ap->ip->i_mount; 2163 mp = ap->ip->i_mount;
2306 align = xfs_get_extsz_hint(ap->ip); 2164 align = xfs_get_extsz_hint(ap->ip);
2307 prod = align / mp->m_sb.sb_rextsize; 2165 prod = align / mp->m_sb.sb_rextsize;
2308 error = xfs_bmap_extsize_align(mp, ap->gotp, ap->prevp, 2166 error = xfs_bmap_extsize_align(mp, &ap->got, &ap->prev,
2309 align, 1, ap->eof, 0, 2167 align, 1, ap->eof, 0,
2310 ap->conv, &ap->off, &ap->alen); 2168 ap->conv, &ap->offset, &ap->length);
2311 if (error) 2169 if (error)
2312 return error; 2170 return error;
2313 ASSERT(ap->alen); 2171 ASSERT(ap->length);
2314 ASSERT(ap->alen % mp->m_sb.sb_rextsize == 0); 2172 ASSERT(ap->length % mp->m_sb.sb_rextsize == 0);
2315 2173
2316 /* 2174 /*
2317 * If the offset & length are not perfectly aligned 2175 * If the offset & length are not perfectly aligned
2318 * then kill prod, it will just get us in trouble. 2176 * then kill prod, it will just get us in trouble.
2319 */ 2177 */
2320 if (do_mod(ap->off, align) || ap->alen % align) 2178 if (do_mod(ap->offset, align) || ap->length % align)
2321 prod = 1; 2179 prod = 1;
2322 /* 2180 /*
2323 * Set ralen to be the actual requested length in rtextents. 2181 * Set ralen to be the actual requested length in rtextents.
2324 */ 2182 */
2325 ralen = ap->alen / mp->m_sb.sb_rextsize; 2183 ralen = ap->length / mp->m_sb.sb_rextsize;
2326 /* 2184 /*
2327 * If the old value was close enough to MAXEXTLEN that 2185 * If the old value was close enough to MAXEXTLEN that
2328 * we rounded up to it, cut it back so it's valid again. 2186 * we rounded up to it, cut it back so it's valid again.
@@ -2337,21 +2195,21 @@ xfs_bmap_rtalloc(
2337 * Lock out other modifications to the RT bitmap inode. 2195 * Lock out other modifications to the RT bitmap inode.
2338 */ 2196 */
2339 xfs_ilock(mp->m_rbmip, XFS_ILOCK_EXCL); 2197 xfs_ilock(mp->m_rbmip, XFS_ILOCK_EXCL);
2340 xfs_trans_ijoin_ref(ap->tp, mp->m_rbmip, XFS_ILOCK_EXCL); 2198 xfs_trans_ijoin(ap->tp, mp->m_rbmip, XFS_ILOCK_EXCL);
2341 2199
2342 /* 2200 /*
2343 * If it's an allocation to an empty file at offset 0, 2201 * If it's an allocation to an empty file at offset 0,
2344 * pick an extent that will space things out in the rt area. 2202 * pick an extent that will space things out in the rt area.
2345 */ 2203 */
2346 if (ap->eof && ap->off == 0) { 2204 if (ap->eof && ap->offset == 0) {
2347 xfs_rtblock_t uninitialized_var(rtx); /* realtime extent no */ 2205 xfs_rtblock_t uninitialized_var(rtx); /* realtime extent no */
2348 2206
2349 error = xfs_rtpick_extent(mp, ap->tp, ralen, &rtx); 2207 error = xfs_rtpick_extent(mp, ap->tp, ralen, &rtx);
2350 if (error) 2208 if (error)
2351 return error; 2209 return error;
2352 ap->rval = rtx * mp->m_sb.sb_rextsize; 2210 ap->blkno = rtx * mp->m_sb.sb_rextsize;
2353 } else { 2211 } else {
2354 ap->rval = 0; 2212 ap->blkno = 0;
2355 } 2213 }
2356 2214
2357 xfs_bmap_adjacent(ap); 2215 xfs_bmap_adjacent(ap);
@@ -2359,23 +2217,23 @@ xfs_bmap_rtalloc(
2359 /* 2217 /*
2360 * Realtime allocation, done through xfs_rtallocate_extent. 2218 * Realtime allocation, done through xfs_rtallocate_extent.
2361 */ 2219 */
2362 atype = ap->rval == 0 ? XFS_ALLOCTYPE_ANY_AG : XFS_ALLOCTYPE_NEAR_BNO; 2220 atype = ap->blkno == 0 ? XFS_ALLOCTYPE_ANY_AG : XFS_ALLOCTYPE_NEAR_BNO;
2363 do_div(ap->rval, mp->m_sb.sb_rextsize); 2221 do_div(ap->blkno, mp->m_sb.sb_rextsize);
2364 rtb = ap->rval; 2222 rtb = ap->blkno;
2365 ap->alen = ralen; 2223 ap->length = ralen;
2366 if ((error = xfs_rtallocate_extent(ap->tp, ap->rval, 1, ap->alen, 2224 if ((error = xfs_rtallocate_extent(ap->tp, ap->blkno, 1, ap->length,
2367 &ralen, atype, ap->wasdel, prod, &rtb))) 2225 &ralen, atype, ap->wasdel, prod, &rtb)))
2368 return error; 2226 return error;
2369 if (rtb == NULLFSBLOCK && prod > 1 && 2227 if (rtb == NULLFSBLOCK && prod > 1 &&
2370 (error = xfs_rtallocate_extent(ap->tp, ap->rval, 1, 2228 (error = xfs_rtallocate_extent(ap->tp, ap->blkno, 1,
2371 ap->alen, &ralen, atype, 2229 ap->length, &ralen, atype,
2372 ap->wasdel, 1, &rtb))) 2230 ap->wasdel, 1, &rtb)))
2373 return error; 2231 return error;
2374 ap->rval = rtb; 2232 ap->blkno = rtb;
2375 if (ap->rval != NULLFSBLOCK) { 2233 if (ap->blkno != NULLFSBLOCK) {
2376 ap->rval *= mp->m_sb.sb_rextsize; 2234 ap->blkno *= mp->m_sb.sb_rextsize;
2377 ralen *= mp->m_sb.sb_rextsize; 2235 ralen *= mp->m_sb.sb_rextsize;
2378 ap->alen = ralen; 2236 ap->length = ralen;
2379 ap->ip->i_d.di_nblocks += ralen; 2237 ap->ip->i_d.di_nblocks += ralen;
2380 xfs_trans_log_inode(ap->tp, ap->ip, XFS_ILOG_CORE); 2238 xfs_trans_log_inode(ap->tp, ap->ip, XFS_ILOG_CORE);
2381 if (ap->wasdel) 2239 if (ap->wasdel)
@@ -2388,7 +2246,7 @@ xfs_bmap_rtalloc(
2388 ap->wasdel ? XFS_TRANS_DQ_DELRTBCOUNT : 2246 ap->wasdel ? XFS_TRANS_DQ_DELRTBCOUNT :
2389 XFS_TRANS_DQ_RTBCOUNT, (long) ralen); 2247 XFS_TRANS_DQ_RTBCOUNT, (long) ralen);
2390 } else { 2248 } else {
2391 ap->alen = 0; 2249 ap->length = 0;
2392 } 2250 }
2393 return 0; 2251 return 0;
2394} 2252}
@@ -2503,7 +2361,7 @@ xfs_bmap_btalloc_nullfb(
2503 * AG as the stream may have moved. 2361 * AG as the stream may have moved.
2504 */ 2362 */
2505 if (xfs_inode_is_filestream(ap->ip)) 2363 if (xfs_inode_is_filestream(ap->ip))
2506 ap->rval = args->fsbno = XFS_AGB_TO_FSB(mp, ag, 0); 2364 ap->blkno = args->fsbno = XFS_AGB_TO_FSB(mp, ag, 0);
2507 2365
2508 return 0; 2366 return 0;
2509} 2367}
@@ -2528,52 +2386,52 @@ xfs_bmap_btalloc(
2528 mp = ap->ip->i_mount; 2386 mp = ap->ip->i_mount;
2529 align = ap->userdata ? xfs_get_extsz_hint(ap->ip) : 0; 2387 align = ap->userdata ? xfs_get_extsz_hint(ap->ip) : 0;
2530 if (unlikely(align)) { 2388 if (unlikely(align)) {
2531 error = xfs_bmap_extsize_align(mp, ap->gotp, ap->prevp, 2389 error = xfs_bmap_extsize_align(mp, &ap->got, &ap->prev,
2532 align, 0, ap->eof, 0, ap->conv, 2390 align, 0, ap->eof, 0, ap->conv,
2533 &ap->off, &ap->alen); 2391 &ap->offset, &ap->length);
2534 ASSERT(!error); 2392 ASSERT(!error);
2535 ASSERT(ap->alen); 2393 ASSERT(ap->length);
2536 } 2394 }
2537 nullfb = ap->firstblock == NULLFSBLOCK; 2395 nullfb = *ap->firstblock == NULLFSBLOCK;
2538 fb_agno = nullfb ? NULLAGNUMBER : XFS_FSB_TO_AGNO(mp, ap->firstblock); 2396 fb_agno = nullfb ? NULLAGNUMBER : XFS_FSB_TO_AGNO(mp, *ap->firstblock);
2539 if (nullfb) { 2397 if (nullfb) {
2540 if (ap->userdata && xfs_inode_is_filestream(ap->ip)) { 2398 if (ap->userdata && xfs_inode_is_filestream(ap->ip)) {
2541 ag = xfs_filestream_lookup_ag(ap->ip); 2399 ag = xfs_filestream_lookup_ag(ap->ip);
2542 ag = (ag != NULLAGNUMBER) ? ag : 0; 2400 ag = (ag != NULLAGNUMBER) ? ag : 0;
2543 ap->rval = XFS_AGB_TO_FSB(mp, ag, 0); 2401 ap->blkno = XFS_AGB_TO_FSB(mp, ag, 0);
2544 } else { 2402 } else {
2545 ap->rval = XFS_INO_TO_FSB(mp, ap->ip->i_ino); 2403 ap->blkno = XFS_INO_TO_FSB(mp, ap->ip->i_ino);
2546 } 2404 }
2547 } else 2405 } else
2548 ap->rval = ap->firstblock; 2406 ap->blkno = *ap->firstblock;
2549 2407
2550 xfs_bmap_adjacent(ap); 2408 xfs_bmap_adjacent(ap);
2551 2409
2552 /* 2410 /*
2553 * If allowed, use ap->rval; otherwise must use firstblock since 2411 * If allowed, use ap->blkno; otherwise must use firstblock since
2554 * it's in the right allocation group. 2412 * it's in the right allocation group.
2555 */ 2413 */
2556 if (nullfb || XFS_FSB_TO_AGNO(mp, ap->rval) == fb_agno) 2414 if (nullfb || XFS_FSB_TO_AGNO(mp, ap->blkno) == fb_agno)
2557 ; 2415 ;
2558 else 2416 else
2559 ap->rval = ap->firstblock; 2417 ap->blkno = *ap->firstblock;
2560 /* 2418 /*
2561 * Normal allocation, done through xfs_alloc_vextent. 2419 * Normal allocation, done through xfs_alloc_vextent.
2562 */ 2420 */
2563 tryagain = isaligned = 0; 2421 tryagain = isaligned = 0;
2564 args.tp = ap->tp; 2422 args.tp = ap->tp;
2565 args.mp = mp; 2423 args.mp = mp;
2566 args.fsbno = ap->rval; 2424 args.fsbno = ap->blkno;
2567 2425
2568 /* Trim the allocation back to the maximum an AG can fit. */ 2426 /* Trim the allocation back to the maximum an AG can fit. */
2569 args.maxlen = MIN(ap->alen, XFS_ALLOC_AG_MAX_USABLE(mp)); 2427 args.maxlen = MIN(ap->length, XFS_ALLOC_AG_MAX_USABLE(mp));
2570 args.firstblock = ap->firstblock; 2428 args.firstblock = *ap->firstblock;
2571 blen = 0; 2429 blen = 0;
2572 if (nullfb) { 2430 if (nullfb) {
2573 error = xfs_bmap_btalloc_nullfb(ap, &args, &blen); 2431 error = xfs_bmap_btalloc_nullfb(ap, &args, &blen);
2574 if (error) 2432 if (error)
2575 return error; 2433 return error;
2576 } else if (ap->low) { 2434 } else if (ap->flist->xbf_low) {
2577 if (xfs_inode_is_filestream(ap->ip)) 2435 if (xfs_inode_is_filestream(ap->ip))
2578 args.type = XFS_ALLOCTYPE_FIRST_AG; 2436 args.type = XFS_ALLOCTYPE_FIRST_AG;
2579 else 2437 else
@@ -2587,14 +2445,14 @@ xfs_bmap_btalloc(
2587 /* apply extent size hints if obtained earlier */ 2445 /* apply extent size hints if obtained earlier */
2588 if (unlikely(align)) { 2446 if (unlikely(align)) {
2589 args.prod = align; 2447 args.prod = align;
2590 if ((args.mod = (xfs_extlen_t)do_mod(ap->off, args.prod))) 2448 if ((args.mod = (xfs_extlen_t)do_mod(ap->offset, args.prod)))
2591 args.mod = (xfs_extlen_t)(args.prod - args.mod); 2449 args.mod = (xfs_extlen_t)(args.prod - args.mod);
2592 } else if (mp->m_sb.sb_blocksize >= PAGE_CACHE_SIZE) { 2450 } else if (mp->m_sb.sb_blocksize >= PAGE_CACHE_SIZE) {
2593 args.prod = 1; 2451 args.prod = 1;
2594 args.mod = 0; 2452 args.mod = 0;
2595 } else { 2453 } else {
2596 args.prod = PAGE_CACHE_SIZE >> mp->m_sb.sb_blocklog; 2454 args.prod = PAGE_CACHE_SIZE >> mp->m_sb.sb_blocklog;
2597 if ((args.mod = (xfs_extlen_t)(do_mod(ap->off, args.prod)))) 2455 if ((args.mod = (xfs_extlen_t)(do_mod(ap->offset, args.prod))))
2598 args.mod = (xfs_extlen_t)(args.prod - args.mod); 2456 args.mod = (xfs_extlen_t)(args.prod - args.mod);
2599 } 2457 }
2600 /* 2458 /*
@@ -2606,8 +2464,8 @@ xfs_bmap_btalloc(
2606 * is >= the stripe unit and the allocation offset is 2464 * is >= the stripe unit and the allocation offset is
2607 * at the end of file. 2465 * at the end of file.
2608 */ 2466 */
2609 if (!ap->low && ap->aeof) { 2467 if (!ap->flist->xbf_low && ap->aeof) {
2610 if (!ap->off) { 2468 if (!ap->offset) {
2611 args.alignment = mp->m_dalign; 2469 args.alignment = mp->m_dalign;
2612 atype = args.type; 2470 atype = args.type;
2613 isaligned = 1; 2471 isaligned = 1;
@@ -2660,7 +2518,7 @@ xfs_bmap_btalloc(
2660 * turned on. 2518 * turned on.
2661 */ 2519 */
2662 args.type = atype; 2520 args.type = atype;
2663 args.fsbno = ap->rval; 2521 args.fsbno = ap->blkno;
2664 args.alignment = mp->m_dalign; 2522 args.alignment = mp->m_dalign;
2665 args.minlen = nextminlen; 2523 args.minlen = nextminlen;
2666 args.minalignslop = 0; 2524 args.minalignslop = 0;
@@ -2674,7 +2532,7 @@ xfs_bmap_btalloc(
2674 * try again. 2532 * try again.
2675 */ 2533 */
2676 args.type = atype; 2534 args.type = atype;
2677 args.fsbno = ap->rval; 2535 args.fsbno = ap->blkno;
2678 args.alignment = 0; 2536 args.alignment = 0;
2679 if ((error = xfs_alloc_vextent(&args))) 2537 if ((error = xfs_alloc_vextent(&args)))
2680 return error; 2538 return error;
@@ -2683,7 +2541,7 @@ xfs_bmap_btalloc(
2683 args.minlen > ap->minlen) { 2541 args.minlen > ap->minlen) {
2684 args.minlen = ap->minlen; 2542 args.minlen = ap->minlen;
2685 args.type = XFS_ALLOCTYPE_START_BNO; 2543 args.type = XFS_ALLOCTYPE_START_BNO;
2686 args.fsbno = ap->rval; 2544 args.fsbno = ap->blkno;
2687 if ((error = xfs_alloc_vextent(&args))) 2545 if ((error = xfs_alloc_vextent(&args)))
2688 return error; 2546 return error;
2689 } 2547 }
@@ -2694,13 +2552,26 @@ xfs_bmap_btalloc(
2694 args.minleft = 0; 2552 args.minleft = 0;
2695 if ((error = xfs_alloc_vextent(&args))) 2553 if ((error = xfs_alloc_vextent(&args)))
2696 return error; 2554 return error;
2697 ap->low = 1; 2555 ap->flist->xbf_low = 1;
2698 } 2556 }
2699 if (args.fsbno != NULLFSBLOCK) { 2557 if (args.fsbno != NULLFSBLOCK) {
2700 ap->firstblock = ap->rval = args.fsbno; 2558 /*
2559 * check the allocation happened at the same or higher AG than
2560 * the first block that was allocated.
2561 */
2562 ASSERT(*ap->firstblock == NULLFSBLOCK ||
2563 XFS_FSB_TO_AGNO(mp, *ap->firstblock) ==
2564 XFS_FSB_TO_AGNO(mp, args.fsbno) ||
2565 (ap->flist->xbf_low &&
2566 XFS_FSB_TO_AGNO(mp, *ap->firstblock) <
2567 XFS_FSB_TO_AGNO(mp, args.fsbno)));
2568
2569 ap->blkno = args.fsbno;
2570 if (*ap->firstblock == NULLFSBLOCK)
2571 *ap->firstblock = args.fsbno;
2701 ASSERT(nullfb || fb_agno == args.agno || 2572 ASSERT(nullfb || fb_agno == args.agno ||
2702 (ap->low && fb_agno < args.agno)); 2573 (ap->flist->xbf_low && fb_agno < args.agno));
2703 ap->alen = args.len; 2574 ap->length = args.len;
2704 ap->ip->i_d.di_nblocks += args.len; 2575 ap->ip->i_d.di_nblocks += args.len;
2705 xfs_trans_log_inode(ap->tp, ap->ip, XFS_ILOG_CORE); 2576 xfs_trans_log_inode(ap->tp, ap->ip, XFS_ILOG_CORE);
2706 if (ap->wasdel) 2577 if (ap->wasdel)
@@ -2714,8 +2585,8 @@ xfs_bmap_btalloc(
2714 XFS_TRANS_DQ_BCOUNT, 2585 XFS_TRANS_DQ_BCOUNT,
2715 (long) args.len); 2586 (long) args.len);
2716 } else { 2587 } else {
2717 ap->rval = NULLFSBLOCK; 2588 ap->blkno = NULLFSBLOCK;
2718 ap->alen = 0; 2589 ap->length = 0;
2719 } 2590 }
2720 return 0; 2591 return 0;
2721} 2592}
@@ -3589,7 +3460,7 @@ xfs_bmap_add_attrfork(
3589 } 3460 }
3590 ASSERT(ip->i_d.di_anextents == 0); 3461 ASSERT(ip->i_d.di_anextents == 0);
3591 3462
3592 xfs_trans_ijoin_ref(tp, ip, XFS_ILOCK_EXCL); 3463 xfs_trans_ijoin(tp, ip, XFS_ILOCK_EXCL);
3593 xfs_trans_log_inode(tp, ip, XFS_ILOG_CORE); 3464 xfs_trans_log_inode(tp, ip, XFS_ILOG_CORE);
3594 3465
3595 switch (ip->i_d.di_format) { 3466 switch (ip->i_d.di_format) {
@@ -3782,19 +3653,11 @@ xfs_bmap_compute_maxlevels(
3782 * Routine to be called at transaction's end by xfs_bmapi, xfs_bunmapi 3653 * Routine to be called at transaction's end by xfs_bmapi, xfs_bunmapi
3783 * caller. Frees all the extents that need freeing, which must be done 3654 * caller. Frees all the extents that need freeing, which must be done
3784 * last due to locking considerations. We never free any extents in 3655 * last due to locking considerations. We never free any extents in
3785 * the first transaction. This is to allow the caller to make the first 3656 * the first transaction.
3786 * transaction a synchronous one so that the pointers to the data being
3787 * broken in this transaction will be permanent before the data is actually
3788 * freed. This is necessary to prevent blocks from being reallocated
3789 * and written to before the free and reallocation are actually permanent.
3790 * We do not just make the first transaction synchronous here, because
3791 * there are more efficient ways to gain the same protection in some cases
3792 * (see the file truncation code).
3793 * 3657 *
3794 * Return 1 if the given transaction was committed and a new one 3658 * Return 1 if the given transaction was committed and a new one
3795 * started, and 0 otherwise in the committed parameter. 3659 * started, and 0 otherwise in the committed parameter.
3796 */ 3660 */
3797/*ARGSUSED*/
3798int /* error */ 3661int /* error */
3799xfs_bmap_finish( 3662xfs_bmap_finish(
3800 xfs_trans_t **tp, /* transaction pointer addr */ 3663 xfs_trans_t **tp, /* transaction pointer addr */
@@ -3994,42 +3857,122 @@ xfs_bmap_last_before(
3994 return 0; 3857 return 0;
3995} 3858}
3996 3859
3860STATIC int
3861xfs_bmap_last_extent(
3862 struct xfs_trans *tp,
3863 struct xfs_inode *ip,
3864 int whichfork,
3865 struct xfs_bmbt_irec *rec,
3866 int *is_empty)
3867{
3868 struct xfs_ifork *ifp = XFS_IFORK_PTR(ip, whichfork);
3869 int error;
3870 int nextents;
3871
3872 if (!(ifp->if_flags & XFS_IFEXTENTS)) {
3873 error = xfs_iread_extents(tp, ip, whichfork);
3874 if (error)
3875 return error;
3876 }
3877
3878 nextents = ifp->if_bytes / sizeof(xfs_bmbt_rec_t);
3879 if (nextents == 0) {
3880 *is_empty = 1;
3881 return 0;
3882 }
3883
3884 xfs_bmbt_get_all(xfs_iext_get_ext(ifp, nextents - 1), rec);
3885 *is_empty = 0;
3886 return 0;
3887}
3888
3889/*
3890 * Check the last inode extent to determine whether this allocation will result
3891 * in blocks being allocated at the end of the file. When we allocate new data
3892 * blocks at the end of the file which do not start at the previous data block,
3893 * we will try to align the new blocks at stripe unit boundaries.
3894 *
3895 * Returns 0 in bma->aeof if the file (fork) is empty as any new write will be
3896 * at, or past the EOF.
3897 */
3898STATIC int
3899xfs_bmap_isaeof(
3900 struct xfs_bmalloca *bma,
3901 int whichfork)
3902{
3903 struct xfs_bmbt_irec rec;
3904 int is_empty;
3905 int error;
3906
3907 bma->aeof = 0;
3908 error = xfs_bmap_last_extent(NULL, bma->ip, whichfork, &rec,
3909 &is_empty);
3910 if (error || is_empty)
3911 return error;
3912
3913 /*
3914 * Check if we are allocation or past the last extent, or at least into
3915 * the last delayed allocated extent.
3916 */
3917 bma->aeof = bma->offset >= rec.br_startoff + rec.br_blockcount ||
3918 (bma->offset >= rec.br_startoff &&
3919 isnullstartblock(rec.br_startblock));
3920 return 0;
3921}
3922
3923/*
3924 * Check if the endoff is outside the last extent. If so the caller will grow
3925 * the allocation to a stripe unit boundary. All offsets are considered outside
3926 * the end of file for an empty fork, so 1 is returned in *eof in that case.
3927 */
3928int
3929xfs_bmap_eof(
3930 struct xfs_inode *ip,
3931 xfs_fileoff_t endoff,
3932 int whichfork,
3933 int *eof)
3934{
3935 struct xfs_bmbt_irec rec;
3936 int error;
3937
3938 error = xfs_bmap_last_extent(NULL, ip, whichfork, &rec, eof);
3939 if (error || *eof)
3940 return error;
3941
3942 *eof = endoff >= rec.br_startoff + rec.br_blockcount;
3943 return 0;
3944}
3945
3997/* 3946/*
3998 * Returns the file-relative block number of the first block past eof in 3947 * Returns the file-relative block number of the first block past eof in
3999 * the file. This is not based on i_size, it is based on the extent records. 3948 * the file. This is not based on i_size, it is based on the extent records.
4000 * Returns 0 for local files, as they do not have extent records. 3949 * Returns 0 for local files, as they do not have extent records.
4001 */ 3950 */
4002int /* error */ 3951int
4003xfs_bmap_last_offset( 3952xfs_bmap_last_offset(
4004 xfs_trans_t *tp, /* transaction pointer */ 3953 struct xfs_trans *tp,
4005 xfs_inode_t *ip, /* incore inode */ 3954 struct xfs_inode *ip,
4006 xfs_fileoff_t *last_block, /* last block */ 3955 xfs_fileoff_t *last_block,
4007 int whichfork) /* data or attr fork */ 3956 int whichfork)
4008{ 3957{
4009 xfs_bmbt_rec_host_t *ep; /* pointer to last extent */ 3958 struct xfs_bmbt_irec rec;
4010 int error; /* error return value */ 3959 int is_empty;
4011 xfs_ifork_t *ifp; /* inode fork pointer */ 3960 int error;
4012 xfs_extnum_t nextents; /* number of extent entries */ 3961
3962 *last_block = 0;
3963
3964 if (XFS_IFORK_FORMAT(ip, whichfork) == XFS_DINODE_FMT_LOCAL)
3965 return 0;
4013 3966
4014 if (XFS_IFORK_FORMAT(ip, whichfork) != XFS_DINODE_FMT_BTREE && 3967 if (XFS_IFORK_FORMAT(ip, whichfork) != XFS_DINODE_FMT_BTREE &&
4015 XFS_IFORK_FORMAT(ip, whichfork) != XFS_DINODE_FMT_EXTENTS && 3968 XFS_IFORK_FORMAT(ip, whichfork) != XFS_DINODE_FMT_EXTENTS)
4016 XFS_IFORK_FORMAT(ip, whichfork) != XFS_DINODE_FMT_LOCAL)
4017 return XFS_ERROR(EIO); 3969 return XFS_ERROR(EIO);
4018 if (XFS_IFORK_FORMAT(ip, whichfork) == XFS_DINODE_FMT_LOCAL) { 3970
4019 *last_block = 0; 3971 error = xfs_bmap_last_extent(NULL, ip, whichfork, &rec, &is_empty);
4020 return 0; 3972 if (error || is_empty)
4021 }
4022 ifp = XFS_IFORK_PTR(ip, whichfork);
4023 if (!(ifp->if_flags & XFS_IFEXTENTS) &&
4024 (error = xfs_iread_extents(tp, ip, whichfork)))
4025 return error; 3973 return error;
4026 nextents = ifp->if_bytes / (uint)sizeof(xfs_bmbt_rec_t); 3974
4027 if (!nextents) { 3975 *last_block = rec.br_startoff + rec.br_blockcount;
4028 *last_block = 0;
4029 return 0;
4030 }
4031 ep = xfs_iext_get_ext(ifp, nextents - 1);
4032 *last_block = xfs_bmbt_get_startoff(ep) + xfs_bmbt_get_blockcount(ep);
4033 return 0; 3976 return 0;
4034} 3977}
4035 3978
@@ -4159,7 +4102,6 @@ xfs_bmap_read_extents(
4159 xfs_extnum_t num_recs; 4102 xfs_extnum_t num_recs;
4160 xfs_extnum_t start; 4103 xfs_extnum_t start;
4161 4104
4162
4163 num_recs = xfs_btree_get_numrecs(block); 4105 num_recs = xfs_btree_get_numrecs(block);
4164 if (unlikely(i + num_recs > room)) { 4106 if (unlikely(i + num_recs > room)) {
4165 ASSERT(i + num_recs <= room); 4107 ASSERT(i + num_recs <= room);
@@ -4282,9 +4224,8 @@ xfs_bmap_validate_ret(
4282 ASSERT(i == 0 || 4224 ASSERT(i == 0 ||
4283 mval[i - 1].br_startoff + mval[i - 1].br_blockcount == 4225 mval[i - 1].br_startoff + mval[i - 1].br_blockcount ==
4284 mval[i].br_startoff); 4226 mval[i].br_startoff);
4285 if ((flags & XFS_BMAPI_WRITE) && !(flags & XFS_BMAPI_DELAY)) 4227 ASSERT(mval[i].br_startblock != DELAYSTARTBLOCK &&
4286 ASSERT(mval[i].br_startblock != DELAYSTARTBLOCK && 4228 mval[i].br_startblock != HOLESTARTBLOCK);
4287 mval[i].br_startblock != HOLESTARTBLOCK);
4288 ASSERT(mval[i].br_state == XFS_EXT_NORM || 4229 ASSERT(mval[i].br_state == XFS_EXT_NORM ||
4289 mval[i].br_state == XFS_EXT_UNWRITTEN); 4230 mval[i].br_state == XFS_EXT_UNWRITTEN);
4290 } 4231 }
@@ -4293,66 +4234,609 @@ xfs_bmap_validate_ret(
4293 4234
4294 4235
4295/* 4236/*
4296 * Map file blocks to filesystem blocks. 4237 * Trim the returned map to the required bounds
4297 * File range is given by the bno/len pair. 4238 */
4298 * Adds blocks to file if a write ("flags & XFS_BMAPI_WRITE" set) 4239STATIC void
4299 * into a hole or past eof. 4240xfs_bmapi_trim_map(
4300 * Only allocates blocks from a single allocation group, 4241 struct xfs_bmbt_irec *mval,
4301 * to avoid locking problems. 4242 struct xfs_bmbt_irec *got,
4243 xfs_fileoff_t *bno,
4244 xfs_filblks_t len,
4245 xfs_fileoff_t obno,
4246 xfs_fileoff_t end,
4247 int n,
4248 int flags)
4249{
4250 if ((flags & XFS_BMAPI_ENTIRE) ||
4251 got->br_startoff + got->br_blockcount <= obno) {
4252 *mval = *got;
4253 if (isnullstartblock(got->br_startblock))
4254 mval->br_startblock = DELAYSTARTBLOCK;
4255 return;
4256 }
4257
4258 if (obno > *bno)
4259 *bno = obno;
4260 ASSERT((*bno >= obno) || (n == 0));
4261 ASSERT(*bno < end);
4262 mval->br_startoff = *bno;
4263 if (isnullstartblock(got->br_startblock))
4264 mval->br_startblock = DELAYSTARTBLOCK;
4265 else
4266 mval->br_startblock = got->br_startblock +
4267 (*bno - got->br_startoff);
4268 /*
4269 * Return the minimum of what we got and what we asked for for
4270 * the length. We can use the len variable here because it is
4271 * modified below and we could have been there before coming
4272 * here if the first part of the allocation didn't overlap what
4273 * was asked for.
4274 */
4275 mval->br_blockcount = XFS_FILBLKS_MIN(end - *bno,
4276 got->br_blockcount - (*bno - got->br_startoff));
4277 mval->br_state = got->br_state;
4278 ASSERT(mval->br_blockcount <= len);
4279 return;
4280}
4281
4282/*
4283 * Update and validate the extent map to return
4284 */
4285STATIC void
4286xfs_bmapi_update_map(
4287 struct xfs_bmbt_irec **map,
4288 xfs_fileoff_t *bno,
4289 xfs_filblks_t *len,
4290 xfs_fileoff_t obno,
4291 xfs_fileoff_t end,
4292 int *n,
4293 int flags)
4294{
4295 xfs_bmbt_irec_t *mval = *map;
4296
4297 ASSERT((flags & XFS_BMAPI_ENTIRE) ||
4298 ((mval->br_startoff + mval->br_blockcount) <= end));
4299 ASSERT((flags & XFS_BMAPI_ENTIRE) || (mval->br_blockcount <= *len) ||
4300 (mval->br_startoff < obno));
4301
4302 *bno = mval->br_startoff + mval->br_blockcount;
4303 *len = end - *bno;
4304 if (*n > 0 && mval->br_startoff == mval[-1].br_startoff) {
4305 /* update previous map with new information */
4306 ASSERT(mval->br_startblock == mval[-1].br_startblock);
4307 ASSERT(mval->br_blockcount > mval[-1].br_blockcount);
4308 ASSERT(mval->br_state == mval[-1].br_state);
4309 mval[-1].br_blockcount = mval->br_blockcount;
4310 mval[-1].br_state = mval->br_state;
4311 } else if (*n > 0 && mval->br_startblock != DELAYSTARTBLOCK &&
4312 mval[-1].br_startblock != DELAYSTARTBLOCK &&
4313 mval[-1].br_startblock != HOLESTARTBLOCK &&
4314 mval->br_startblock == mval[-1].br_startblock +
4315 mval[-1].br_blockcount &&
4316 ((flags & XFS_BMAPI_IGSTATE) ||
4317 mval[-1].br_state == mval->br_state)) {
4318 ASSERT(mval->br_startoff ==
4319 mval[-1].br_startoff + mval[-1].br_blockcount);
4320 mval[-1].br_blockcount += mval->br_blockcount;
4321 } else if (*n > 0 &&
4322 mval->br_startblock == DELAYSTARTBLOCK &&
4323 mval[-1].br_startblock == DELAYSTARTBLOCK &&
4324 mval->br_startoff ==
4325 mval[-1].br_startoff + mval[-1].br_blockcount) {
4326 mval[-1].br_blockcount += mval->br_blockcount;
4327 mval[-1].br_state = mval->br_state;
4328 } else if (!((*n == 0) &&
4329 ((mval->br_startoff + mval->br_blockcount) <=
4330 obno))) {
4331 mval++;
4332 (*n)++;
4333 }
4334 *map = mval;
4335}
4336
4337/*
4338 * Map file blocks to filesystem blocks without allocation.
4339 */
4340int
4341xfs_bmapi_read(
4342 struct xfs_inode *ip,
4343 xfs_fileoff_t bno,
4344 xfs_filblks_t len,
4345 struct xfs_bmbt_irec *mval,
4346 int *nmap,
4347 int flags)
4348{
4349 struct xfs_mount *mp = ip->i_mount;
4350 struct xfs_ifork *ifp;
4351 struct xfs_bmbt_irec got;
4352 struct xfs_bmbt_irec prev;
4353 xfs_fileoff_t obno;
4354 xfs_fileoff_t end;
4355 xfs_extnum_t lastx;
4356 int error;
4357 int eof;
4358 int n = 0;
4359 int whichfork = (flags & XFS_BMAPI_ATTRFORK) ?
4360 XFS_ATTR_FORK : XFS_DATA_FORK;
4361
4362 ASSERT(*nmap >= 1);
4363 ASSERT(!(flags & ~(XFS_BMAPI_ATTRFORK|XFS_BMAPI_ENTIRE|
4364 XFS_BMAPI_IGSTATE)));
4365
4366 if (unlikely(XFS_TEST_ERROR(
4367 (XFS_IFORK_FORMAT(ip, whichfork) != XFS_DINODE_FMT_EXTENTS &&
4368 XFS_IFORK_FORMAT(ip, whichfork) != XFS_DINODE_FMT_BTREE),
4369 mp, XFS_ERRTAG_BMAPIFORMAT, XFS_RANDOM_BMAPIFORMAT))) {
4370 XFS_ERROR_REPORT("xfs_bmapi_read", XFS_ERRLEVEL_LOW, mp);
4371 return XFS_ERROR(EFSCORRUPTED);
4372 }
4373
4374 if (XFS_FORCED_SHUTDOWN(mp))
4375 return XFS_ERROR(EIO);
4376
4377 XFS_STATS_INC(xs_blk_mapr);
4378
4379 ifp = XFS_IFORK_PTR(ip, whichfork);
4380 ASSERT(ifp->if_ext_max ==
4381 XFS_IFORK_SIZE(ip, whichfork) / (uint)sizeof(xfs_bmbt_rec_t));
4382
4383 if (!(ifp->if_flags & XFS_IFEXTENTS)) {
4384 error = xfs_iread_extents(NULL, ip, whichfork);
4385 if (error)
4386 return error;
4387 }
4388
4389 xfs_bmap_search_extents(ip, bno, whichfork, &eof, &lastx, &got, &prev);
4390 end = bno + len;
4391 obno = bno;
4392
4393 while (bno < end && n < *nmap) {
4394 /* Reading past eof, act as though there's a hole up to end. */
4395 if (eof)
4396 got.br_startoff = end;
4397 if (got.br_startoff > bno) {
4398 /* Reading in a hole. */
4399 mval->br_startoff = bno;
4400 mval->br_startblock = HOLESTARTBLOCK;
4401 mval->br_blockcount =
4402 XFS_FILBLKS_MIN(len, got.br_startoff - bno);
4403 mval->br_state = XFS_EXT_NORM;
4404 bno += mval->br_blockcount;
4405 len -= mval->br_blockcount;
4406 mval++;
4407 n++;
4408 continue;
4409 }
4410
4411 /* set up the extent map to return. */
4412 xfs_bmapi_trim_map(mval, &got, &bno, len, obno, end, n, flags);
4413 xfs_bmapi_update_map(&mval, &bno, &len, obno, end, &n, flags);
4414
4415 /* If we're done, stop now. */
4416 if (bno >= end || n >= *nmap)
4417 break;
4418
4419 /* Else go on to the next record. */
4420 if (++lastx < ifp->if_bytes / sizeof(xfs_bmbt_rec_t))
4421 xfs_bmbt_get_all(xfs_iext_get_ext(ifp, lastx), &got);
4422 else
4423 eof = 1;
4424 }
4425 *nmap = n;
4426 return 0;
4427}
4428
4429STATIC int
4430xfs_bmapi_reserve_delalloc(
4431 struct xfs_inode *ip,
4432 xfs_fileoff_t aoff,
4433 xfs_filblks_t len,
4434 struct xfs_bmbt_irec *got,
4435 struct xfs_bmbt_irec *prev,
4436 xfs_extnum_t *lastx,
4437 int eof)
4438{
4439 struct xfs_mount *mp = ip->i_mount;
4440 struct xfs_ifork *ifp = XFS_IFORK_PTR(ip, XFS_DATA_FORK);
4441 xfs_extlen_t alen;
4442 xfs_extlen_t indlen;
4443 char rt = XFS_IS_REALTIME_INODE(ip);
4444 xfs_extlen_t extsz;
4445 int error;
4446
4447 alen = XFS_FILBLKS_MIN(len, MAXEXTLEN);
4448 if (!eof)
4449 alen = XFS_FILBLKS_MIN(alen, got->br_startoff - aoff);
4450
4451 /* Figure out the extent size, adjust alen */
4452 extsz = xfs_get_extsz_hint(ip);
4453 if (extsz) {
4454 /*
4455 * Make sure we don't exceed a single extent length when we
4456 * align the extent by reducing length we are going to
4457 * allocate by the maximum amount extent size aligment may
4458 * require.
4459 */
4460 alen = XFS_FILBLKS_MIN(len, MAXEXTLEN - (2 * extsz - 1));
4461 error = xfs_bmap_extsize_align(mp, got, prev, extsz, rt, eof,
4462 1, 0, &aoff, &alen);
4463 ASSERT(!error);
4464 }
4465
4466 if (rt)
4467 extsz = alen / mp->m_sb.sb_rextsize;
4468
4469 /*
4470 * Make a transaction-less quota reservation for delayed allocation
4471 * blocks. This number gets adjusted later. We return if we haven't
4472 * allocated blocks already inside this loop.
4473 */
4474 error = xfs_trans_reserve_quota_nblks(NULL, ip, (long)alen, 0,
4475 rt ? XFS_QMOPT_RES_RTBLKS : XFS_QMOPT_RES_REGBLKS);
4476 if (error)
4477 return error;
4478
4479 /*
4480 * Split changing sb for alen and indlen since they could be coming
4481 * from different places.
4482 */
4483 indlen = (xfs_extlen_t)xfs_bmap_worst_indlen(ip, alen);
4484 ASSERT(indlen > 0);
4485
4486 if (rt) {
4487 error = xfs_mod_incore_sb(mp, XFS_SBS_FREXTENTS,
4488 -((int64_t)extsz), 0);
4489 } else {
4490 error = xfs_icsb_modify_counters(mp, XFS_SBS_FDBLOCKS,
4491 -((int64_t)alen), 0);
4492 }
4493
4494 if (error)
4495 goto out_unreserve_quota;
4496
4497 error = xfs_icsb_modify_counters(mp, XFS_SBS_FDBLOCKS,
4498 -((int64_t)indlen), 0);
4499 if (error)
4500 goto out_unreserve_blocks;
4501
4502
4503 ip->i_delayed_blks += alen;
4504
4505 got->br_startoff = aoff;
4506 got->br_startblock = nullstartblock(indlen);
4507 got->br_blockcount = alen;
4508 got->br_state = XFS_EXT_NORM;
4509 xfs_bmap_add_extent_hole_delay(ip, lastx, got);
4510
4511 /*
4512 * Update our extent pointer, given that xfs_bmap_add_extent_hole_delay
4513 * might have merged it into one of the neighbouring ones.
4514 */
4515 xfs_bmbt_get_all(xfs_iext_get_ext(ifp, *lastx), got);
4516
4517 ASSERT(got->br_startoff <= aoff);
4518 ASSERT(got->br_startoff + got->br_blockcount >= aoff + alen);
4519 ASSERT(isnullstartblock(got->br_startblock));
4520 ASSERT(got->br_state == XFS_EXT_NORM);
4521 return 0;
4522
4523out_unreserve_blocks:
4524 if (rt)
4525 xfs_mod_incore_sb(mp, XFS_SBS_FREXTENTS, extsz, 0);
4526 else
4527 xfs_icsb_modify_counters(mp, XFS_SBS_FDBLOCKS, alen, 0);
4528out_unreserve_quota:
4529 if (XFS_IS_QUOTA_ON(mp))
4530 xfs_trans_unreserve_quota_nblks(NULL, ip, alen, 0, rt ?
4531 XFS_QMOPT_RES_RTBLKS : XFS_QMOPT_RES_REGBLKS);
4532 return error;
4533}
4534
4535/*
4536 * Map file blocks to filesystem blocks, adding delayed allocations as needed.
4537 */
4538int
4539xfs_bmapi_delay(
4540 struct xfs_inode *ip, /* incore inode */
4541 xfs_fileoff_t bno, /* starting file offs. mapped */
4542 xfs_filblks_t len, /* length to map in file */
4543 struct xfs_bmbt_irec *mval, /* output: map values */
4544 int *nmap, /* i/o: mval size/count */
4545 int flags) /* XFS_BMAPI_... */
4546{
4547 struct xfs_mount *mp = ip->i_mount;
4548 struct xfs_ifork *ifp = XFS_IFORK_PTR(ip, XFS_DATA_FORK);
4549 struct xfs_bmbt_irec got; /* current file extent record */
4550 struct xfs_bmbt_irec prev; /* previous file extent record */
4551 xfs_fileoff_t obno; /* old block number (offset) */
4552 xfs_fileoff_t end; /* end of mapped file region */
4553 xfs_extnum_t lastx; /* last useful extent number */
4554 int eof; /* we've hit the end of extents */
4555 int n = 0; /* current extent index */
4556 int error = 0;
4557
4558 ASSERT(*nmap >= 1);
4559 ASSERT(*nmap <= XFS_BMAP_MAX_NMAP);
4560 ASSERT(!(flags & ~XFS_BMAPI_ENTIRE));
4561
4562 if (unlikely(XFS_TEST_ERROR(
4563 (XFS_IFORK_FORMAT(ip, XFS_DATA_FORK) != XFS_DINODE_FMT_EXTENTS &&
4564 XFS_IFORK_FORMAT(ip, XFS_DATA_FORK) != XFS_DINODE_FMT_BTREE),
4565 mp, XFS_ERRTAG_BMAPIFORMAT, XFS_RANDOM_BMAPIFORMAT))) {
4566 XFS_ERROR_REPORT("xfs_bmapi_delay", XFS_ERRLEVEL_LOW, mp);
4567 return XFS_ERROR(EFSCORRUPTED);
4568 }
4569
4570 if (XFS_FORCED_SHUTDOWN(mp))
4571 return XFS_ERROR(EIO);
4572
4573 XFS_STATS_INC(xs_blk_mapw);
4574
4575 if (!(ifp->if_flags & XFS_IFEXTENTS)) {
4576 error = xfs_iread_extents(NULL, ip, XFS_DATA_FORK);
4577 if (error)
4578 return error;
4579 }
4580
4581 xfs_bmap_search_extents(ip, bno, XFS_DATA_FORK, &eof, &lastx, &got, &prev);
4582 end = bno + len;
4583 obno = bno;
4584
4585 while (bno < end && n < *nmap) {
4586 if (eof || got.br_startoff > bno) {
4587 error = xfs_bmapi_reserve_delalloc(ip, bno, len, &got,
4588 &prev, &lastx, eof);
4589 if (error) {
4590 if (n == 0) {
4591 *nmap = 0;
4592 return error;
4593 }
4594 break;
4595 }
4596 }
4597
4598 /* set up the extent map to return. */
4599 xfs_bmapi_trim_map(mval, &got, &bno, len, obno, end, n, flags);
4600 xfs_bmapi_update_map(&mval, &bno, &len, obno, end, &n, flags);
4601
4602 /* If we're done, stop now. */
4603 if (bno >= end || n >= *nmap)
4604 break;
4605
4606 /* Else go on to the next record. */
4607 prev = got;
4608 if (++lastx < ifp->if_bytes / sizeof(xfs_bmbt_rec_t))
4609 xfs_bmbt_get_all(xfs_iext_get_ext(ifp, lastx), &got);
4610 else
4611 eof = 1;
4612 }
4613
4614 *nmap = n;
4615 return 0;
4616}
4617
4618
4619STATIC int
4620xfs_bmapi_allocate(
4621 struct xfs_bmalloca *bma,
4622 int flags)
4623{
4624 struct xfs_mount *mp = bma->ip->i_mount;
4625 int whichfork = (flags & XFS_BMAPI_ATTRFORK) ?
4626 XFS_ATTR_FORK : XFS_DATA_FORK;
4627 struct xfs_ifork *ifp = XFS_IFORK_PTR(bma->ip, whichfork);
4628 int tmp_logflags = 0;
4629 int error;
4630 int rt;
4631
4632 rt = (whichfork == XFS_DATA_FORK) && XFS_IS_REALTIME_INODE(bma->ip);
4633
4634 /*
4635 * For the wasdelay case, we could also just allocate the stuff asked
4636 * for in this bmap call but that wouldn't be as good.
4637 */
4638 if (bma->wasdel) {
4639 bma->length = (xfs_extlen_t)bma->got.br_blockcount;
4640 bma->offset = bma->got.br_startoff;
4641 if (bma->idx != NULLEXTNUM && bma->idx) {
4642 xfs_bmbt_get_all(xfs_iext_get_ext(ifp, bma->idx - 1),
4643 &bma->prev);
4644 }
4645 } else {
4646 bma->length = XFS_FILBLKS_MIN(bma->length, MAXEXTLEN);
4647 if (!bma->eof)
4648 bma->length = XFS_FILBLKS_MIN(bma->length,
4649 bma->got.br_startoff - bma->offset);
4650 }
4651
4652 /*
4653 * Indicate if this is the first user data in the file, or just any
4654 * user data.
4655 */
4656 if (!(flags & XFS_BMAPI_METADATA)) {
4657 bma->userdata = (bma->offset == 0) ?
4658 XFS_ALLOC_INITIAL_USER_DATA : XFS_ALLOC_USERDATA;
4659 }
4660
4661 bma->minlen = (flags & XFS_BMAPI_CONTIG) ? bma->length : 1;
4662
4663 /*
4664 * Only want to do the alignment at the eof if it is userdata and
4665 * allocation length is larger than a stripe unit.
4666 */
4667 if (mp->m_dalign && bma->length >= mp->m_dalign &&
4668 !(flags & XFS_BMAPI_METADATA) && whichfork == XFS_DATA_FORK) {
4669 error = xfs_bmap_isaeof(bma, whichfork);
4670 if (error)
4671 return error;
4672 }
4673
4674 error = xfs_bmap_alloc(bma);
4675 if (error)
4676 return error;
4677
4678 if (bma->flist->xbf_low)
4679 bma->minleft = 0;
4680 if (bma->cur)
4681 bma->cur->bc_private.b.firstblock = *bma->firstblock;
4682 if (bma->blkno == NULLFSBLOCK)
4683 return 0;
4684 if ((ifp->if_flags & XFS_IFBROOT) && !bma->cur) {
4685 bma->cur = xfs_bmbt_init_cursor(mp, bma->tp, bma->ip, whichfork);
4686 bma->cur->bc_private.b.firstblock = *bma->firstblock;
4687 bma->cur->bc_private.b.flist = bma->flist;
4688 }
4689 /*
4690 * Bump the number of extents we've allocated
4691 * in this call.
4692 */
4693 bma->nallocs++;
4694
4695 if (bma->cur)
4696 bma->cur->bc_private.b.flags =
4697 bma->wasdel ? XFS_BTCUR_BPRV_WASDEL : 0;
4698
4699 bma->got.br_startoff = bma->offset;
4700 bma->got.br_startblock = bma->blkno;
4701 bma->got.br_blockcount = bma->length;
4702 bma->got.br_state = XFS_EXT_NORM;
4703
4704 /*
4705 * A wasdelay extent has been initialized, so shouldn't be flagged
4706 * as unwritten.
4707 */
4708 if (!bma->wasdel && (flags & XFS_BMAPI_PREALLOC) &&
4709 xfs_sb_version_hasextflgbit(&mp->m_sb))
4710 bma->got.br_state = XFS_EXT_UNWRITTEN;
4711
4712 if (bma->wasdel)
4713 error = xfs_bmap_add_extent_delay_real(bma);
4714 else
4715 error = xfs_bmap_add_extent_hole_real(bma, whichfork);
4716
4717 bma->logflags |= tmp_logflags;
4718 if (error)
4719 return error;
4720
4721 /*
4722 * Update our extent pointer, given that xfs_bmap_add_extent_delay_real
4723 * or xfs_bmap_add_extent_hole_real might have merged it into one of
4724 * the neighbouring ones.
4725 */
4726 xfs_bmbt_get_all(xfs_iext_get_ext(ifp, bma->idx), &bma->got);
4727
4728 ASSERT(bma->got.br_startoff <= bma->offset);
4729 ASSERT(bma->got.br_startoff + bma->got.br_blockcount >=
4730 bma->offset + bma->length);
4731 ASSERT(bma->got.br_state == XFS_EXT_NORM ||
4732 bma->got.br_state == XFS_EXT_UNWRITTEN);
4733 return 0;
4734}
4735
4736STATIC int
4737xfs_bmapi_convert_unwritten(
4738 struct xfs_bmalloca *bma,
4739 struct xfs_bmbt_irec *mval,
4740 xfs_filblks_t len,
4741 int flags)
4742{
4743 int whichfork = (flags & XFS_BMAPI_ATTRFORK) ?
4744 XFS_ATTR_FORK : XFS_DATA_FORK;
4745 struct xfs_ifork *ifp = XFS_IFORK_PTR(bma->ip, whichfork);
4746 int tmp_logflags = 0;
4747 int error;
4748
4749 /* check if we need to do unwritten->real conversion */
4750 if (mval->br_state == XFS_EXT_UNWRITTEN &&
4751 (flags & XFS_BMAPI_PREALLOC))
4752 return 0;
4753
4754 /* check if we need to do real->unwritten conversion */
4755 if (mval->br_state == XFS_EXT_NORM &&
4756 (flags & (XFS_BMAPI_PREALLOC | XFS_BMAPI_CONVERT)) !=
4757 (XFS_BMAPI_PREALLOC | XFS_BMAPI_CONVERT))
4758 return 0;
4759
4760 /*
4761 * Modify (by adding) the state flag, if writing.
4762 */
4763 ASSERT(mval->br_blockcount <= len);
4764 if ((ifp->if_flags & XFS_IFBROOT) && !bma->cur) {
4765 bma->cur = xfs_bmbt_init_cursor(bma->ip->i_mount, bma->tp,
4766 bma->ip, whichfork);
4767 bma->cur->bc_private.b.firstblock = *bma->firstblock;
4768 bma->cur->bc_private.b.flist = bma->flist;
4769 }
4770 mval->br_state = (mval->br_state == XFS_EXT_UNWRITTEN)
4771 ? XFS_EXT_NORM : XFS_EXT_UNWRITTEN;
4772
4773 error = xfs_bmap_add_extent_unwritten_real(bma->tp, bma->ip, &bma->idx,
4774 &bma->cur, mval, bma->firstblock, bma->flist,
4775 &tmp_logflags);
4776 bma->logflags |= tmp_logflags;
4777 if (error)
4778 return error;
4779
4780 /*
4781 * Update our extent pointer, given that
4782 * xfs_bmap_add_extent_unwritten_real might have merged it into one
4783 * of the neighbouring ones.
4784 */
4785 xfs_bmbt_get_all(xfs_iext_get_ext(ifp, bma->idx), &bma->got);
4786
4787 /*
4788 * We may have combined previously unwritten space with written space,
4789 * so generate another request.
4790 */
4791 if (mval->br_blockcount < len)
4792 return EAGAIN;
4793 return 0;
4794}
4795
4796/*
4797 * Map file blocks to filesystem blocks, and allocate blocks or convert the
4798 * extent state if necessary. Details behaviour is controlled by the flags
4799 * parameter. Only allocates blocks from a single allocation group, to avoid
4800 * locking problems.
4801 *
4302 * The returned value in "firstblock" from the first call in a transaction 4802 * The returned value in "firstblock" from the first call in a transaction
4303 * must be remembered and presented to subsequent calls in "firstblock". 4803 * must be remembered and presented to subsequent calls in "firstblock".
4304 * An upper bound for the number of blocks to be allocated is supplied to 4804 * An upper bound for the number of blocks to be allocated is supplied to
4305 * the first call in "total"; if no allocation group has that many free 4805 * the first call in "total"; if no allocation group has that many free
4306 * blocks then the call will fail (return NULLFSBLOCK in "firstblock"). 4806 * blocks then the call will fail (return NULLFSBLOCK in "firstblock").
4307 */ 4807 */
4308int /* error */ 4808int
4309xfs_bmapi( 4809xfs_bmapi_write(
4310 xfs_trans_t *tp, /* transaction pointer */ 4810 struct xfs_trans *tp, /* transaction pointer */
4311 xfs_inode_t *ip, /* incore inode */ 4811 struct xfs_inode *ip, /* incore inode */
4312 xfs_fileoff_t bno, /* starting file offs. mapped */ 4812 xfs_fileoff_t bno, /* starting file offs. mapped */
4313 xfs_filblks_t len, /* length to map in file */ 4813 xfs_filblks_t len, /* length to map in file */
4314 int flags, /* XFS_BMAPI_... */ 4814 int flags, /* XFS_BMAPI_... */
4315 xfs_fsblock_t *firstblock, /* first allocated block 4815 xfs_fsblock_t *firstblock, /* first allocated block
4316 controls a.g. for allocs */ 4816 controls a.g. for allocs */
4317 xfs_extlen_t total, /* total blocks needed */ 4817 xfs_extlen_t total, /* total blocks needed */
4318 xfs_bmbt_irec_t *mval, /* output: map values */ 4818 struct xfs_bmbt_irec *mval, /* output: map values */
4319 int *nmap, /* i/o: mval size/count */ 4819 int *nmap, /* i/o: mval size/count */
4320 xfs_bmap_free_t *flist) /* i/o: list extents to free */ 4820 struct xfs_bmap_free *flist) /* i/o: list extents to free */
4321{ 4821{
4322 xfs_fsblock_t abno; /* allocated block number */ 4822 struct xfs_mount *mp = ip->i_mount;
4323 xfs_extlen_t alen; /* allocated extent length */ 4823 struct xfs_ifork *ifp;
4324 xfs_fileoff_t aoff; /* allocated file offset */ 4824 struct xfs_bmalloca bma = { 0 }; /* args for xfs_bmap_alloc */
4325 xfs_bmalloca_t bma = { 0 }; /* args for xfs_bmap_alloc */ 4825 xfs_fileoff_t end; /* end of mapped file region */
4326 xfs_btree_cur_t *cur; /* bmap btree cursor */ 4826 int eof; /* after the end of extents */
4327 xfs_fileoff_t end; /* end of mapped file region */ 4827 int error; /* error return */
4328 int eof; /* we've hit the end of extents */ 4828 int n; /* current extent index */
4329 xfs_bmbt_rec_host_t *ep; /* extent record pointer */ 4829 xfs_fileoff_t obno; /* old block number (offset) */
4330 int error; /* error return */ 4830 int whichfork; /* data or attr fork */
4331 xfs_bmbt_irec_t got; /* current file extent record */ 4831 char inhole; /* current location is hole in file */
4332 xfs_ifork_t *ifp; /* inode fork pointer */ 4832 char wasdelay; /* old extent was delayed */
4333 xfs_extlen_t indlen; /* indirect blocks length */ 4833
4334 xfs_extnum_t lastx; /* last useful extent number */
4335 int logflags; /* flags for transaction logging */
4336 xfs_extlen_t minleft; /* min blocks left after allocation */
4337 xfs_extlen_t minlen; /* min allocation size */
4338 xfs_mount_t *mp; /* xfs mount structure */
4339 int n; /* current extent index */
4340 int nallocs; /* number of extents alloc'd */
4341 xfs_extnum_t nextents; /* number of extents in file */
4342 xfs_fileoff_t obno; /* old block number (offset) */
4343 xfs_bmbt_irec_t prev; /* previous file extent record */
4344 int tmp_logflags; /* temp flags holder */
4345 int whichfork; /* data or attr fork */
4346 char inhole; /* current location is hole in file */
4347 char wasdelay; /* old extent was delayed */
4348 char wr; /* this is a write request */
4349 char rt; /* this is a realtime file */
4350#ifdef DEBUG 4834#ifdef DEBUG
4351 xfs_fileoff_t orig_bno; /* original block number value */ 4835 xfs_fileoff_t orig_bno; /* original block number value */
4352 int orig_flags; /* original flags arg value */ 4836 int orig_flags; /* original flags arg value */
4353 xfs_filblks_t orig_len; /* original value of len arg */ 4837 xfs_filblks_t orig_len; /* original value of len arg */
4354 xfs_bmbt_irec_t *orig_mval; /* original value of mval */ 4838 struct xfs_bmbt_irec *orig_mval; /* original value of mval */
4355 int orig_nmap; /* original value of *nmap */ 4839 int orig_nmap; /* original value of *nmap */
4356 4840
4357 orig_bno = bno; 4841 orig_bno = bno;
4358 orig_len = len; 4842 orig_len = len;
@@ -4360,488 +4844,133 @@ xfs_bmapi(
4360 orig_mval = mval; 4844 orig_mval = mval;
4361 orig_nmap = *nmap; 4845 orig_nmap = *nmap;
4362#endif 4846#endif
4847
4363 ASSERT(*nmap >= 1); 4848 ASSERT(*nmap >= 1);
4364 ASSERT(*nmap <= XFS_BMAP_MAX_NMAP || !(flags & XFS_BMAPI_WRITE)); 4849 ASSERT(*nmap <= XFS_BMAP_MAX_NMAP);
4850 ASSERT(!(flags & XFS_BMAPI_IGSTATE));
4851 ASSERT(tp != NULL);
4852
4365 whichfork = (flags & XFS_BMAPI_ATTRFORK) ? 4853 whichfork = (flags & XFS_BMAPI_ATTRFORK) ?
4366 XFS_ATTR_FORK : XFS_DATA_FORK; 4854 XFS_ATTR_FORK : XFS_DATA_FORK;
4367 mp = ip->i_mount; 4855
4368 if (unlikely(XFS_TEST_ERROR( 4856 if (unlikely(XFS_TEST_ERROR(
4369 (XFS_IFORK_FORMAT(ip, whichfork) != XFS_DINODE_FMT_EXTENTS && 4857 (XFS_IFORK_FORMAT(ip, whichfork) != XFS_DINODE_FMT_EXTENTS &&
4370 XFS_IFORK_FORMAT(ip, whichfork) != XFS_DINODE_FMT_BTREE && 4858 XFS_IFORK_FORMAT(ip, whichfork) != XFS_DINODE_FMT_BTREE &&
4371 XFS_IFORK_FORMAT(ip, whichfork) != XFS_DINODE_FMT_LOCAL), 4859 XFS_IFORK_FORMAT(ip, whichfork) != XFS_DINODE_FMT_LOCAL),
4372 mp, XFS_ERRTAG_BMAPIFORMAT, XFS_RANDOM_BMAPIFORMAT))) { 4860 mp, XFS_ERRTAG_BMAPIFORMAT, XFS_RANDOM_BMAPIFORMAT))) {
4373 XFS_ERROR_REPORT("xfs_bmapi", XFS_ERRLEVEL_LOW, mp); 4861 XFS_ERROR_REPORT("xfs_bmapi_write", XFS_ERRLEVEL_LOW, mp);
4374 return XFS_ERROR(EFSCORRUPTED); 4862 return XFS_ERROR(EFSCORRUPTED);
4375 } 4863 }
4864
4376 if (XFS_FORCED_SHUTDOWN(mp)) 4865 if (XFS_FORCED_SHUTDOWN(mp))
4377 return XFS_ERROR(EIO); 4866 return XFS_ERROR(EIO);
4378 rt = (whichfork == XFS_DATA_FORK) && XFS_IS_REALTIME_INODE(ip); 4867
4379 ifp = XFS_IFORK_PTR(ip, whichfork); 4868 ifp = XFS_IFORK_PTR(ip, whichfork);
4380 ASSERT(ifp->if_ext_max == 4869 ASSERT(ifp->if_ext_max ==
4381 XFS_IFORK_SIZE(ip, whichfork) / (uint)sizeof(xfs_bmbt_rec_t)); 4870 XFS_IFORK_SIZE(ip, whichfork) / (uint)sizeof(xfs_bmbt_rec_t));
4382 if ((wr = (flags & XFS_BMAPI_WRITE)) != 0) 4871
4383 XFS_STATS_INC(xs_blk_mapw); 4872 XFS_STATS_INC(xs_blk_mapw);
4384 else 4873
4385 XFS_STATS_INC(xs_blk_mapr);
4386 /*
4387 * IGSTATE flag is used to combine extents which
4388 * differ only due to the state of the extents.
4389 * This technique is used from xfs_getbmap()
4390 * when the caller does not wish to see the
4391 * separation (which is the default).
4392 *
4393 * This technique is also used when writing a
4394 * buffer which has been partially written,
4395 * (usually by being flushed during a chunkread),
4396 * to ensure one write takes place. This also
4397 * prevents a change in the xfs inode extents at
4398 * this time, intentionally. This change occurs
4399 * on completion of the write operation, in
4400 * xfs_strat_comp(), where the xfs_bmapi() call
4401 * is transactioned, and the extents combined.
4402 */
4403 if ((flags & XFS_BMAPI_IGSTATE) && wr) /* if writing unwritten space */
4404 wr = 0; /* no allocations are allowed */
4405 ASSERT(wr || !(flags & XFS_BMAPI_DELAY));
4406 logflags = 0;
4407 nallocs = 0;
4408 cur = NULL;
4409 if (XFS_IFORK_FORMAT(ip, whichfork) == XFS_DINODE_FMT_LOCAL) { 4874 if (XFS_IFORK_FORMAT(ip, whichfork) == XFS_DINODE_FMT_LOCAL) {
4410 ASSERT(wr && tp); 4875 error = xfs_bmap_local_to_extents(tp, ip, firstblock, total,
4411 if ((error = xfs_bmap_local_to_extents(tp, ip, 4876 &bma.logflags, whichfork);
4412 firstblock, total, &logflags, whichfork))) 4877 if (error)
4413 goto error0; 4878 goto error0;
4414 } 4879 }
4415 if (wr && *firstblock == NULLFSBLOCK) { 4880
4881 if (*firstblock == NULLFSBLOCK) {
4416 if (XFS_IFORK_FORMAT(ip, whichfork) == XFS_DINODE_FMT_BTREE) 4882 if (XFS_IFORK_FORMAT(ip, whichfork) == XFS_DINODE_FMT_BTREE)
4417 minleft = be16_to_cpu(ifp->if_broot->bb_level) + 1; 4883 bma.minleft = be16_to_cpu(ifp->if_broot->bb_level) + 1;
4418 else 4884 else
4419 minleft = 1; 4885 bma.minleft = 1;
4420 } else 4886 } else {
4421 minleft = 0; 4887 bma.minleft = 0;
4422 if (!(ifp->if_flags & XFS_IFEXTENTS) && 4888 }
4423 (error = xfs_iread_extents(tp, ip, whichfork))) 4889
4424 goto error0; 4890 if (!(ifp->if_flags & XFS_IFEXTENTS)) {
4425 ep = xfs_bmap_search_extents(ip, bno, whichfork, &eof, &lastx, &got, 4891 error = xfs_iread_extents(tp, ip, whichfork);
4426 &prev); 4892 if (error)
4427 nextents = ifp->if_bytes / (uint)sizeof(xfs_bmbt_rec_t); 4893 goto error0;
4894 }
4895
4896 xfs_bmap_search_extents(ip, bno, whichfork, &eof, &bma.idx, &bma.got,
4897 &bma.prev);
4428 n = 0; 4898 n = 0;
4429 end = bno + len; 4899 end = bno + len;
4430 obno = bno; 4900 obno = bno;
4431 bma.ip = NULL; 4901
4902 bma.tp = tp;
4903 bma.ip = ip;
4904 bma.total = total;
4905 bma.userdata = 0;
4906 bma.flist = flist;
4907 bma.firstblock = firstblock;
4432 4908
4433 while (bno < end && n < *nmap) { 4909 while (bno < end && n < *nmap) {
4434 /* 4910 inhole = eof || bma.got.br_startoff > bno;
4435 * Reading past eof, act as though there's a hole 4911 wasdelay = !inhole && isnullstartblock(bma.got.br_startblock);
4436 * up to end. 4912
4437 */
4438 if (eof && !wr)
4439 got.br_startoff = end;
4440 inhole = eof || got.br_startoff > bno;
4441 wasdelay = wr && !inhole && !(flags & XFS_BMAPI_DELAY) &&
4442 isnullstartblock(got.br_startblock);
4443 /* 4913 /*
4444 * First, deal with the hole before the allocated space 4914 * First, deal with the hole before the allocated space
4445 * that we found, if any. 4915 * that we found, if any.
4446 */ 4916 */
4447 if (wr && (inhole || wasdelay)) { 4917 if (inhole || wasdelay) {
4448 /* 4918 bma.eof = eof;
4449 * For the wasdelay case, we could also just 4919 bma.conv = !!(flags & XFS_BMAPI_CONVERT);
4450 * allocate the stuff asked for in this bmap call 4920 bma.wasdel = wasdelay;
4451 * but that wouldn't be as good. 4921 bma.length = len;
4452 */ 4922 bma.offset = bno;
4453 if (wasdelay) { 4923
4454 alen = (xfs_extlen_t)got.br_blockcount; 4924 error = xfs_bmapi_allocate(&bma, flags);
4455 aoff = got.br_startoff;
4456 if (lastx != NULLEXTNUM && lastx) {
4457 ep = xfs_iext_get_ext(ifp, lastx - 1);
4458 xfs_bmbt_get_all(ep, &prev);
4459 }
4460 } else {
4461 alen = (xfs_extlen_t)
4462 XFS_FILBLKS_MIN(len, MAXEXTLEN);
4463 if (!eof)
4464 alen = (xfs_extlen_t)
4465 XFS_FILBLKS_MIN(alen,
4466 got.br_startoff - bno);
4467 aoff = bno;
4468 }
4469 minlen = (flags & XFS_BMAPI_CONTIG) ? alen : 1;
4470 if (flags & XFS_BMAPI_DELAY) {
4471 xfs_extlen_t extsz;
4472
4473 /* Figure out the extent size, adjust alen */
4474 extsz = xfs_get_extsz_hint(ip);
4475 if (extsz) {
4476 /*
4477 * make sure we don't exceed a single
4478 * extent length when we align the
4479 * extent by reducing length we are
4480 * going to allocate by the maximum
4481 * amount extent size aligment may
4482 * require.
4483 */
4484 alen = XFS_FILBLKS_MIN(len,
4485 MAXEXTLEN - (2 * extsz - 1));
4486 error = xfs_bmap_extsize_align(mp,
4487 &got, &prev, extsz,
4488 rt, eof,
4489 flags&XFS_BMAPI_DELAY,
4490 flags&XFS_BMAPI_CONVERT,
4491 &aoff, &alen);
4492 ASSERT(!error);
4493 }
4494
4495 if (rt)
4496 extsz = alen / mp->m_sb.sb_rextsize;
4497
4498 /*
4499 * Make a transaction-less quota reservation for
4500 * delayed allocation blocks. This number gets
4501 * adjusted later. We return if we haven't
4502 * allocated blocks already inside this loop.
4503 */
4504 error = xfs_trans_reserve_quota_nblks(
4505 NULL, ip, (long)alen, 0,
4506 rt ? XFS_QMOPT_RES_RTBLKS :
4507 XFS_QMOPT_RES_REGBLKS);
4508 if (error) {
4509 if (n == 0) {
4510 *nmap = 0;
4511 ASSERT(cur == NULL);
4512 return error;
4513 }
4514 break;
4515 }
4516
4517 /*
4518 * Split changing sb for alen and indlen since
4519 * they could be coming from different places.
4520 */
4521 indlen = (xfs_extlen_t)
4522 xfs_bmap_worst_indlen(ip, alen);
4523 ASSERT(indlen > 0);
4524
4525 if (rt) {
4526 error = xfs_mod_incore_sb(mp,
4527 XFS_SBS_FREXTENTS,
4528 -((int64_t)extsz), 0);
4529 } else {
4530 error = xfs_icsb_modify_counters(mp,
4531 XFS_SBS_FDBLOCKS,
4532 -((int64_t)alen), 0);
4533 }
4534 if (!error) {
4535 error = xfs_icsb_modify_counters(mp,
4536 XFS_SBS_FDBLOCKS,
4537 -((int64_t)indlen), 0);
4538 if (error && rt)
4539 xfs_mod_incore_sb(mp,
4540 XFS_SBS_FREXTENTS,
4541 (int64_t)extsz, 0);
4542 else if (error)
4543 xfs_icsb_modify_counters(mp,
4544 XFS_SBS_FDBLOCKS,
4545 (int64_t)alen, 0);
4546 }
4547
4548 if (error) {
4549 if (XFS_IS_QUOTA_ON(mp))
4550 /* unreserve the blocks now */
4551 (void)
4552 xfs_trans_unreserve_quota_nblks(
4553 NULL, ip,
4554 (long)alen, 0, rt ?
4555 XFS_QMOPT_RES_RTBLKS :
4556 XFS_QMOPT_RES_REGBLKS);
4557 break;
4558 }
4559
4560 ip->i_delayed_blks += alen;
4561 abno = nullstartblock(indlen);
4562 } else {
4563 /*
4564 * If first time, allocate and fill in
4565 * once-only bma fields.
4566 */
4567 if (bma.ip == NULL) {
4568 bma.tp = tp;
4569 bma.ip = ip;
4570 bma.prevp = &prev;
4571 bma.gotp = &got;
4572 bma.total = total;
4573 bma.userdata = 0;
4574 }
4575 /* Indicate if this is the first user data
4576 * in the file, or just any user data.
4577 */
4578 if (!(flags & XFS_BMAPI_METADATA)) {
4579 bma.userdata = (aoff == 0) ?
4580 XFS_ALLOC_INITIAL_USER_DATA :
4581 XFS_ALLOC_USERDATA;
4582 }
4583 /*
4584 * Fill in changeable bma fields.
4585 */
4586 bma.eof = eof;
4587 bma.firstblock = *firstblock;
4588 bma.alen = alen;
4589 bma.off = aoff;
4590 bma.conv = !!(flags & XFS_BMAPI_CONVERT);
4591 bma.wasdel = wasdelay;
4592 bma.minlen = minlen;
4593 bma.low = flist->xbf_low;
4594 bma.minleft = minleft;
4595 /*
4596 * Only want to do the alignment at the
4597 * eof if it is userdata and allocation length
4598 * is larger than a stripe unit.
4599 */
4600 if (mp->m_dalign && alen >= mp->m_dalign &&
4601 (!(flags & XFS_BMAPI_METADATA)) &&
4602 (whichfork == XFS_DATA_FORK)) {
4603 if ((error = xfs_bmap_isaeof(ip, aoff,
4604 whichfork, &bma.aeof)))
4605 goto error0;
4606 } else
4607 bma.aeof = 0;
4608 /*
4609 * Call allocator.
4610 */
4611 if ((error = xfs_bmap_alloc(&bma)))
4612 goto error0;
4613 /*
4614 * Copy out result fields.
4615 */
4616 abno = bma.rval;
4617 if ((flist->xbf_low = bma.low))
4618 minleft = 0;
4619 alen = bma.alen;
4620 aoff = bma.off;
4621 ASSERT(*firstblock == NULLFSBLOCK ||
4622 XFS_FSB_TO_AGNO(mp, *firstblock) ==
4623 XFS_FSB_TO_AGNO(mp, bma.firstblock) ||
4624 (flist->xbf_low &&
4625 XFS_FSB_TO_AGNO(mp, *firstblock) <
4626 XFS_FSB_TO_AGNO(mp, bma.firstblock)));
4627 *firstblock = bma.firstblock;
4628 if (cur)
4629 cur->bc_private.b.firstblock =
4630 *firstblock;
4631 if (abno == NULLFSBLOCK)
4632 break;
4633 if ((ifp->if_flags & XFS_IFBROOT) && !cur) {
4634 cur = xfs_bmbt_init_cursor(mp, tp,
4635 ip, whichfork);
4636 cur->bc_private.b.firstblock =
4637 *firstblock;
4638 cur->bc_private.b.flist = flist;
4639 }
4640 /*
4641 * Bump the number of extents we've allocated
4642 * in this call.
4643 */
4644 nallocs++;
4645 }
4646 if (cur)
4647 cur->bc_private.b.flags =
4648 wasdelay ? XFS_BTCUR_BPRV_WASDEL : 0;
4649 got.br_startoff = aoff;
4650 got.br_startblock = abno;
4651 got.br_blockcount = alen;
4652 got.br_state = XFS_EXT_NORM; /* assume normal */
4653 /*
4654 * Determine state of extent, and the filesystem.
4655 * A wasdelay extent has been initialized, so
4656 * shouldn't be flagged as unwritten.
4657 */
4658 if (wr && xfs_sb_version_hasextflgbit(&mp->m_sb)) {
4659 if (!wasdelay && (flags & XFS_BMAPI_PREALLOC))
4660 got.br_state = XFS_EXT_UNWRITTEN;
4661 }
4662 error = xfs_bmap_add_extent(tp, ip, &lastx, &cur, &got,
4663 firstblock, flist, &tmp_logflags,
4664 whichfork);
4665 logflags |= tmp_logflags;
4666 if (error) 4925 if (error)
4667 goto error0; 4926 goto error0;
4668 ep = xfs_iext_get_ext(ifp, lastx); 4927 if (bma.blkno == NULLFSBLOCK)
4669 nextents = ifp->if_bytes / (uint)sizeof(xfs_bmbt_rec_t); 4928 break;
4670 xfs_bmbt_get_all(ep, &got);
4671 ASSERT(got.br_startoff <= aoff);
4672 ASSERT(got.br_startoff + got.br_blockcount >=
4673 aoff + alen);
4674#ifdef DEBUG
4675 if (flags & XFS_BMAPI_DELAY) {
4676 ASSERT(isnullstartblock(got.br_startblock));
4677 ASSERT(startblockval(got.br_startblock) > 0);
4678 }
4679 ASSERT(got.br_state == XFS_EXT_NORM ||
4680 got.br_state == XFS_EXT_UNWRITTEN);
4681#endif
4682 /*
4683 * Fall down into the found allocated space case.
4684 */
4685 } else if (inhole) {
4686 /*
4687 * Reading in a hole.
4688 */
4689 mval->br_startoff = bno;
4690 mval->br_startblock = HOLESTARTBLOCK;
4691 mval->br_blockcount =
4692 XFS_FILBLKS_MIN(len, got.br_startoff - bno);
4693 mval->br_state = XFS_EXT_NORM;
4694 bno += mval->br_blockcount;
4695 len -= mval->br_blockcount;
4696 mval++;
4697 n++;
4698 continue;
4699 }
4700 /*
4701 * Then deal with the allocated space we found.
4702 */
4703 ASSERT(ep != NULL);
4704 if (!(flags & XFS_BMAPI_ENTIRE) &&
4705 (got.br_startoff + got.br_blockcount > obno)) {
4706 if (obno > bno)
4707 bno = obno;
4708 ASSERT((bno >= obno) || (n == 0));
4709 ASSERT(bno < end);
4710 mval->br_startoff = bno;
4711 if (isnullstartblock(got.br_startblock)) {
4712 ASSERT(!wr || (flags & XFS_BMAPI_DELAY));
4713 mval->br_startblock = DELAYSTARTBLOCK;
4714 } else
4715 mval->br_startblock =
4716 got.br_startblock +
4717 (bno - got.br_startoff);
4718 /*
4719 * Return the minimum of what we got and what we
4720 * asked for for the length. We can use the len
4721 * variable here because it is modified below
4722 * and we could have been there before coming
4723 * here if the first part of the allocation
4724 * didn't overlap what was asked for.
4725 */
4726 mval->br_blockcount =
4727 XFS_FILBLKS_MIN(end - bno, got.br_blockcount -
4728 (bno - got.br_startoff));
4729 mval->br_state = got.br_state;
4730 ASSERT(mval->br_blockcount <= len);
4731 } else {
4732 *mval = got;
4733 if (isnullstartblock(mval->br_startblock)) {
4734 ASSERT(!wr || (flags & XFS_BMAPI_DELAY));
4735 mval->br_startblock = DELAYSTARTBLOCK;
4736 }
4737 } 4929 }
4738 4930
4739 /* 4931 /* Deal with the allocated space we found. */
4740 * Check if writing previously allocated but 4932 xfs_bmapi_trim_map(mval, &bma.got, &bno, len, obno,
4741 * unwritten extents. 4933 end, n, flags);
4742 */ 4934
4743 if (wr && 4935 /* Execute unwritten extent conversion if necessary */
4744 ((mval->br_state == XFS_EXT_UNWRITTEN && 4936 error = xfs_bmapi_convert_unwritten(&bma, mval, len, flags);
4745 ((flags & (XFS_BMAPI_PREALLOC|XFS_BMAPI_DELAY)) == 0)) || 4937 if (error == EAGAIN)
4746 (mval->br_state == XFS_EXT_NORM && 4938 continue;
4747 ((flags & (XFS_BMAPI_PREALLOC|XFS_BMAPI_CONVERT)) == 4939 if (error)
4748 (XFS_BMAPI_PREALLOC|XFS_BMAPI_CONVERT))))) { 4940 goto error0;
4749 /* 4941
4750 * Modify (by adding) the state flag, if writing. 4942 /* update the extent map to return */
4751 */ 4943 xfs_bmapi_update_map(&mval, &bno, &len, obno, end, &n, flags);
4752 ASSERT(mval->br_blockcount <= len);
4753 if ((ifp->if_flags & XFS_IFBROOT) && !cur) {
4754 cur = xfs_bmbt_init_cursor(mp,
4755 tp, ip, whichfork);
4756 cur->bc_private.b.firstblock =
4757 *firstblock;
4758 cur->bc_private.b.flist = flist;
4759 }
4760 mval->br_state = (mval->br_state == XFS_EXT_UNWRITTEN)
4761 ? XFS_EXT_NORM
4762 : XFS_EXT_UNWRITTEN;
4763 error = xfs_bmap_add_extent(tp, ip, &lastx, &cur, mval,
4764 firstblock, flist, &tmp_logflags,
4765 whichfork);
4766 logflags |= tmp_logflags;
4767 if (error)
4768 goto error0;
4769 ep = xfs_iext_get_ext(ifp, lastx);
4770 nextents = ifp->if_bytes / (uint)sizeof(xfs_bmbt_rec_t);
4771 xfs_bmbt_get_all(ep, &got);
4772 /*
4773 * We may have combined previously unwritten
4774 * space with written space, so generate
4775 * another request.
4776 */
4777 if (mval->br_blockcount < len)
4778 continue;
4779 }
4780 4944
4781 ASSERT((flags & XFS_BMAPI_ENTIRE) ||
4782 ((mval->br_startoff + mval->br_blockcount) <= end));
4783 ASSERT((flags & XFS_BMAPI_ENTIRE) ||
4784 (mval->br_blockcount <= len) ||
4785 (mval->br_startoff < obno));
4786 bno = mval->br_startoff + mval->br_blockcount;
4787 len = end - bno;
4788 if (n > 0 && mval->br_startoff == mval[-1].br_startoff) {
4789 ASSERT(mval->br_startblock == mval[-1].br_startblock);
4790 ASSERT(mval->br_blockcount > mval[-1].br_blockcount);
4791 ASSERT(mval->br_state == mval[-1].br_state);
4792 mval[-1].br_blockcount = mval->br_blockcount;
4793 mval[-1].br_state = mval->br_state;
4794 } else if (n > 0 && mval->br_startblock != DELAYSTARTBLOCK &&
4795 mval[-1].br_startblock != DELAYSTARTBLOCK &&
4796 mval[-1].br_startblock != HOLESTARTBLOCK &&
4797 mval->br_startblock ==
4798 mval[-1].br_startblock + mval[-1].br_blockcount &&
4799 ((flags & XFS_BMAPI_IGSTATE) ||
4800 mval[-1].br_state == mval->br_state)) {
4801 ASSERT(mval->br_startoff ==
4802 mval[-1].br_startoff + mval[-1].br_blockcount);
4803 mval[-1].br_blockcount += mval->br_blockcount;
4804 } else if (n > 0 &&
4805 mval->br_startblock == DELAYSTARTBLOCK &&
4806 mval[-1].br_startblock == DELAYSTARTBLOCK &&
4807 mval->br_startoff ==
4808 mval[-1].br_startoff + mval[-1].br_blockcount) {
4809 mval[-1].br_blockcount += mval->br_blockcount;
4810 mval[-1].br_state = mval->br_state;
4811 } else if (!((n == 0) &&
4812 ((mval->br_startoff + mval->br_blockcount) <=
4813 obno))) {
4814 mval++;
4815 n++;
4816 }
4817 /* 4945 /*
4818 * If we're done, stop now. Stop when we've allocated 4946 * If we're done, stop now. Stop when we've allocated
4819 * XFS_BMAP_MAX_NMAP extents no matter what. Otherwise 4947 * XFS_BMAP_MAX_NMAP extents no matter what. Otherwise
4820 * the transaction may get too big. 4948 * the transaction may get too big.
4821 */ 4949 */
4822 if (bno >= end || n >= *nmap || nallocs >= *nmap) 4950 if (bno >= end || n >= *nmap || bma.nallocs >= *nmap)
4823 break; 4951 break;
4824 /* 4952
4825 * Else go on to the next record. 4953 /* Else go on to the next record. */
4826 */ 4954 bma.prev = bma.got;
4827 prev = got; 4955 if (++bma.idx < ifp->if_bytes / sizeof(xfs_bmbt_rec_t)) {
4828 if (++lastx < nextents) { 4956 xfs_bmbt_get_all(xfs_iext_get_ext(ifp, bma.idx),
4829 ep = xfs_iext_get_ext(ifp, lastx); 4957 &bma.got);
4830 xfs_bmbt_get_all(ep, &got); 4958 } else
4831 } else {
4832 eof = 1; 4959 eof = 1;
4833 }
4834 } 4960 }
4835 *nmap = n; 4961 *nmap = n;
4962
4836 /* 4963 /*
4837 * Transform from btree to extents, give it cur. 4964 * Transform from btree to extents, give it cur.
4838 */ 4965 */
4839 if (tp && XFS_IFORK_FORMAT(ip, whichfork) == XFS_DINODE_FMT_BTREE && 4966 if (XFS_IFORK_FORMAT(ip, whichfork) == XFS_DINODE_FMT_BTREE &&
4840 XFS_IFORK_NEXTENTS(ip, whichfork) <= ifp->if_ext_max) { 4967 XFS_IFORK_NEXTENTS(ip, whichfork) <= ifp->if_ext_max) {
4841 ASSERT(wr && cur); 4968 int tmp_logflags = 0;
4842 error = xfs_bmap_btree_to_extents(tp, ip, cur, 4969
4970 ASSERT(bma.cur);
4971 error = xfs_bmap_btree_to_extents(tp, ip, bma.cur,
4843 &tmp_logflags, whichfork); 4972 &tmp_logflags, whichfork);
4844 logflags |= tmp_logflags; 4973 bma.logflags |= tmp_logflags;
4845 if (error) 4974 if (error)
4846 goto error0; 4975 goto error0;
4847 } 4976 }
@@ -4855,34 +4984,33 @@ error0:
4855 * Log everything. Do this after conversion, there's no point in 4984 * Log everything. Do this after conversion, there's no point in
4856 * logging the extent records if we've converted to btree format. 4985 * logging the extent records if we've converted to btree format.
4857 */ 4986 */
4858 if ((logflags & xfs_ilog_fext(whichfork)) && 4987 if ((bma.logflags & xfs_ilog_fext(whichfork)) &&
4859 XFS_IFORK_FORMAT(ip, whichfork) != XFS_DINODE_FMT_EXTENTS) 4988 XFS_IFORK_FORMAT(ip, whichfork) != XFS_DINODE_FMT_EXTENTS)
4860 logflags &= ~xfs_ilog_fext(whichfork); 4989 bma.logflags &= ~xfs_ilog_fext(whichfork);
4861 else if ((logflags & xfs_ilog_fbroot(whichfork)) && 4990 else if ((bma.logflags & xfs_ilog_fbroot(whichfork)) &&
4862 XFS_IFORK_FORMAT(ip, whichfork) != XFS_DINODE_FMT_BTREE) 4991 XFS_IFORK_FORMAT(ip, whichfork) != XFS_DINODE_FMT_BTREE)
4863 logflags &= ~xfs_ilog_fbroot(whichfork); 4992 bma.logflags &= ~xfs_ilog_fbroot(whichfork);
4864 /* 4993 /*
4865 * Log whatever the flags say, even if error. Otherwise we might miss 4994 * Log whatever the flags say, even if error. Otherwise we might miss
4866 * detecting a case where the data is changed, there's an error, 4995 * detecting a case where the data is changed, there's an error,
4867 * and it's not logged so we don't shutdown when we should. 4996 * and it's not logged so we don't shutdown when we should.
4868 */ 4997 */
4869 if (logflags) { 4998 if (bma.logflags)
4870 ASSERT(tp && wr); 4999 xfs_trans_log_inode(tp, ip, bma.logflags);
4871 xfs_trans_log_inode(tp, ip, logflags); 5000
4872 } 5001 if (bma.cur) {
4873 if (cur) {
4874 if (!error) { 5002 if (!error) {
4875 ASSERT(*firstblock == NULLFSBLOCK || 5003 ASSERT(*firstblock == NULLFSBLOCK ||
4876 XFS_FSB_TO_AGNO(mp, *firstblock) == 5004 XFS_FSB_TO_AGNO(mp, *firstblock) ==
4877 XFS_FSB_TO_AGNO(mp, 5005 XFS_FSB_TO_AGNO(mp,
4878 cur->bc_private.b.firstblock) || 5006 bma.cur->bc_private.b.firstblock) ||
4879 (flist->xbf_low && 5007 (flist->xbf_low &&
4880 XFS_FSB_TO_AGNO(mp, *firstblock) < 5008 XFS_FSB_TO_AGNO(mp, *firstblock) <
4881 XFS_FSB_TO_AGNO(mp, 5009 XFS_FSB_TO_AGNO(mp,
4882 cur->bc_private.b.firstblock))); 5010 bma.cur->bc_private.b.firstblock)));
4883 *firstblock = cur->bc_private.b.firstblock; 5011 *firstblock = bma.cur->bc_private.b.firstblock;
4884 } 5012 }
4885 xfs_btree_del_cursor(cur, 5013 xfs_btree_del_cursor(bma.cur,
4886 error ? XFS_BTREE_ERROR : XFS_BTREE_NOERROR); 5014 error ? XFS_BTREE_ERROR : XFS_BTREE_NOERROR);
4887 } 5015 }
4888 if (!error) 5016 if (!error)
@@ -4892,58 +5020,6 @@ error0:
4892} 5020}
4893 5021
4894/* 5022/*
4895 * Map file blocks to filesystem blocks, simple version.
4896 * One block (extent) only, read-only.
4897 * For flags, only the XFS_BMAPI_ATTRFORK flag is examined.
4898 * For the other flag values, the effect is as if XFS_BMAPI_METADATA
4899 * was set and all the others were clear.
4900 */
4901int /* error */
4902xfs_bmapi_single(
4903 xfs_trans_t *tp, /* transaction pointer */
4904 xfs_inode_t *ip, /* incore inode */
4905 int whichfork, /* data or attr fork */
4906 xfs_fsblock_t *fsb, /* output: mapped block */
4907 xfs_fileoff_t bno) /* starting file offs. mapped */
4908{
4909 int eof; /* we've hit the end of extents */
4910 int error; /* error return */
4911 xfs_bmbt_irec_t got; /* current file extent record */
4912 xfs_ifork_t *ifp; /* inode fork pointer */
4913 xfs_extnum_t lastx; /* last useful extent number */
4914 xfs_bmbt_irec_t prev; /* previous file extent record */
4915
4916 ifp = XFS_IFORK_PTR(ip, whichfork);
4917 if (unlikely(
4918 XFS_IFORK_FORMAT(ip, whichfork) != XFS_DINODE_FMT_BTREE &&
4919 XFS_IFORK_FORMAT(ip, whichfork) != XFS_DINODE_FMT_EXTENTS)) {
4920 XFS_ERROR_REPORT("xfs_bmapi_single", XFS_ERRLEVEL_LOW,
4921 ip->i_mount);
4922 return XFS_ERROR(EFSCORRUPTED);
4923 }
4924 if (XFS_FORCED_SHUTDOWN(ip->i_mount))
4925 return XFS_ERROR(EIO);
4926 XFS_STATS_INC(xs_blk_mapr);
4927 if (!(ifp->if_flags & XFS_IFEXTENTS) &&
4928 (error = xfs_iread_extents(tp, ip, whichfork)))
4929 return error;
4930 (void)xfs_bmap_search_extents(ip, bno, whichfork, &eof, &lastx, &got,
4931 &prev);
4932 /*
4933 * Reading past eof, act as though there's a hole
4934 * up to end.
4935 */
4936 if (eof || got.br_startoff > bno) {
4937 *fsb = NULLFSBLOCK;
4938 return 0;
4939 }
4940 ASSERT(!isnullstartblock(got.br_startblock));
4941 ASSERT(bno < got.br_startoff + got.br_blockcount);
4942 *fsb = got.br_startblock + (bno - got.br_startoff);
4943 return 0;
4944}
4945
4946/*
4947 * Unmap (remove) blocks from a file. 5023 * Unmap (remove) blocks from a file.
4948 * If nexts is nonzero then the number of extents to remove is limited to 5024 * If nexts is nonzero then the number of extents to remove is limited to
4949 * that value. If not all extents in the block range can be removed then 5025 * that value. If not all extents in the block range can be removed then
@@ -5114,9 +5190,9 @@ xfs_bunmapi(
5114 del.br_blockcount = mod; 5190 del.br_blockcount = mod;
5115 } 5191 }
5116 del.br_state = XFS_EXT_UNWRITTEN; 5192 del.br_state = XFS_EXT_UNWRITTEN;
5117 error = xfs_bmap_add_extent(tp, ip, &lastx, &cur, &del, 5193 error = xfs_bmap_add_extent_unwritten_real(tp, ip,
5118 firstblock, flist, &logflags, 5194 &lastx, &cur, &del, firstblock, flist,
5119 XFS_DATA_FORK); 5195 &logflags);
5120 if (error) 5196 if (error)
5121 goto error0; 5197 goto error0;
5122 goto nodelete; 5198 goto nodelete;
@@ -5172,18 +5248,18 @@ xfs_bunmapi(
5172 } 5248 }
5173 prev.br_state = XFS_EXT_UNWRITTEN; 5249 prev.br_state = XFS_EXT_UNWRITTEN;
5174 lastx--; 5250 lastx--;
5175 error = xfs_bmap_add_extent(tp, ip, &lastx, 5251 error = xfs_bmap_add_extent_unwritten_real(tp,
5176 &cur, &prev, firstblock, flist, 5252 ip, &lastx, &cur, &prev,
5177 &logflags, XFS_DATA_FORK); 5253 firstblock, flist, &logflags);
5178 if (error) 5254 if (error)
5179 goto error0; 5255 goto error0;
5180 goto nodelete; 5256 goto nodelete;
5181 } else { 5257 } else {
5182 ASSERT(del.br_state == XFS_EXT_NORM); 5258 ASSERT(del.br_state == XFS_EXT_NORM);
5183 del.br_state = XFS_EXT_UNWRITTEN; 5259 del.br_state = XFS_EXT_UNWRITTEN;
5184 error = xfs_bmap_add_extent(tp, ip, &lastx, 5260 error = xfs_bmap_add_extent_unwritten_real(tp,
5185 &cur, &del, firstblock, flist, 5261 ip, &lastx, &cur, &del,
5186 &logflags, XFS_DATA_FORK); 5262 firstblock, flist, &logflags);
5187 if (error) 5263 if (error)
5188 goto error0; 5264 goto error0;
5189 goto nodelete; 5265 goto nodelete;
@@ -5505,10 +5581,9 @@ xfs_getbmap(
5505 5581
5506 do { 5582 do {
5507 nmap = (nexleft > subnex) ? subnex : nexleft; 5583 nmap = (nexleft > subnex) ? subnex : nexleft;
5508 error = xfs_bmapi(NULL, ip, XFS_BB_TO_FSBT(mp, bmv->bmv_offset), 5584 error = xfs_bmapi_read(ip, XFS_BB_TO_FSBT(mp, bmv->bmv_offset),
5509 XFS_BB_TO_FSB(mp, bmv->bmv_length), 5585 XFS_BB_TO_FSB(mp, bmv->bmv_length),
5510 bmapi_flags, NULL, 0, map, &nmap, 5586 map, &nmap, bmapi_flags);
5511 NULL);
5512 if (error) 5587 if (error)
5513 goto out_free_map; 5588 goto out_free_map;
5514 ASSERT(nmap <= subnex); 5589 ASSERT(nmap <= subnex);
@@ -5582,89 +5657,6 @@ xfs_getbmap(
5582 return error; 5657 return error;
5583} 5658}
5584 5659
5585/*
5586 * Check the last inode extent to determine whether this allocation will result
5587 * in blocks being allocated at the end of the file. When we allocate new data
5588 * blocks at the end of the file which do not start at the previous data block,
5589 * we will try to align the new blocks at stripe unit boundaries.
5590 */
5591STATIC int /* error */
5592xfs_bmap_isaeof(
5593 xfs_inode_t *ip, /* incore inode pointer */
5594 xfs_fileoff_t off, /* file offset in fsblocks */
5595 int whichfork, /* data or attribute fork */
5596 char *aeof) /* return value */
5597{
5598 int error; /* error return value */
5599 xfs_ifork_t *ifp; /* inode fork pointer */
5600 xfs_bmbt_rec_host_t *lastrec; /* extent record pointer */
5601 xfs_extnum_t nextents; /* number of file extents */
5602 xfs_bmbt_irec_t s; /* expanded extent record */
5603
5604 ASSERT(whichfork == XFS_DATA_FORK);
5605 ifp = XFS_IFORK_PTR(ip, whichfork);
5606 if (!(ifp->if_flags & XFS_IFEXTENTS) &&
5607 (error = xfs_iread_extents(NULL, ip, whichfork)))
5608 return error;
5609 nextents = ifp->if_bytes / (uint)sizeof(xfs_bmbt_rec_t);
5610 if (nextents == 0) {
5611 *aeof = 1;
5612 return 0;
5613 }
5614 /*
5615 * Go to the last extent
5616 */
5617 lastrec = xfs_iext_get_ext(ifp, nextents - 1);
5618 xfs_bmbt_get_all(lastrec, &s);
5619 /*
5620 * Check we are allocating in the last extent (for delayed allocations)
5621 * or past the last extent for non-delayed allocations.
5622 */
5623 *aeof = (off >= s.br_startoff &&
5624 off < s.br_startoff + s.br_blockcount &&
5625 isnullstartblock(s.br_startblock)) ||
5626 off >= s.br_startoff + s.br_blockcount;
5627 return 0;
5628}
5629
5630/*
5631 * Check if the endoff is outside the last extent. If so the caller will grow
5632 * the allocation to a stripe unit boundary.
5633 */
5634int /* error */
5635xfs_bmap_eof(
5636 xfs_inode_t *ip, /* incore inode pointer */
5637 xfs_fileoff_t endoff, /* file offset in fsblocks */
5638 int whichfork, /* data or attribute fork */
5639 int *eof) /* result value */
5640{
5641 xfs_fsblock_t blockcount; /* extent block count */
5642 int error; /* error return value */
5643 xfs_ifork_t *ifp; /* inode fork pointer */
5644 xfs_bmbt_rec_host_t *lastrec; /* extent record pointer */
5645 xfs_extnum_t nextents; /* number of file extents */
5646 xfs_fileoff_t startoff; /* extent starting file offset */
5647
5648 ASSERT(whichfork == XFS_DATA_FORK);
5649 ifp = XFS_IFORK_PTR(ip, whichfork);
5650 if (!(ifp->if_flags & XFS_IFEXTENTS) &&
5651 (error = xfs_iread_extents(NULL, ip, whichfork)))
5652 return error;
5653 nextents = ifp->if_bytes / (uint)sizeof(xfs_bmbt_rec_t);
5654 if (nextents == 0) {
5655 *eof = 1;
5656 return 0;
5657 }
5658 /*
5659 * Go to the last extent
5660 */
5661 lastrec = xfs_iext_get_ext(ifp, nextents - 1);
5662 startoff = xfs_bmbt_get_startoff(lastrec);
5663 blockcount = xfs_bmbt_get_blockcount(lastrec);
5664 *eof = endoff >= startoff + blockcount;
5665 return 0;
5666}
5667
5668#ifdef DEBUG 5660#ifdef DEBUG
5669STATIC struct xfs_buf * 5661STATIC struct xfs_buf *
5670xfs_bmap_get_bp( 5662xfs_bmap_get_bp(
@@ -6099,9 +6091,8 @@ xfs_bmap_punch_delalloc_range(
6099 * trying to remove a real extent (which requires a 6091 * trying to remove a real extent (which requires a
6100 * transaction) or a hole, which is probably a bad idea... 6092 * transaction) or a hole, which is probably a bad idea...
6101 */ 6093 */
6102 error = xfs_bmapi(NULL, ip, start_fsb, 1, 6094 error = xfs_bmapi_read(ip, start_fsb, 1, &imap, &nimaps,
6103 XFS_BMAPI_ENTIRE, NULL, 0, &imap, 6095 XFS_BMAPI_ENTIRE);
6104 &nimaps, NULL);
6105 6096
6106 if (error) { 6097 if (error) {
6107 /* something screwed, just bail */ 6098 /* something screwed, just bail */
diff --git a/fs/xfs/xfs_bmap.h b/fs/xfs/xfs_bmap.h
index c62234bde053..89ee672d378a 100644
--- a/fs/xfs/xfs_bmap.h
+++ b/fs/xfs/xfs_bmap.h
@@ -62,27 +62,23 @@ typedef struct xfs_bmap_free
62#define XFS_BMAP_MAX_NMAP 4 62#define XFS_BMAP_MAX_NMAP 4
63 63
64/* 64/*
65 * Flags for xfs_bmapi 65 * Flags for xfs_bmapi_*
66 */ 66 */
67#define XFS_BMAPI_WRITE 0x001 /* write operation: allocate space */ 67#define XFS_BMAPI_ENTIRE 0x001 /* return entire extent, not trimmed */
68#define XFS_BMAPI_DELAY 0x002 /* delayed write operation */ 68#define XFS_BMAPI_METADATA 0x002 /* mapping metadata not user data */
69#define XFS_BMAPI_ENTIRE 0x004 /* return entire extent, not trimmed */ 69#define XFS_BMAPI_ATTRFORK 0x004 /* use attribute fork not data */
70#define XFS_BMAPI_METADATA 0x008 /* mapping metadata not user data */ 70#define XFS_BMAPI_PREALLOC 0x008 /* preallocation op: unwritten space */
71#define XFS_BMAPI_ATTRFORK 0x010 /* use attribute fork not data */ 71#define XFS_BMAPI_IGSTATE 0x010 /* Ignore state - */
72#define XFS_BMAPI_PREALLOC 0x040 /* preallocation op: unwritten space */
73#define XFS_BMAPI_IGSTATE 0x080 /* Ignore state - */
74 /* combine contig. space */ 72 /* combine contig. space */
75#define XFS_BMAPI_CONTIG 0x100 /* must allocate only one extent */ 73#define XFS_BMAPI_CONTIG 0x020 /* must allocate only one extent */
76/* 74/*
77 * unwritten extent conversion - this needs write cache flushing and no additional 75 * unwritten extent conversion - this needs write cache flushing and no additional
78 * allocation alignments. When specified with XFS_BMAPI_PREALLOC it converts 76 * allocation alignments. When specified with XFS_BMAPI_PREALLOC it converts
79 * from written to unwritten, otherwise convert from unwritten to written. 77 * from written to unwritten, otherwise convert from unwritten to written.
80 */ 78 */
81#define XFS_BMAPI_CONVERT 0x200 79#define XFS_BMAPI_CONVERT 0x040
82 80
83#define XFS_BMAPI_FLAGS \ 81#define XFS_BMAPI_FLAGS \
84 { XFS_BMAPI_WRITE, "WRITE" }, \
85 { XFS_BMAPI_DELAY, "DELAY" }, \
86 { XFS_BMAPI_ENTIRE, "ENTIRE" }, \ 82 { XFS_BMAPI_ENTIRE, "ENTIRE" }, \
87 { XFS_BMAPI_METADATA, "METADATA" }, \ 83 { XFS_BMAPI_METADATA, "METADATA" }, \
88 { XFS_BMAPI_ATTRFORK, "ATTRFORK" }, \ 84 { XFS_BMAPI_ATTRFORK, "ATTRFORK" }, \
@@ -113,21 +109,28 @@ static inline void xfs_bmap_init(xfs_bmap_free_t *flp, xfs_fsblock_t *fbp)
113 * Argument structure for xfs_bmap_alloc. 109 * Argument structure for xfs_bmap_alloc.
114 */ 110 */
115typedef struct xfs_bmalloca { 111typedef struct xfs_bmalloca {
116 xfs_fsblock_t firstblock; /* i/o first block allocated */ 112 xfs_fsblock_t *firstblock; /* i/o first block allocated */
117 xfs_fsblock_t rval; /* starting block of new extent */ 113 struct xfs_bmap_free *flist; /* bmap freelist */
118 xfs_fileoff_t off; /* offset in file filling in */
119 struct xfs_trans *tp; /* transaction pointer */ 114 struct xfs_trans *tp; /* transaction pointer */
120 struct xfs_inode *ip; /* incore inode pointer */ 115 struct xfs_inode *ip; /* incore inode pointer */
121 struct xfs_bmbt_irec *prevp; /* extent before the new one */ 116 struct xfs_bmbt_irec prev; /* extent before the new one */
122 struct xfs_bmbt_irec *gotp; /* extent after, or delayed */ 117 struct xfs_bmbt_irec got; /* extent after, or delayed */
123 xfs_extlen_t alen; /* i/o length asked/allocated */ 118
119 xfs_fileoff_t offset; /* offset in file filling in */
120 xfs_extlen_t length; /* i/o length asked/allocated */
121 xfs_fsblock_t blkno; /* starting block of new extent */
122
123 struct xfs_btree_cur *cur; /* btree cursor */
124 xfs_extnum_t idx; /* current extent index */
125 int nallocs;/* number of extents alloc'd */
126 int logflags;/* flags for transaction logging */
127
124 xfs_extlen_t total; /* total blocks needed for xaction */ 128 xfs_extlen_t total; /* total blocks needed for xaction */
125 xfs_extlen_t minlen; /* minimum allocation size (blocks) */ 129 xfs_extlen_t minlen; /* minimum allocation size (blocks) */
126 xfs_extlen_t minleft; /* amount must be left after alloc */ 130 xfs_extlen_t minleft; /* amount must be left after alloc */
127 char eof; /* set if allocating past last extent */ 131 char eof; /* set if allocating past last extent */
128 char wasdel; /* replacing a delayed allocation */ 132 char wasdel; /* replacing a delayed allocation */
129 char userdata;/* set if is user data */ 133 char userdata;/* set if is user data */
130 char low; /* low on space, using seq'l ags */
131 char aeof; /* allocated space at eof */ 134 char aeof; /* allocated space at eof */
132 char conv; /* overwriting unwritten extents */ 135 char conv; /* overwriting unwritten extents */
133} xfs_bmalloca_t; 136} xfs_bmalloca_t;
@@ -152,251 +155,62 @@ typedef struct xfs_bmalloca {
152 { BMAP_RIGHT_FILLING, "RF" }, \ 155 { BMAP_RIGHT_FILLING, "RF" }, \
153 { BMAP_ATTRFORK, "ATTR" } 156 { BMAP_ATTRFORK, "ATTR" }
154 157
155/*
156 * Add bmap trace insert entries for all the contents of the extent list.
157 *
158 * Quite excessive tracing. Only do this for debug builds.
159 */
160#if defined(__KERNEL) && defined(DEBUG) 158#if defined(__KERNEL) && defined(DEBUG)
161void 159void xfs_bmap_trace_exlist(struct xfs_inode *ip, xfs_extnum_t cnt,
162xfs_bmap_trace_exlist( 160 int whichfork, unsigned long caller_ip);
163 struct xfs_inode *ip, /* incore inode pointer */
164 xfs_extnum_t cnt, /* count of entries in list */
165 int whichfork,
166 unsigned long caller_ip); /* data or attr fork */
167#define XFS_BMAP_TRACE_EXLIST(ip,c,w) \ 161#define XFS_BMAP_TRACE_EXLIST(ip,c,w) \
168 xfs_bmap_trace_exlist(ip,c,w, _THIS_IP_) 162 xfs_bmap_trace_exlist(ip,c,w, _THIS_IP_)
169#else 163#else
170#define XFS_BMAP_TRACE_EXLIST(ip,c,w) 164#define XFS_BMAP_TRACE_EXLIST(ip,c,w)
171#endif 165#endif
172 166
173/* 167int xfs_bmap_add_attrfork(struct xfs_inode *ip, int size, int rsvd);
174 * Convert inode from non-attributed to attributed. 168void xfs_bmap_add_free(xfs_fsblock_t bno, xfs_filblks_t len,
175 * Must not be in a transaction, ip must not be locked. 169 struct xfs_bmap_free *flist, struct xfs_mount *mp);
176 */ 170void xfs_bmap_cancel(struct xfs_bmap_free *flist);
177int /* error code */ 171void xfs_bmap_compute_maxlevels(struct xfs_mount *mp, int whichfork);
178xfs_bmap_add_attrfork( 172int xfs_bmap_first_unused(struct xfs_trans *tp, struct xfs_inode *ip,
179 struct xfs_inode *ip, /* incore inode pointer */ 173 xfs_extlen_t len, xfs_fileoff_t *unused, int whichfork);
180 int size, /* space needed for new attribute */ 174int xfs_bmap_last_before(struct xfs_trans *tp, struct xfs_inode *ip,
181 int rsvd); /* flag for reserved block allocation */ 175 xfs_fileoff_t *last_block, int whichfork);
182 176int xfs_bmap_last_offset(struct xfs_trans *tp, struct xfs_inode *ip,
183/* 177 xfs_fileoff_t *unused, int whichfork);
184 * Add the extent to the list of extents to be free at transaction end. 178int xfs_bmap_one_block(struct xfs_inode *ip, int whichfork);
185 * The list is maintained sorted (by block number). 179int xfs_bmap_read_extents(struct xfs_trans *tp, struct xfs_inode *ip,
186 */ 180 int whichfork);
187void 181int xfs_bmapi_read(struct xfs_inode *ip, xfs_fileoff_t bno,
188xfs_bmap_add_free( 182 xfs_filblks_t len, struct xfs_bmbt_irec *mval,
189 xfs_fsblock_t bno, /* fs block number of extent */ 183 int *nmap, int flags);
190 xfs_filblks_t len, /* length of extent */ 184int xfs_bmapi_delay(struct xfs_inode *ip, xfs_fileoff_t bno,
191 xfs_bmap_free_t *flist, /* list of extents */ 185 xfs_filblks_t len, struct xfs_bmbt_irec *mval,
192 struct xfs_mount *mp); /* mount point structure */ 186 int *nmap, int flags);
193 187int xfs_bmapi_write(struct xfs_trans *tp, struct xfs_inode *ip,
194/* 188 xfs_fileoff_t bno, xfs_filblks_t len, int flags,
195 * Routine to clean up the free list data structure when 189 xfs_fsblock_t *firstblock, xfs_extlen_t total,
196 * an error occurs during a transaction. 190 struct xfs_bmbt_irec *mval, int *nmap,
197 */ 191 struct xfs_bmap_free *flist);
198void 192int xfs_bunmapi(struct xfs_trans *tp, struct xfs_inode *ip,
199xfs_bmap_cancel( 193 xfs_fileoff_t bno, xfs_filblks_t len, int flags,
200 xfs_bmap_free_t *flist); /* free list to clean up */ 194 xfs_extnum_t nexts, xfs_fsblock_t *firstblock,
201 195 struct xfs_bmap_free *flist, int *done);
202/* 196int xfs_check_nostate_extents(struct xfs_ifork *ifp, xfs_extnum_t idx,
203 * Compute and fill in the value of the maximum depth of a bmap btree 197 xfs_extnum_t num);
204 * in this filesystem. Done once, during mount. 198uint xfs_default_attroffset(struct xfs_inode *ip);
205 */
206void
207xfs_bmap_compute_maxlevels(
208 struct xfs_mount *mp, /* file system mount structure */
209 int whichfork); /* data or attr fork */
210
211/*
212 * Returns the file-relative block number of the first unused block in the file.
213 * This is the lowest-address hole if the file has holes, else the first block
214 * past the end of file.
215 */
216int /* error */
217xfs_bmap_first_unused(
218 struct xfs_trans *tp, /* transaction pointer */
219 struct xfs_inode *ip, /* incore inode */
220 xfs_extlen_t len, /* size of hole to find */
221 xfs_fileoff_t *unused, /* unused block num */
222 int whichfork); /* data or attr fork */
223
224/*
225 * Returns the file-relative block number of the last block + 1 before
226 * last_block (input value) in the file.
227 * This is not based on i_size, it is based on the extent list.
228 * Returns 0 for local files, as they do not have an extent list.
229 */
230int /* error */
231xfs_bmap_last_before(
232 struct xfs_trans *tp, /* transaction pointer */
233 struct xfs_inode *ip, /* incore inode */
234 xfs_fileoff_t *last_block, /* last block */
235 int whichfork); /* data or attr fork */
236
237/*
238 * Returns the file-relative block number of the first block past eof in
239 * the file. This is not based on i_size, it is based on the extent list.
240 * Returns 0 for local files, as they do not have an extent list.
241 */
242int /* error */
243xfs_bmap_last_offset(
244 struct xfs_trans *tp, /* transaction pointer */
245 struct xfs_inode *ip, /* incore inode */
246 xfs_fileoff_t *unused, /* last block num */
247 int whichfork); /* data or attr fork */
248
249/*
250 * Returns whether the selected fork of the inode has exactly one
251 * block or not. For the data fork we check this matches di_size,
252 * implying the file's range is 0..bsize-1.
253 */
254int
255xfs_bmap_one_block(
256 struct xfs_inode *ip, /* incore inode */
257 int whichfork); /* data or attr fork */
258
259/*
260 * Read in the extents to iu_extents.
261 * All inode fields are set up by caller, we just traverse the btree
262 * and copy the records in.
263 */
264int /* error */
265xfs_bmap_read_extents(
266 struct xfs_trans *tp, /* transaction pointer */
267 struct xfs_inode *ip, /* incore inode */
268 int whichfork); /* data or attr fork */
269
270/*
271 * Map file blocks to filesystem blocks.
272 * File range is given by the bno/len pair.
273 * Adds blocks to file if a write ("flags & XFS_BMAPI_WRITE" set)
274 * into a hole or past eof.
275 * Only allocates blocks from a single allocation group,
276 * to avoid locking problems.
277 * The returned value in "firstblock" from the first call in a transaction
278 * must be remembered and presented to subsequent calls in "firstblock".
279 * An upper bound for the number of blocks to be allocated is supplied to
280 * the first call in "total"; if no allocation group has that many free
281 * blocks then the call will fail (return NULLFSBLOCK in "firstblock").
282 */
283int /* error */
284xfs_bmapi(
285 struct xfs_trans *tp, /* transaction pointer */
286 struct xfs_inode *ip, /* incore inode */
287 xfs_fileoff_t bno, /* starting file offs. mapped */
288 xfs_filblks_t len, /* length to map in file */
289 int flags, /* XFS_BMAPI_... */
290 xfs_fsblock_t *firstblock, /* first allocated block
291 controls a.g. for allocs */
292 xfs_extlen_t total, /* total blocks needed */
293 struct xfs_bmbt_irec *mval, /* output: map values */
294 int *nmap, /* i/o: mval size/count */
295 xfs_bmap_free_t *flist); /* i/o: list extents to free */
296
297/*
298 * Map file blocks to filesystem blocks, simple version.
299 * One block only, read-only.
300 * For flags, only the XFS_BMAPI_ATTRFORK flag is examined.
301 * For the other flag values, the effect is as if XFS_BMAPI_METADATA
302 * was set and all the others were clear.
303 */
304int /* error */
305xfs_bmapi_single(
306 struct xfs_trans *tp, /* transaction pointer */
307 struct xfs_inode *ip, /* incore inode */
308 int whichfork, /* data or attr fork */
309 xfs_fsblock_t *fsb, /* output: mapped block */
310 xfs_fileoff_t bno); /* starting file offs. mapped */
311
312/*
313 * Unmap (remove) blocks from a file.
314 * If nexts is nonzero then the number of extents to remove is limited to
315 * that value. If not all extents in the block range can be removed then
316 * *done is set.
317 */
318int /* error */
319xfs_bunmapi(
320 struct xfs_trans *tp, /* transaction pointer */
321 struct xfs_inode *ip, /* incore inode */
322 xfs_fileoff_t bno, /* starting offset to unmap */
323 xfs_filblks_t len, /* length to unmap in file */
324 int flags, /* XFS_BMAPI_... */
325 xfs_extnum_t nexts, /* number of extents max */
326 xfs_fsblock_t *firstblock, /* first allocated block
327 controls a.g. for allocs */
328 xfs_bmap_free_t *flist, /* i/o: list extents to free */
329 int *done); /* set if not done yet */
330
331/*
332 * Check an extent list, which has just been read, for
333 * any bit in the extent flag field.
334 */
335int
336xfs_check_nostate_extents(
337 struct xfs_ifork *ifp,
338 xfs_extnum_t idx,
339 xfs_extnum_t num);
340
341uint
342xfs_default_attroffset(
343 struct xfs_inode *ip);
344 199
345#ifdef __KERNEL__ 200#ifdef __KERNEL__
346
347/*
348 * Routine to be called at transaction's end by xfs_bmapi, xfs_bunmapi
349 * caller. Frees all the extents that need freeing, which must be done
350 * last due to locking considerations.
351 *
352 * Return 1 if the given transaction was committed and a new one allocated,
353 * and 0 otherwise.
354 */
355int /* error */
356xfs_bmap_finish(
357 struct xfs_trans **tp, /* transaction pointer addr */
358 xfs_bmap_free_t *flist, /* i/o: list extents to free */
359 int *committed); /* xact committed or not */
360
361/* bmap to userspace formatter - copy to user & advance pointer */ 201/* bmap to userspace formatter - copy to user & advance pointer */
362typedef int (*xfs_bmap_format_t)(void **, struct getbmapx *, int *); 202typedef int (*xfs_bmap_format_t)(void **, struct getbmapx *, int *);
363 203
364/* 204int xfs_bmap_finish(struct xfs_trans **tp, struct xfs_bmap_free *flist,
365 * Get inode's extents as described in bmv, and format for output. 205 int *committed);
366 */ 206int xfs_getbmap(struct xfs_inode *ip, struct getbmapx *bmv,
367int /* error code */ 207 xfs_bmap_format_t formatter, void *arg);
368xfs_getbmap( 208int xfs_bmap_eof(struct xfs_inode *ip, xfs_fileoff_t endoff,
369 xfs_inode_t *ip, 209 int whichfork, int *eof);
370 struct getbmapx *bmv, /* user bmap structure */ 210int xfs_bmap_count_blocks(struct xfs_trans *tp, struct xfs_inode *ip,
371 xfs_bmap_format_t formatter, /* format to user */ 211 int whichfork, int *count);
372 void *arg); /* formatter arg */ 212int xfs_bmap_punch_delalloc_range(struct xfs_inode *ip,
373 213 xfs_fileoff_t start_fsb, xfs_fileoff_t length);
374/*
375 * Check if the endoff is outside the last extent. If so the caller will grow
376 * the allocation to a stripe unit boundary
377 */
378int
379xfs_bmap_eof(
380 struct xfs_inode *ip,
381 xfs_fileoff_t endoff,
382 int whichfork,
383 int *eof);
384
385/*
386 * Count fsblocks of the given fork.
387 */
388int
389xfs_bmap_count_blocks(
390 xfs_trans_t *tp,
391 struct xfs_inode *ip,
392 int whichfork,
393 int *count);
394
395int
396xfs_bmap_punch_delalloc_range(
397 struct xfs_inode *ip,
398 xfs_fileoff_t start_fsb,
399 xfs_fileoff_t length);
400#endif /* __KERNEL__ */ 214#endif /* __KERNEL__ */
401 215
402#endif /* __XFS_BMAP_H__ */ 216#endif /* __XFS_BMAP_H__ */
diff --git a/fs/xfs/xfs_btree.c b/fs/xfs/xfs_btree.c
index 2b9fd385e27d..1f19f03af9d3 100644
--- a/fs/xfs/xfs_btree.c
+++ b/fs/xfs/xfs_btree.c
@@ -631,7 +631,7 @@ xfs_btree_read_bufl(
631 } 631 }
632 ASSERT(!xfs_buf_geterror(bp)); 632 ASSERT(!xfs_buf_geterror(bp));
633 if (bp) 633 if (bp)
634 XFS_BUF_SET_VTYPE_REF(bp, B_FS_MAP, refval); 634 xfs_buf_set_ref(bp, refval);
635 *bpp = bp; 635 *bpp = bp;
636 return 0; 636 return 0;
637} 637}
@@ -939,13 +939,13 @@ xfs_btree_set_refs(
939 switch (cur->bc_btnum) { 939 switch (cur->bc_btnum) {
940 case XFS_BTNUM_BNO: 940 case XFS_BTNUM_BNO:
941 case XFS_BTNUM_CNT: 941 case XFS_BTNUM_CNT:
942 XFS_BUF_SET_VTYPE_REF(bp, B_FS_MAP, XFS_ALLOC_BTREE_REF); 942 xfs_buf_set_ref(bp, XFS_ALLOC_BTREE_REF);
943 break; 943 break;
944 case XFS_BTNUM_INO: 944 case XFS_BTNUM_INO:
945 XFS_BUF_SET_VTYPE_REF(bp, B_FS_INOMAP, XFS_INO_BTREE_REF); 945 xfs_buf_set_ref(bp, XFS_INO_BTREE_REF);
946 break; 946 break;
947 case XFS_BTNUM_BMAP: 947 case XFS_BTNUM_BMAP:
948 XFS_BUF_SET_VTYPE_REF(bp, B_FS_MAP, XFS_BMAP_BTREE_REF); 948 xfs_buf_set_ref(bp, XFS_BMAP_BTREE_REF);
949 break; 949 break;
950 default: 950 default:
951 ASSERT(0); 951 ASSERT(0);
@@ -970,7 +970,8 @@ xfs_btree_get_buf_block(
970 *bpp = xfs_trans_get_buf(cur->bc_tp, mp->m_ddev_targp, d, 970 *bpp = xfs_trans_get_buf(cur->bc_tp, mp->m_ddev_targp, d,
971 mp->m_bsize, flags); 971 mp->m_bsize, flags);
972 972
973 ASSERT(!xfs_buf_geterror(*bpp)); 973 if (!*bpp)
974 return ENOMEM;
974 975
975 *block = XFS_BUF_TO_BLOCK(*bpp); 976 *block = XFS_BUF_TO_BLOCK(*bpp);
976 return 0; 977 return 0;
diff --git a/fs/xfs/xfs_buf.c b/fs/xfs/xfs_buf.c
index c57836dc778f..cf0ac056815f 100644
--- a/fs/xfs/xfs_buf.c
+++ b/fs/xfs/xfs_buf.c
@@ -43,7 +43,6 @@
43 43
44static kmem_zone_t *xfs_buf_zone; 44static kmem_zone_t *xfs_buf_zone;
45STATIC int xfsbufd(void *); 45STATIC int xfsbufd(void *);
46STATIC void xfs_buf_delwri_queue(xfs_buf_t *, int);
47 46
48static struct workqueue_struct *xfslogd_workqueue; 47static struct workqueue_struct *xfslogd_workqueue;
49struct workqueue_struct *xfsdatad_workqueue; 48struct workqueue_struct *xfsdatad_workqueue;
@@ -66,10 +65,6 @@ struct workqueue_struct *xfsconvertd_workqueue;
66#define xb_to_km(flags) \ 65#define xb_to_km(flags) \
67 (((flags) & XBF_DONT_BLOCK) ? KM_NOFS : KM_SLEEP) 66 (((flags) & XBF_DONT_BLOCK) ? KM_NOFS : KM_SLEEP)
68 67
69#define xfs_buf_allocate(flags) \
70 kmem_zone_alloc(xfs_buf_zone, xb_to_km(flags))
71#define xfs_buf_deallocate(bp) \
72 kmem_zone_free(xfs_buf_zone, (bp));
73 68
74static inline int 69static inline int
75xfs_buf_is_vmapped( 70xfs_buf_is_vmapped(
@@ -152,6 +147,7 @@ xfs_buf_stale(
152 struct xfs_buf *bp) 147 struct xfs_buf *bp)
153{ 148{
154 bp->b_flags |= XBF_STALE; 149 bp->b_flags |= XBF_STALE;
150 xfs_buf_delwri_dequeue(bp);
155 atomic_set(&(bp)->b_lru_ref, 0); 151 atomic_set(&(bp)->b_lru_ref, 0);
156 if (!list_empty(&bp->b_lru)) { 152 if (!list_empty(&bp->b_lru)) {
157 struct xfs_buftarg *btp = bp->b_target; 153 struct xfs_buftarg *btp = bp->b_target;
@@ -167,14 +163,19 @@ xfs_buf_stale(
167 ASSERT(atomic_read(&bp->b_hold) >= 1); 163 ASSERT(atomic_read(&bp->b_hold) >= 1);
168} 164}
169 165
170STATIC void 166struct xfs_buf *
171_xfs_buf_initialize( 167xfs_buf_alloc(
172 xfs_buf_t *bp, 168 struct xfs_buftarg *target,
173 xfs_buftarg_t *target,
174 xfs_off_t range_base, 169 xfs_off_t range_base,
175 size_t range_length, 170 size_t range_length,
176 xfs_buf_flags_t flags) 171 xfs_buf_flags_t flags)
177{ 172{
173 struct xfs_buf *bp;
174
175 bp = kmem_zone_alloc(xfs_buf_zone, xb_to_km(flags));
176 if (unlikely(!bp))
177 return NULL;
178
178 /* 179 /*
179 * We don't want certain flags to appear in b_flags. 180 * We don't want certain flags to appear in b_flags.
180 */ 181 */
@@ -203,8 +204,9 @@ _xfs_buf_initialize(
203 init_waitqueue_head(&bp->b_waiters); 204 init_waitqueue_head(&bp->b_waiters);
204 205
205 XFS_STATS_INC(xb_create); 206 XFS_STATS_INC(xb_create);
206
207 trace_xfs_buf_init(bp, _RET_IP_); 207 trace_xfs_buf_init(bp, _RET_IP_);
208
209 return bp;
208} 210}
209 211
210/* 212/*
@@ -277,7 +279,7 @@ xfs_buf_free(
277 } else if (bp->b_flags & _XBF_KMEM) 279 } else if (bp->b_flags & _XBF_KMEM)
278 kmem_free(bp->b_addr); 280 kmem_free(bp->b_addr);
279 _xfs_buf_free_pages(bp); 281 _xfs_buf_free_pages(bp);
280 xfs_buf_deallocate(bp); 282 kmem_zone_free(xfs_buf_zone, bp);
281} 283}
282 284
283/* 285/*
@@ -416,10 +418,7 @@ _xfs_buf_map_pages(
416/* 418/*
417 * Look up, and creates if absent, a lockable buffer for 419 * Look up, and creates if absent, a lockable buffer for
418 * a given range of an inode. The buffer is returned 420 * a given range of an inode. The buffer is returned
419 * locked. If other overlapping buffers exist, they are 421 * locked. No I/O is implied by this call.
420 * released before the new buffer is created and locked,
421 * which may imply that this call will block until those buffers
422 * are unlocked. No I/O is implied by this call.
423 */ 422 */
424xfs_buf_t * 423xfs_buf_t *
425_xfs_buf_find( 424_xfs_buf_find(
@@ -481,8 +480,6 @@ _xfs_buf_find(
481 480
482 /* No match found */ 481 /* No match found */
483 if (new_bp) { 482 if (new_bp) {
484 _xfs_buf_initialize(new_bp, btp, range_base,
485 range_length, flags);
486 rb_link_node(&new_bp->b_rbnode, parent, rbp); 483 rb_link_node(&new_bp->b_rbnode, parent, rbp);
487 rb_insert_color(&new_bp->b_rbnode, &pag->pag_buf_tree); 484 rb_insert_color(&new_bp->b_rbnode, &pag->pag_buf_tree);
488 /* the buffer keeps the perag reference until it is freed */ 485 /* the buffer keeps the perag reference until it is freed */
@@ -525,35 +522,51 @@ found:
525} 522}
526 523
527/* 524/*
528 * Assembles a buffer covering the specified range. 525 * Assembles a buffer covering the specified range. The code is optimised for
529 * Storage in memory for all portions of the buffer will be allocated, 526 * cache hits, as metadata intensive workloads will see 3 orders of magnitude
530 * although backing storage may not be. 527 * more hits than misses.
531 */ 528 */
532xfs_buf_t * 529struct xfs_buf *
533xfs_buf_get( 530xfs_buf_get(
534 xfs_buftarg_t *target,/* target for buffer */ 531 xfs_buftarg_t *target,/* target for buffer */
535 xfs_off_t ioff, /* starting offset of range */ 532 xfs_off_t ioff, /* starting offset of range */
536 size_t isize, /* length of range */ 533 size_t isize, /* length of range */
537 xfs_buf_flags_t flags) 534 xfs_buf_flags_t flags)
538{ 535{
539 xfs_buf_t *bp, *new_bp; 536 struct xfs_buf *bp;
537 struct xfs_buf *new_bp;
540 int error = 0; 538 int error = 0;
541 539
542 new_bp = xfs_buf_allocate(flags); 540 bp = _xfs_buf_find(target, ioff, isize, flags, NULL);
541 if (likely(bp))
542 goto found;
543
544 new_bp = xfs_buf_alloc(target, ioff << BBSHIFT, isize << BBSHIFT,
545 flags);
543 if (unlikely(!new_bp)) 546 if (unlikely(!new_bp))
544 return NULL; 547 return NULL;
545 548
546 bp = _xfs_buf_find(target, ioff, isize, flags, new_bp); 549 bp = _xfs_buf_find(target, ioff, isize, flags, new_bp);
550 if (!bp) {
551 kmem_zone_free(xfs_buf_zone, new_bp);
552 return NULL;
553 }
554
547 if (bp == new_bp) { 555 if (bp == new_bp) {
548 error = xfs_buf_allocate_memory(bp, flags); 556 error = xfs_buf_allocate_memory(bp, flags);
549 if (error) 557 if (error)
550 goto no_buffer; 558 goto no_buffer;
551 } else { 559 } else
552 xfs_buf_deallocate(new_bp); 560 kmem_zone_free(xfs_buf_zone, new_bp);
553 if (unlikely(bp == NULL))
554 return NULL;
555 }
556 561
562 /*
563 * Now we have a workable buffer, fill in the block number so
564 * that we can do IO on it.
565 */
566 bp->b_bn = ioff;
567 bp->b_count_desired = bp->b_buffer_length;
568
569found:
557 if (!(bp->b_flags & XBF_MAPPED)) { 570 if (!(bp->b_flags & XBF_MAPPED)) {
558 error = _xfs_buf_map_pages(bp, flags); 571 error = _xfs_buf_map_pages(bp, flags);
559 if (unlikely(error)) { 572 if (unlikely(error)) {
@@ -564,18 +577,10 @@ xfs_buf_get(
564 } 577 }
565 578
566 XFS_STATS_INC(xb_get); 579 XFS_STATS_INC(xb_get);
567
568 /*
569 * Always fill in the block number now, the mapped cases can do
570 * their own overlay of this later.
571 */
572 bp->b_bn = ioff;
573 bp->b_count_desired = bp->b_buffer_length;
574
575 trace_xfs_buf_get(bp, flags, _RET_IP_); 580 trace_xfs_buf_get(bp, flags, _RET_IP_);
576 return bp; 581 return bp;
577 582
578 no_buffer: 583no_buffer:
579 if (flags & (XBF_LOCK | XBF_TRYLOCK)) 584 if (flags & (XBF_LOCK | XBF_TRYLOCK))
580 xfs_buf_unlock(bp); 585 xfs_buf_unlock(bp);
581 xfs_buf_rele(bp); 586 xfs_buf_rele(bp);
@@ -689,19 +694,6 @@ xfs_buf_read_uncached(
689 return bp; 694 return bp;
690} 695}
691 696
692xfs_buf_t *
693xfs_buf_get_empty(
694 size_t len,
695 xfs_buftarg_t *target)
696{
697 xfs_buf_t *bp;
698
699 bp = xfs_buf_allocate(0);
700 if (bp)
701 _xfs_buf_initialize(bp, target, 0, len, 0);
702 return bp;
703}
704
705/* 697/*
706 * Return a buffer allocated as an empty buffer and associated to external 698 * Return a buffer allocated as an empty buffer and associated to external
707 * memory via xfs_buf_associate_memory() back to it's empty state. 699 * memory via xfs_buf_associate_memory() back to it's empty state.
@@ -787,10 +779,9 @@ xfs_buf_get_uncached(
787 int error, i; 779 int error, i;
788 xfs_buf_t *bp; 780 xfs_buf_t *bp;
789 781
790 bp = xfs_buf_allocate(0); 782 bp = xfs_buf_alloc(target, 0, len, 0);
791 if (unlikely(bp == NULL)) 783 if (unlikely(bp == NULL))
792 goto fail; 784 goto fail;
793 _xfs_buf_initialize(bp, target, 0, len, 0);
794 785
795 error = _xfs_buf_get_pages(bp, page_count, 0); 786 error = _xfs_buf_get_pages(bp, page_count, 0);
796 if (error) 787 if (error)
@@ -818,7 +809,7 @@ xfs_buf_get_uncached(
818 __free_page(bp->b_pages[i]); 809 __free_page(bp->b_pages[i]);
819 _xfs_buf_free_pages(bp); 810 _xfs_buf_free_pages(bp);
820 fail_free_buf: 811 fail_free_buf:
821 xfs_buf_deallocate(bp); 812 kmem_zone_free(xfs_buf_zone, bp);
822 fail: 813 fail:
823 return NULL; 814 return NULL;
824} 815}
@@ -937,12 +928,6 @@ void
937xfs_buf_unlock( 928xfs_buf_unlock(
938 struct xfs_buf *bp) 929 struct xfs_buf *bp)
939{ 930{
940 if ((bp->b_flags & (XBF_DELWRI|_XBF_DELWRI_Q)) == XBF_DELWRI) {
941 atomic_inc(&bp->b_hold);
942 bp->b_flags |= XBF_ASYNC;
943 xfs_buf_delwri_queue(bp, 0);
944 }
945
946 XB_CLEAR_OWNER(bp); 931 XB_CLEAR_OWNER(bp);
947 up(&bp->b_sema); 932 up(&bp->b_sema);
948 933
@@ -1019,9 +1004,19 @@ xfs_buf_ioerror(
1019 trace_xfs_buf_ioerror(bp, error, _RET_IP_); 1004 trace_xfs_buf_ioerror(bp, error, _RET_IP_);
1020} 1005}
1021 1006
1007void
1008xfs_buf_ioerror_alert(
1009 struct xfs_buf *bp,
1010 const char *func)
1011{
1012 xfs_alert(bp->b_target->bt_mount,
1013"metadata I/O error: block 0x%llx (\"%s\") error %d buf count %zd",
1014 (__uint64_t)XFS_BUF_ADDR(bp), func,
1015 bp->b_error, XFS_BUF_COUNT(bp));
1016}
1017
1022int 1018int
1023xfs_bwrite( 1019xfs_bwrite(
1024 struct xfs_mount *mp,
1025 struct xfs_buf *bp) 1020 struct xfs_buf *bp)
1026{ 1021{
1027 int error; 1022 int error;
@@ -1033,25 +1028,13 @@ xfs_bwrite(
1033 xfs_bdstrat_cb(bp); 1028 xfs_bdstrat_cb(bp);
1034 1029
1035 error = xfs_buf_iowait(bp); 1030 error = xfs_buf_iowait(bp);
1036 if (error) 1031 if (error) {
1037 xfs_force_shutdown(mp, SHUTDOWN_META_IO_ERROR); 1032 xfs_force_shutdown(bp->b_target->bt_mount,
1038 xfs_buf_relse(bp); 1033 SHUTDOWN_META_IO_ERROR);
1034 }
1039 return error; 1035 return error;
1040} 1036}
1041 1037
1042void
1043xfs_bdwrite(
1044 void *mp,
1045 struct xfs_buf *bp)
1046{
1047 trace_xfs_buf_bdwrite(bp, _RET_IP_);
1048
1049 bp->b_flags &= ~XBF_READ;
1050 bp->b_flags |= (XBF_DELWRI | XBF_ASYNC);
1051
1052 xfs_buf_delwri_queue(bp, 1);
1053}
1054
1055/* 1038/*
1056 * Called when we want to stop a buffer from getting written or read. 1039 * Called when we want to stop a buffer from getting written or read.
1057 * We attach the EIO error, muck with its flags, and call xfs_buf_ioend 1040 * We attach the EIO error, muck with its flags, and call xfs_buf_ioend
@@ -1074,9 +1057,8 @@ xfs_bioerror(
1074 * We're calling xfs_buf_ioend, so delete XBF_DONE flag. 1057 * We're calling xfs_buf_ioend, so delete XBF_DONE flag.
1075 */ 1058 */
1076 XFS_BUF_UNREAD(bp); 1059 XFS_BUF_UNREAD(bp);
1077 XFS_BUF_UNDELAYWRITE(bp);
1078 XFS_BUF_UNDONE(bp); 1060 XFS_BUF_UNDONE(bp);
1079 XFS_BUF_STALE(bp); 1061 xfs_buf_stale(bp);
1080 1062
1081 xfs_buf_ioend(bp, 0); 1063 xfs_buf_ioend(bp, 0);
1082 1064
@@ -1103,9 +1085,8 @@ xfs_bioerror_relse(
1103 * change that interface. 1085 * change that interface.
1104 */ 1086 */
1105 XFS_BUF_UNREAD(bp); 1087 XFS_BUF_UNREAD(bp);
1106 XFS_BUF_UNDELAYWRITE(bp);
1107 XFS_BUF_DONE(bp); 1088 XFS_BUF_DONE(bp);
1108 XFS_BUF_STALE(bp); 1089 xfs_buf_stale(bp);
1109 bp->b_iodone = NULL; 1090 bp->b_iodone = NULL;
1110 if (!(fl & XBF_ASYNC)) { 1091 if (!(fl & XBF_ASYNC)) {
1111 /* 1092 /*
@@ -1115,7 +1096,7 @@ xfs_bioerror_relse(
1115 * ASYNC buffers. 1096 * ASYNC buffers.
1116 */ 1097 */
1117 xfs_buf_ioerror(bp, EIO); 1098 xfs_buf_ioerror(bp, EIO);
1118 XFS_BUF_FINISH_IOWAIT(bp); 1099 complete(&bp->b_iowait);
1119 } else { 1100 } else {
1120 xfs_buf_relse(bp); 1101 xfs_buf_relse(bp);
1121 } 1102 }
@@ -1275,15 +1256,10 @@ xfs_buf_iorequest(
1275{ 1256{
1276 trace_xfs_buf_iorequest(bp, _RET_IP_); 1257 trace_xfs_buf_iorequest(bp, _RET_IP_);
1277 1258
1278 if (bp->b_flags & XBF_DELWRI) { 1259 ASSERT(!(bp->b_flags & XBF_DELWRI));
1279 xfs_buf_delwri_queue(bp, 1);
1280 return 0;
1281 }
1282 1260
1283 if (bp->b_flags & XBF_WRITE) { 1261 if (bp->b_flags & XBF_WRITE)
1284 xfs_buf_wait_unpin(bp); 1262 xfs_buf_wait_unpin(bp);
1285 }
1286
1287 xfs_buf_hold(bp); 1263 xfs_buf_hold(bp);
1288 1264
1289 /* Set the count to 1 initially, this will stop an I/O 1265 /* Set the count to 1 initially, this will stop an I/O
@@ -1481,9 +1457,13 @@ xfs_setsize_buftarg_flags(
1481 btp->bt_smask = sectorsize - 1; 1457 btp->bt_smask = sectorsize - 1;
1482 1458
1483 if (set_blocksize(btp->bt_bdev, sectorsize)) { 1459 if (set_blocksize(btp->bt_bdev, sectorsize)) {
1460 char name[BDEVNAME_SIZE];
1461
1462 bdevname(btp->bt_bdev, name);
1463
1484 xfs_warn(btp->bt_mount, 1464 xfs_warn(btp->bt_mount,
1485 "Cannot set_blocksize to %u on device %s\n", 1465 "Cannot set_blocksize to %u on device %s\n",
1486 sectorsize, xfs_buf_target_name(btp)); 1466 sectorsize, name);
1487 return EINVAL; 1467 return EINVAL;
1488 } 1468 }
1489 1469
@@ -1514,12 +1494,12 @@ xfs_setsize_buftarg(
1514} 1494}
1515 1495
1516STATIC int 1496STATIC int
1517xfs_alloc_delwrite_queue( 1497xfs_alloc_delwri_queue(
1518 xfs_buftarg_t *btp, 1498 xfs_buftarg_t *btp,
1519 const char *fsname) 1499 const char *fsname)
1520{ 1500{
1521 INIT_LIST_HEAD(&btp->bt_delwrite_queue); 1501 INIT_LIST_HEAD(&btp->bt_delwri_queue);
1522 spin_lock_init(&btp->bt_delwrite_lock); 1502 spin_lock_init(&btp->bt_delwri_lock);
1523 btp->bt_flags = 0; 1503 btp->bt_flags = 0;
1524 btp->bt_task = kthread_run(xfsbufd, btp, "xfsbufd/%s", fsname); 1504 btp->bt_task = kthread_run(xfsbufd, btp, "xfsbufd/%s", fsname);
1525 if (IS_ERR(btp->bt_task)) 1505 if (IS_ERR(btp->bt_task))
@@ -1549,7 +1529,7 @@ xfs_alloc_buftarg(
1549 spin_lock_init(&btp->bt_lru_lock); 1529 spin_lock_init(&btp->bt_lru_lock);
1550 if (xfs_setsize_buftarg_early(btp, bdev)) 1530 if (xfs_setsize_buftarg_early(btp, bdev))
1551 goto error; 1531 goto error;
1552 if (xfs_alloc_delwrite_queue(btp, fsname)) 1532 if (xfs_alloc_delwri_queue(btp, fsname))
1553 goto error; 1533 goto error;
1554 btp->bt_shrinker.shrink = xfs_buftarg_shrink; 1534 btp->bt_shrinker.shrink = xfs_buftarg_shrink;
1555 btp->bt_shrinker.seeks = DEFAULT_SEEKS; 1535 btp->bt_shrinker.seeks = DEFAULT_SEEKS;
@@ -1565,56 +1545,48 @@ error:
1565/* 1545/*
1566 * Delayed write buffer handling 1546 * Delayed write buffer handling
1567 */ 1547 */
1568STATIC void 1548void
1569xfs_buf_delwri_queue( 1549xfs_buf_delwri_queue(
1570 xfs_buf_t *bp, 1550 xfs_buf_t *bp)
1571 int unlock)
1572{ 1551{
1573 struct list_head *dwq = &bp->b_target->bt_delwrite_queue; 1552 struct xfs_buftarg *btp = bp->b_target;
1574 spinlock_t *dwlk = &bp->b_target->bt_delwrite_lock;
1575 1553
1576 trace_xfs_buf_delwri_queue(bp, _RET_IP_); 1554 trace_xfs_buf_delwri_queue(bp, _RET_IP_);
1577 1555
1578 ASSERT((bp->b_flags&(XBF_DELWRI|XBF_ASYNC)) == (XBF_DELWRI|XBF_ASYNC)); 1556 ASSERT(!(bp->b_flags & XBF_READ));
1579 1557
1580 spin_lock(dwlk); 1558 spin_lock(&btp->bt_delwri_lock);
1581 /* If already in the queue, dequeue and place at tail */
1582 if (!list_empty(&bp->b_list)) { 1559 if (!list_empty(&bp->b_list)) {
1560 /* if already in the queue, move it to the tail */
1583 ASSERT(bp->b_flags & _XBF_DELWRI_Q); 1561 ASSERT(bp->b_flags & _XBF_DELWRI_Q);
1584 if (unlock) 1562 list_move_tail(&bp->b_list, &btp->bt_delwri_queue);
1585 atomic_dec(&bp->b_hold); 1563 } else {
1586 list_del(&bp->b_list);
1587 }
1588
1589 if (list_empty(dwq)) {
1590 /* start xfsbufd as it is about to have something to do */ 1564 /* start xfsbufd as it is about to have something to do */
1591 wake_up_process(bp->b_target->bt_task); 1565 if (list_empty(&btp->bt_delwri_queue))
1592 } 1566 wake_up_process(bp->b_target->bt_task);
1593 1567
1594 bp->b_flags |= _XBF_DELWRI_Q; 1568 atomic_inc(&bp->b_hold);
1595 list_add_tail(&bp->b_list, dwq); 1569 bp->b_flags |= XBF_DELWRI | _XBF_DELWRI_Q | XBF_ASYNC;
1570 list_add_tail(&bp->b_list, &btp->bt_delwri_queue);
1571 }
1596 bp->b_queuetime = jiffies; 1572 bp->b_queuetime = jiffies;
1597 spin_unlock(dwlk); 1573 spin_unlock(&btp->bt_delwri_lock);
1598
1599 if (unlock)
1600 xfs_buf_unlock(bp);
1601} 1574}
1602 1575
1603void 1576void
1604xfs_buf_delwri_dequeue( 1577xfs_buf_delwri_dequeue(
1605 xfs_buf_t *bp) 1578 xfs_buf_t *bp)
1606{ 1579{
1607 spinlock_t *dwlk = &bp->b_target->bt_delwrite_lock;
1608 int dequeued = 0; 1580 int dequeued = 0;
1609 1581
1610 spin_lock(dwlk); 1582 spin_lock(&bp->b_target->bt_delwri_lock);
1611 if ((bp->b_flags & XBF_DELWRI) && !list_empty(&bp->b_list)) { 1583 if ((bp->b_flags & XBF_DELWRI) && !list_empty(&bp->b_list)) {
1612 ASSERT(bp->b_flags & _XBF_DELWRI_Q); 1584 ASSERT(bp->b_flags & _XBF_DELWRI_Q);
1613 list_del_init(&bp->b_list); 1585 list_del_init(&bp->b_list);
1614 dequeued = 1; 1586 dequeued = 1;
1615 } 1587 }
1616 bp->b_flags &= ~(XBF_DELWRI|_XBF_DELWRI_Q); 1588 bp->b_flags &= ~(XBF_DELWRI|_XBF_DELWRI_Q);
1617 spin_unlock(dwlk); 1589 spin_unlock(&bp->b_target->bt_delwri_lock);
1618 1590
1619 if (dequeued) 1591 if (dequeued)
1620 xfs_buf_rele(bp); 1592 xfs_buf_rele(bp);
@@ -1646,16 +1618,9 @@ xfs_buf_delwri_promote(
1646 if (bp->b_queuetime < jiffies - age) 1618 if (bp->b_queuetime < jiffies - age)
1647 return; 1619 return;
1648 bp->b_queuetime = jiffies - age; 1620 bp->b_queuetime = jiffies - age;
1649 spin_lock(&btp->bt_delwrite_lock); 1621 spin_lock(&btp->bt_delwri_lock);
1650 list_move(&bp->b_list, &btp->bt_delwrite_queue); 1622 list_move(&bp->b_list, &btp->bt_delwri_queue);
1651 spin_unlock(&btp->bt_delwrite_lock); 1623 spin_unlock(&btp->bt_delwri_lock);
1652}
1653
1654STATIC void
1655xfs_buf_runall_queues(
1656 struct workqueue_struct *queue)
1657{
1658 flush_workqueue(queue);
1659} 1624}
1660 1625
1661/* 1626/*
@@ -1669,15 +1634,13 @@ xfs_buf_delwri_split(
1669 unsigned long age) 1634 unsigned long age)
1670{ 1635{
1671 xfs_buf_t *bp, *n; 1636 xfs_buf_t *bp, *n;
1672 struct list_head *dwq = &target->bt_delwrite_queue;
1673 spinlock_t *dwlk = &target->bt_delwrite_lock;
1674 int skipped = 0; 1637 int skipped = 0;
1675 int force; 1638 int force;
1676 1639
1677 force = test_and_clear_bit(XBT_FORCE_FLUSH, &target->bt_flags); 1640 force = test_and_clear_bit(XBT_FORCE_FLUSH, &target->bt_flags);
1678 INIT_LIST_HEAD(list); 1641 INIT_LIST_HEAD(list);
1679 spin_lock(dwlk); 1642 spin_lock(&target->bt_delwri_lock);
1680 list_for_each_entry_safe(bp, n, dwq, b_list) { 1643 list_for_each_entry_safe(bp, n, &target->bt_delwri_queue, b_list) {
1681 ASSERT(bp->b_flags & XBF_DELWRI); 1644 ASSERT(bp->b_flags & XBF_DELWRI);
1682 1645
1683 if (!xfs_buf_ispinned(bp) && xfs_buf_trylock(bp)) { 1646 if (!xfs_buf_ispinned(bp) && xfs_buf_trylock(bp)) {
@@ -1694,10 +1657,9 @@ xfs_buf_delwri_split(
1694 } else 1657 } else
1695 skipped++; 1658 skipped++;
1696 } 1659 }
1697 spin_unlock(dwlk);
1698 1660
1661 spin_unlock(&target->bt_delwri_lock);
1699 return skipped; 1662 return skipped;
1700
1701} 1663}
1702 1664
1703/* 1665/*
@@ -1747,7 +1709,7 @@ xfsbufd(
1747 } 1709 }
1748 1710
1749 /* sleep for a long time if there is nothing to do. */ 1711 /* sleep for a long time if there is nothing to do. */
1750 if (list_empty(&target->bt_delwrite_queue)) 1712 if (list_empty(&target->bt_delwri_queue))
1751 tout = MAX_SCHEDULE_TIMEOUT; 1713 tout = MAX_SCHEDULE_TIMEOUT;
1752 schedule_timeout_interruptible(tout); 1714 schedule_timeout_interruptible(tout);
1753 1715
@@ -1783,9 +1745,7 @@ xfs_flush_buftarg(
1783 LIST_HEAD(wait_list); 1745 LIST_HEAD(wait_list);
1784 struct blk_plug plug; 1746 struct blk_plug plug;
1785 1747
1786 xfs_buf_runall_queues(xfsconvertd_workqueue); 1748 flush_workqueue(xfslogd_workqueue);
1787 xfs_buf_runall_queues(xfsdatad_workqueue);
1788 xfs_buf_runall_queues(xfslogd_workqueue);
1789 1749
1790 set_bit(XBT_FORCE_FLUSH, &target->bt_flags); 1750 set_bit(XBT_FORCE_FLUSH, &target->bt_flags);
1791 pincount = xfs_buf_delwri_split(target, &tmp_list, 0); 1751 pincount = xfs_buf_delwri_split(target, &tmp_list, 0);
@@ -1866,11 +1826,3 @@ xfs_buf_terminate(void)
1866 destroy_workqueue(xfslogd_workqueue); 1826 destroy_workqueue(xfslogd_workqueue);
1867 kmem_zone_destroy(xfs_buf_zone); 1827 kmem_zone_destroy(xfs_buf_zone);
1868} 1828}
1869
1870#ifdef CONFIG_KDB_MODULES
1871struct list_head *
1872xfs_get_buftarg_list(void)
1873{
1874 return &xfs_buftarg_list;
1875}
1876#endif
diff --git a/fs/xfs/xfs_buf.h b/fs/xfs/xfs_buf.h
index 620972b8094d..5bab046e859f 100644
--- a/fs/xfs/xfs_buf.h
+++ b/fs/xfs/xfs_buf.h
@@ -105,8 +105,8 @@ typedef struct xfs_buftarg {
105 105
106 /* per device delwri queue */ 106 /* per device delwri queue */
107 struct task_struct *bt_task; 107 struct task_struct *bt_task;
108 struct list_head bt_delwrite_queue; 108 struct list_head bt_delwri_queue;
109 spinlock_t bt_delwrite_lock; 109 spinlock_t bt_delwri_lock;
110 unsigned long bt_flags; 110 unsigned long bt_flags;
111 111
112 /* LRU control structures */ 112 /* LRU control structures */
@@ -175,7 +175,8 @@ extern xfs_buf_t *xfs_buf_get(xfs_buftarg_t *, xfs_off_t, size_t,
175extern xfs_buf_t *xfs_buf_read(xfs_buftarg_t *, xfs_off_t, size_t, 175extern xfs_buf_t *xfs_buf_read(xfs_buftarg_t *, xfs_off_t, size_t,
176 xfs_buf_flags_t); 176 xfs_buf_flags_t);
177 177
178extern xfs_buf_t *xfs_buf_get_empty(size_t, xfs_buftarg_t *); 178struct xfs_buf *xfs_buf_alloc(struct xfs_buftarg *, xfs_off_t, size_t,
179 xfs_buf_flags_t);
179extern void xfs_buf_set_empty(struct xfs_buf *bp, size_t len); 180extern void xfs_buf_set_empty(struct xfs_buf *bp, size_t len);
180extern xfs_buf_t *xfs_buf_get_uncached(struct xfs_buftarg *, size_t, int); 181extern xfs_buf_t *xfs_buf_get_uncached(struct xfs_buftarg *, size_t, int);
181extern int xfs_buf_associate_memory(xfs_buf_t *, void *, size_t); 182extern int xfs_buf_associate_memory(xfs_buf_t *, void *, size_t);
@@ -197,14 +198,14 @@ extern void xfs_buf_unlock(xfs_buf_t *);
197 ((bp)->b_sema.count <= 0) 198 ((bp)->b_sema.count <= 0)
198 199
199/* Buffer Read and Write Routines */ 200/* Buffer Read and Write Routines */
200extern int xfs_bwrite(struct xfs_mount *mp, struct xfs_buf *bp); 201extern int xfs_bwrite(struct xfs_buf *bp);
201extern void xfs_bdwrite(void *mp, xfs_buf_t *bp);
202 202
203extern void xfsbdstrat(struct xfs_mount *, struct xfs_buf *); 203extern void xfsbdstrat(struct xfs_mount *, struct xfs_buf *);
204extern int xfs_bdstrat_cb(struct xfs_buf *); 204extern int xfs_bdstrat_cb(struct xfs_buf *);
205 205
206extern void xfs_buf_ioend(xfs_buf_t *, int); 206extern void xfs_buf_ioend(xfs_buf_t *, int);
207extern void xfs_buf_ioerror(xfs_buf_t *, int); 207extern void xfs_buf_ioerror(xfs_buf_t *, int);
208extern void xfs_buf_ioerror_alert(struct xfs_buf *, const char *func);
208extern int xfs_buf_iorequest(xfs_buf_t *); 209extern int xfs_buf_iorequest(xfs_buf_t *);
209extern int xfs_buf_iowait(xfs_buf_t *); 210extern int xfs_buf_iowait(xfs_buf_t *);
210extern void xfs_buf_iomove(xfs_buf_t *, size_t, size_t, void *, 211extern void xfs_buf_iomove(xfs_buf_t *, size_t, size_t, void *,
@@ -221,38 +222,22 @@ static inline int xfs_buf_geterror(xfs_buf_t *bp)
221extern xfs_caddr_t xfs_buf_offset(xfs_buf_t *, size_t); 222extern xfs_caddr_t xfs_buf_offset(xfs_buf_t *, size_t);
222 223
223/* Delayed Write Buffer Routines */ 224/* Delayed Write Buffer Routines */
224extern void xfs_buf_delwri_dequeue(xfs_buf_t *); 225extern void xfs_buf_delwri_queue(struct xfs_buf *);
225extern void xfs_buf_delwri_promote(xfs_buf_t *); 226extern void xfs_buf_delwri_dequeue(struct xfs_buf *);
227extern void xfs_buf_delwri_promote(struct xfs_buf *);
226 228
227/* Buffer Daemon Setup Routines */ 229/* Buffer Daemon Setup Routines */
228extern int xfs_buf_init(void); 230extern int xfs_buf_init(void);
229extern void xfs_buf_terminate(void); 231extern void xfs_buf_terminate(void);
230 232
231static inline const char *
232xfs_buf_target_name(struct xfs_buftarg *target)
233{
234 static char __b[BDEVNAME_SIZE];
235
236 return bdevname(target->bt_bdev, __b);
237}
238
239
240#define XFS_BUF_ZEROFLAGS(bp) \ 233#define XFS_BUF_ZEROFLAGS(bp) \
241 ((bp)->b_flags &= ~(XBF_READ|XBF_WRITE|XBF_ASYNC|XBF_DELWRI| \ 234 ((bp)->b_flags &= ~(XBF_READ|XBF_WRITE|XBF_ASYNC|XBF_DELWRI| \
242 XBF_SYNCIO|XBF_FUA|XBF_FLUSH)) 235 XBF_SYNCIO|XBF_FUA|XBF_FLUSH))
243 236
244void xfs_buf_stale(struct xfs_buf *bp); 237void xfs_buf_stale(struct xfs_buf *bp);
245#define XFS_BUF_STALE(bp) xfs_buf_stale(bp);
246#define XFS_BUF_UNSTALE(bp) ((bp)->b_flags &= ~XBF_STALE) 238#define XFS_BUF_UNSTALE(bp) ((bp)->b_flags &= ~XBF_STALE)
247#define XFS_BUF_ISSTALE(bp) ((bp)->b_flags & XBF_STALE) 239#define XFS_BUF_ISSTALE(bp) ((bp)->b_flags & XBF_STALE)
248#define XFS_BUF_SUPER_STALE(bp) do { \ 240
249 XFS_BUF_STALE(bp); \
250 xfs_buf_delwri_dequeue(bp); \
251 XFS_BUF_DONE(bp); \
252 } while (0)
253
254#define XFS_BUF_DELAYWRITE(bp) ((bp)->b_flags |= XBF_DELWRI)
255#define XFS_BUF_UNDELAYWRITE(bp) xfs_buf_delwri_dequeue(bp)
256#define XFS_BUF_ISDELAYWRITE(bp) ((bp)->b_flags & XBF_DELWRI) 241#define XFS_BUF_ISDELAYWRITE(bp) ((bp)->b_flags & XBF_DELWRI)
257 242
258#define XFS_BUF_DONE(bp) ((bp)->b_flags |= XBF_DONE) 243#define XFS_BUF_DONE(bp) ((bp)->b_flags |= XBF_DONE)
@@ -280,23 +265,16 @@ void xfs_buf_stale(struct xfs_buf *bp);
280#define XFS_BUF_SIZE(bp) ((bp)->b_buffer_length) 265#define XFS_BUF_SIZE(bp) ((bp)->b_buffer_length)
281#define XFS_BUF_SET_SIZE(bp, cnt) ((bp)->b_buffer_length = (cnt)) 266#define XFS_BUF_SET_SIZE(bp, cnt) ((bp)->b_buffer_length = (cnt))
282 267
283static inline void 268static inline void xfs_buf_set_ref(struct xfs_buf *bp, int lru_ref)
284xfs_buf_set_ref(
285 struct xfs_buf *bp,
286 int lru_ref)
287{ 269{
288 atomic_set(&bp->b_lru_ref, lru_ref); 270 atomic_set(&bp->b_lru_ref, lru_ref);
289} 271}
290#define XFS_BUF_SET_VTYPE_REF(bp, type, ref) xfs_buf_set_ref(bp, ref)
291#define XFS_BUF_SET_VTYPE(bp, type) do { } while (0)
292 272
293static inline int xfs_buf_ispinned(struct xfs_buf *bp) 273static inline int xfs_buf_ispinned(struct xfs_buf *bp)
294{ 274{
295 return atomic_read(&bp->b_pin_count); 275 return atomic_read(&bp->b_pin_count);
296} 276}
297 277
298#define XFS_BUF_FINISH_IOWAIT(bp) complete(&bp->b_iowait);
299
300static inline void xfs_buf_relse(xfs_buf_t *bp) 278static inline void xfs_buf_relse(xfs_buf_t *bp)
301{ 279{
302 xfs_buf_unlock(bp); 280 xfs_buf_unlock(bp);
@@ -313,14 +291,7 @@ extern void xfs_wait_buftarg(xfs_buftarg_t *);
313extern int xfs_setsize_buftarg(xfs_buftarg_t *, unsigned int, unsigned int); 291extern int xfs_setsize_buftarg(xfs_buftarg_t *, unsigned int, unsigned int);
314extern int xfs_flush_buftarg(xfs_buftarg_t *, int); 292extern int xfs_flush_buftarg(xfs_buftarg_t *, int);
315 293
316#ifdef CONFIG_KDB_MODULES
317extern struct list_head *xfs_get_buftarg_list(void);
318#endif
319
320#define xfs_getsize_buftarg(buftarg) block_size((buftarg)->bt_bdev) 294#define xfs_getsize_buftarg(buftarg) block_size((buftarg)->bt_bdev)
321#define xfs_readonly_buftarg(buftarg) bdev_read_only((buftarg)->bt_bdev) 295#define xfs_readonly_buftarg(buftarg) bdev_read_only((buftarg)->bt_bdev)
322 296
323#define xfs_binval(buftarg) xfs_flush_buftarg(buftarg, 1)
324#define XFS_bflush(buftarg) xfs_flush_buftarg(buftarg, 1)
325
326#endif /* __XFS_BUF_H__ */ 297#endif /* __XFS_BUF_H__ */
diff --git a/fs/xfs/xfs_buf_item.c b/fs/xfs/xfs_buf_item.c
index ef43fce519a1..1a3513881bce 100644
--- a/fs/xfs/xfs_buf_item.c
+++ b/fs/xfs/xfs_buf_item.c
@@ -967,7 +967,8 @@ xfs_buf_iodone_callbacks(
967 * I/O errors, there's no point in giving this a retry. 967 * I/O errors, there's no point in giving this a retry.
968 */ 968 */
969 if (XFS_FORCED_SHUTDOWN(mp)) { 969 if (XFS_FORCED_SHUTDOWN(mp)) {
970 XFS_BUF_SUPER_STALE(bp); 970 xfs_buf_stale(bp);
971 XFS_BUF_DONE(bp);
971 trace_xfs_buf_item_iodone(bp, _RET_IP_); 972 trace_xfs_buf_item_iodone(bp, _RET_IP_);
972 goto do_callbacks; 973 goto do_callbacks;
973 } 974 }
@@ -975,9 +976,7 @@ xfs_buf_iodone_callbacks(
975 if (bp->b_target != lasttarg || 976 if (bp->b_target != lasttarg ||
976 time_after(jiffies, (lasttime + 5*HZ))) { 977 time_after(jiffies, (lasttime + 5*HZ))) {
977 lasttime = jiffies; 978 lasttime = jiffies;
978 xfs_alert(mp, "Device %s: metadata write error block 0x%llx", 979 xfs_buf_ioerror_alert(bp, __func__);
979 xfs_buf_target_name(bp->b_target),
980 (__uint64_t)XFS_BUF_ADDR(bp));
981 } 980 }
982 lasttarg = bp->b_target; 981 lasttarg = bp->b_target;
983 982
@@ -993,7 +992,7 @@ xfs_buf_iodone_callbacks(
993 xfs_buf_ioerror(bp, 0); /* errno of 0 unsets the flag */ 992 xfs_buf_ioerror(bp, 0); /* errno of 0 unsets the flag */
994 993
995 if (!XFS_BUF_ISSTALE(bp)) { 994 if (!XFS_BUF_ISSTALE(bp)) {
996 XFS_BUF_DELAYWRITE(bp); 995 xfs_buf_delwri_queue(bp);
997 XFS_BUF_DONE(bp); 996 XFS_BUF_DONE(bp);
998 } 997 }
999 ASSERT(bp->b_iodone != NULL); 998 ASSERT(bp->b_iodone != NULL);
@@ -1006,9 +1005,8 @@ xfs_buf_iodone_callbacks(
1006 * If the write of the buffer was synchronous, we want to make 1005 * If the write of the buffer was synchronous, we want to make
1007 * sure to return the error to the caller of xfs_bwrite(). 1006 * sure to return the error to the caller of xfs_bwrite().
1008 */ 1007 */
1009 XFS_BUF_STALE(bp); 1008 xfs_buf_stale(bp);
1010 XFS_BUF_DONE(bp); 1009 XFS_BUF_DONE(bp);
1011 XFS_BUF_UNDELAYWRITE(bp);
1012 1010
1013 trace_xfs_buf_error_relse(bp, _RET_IP_); 1011 trace_xfs_buf_error_relse(bp, _RET_IP_);
1014 1012
diff --git a/fs/xfs/xfs_da_btree.c b/fs/xfs/xfs_da_btree.c
index ee9d5427fcd4..77c74257c2a3 100644
--- a/fs/xfs/xfs_da_btree.c
+++ b/fs/xfs/xfs_da_btree.c
@@ -1578,9 +1578,8 @@ xfs_da_grow_inode_int(
1578 */ 1578 */
1579 nmap = 1; 1579 nmap = 1;
1580 ASSERT(args->firstblock != NULL); 1580 ASSERT(args->firstblock != NULL);
1581 error = xfs_bmapi(tp, dp, *bno, count, 1581 error = xfs_bmapi_write(tp, dp, *bno, count,
1582 xfs_bmapi_aflag(w)|XFS_BMAPI_WRITE|XFS_BMAPI_METADATA| 1582 xfs_bmapi_aflag(w)|XFS_BMAPI_METADATA|XFS_BMAPI_CONTIG,
1583 XFS_BMAPI_CONTIG,
1584 args->firstblock, args->total, &map, &nmap, 1583 args->firstblock, args->total, &map, &nmap,
1585 args->flist); 1584 args->flist);
1586 if (error) 1585 if (error)
@@ -1602,9 +1601,8 @@ xfs_da_grow_inode_int(
1602 for (b = *bno, mapi = 0; b < *bno + count; ) { 1601 for (b = *bno, mapi = 0; b < *bno + count; ) {
1603 nmap = MIN(XFS_BMAP_MAX_NMAP, count); 1602 nmap = MIN(XFS_BMAP_MAX_NMAP, count);
1604 c = (int)(*bno + count - b); 1603 c = (int)(*bno + count - b);
1605 error = xfs_bmapi(tp, dp, b, c, 1604 error = xfs_bmapi_write(tp, dp, b, c,
1606 xfs_bmapi_aflag(w)|XFS_BMAPI_WRITE| 1605 xfs_bmapi_aflag(w)|XFS_BMAPI_METADATA,
1607 XFS_BMAPI_METADATA,
1608 args->firstblock, args->total, 1606 args->firstblock, args->total,
1609 &mapp[mapi], &nmap, args->flist); 1607 &mapp[mapi], &nmap, args->flist);
1610 if (error) 1608 if (error)
@@ -1975,33 +1973,16 @@ xfs_da_do_buf(
1975 /* 1973 /*
1976 * Optimize the one-block case. 1974 * Optimize the one-block case.
1977 */ 1975 */
1978 if (nfsb == 1) { 1976 if (nfsb == 1)
1979 xfs_fsblock_t fsb;
1980
1981 if ((error =
1982 xfs_bmapi_single(trans, dp, whichfork, &fsb,
1983 (xfs_fileoff_t)bno))) {
1984 return error;
1985 }
1986 mapp = &map; 1977 mapp = &map;
1987 if (fsb == NULLFSBLOCK) { 1978 else
1988 nmap = 0;
1989 } else {
1990 map.br_startblock = fsb;
1991 map.br_startoff = (xfs_fileoff_t)bno;
1992 map.br_blockcount = 1;
1993 nmap = 1;
1994 }
1995 } else {
1996 mapp = kmem_alloc(sizeof(*mapp) * nfsb, KM_SLEEP); 1979 mapp = kmem_alloc(sizeof(*mapp) * nfsb, KM_SLEEP);
1997 nmap = nfsb; 1980
1998 if ((error = xfs_bmapi(trans, dp, (xfs_fileoff_t)bno, 1981 nmap = nfsb;
1999 nfsb, 1982 error = xfs_bmapi_read(dp, (xfs_fileoff_t)bno, nfsb, mapp,
2000 XFS_BMAPI_METADATA | 1983 &nmap, xfs_bmapi_aflag(whichfork));
2001 xfs_bmapi_aflag(whichfork), 1984 if (error)
2002 NULL, 0, mapp, &nmap, NULL))) 1985 goto exit0;
2003 goto exit0;
2004 }
2005 } else { 1986 } else {
2006 map.br_startblock = XFS_DADDR_TO_FSB(mp, mappedbno); 1987 map.br_startblock = XFS_DADDR_TO_FSB(mp, mappedbno);
2007 map.br_startoff = (xfs_fileoff_t)bno; 1988 map.br_startoff = (xfs_fileoff_t)bno;
@@ -2072,13 +2053,10 @@ xfs_da_do_buf(
2072 if (!bp) 2053 if (!bp)
2073 continue; 2054 continue;
2074 if (caller == 1) { 2055 if (caller == 1) {
2075 if (whichfork == XFS_ATTR_FORK) { 2056 if (whichfork == XFS_ATTR_FORK)
2076 XFS_BUF_SET_VTYPE_REF(bp, B_FS_ATTR_BTREE, 2057 xfs_buf_set_ref(bp, XFS_ATTR_BTREE_REF);
2077 XFS_ATTR_BTREE_REF); 2058 else
2078 } else { 2059 xfs_buf_set_ref(bp, XFS_DIR_BTREE_REF);
2079 XFS_BUF_SET_VTYPE_REF(bp, B_FS_DIR_BTREE,
2080 XFS_DIR_BTREE_REF);
2081 }
2082 } 2060 }
2083 if (bplist) { 2061 if (bplist) {
2084 bplist[nbplist++] = bp; 2062 bplist[nbplist++] = bp;
diff --git a/fs/xfs/xfs_dfrag.c b/fs/xfs/xfs_dfrag.c
index 9a84a85c03b1..654dc6f05bac 100644
--- a/fs/xfs/xfs_dfrag.c
+++ b/fs/xfs/xfs_dfrag.c
@@ -425,8 +425,8 @@ xfs_swap_extents(
425 } 425 }
426 426
427 427
428 xfs_trans_ijoin_ref(tp, ip, XFS_ILOCK_EXCL | XFS_IOLOCK_EXCL); 428 xfs_trans_ijoin(tp, ip, XFS_ILOCK_EXCL | XFS_IOLOCK_EXCL);
429 xfs_trans_ijoin_ref(tp, tip, XFS_ILOCK_EXCL | XFS_IOLOCK_EXCL); 429 xfs_trans_ijoin(tp, tip, XFS_ILOCK_EXCL | XFS_IOLOCK_EXCL);
430 430
431 xfs_trans_log_inode(tp, ip, ilf_fields); 431 xfs_trans_log_inode(tp, ip, ilf_fields);
432 xfs_trans_log_inode(tp, tip, tilf_fields); 432 xfs_trans_log_inode(tp, tip, tilf_fields);
@@ -438,7 +438,7 @@ xfs_swap_extents(
438 if (mp->m_flags & XFS_MOUNT_WSYNC) 438 if (mp->m_flags & XFS_MOUNT_WSYNC)
439 xfs_trans_set_sync(tp); 439 xfs_trans_set_sync(tp);
440 440
441 error = xfs_trans_commit(tp, XFS_TRANS_SWAPEXT); 441 error = xfs_trans_commit(tp, 0);
442 442
443 trace_xfs_swap_extent_after(ip, 0); 443 trace_xfs_swap_extent_after(ip, 0);
444 trace_xfs_swap_extent_after(tip, 1); 444 trace_xfs_swap_extent_after(tip, 1);
diff --git a/fs/xfs/xfs_dir2_leaf.c b/fs/xfs/xfs_dir2_leaf.c
index ca2386d82cdf..66e108f561a3 100644
--- a/fs/xfs/xfs_dir2_leaf.c
+++ b/fs/xfs/xfs_dir2_leaf.c
@@ -888,12 +888,10 @@ xfs_dir2_leaf_getdents(
888 * we already have in the table. 888 * we already have in the table.
889 */ 889 */
890 nmap = map_size - map_valid; 890 nmap = map_size - map_valid;
891 error = xfs_bmapi(NULL, dp, 891 error = xfs_bmapi_read(dp, map_off,
892 map_off,
893 xfs_dir2_byte_to_da(mp, 892 xfs_dir2_byte_to_da(mp,
894 XFS_DIR2_LEAF_OFFSET) - map_off, 893 XFS_DIR2_LEAF_OFFSET) - map_off,
895 XFS_BMAPI_METADATA, NULL, 0, 894 &map[map_valid], &nmap, 0);
896 &map[map_valid], &nmap, NULL);
897 /* 895 /*
898 * Don't know if we should ignore this or 896 * Don't know if we should ignore this or
899 * try to return an error. 897 * try to return an error.
diff --git a/fs/xfs/xfs_discard.c b/fs/xfs/xfs_discard.c
index 244e797dae32..8a24f0c6c860 100644
--- a/fs/xfs/xfs_discard.c
+++ b/fs/xfs/xfs_discard.c
@@ -38,7 +38,7 @@ xfs_trim_extents(
38 struct xfs_mount *mp, 38 struct xfs_mount *mp,
39 xfs_agnumber_t agno, 39 xfs_agnumber_t agno,
40 xfs_fsblock_t start, 40 xfs_fsblock_t start,
41 xfs_fsblock_t len, 41 xfs_fsblock_t end,
42 xfs_fsblock_t minlen, 42 xfs_fsblock_t minlen,
43 __uint64_t *blocks_trimmed) 43 __uint64_t *blocks_trimmed)
44{ 44{
@@ -100,7 +100,7 @@ xfs_trim_extents(
100 * down partially overlapping ranges for now. 100 * down partially overlapping ranges for now.
101 */ 101 */
102 if (XFS_AGB_TO_FSB(mp, agno, fbno) + flen < start || 102 if (XFS_AGB_TO_FSB(mp, agno, fbno) + flen < start ||
103 XFS_AGB_TO_FSB(mp, agno, fbno) >= start + len) { 103 XFS_AGB_TO_FSB(mp, agno, fbno) > end) {
104 trace_xfs_discard_exclude(mp, agno, fbno, flen); 104 trace_xfs_discard_exclude(mp, agno, fbno, flen);
105 goto next_extent; 105 goto next_extent;
106 } 106 }
@@ -145,7 +145,7 @@ xfs_ioc_trim(
145 struct request_queue *q = mp->m_ddev_targp->bt_bdev->bd_disk->queue; 145 struct request_queue *q = mp->m_ddev_targp->bt_bdev->bd_disk->queue;
146 unsigned int granularity = q->limits.discard_granularity; 146 unsigned int granularity = q->limits.discard_granularity;
147 struct fstrim_range range; 147 struct fstrim_range range;
148 xfs_fsblock_t start, len, minlen; 148 xfs_fsblock_t start, end, minlen;
149 xfs_agnumber_t start_agno, end_agno, agno; 149 xfs_agnumber_t start_agno, end_agno, agno;
150 __uint64_t blocks_trimmed = 0; 150 __uint64_t blocks_trimmed = 0;
151 int error, last_error = 0; 151 int error, last_error = 0;
@@ -165,19 +165,19 @@ xfs_ioc_trim(
165 * matter as trimming blocks is an advisory interface. 165 * matter as trimming blocks is an advisory interface.
166 */ 166 */
167 start = XFS_B_TO_FSBT(mp, range.start); 167 start = XFS_B_TO_FSBT(mp, range.start);
168 len = XFS_B_TO_FSBT(mp, range.len); 168 end = start + XFS_B_TO_FSBT(mp, range.len) - 1;
169 minlen = XFS_B_TO_FSB(mp, max_t(u64, granularity, range.minlen)); 169 minlen = XFS_B_TO_FSB(mp, max_t(u64, granularity, range.minlen));
170 170
171 start_agno = XFS_FSB_TO_AGNO(mp, start); 171 if (start >= mp->m_sb.sb_dblocks)
172 if (start_agno >= mp->m_sb.sb_agcount)
173 return -XFS_ERROR(EINVAL); 172 return -XFS_ERROR(EINVAL);
173 if (end > mp->m_sb.sb_dblocks - 1)
174 end = mp->m_sb.sb_dblocks - 1;
174 175
175 end_agno = XFS_FSB_TO_AGNO(mp, start + len); 176 start_agno = XFS_FSB_TO_AGNO(mp, start);
176 if (end_agno >= mp->m_sb.sb_agcount) 177 end_agno = XFS_FSB_TO_AGNO(mp, end);
177 end_agno = mp->m_sb.sb_agcount - 1;
178 178
179 for (agno = start_agno; agno <= end_agno; agno++) { 179 for (agno = start_agno; agno <= end_agno; agno++) {
180 error = -xfs_trim_extents(mp, agno, start, len, minlen, 180 error = -xfs_trim_extents(mp, agno, start, end, minlen,
181 &blocks_trimmed); 181 &blocks_trimmed);
182 if (error) 182 if (error)
183 last_error = error; 183 last_error = error;
diff --git a/fs/xfs/xfs_dquot.c b/fs/xfs/xfs_dquot.c
index db62959bed13..25d7280e9f6b 100644
--- a/fs/xfs/xfs_dquot.c
+++ b/fs/xfs/xfs_dquot.c
@@ -377,16 +377,14 @@ xfs_qm_dqalloc(
377 return (ESRCH); 377 return (ESRCH);
378 } 378 }
379 379
380 xfs_trans_ijoin_ref(tp, quotip, XFS_ILOCK_EXCL); 380 xfs_trans_ijoin(tp, quotip, XFS_ILOCK_EXCL);
381 nmaps = 1; 381 nmaps = 1;
382 if ((error = xfs_bmapi(tp, quotip, 382 error = xfs_bmapi_write(tp, quotip, offset_fsb,
383 offset_fsb, XFS_DQUOT_CLUSTER_SIZE_FSB, 383 XFS_DQUOT_CLUSTER_SIZE_FSB, XFS_BMAPI_METADATA,
384 XFS_BMAPI_METADATA | XFS_BMAPI_WRITE, 384 &firstblock, XFS_QM_DQALLOC_SPACE_RES(mp),
385 &firstblock, 385 &map, &nmaps, &flist);
386 XFS_QM_DQALLOC_SPACE_RES(mp), 386 if (error)
387 &map, &nmaps, &flist))) {
388 goto error0; 387 goto error0;
389 }
390 ASSERT(map.br_blockcount == XFS_DQUOT_CLUSTER_SIZE_FSB); 388 ASSERT(map.br_blockcount == XFS_DQUOT_CLUSTER_SIZE_FSB);
391 ASSERT(nmaps == 1); 389 ASSERT(nmaps == 1);
392 ASSERT((map.br_startblock != DELAYSTARTBLOCK) && 390 ASSERT((map.br_startblock != DELAYSTARTBLOCK) &&
@@ -402,8 +400,11 @@ xfs_qm_dqalloc(
402 dqp->q_blkno, 400 dqp->q_blkno,
403 mp->m_quotainfo->qi_dqchunklen, 401 mp->m_quotainfo->qi_dqchunklen,
404 0); 402 0);
405 if (!bp || (error = xfs_buf_geterror(bp))) 403
404 error = xfs_buf_geterror(bp);
405 if (error)
406 goto error1; 406 goto error1;
407
407 /* 408 /*
408 * Make a chunk of dquots out of this buffer and log 409 * Make a chunk of dquots out of this buffer and log
409 * the entire thing. 410 * the entire thing.
@@ -485,9 +486,8 @@ xfs_qm_dqtobp(
485 /* 486 /*
486 * Find the block map; no allocations yet 487 * Find the block map; no allocations yet
487 */ 488 */
488 error = xfs_bmapi(NULL, quotip, dqp->q_fileoffset, 489 error = xfs_bmapi_read(quotip, dqp->q_fileoffset,
489 XFS_DQUOT_CLUSTER_SIZE_FSB, XFS_BMAPI_METADATA, 490 XFS_DQUOT_CLUSTER_SIZE_FSB, &map, &nmaps, 0);
490 NULL, 0, &map, &nmaps, NULL);
491 491
492 xfs_iunlock(quotip, XFS_ILOCK_SHARED); 492 xfs_iunlock(quotip, XFS_ILOCK_SHARED);
493 if (error) 493 if (error)
@@ -605,7 +605,7 @@ xfs_qm_dqread(
605 dqp->q_res_rtbcount = be64_to_cpu(ddqp->d_rtbcount); 605 dqp->q_res_rtbcount = be64_to_cpu(ddqp->d_rtbcount);
606 606
607 /* Mark the buf so that this will stay incore a little longer */ 607 /* Mark the buf so that this will stay incore a little longer */
608 XFS_BUF_SET_VTYPE_REF(bp, B_FS_DQUOT, XFS_DQUOT_REF); 608 xfs_buf_set_ref(bp, XFS_DQUOT_REF);
609 609
610 /* 610 /*
611 * We got the buffer with a xfs_trans_read_buf() (in dqtobp()) 611 * We got the buffer with a xfs_trans_read_buf() (in dqtobp())
@@ -1242,9 +1242,11 @@ xfs_qm_dqflush(
1242 } 1242 }
1243 1243
1244 if (flags & SYNC_WAIT) 1244 if (flags & SYNC_WAIT)
1245 error = xfs_bwrite(mp, bp); 1245 error = xfs_bwrite(bp);
1246 else 1246 else
1247 xfs_bdwrite(mp, bp); 1247 xfs_buf_delwri_queue(bp);
1248
1249 xfs_buf_relse(bp);
1248 1250
1249 trace_xfs_dqflush_done(dqp); 1251 trace_xfs_dqflush_done(dqp);
1250 1252
diff --git a/fs/xfs/xfs_export.c b/fs/xfs/xfs_export.c
index 75e5d322e48f..da108977b21f 100644
--- a/fs/xfs/xfs_export.c
+++ b/fs/xfs/xfs_export.c
@@ -229,16 +229,16 @@ xfs_fs_nfs_commit_metadata(
229{ 229{
230 struct xfs_inode *ip = XFS_I(inode); 230 struct xfs_inode *ip = XFS_I(inode);
231 struct xfs_mount *mp = ip->i_mount; 231 struct xfs_mount *mp = ip->i_mount;
232 int error = 0; 232 xfs_lsn_t lsn = 0;
233 233
234 xfs_ilock(ip, XFS_ILOCK_SHARED); 234 xfs_ilock(ip, XFS_ILOCK_SHARED);
235 if (xfs_ipincount(ip)) { 235 if (xfs_ipincount(ip))
236 error = _xfs_log_force_lsn(mp, ip->i_itemp->ili_last_lsn, 236 lsn = ip->i_itemp->ili_last_lsn;
237 XFS_LOG_SYNC, NULL);
238 }
239 xfs_iunlock(ip, XFS_ILOCK_SHARED); 237 xfs_iunlock(ip, XFS_ILOCK_SHARED);
240 238
241 return error; 239 if (!lsn)
240 return 0;
241 return _xfs_log_force_lsn(mp, lsn, XFS_LOG_SYNC, NULL);
242} 242}
243 243
244const struct export_operations xfs_export_operations = { 244const struct export_operations xfs_export_operations = {
diff --git a/fs/xfs/xfs_file.c b/fs/xfs/xfs_file.c
index 7f7b42469ea7..753ed9b5c70b 100644
--- a/fs/xfs/xfs_file.c
+++ b/fs/xfs/xfs_file.c
@@ -124,6 +124,35 @@ xfs_iozero(
124 return (-status); 124 return (-status);
125} 125}
126 126
127/*
128 * Fsync operations on directories are much simpler than on regular files,
129 * as there is no file data to flush, and thus also no need for explicit
130 * cache flush operations, and there are no non-transaction metadata updates
131 * on directories either.
132 */
133STATIC int
134xfs_dir_fsync(
135 struct file *file,
136 loff_t start,
137 loff_t end,
138 int datasync)
139{
140 struct xfs_inode *ip = XFS_I(file->f_mapping->host);
141 struct xfs_mount *mp = ip->i_mount;
142 xfs_lsn_t lsn = 0;
143
144 trace_xfs_dir_fsync(ip);
145
146 xfs_ilock(ip, XFS_ILOCK_SHARED);
147 if (xfs_ipincount(ip))
148 lsn = ip->i_itemp->ili_last_lsn;
149 xfs_iunlock(ip, XFS_ILOCK_SHARED);
150
151 if (!lsn)
152 return 0;
153 return _xfs_log_force_lsn(mp, lsn, XFS_LOG_SYNC, NULL);
154}
155
127STATIC int 156STATIC int
128xfs_file_fsync( 157xfs_file_fsync(
129 struct file *file, 158 struct file *file,
@@ -137,6 +166,7 @@ xfs_file_fsync(
137 struct xfs_trans *tp; 166 struct xfs_trans *tp;
138 int error = 0; 167 int error = 0;
139 int log_flushed = 0; 168 int log_flushed = 0;
169 xfs_lsn_t lsn = 0;
140 170
141 trace_xfs_file_fsync(ip); 171 trace_xfs_file_fsync(ip);
142 172
@@ -149,10 +179,6 @@ xfs_file_fsync(
149 179
150 xfs_iflags_clear(ip, XFS_ITRUNCATED); 180 xfs_iflags_clear(ip, XFS_ITRUNCATED);
151 181
152 xfs_ilock(ip, XFS_IOLOCK_SHARED);
153 xfs_ioend_wait(ip);
154 xfs_iunlock(ip, XFS_IOLOCK_SHARED);
155
156 if (mp->m_flags & XFS_MOUNT_BARRIER) { 182 if (mp->m_flags & XFS_MOUNT_BARRIER) {
157 /* 183 /*
158 * If we have an RT and/or log subvolume we need to make sure 184 * If we have an RT and/or log subvolume we need to make sure
@@ -216,11 +242,11 @@ xfs_file_fsync(
216 * transaction. So we play it safe and fire off the 242 * transaction. So we play it safe and fire off the
217 * transaction anyway. 243 * transaction anyway.
218 */ 244 */
219 xfs_trans_ijoin(tp, ip); 245 xfs_trans_ijoin(tp, ip, 0);
220 xfs_trans_log_inode(tp, ip, XFS_ILOG_CORE); 246 xfs_trans_log_inode(tp, ip, XFS_ILOG_CORE);
221 xfs_trans_set_sync(tp); 247 error = xfs_trans_commit(tp, 0);
222 error = _xfs_trans_commit(tp, 0, &log_flushed);
223 248
249 lsn = ip->i_itemp->ili_last_lsn;
224 xfs_iunlock(ip, XFS_ILOCK_EXCL); 250 xfs_iunlock(ip, XFS_ILOCK_EXCL);
225 } else { 251 } else {
226 /* 252 /*
@@ -231,14 +257,14 @@ xfs_file_fsync(
231 * disk yet, the inode will be still be pinned. If it is, 257 * disk yet, the inode will be still be pinned. If it is,
232 * force the log. 258 * force the log.
233 */ 259 */
234 if (xfs_ipincount(ip)) { 260 if (xfs_ipincount(ip))
235 error = _xfs_log_force_lsn(mp, 261 lsn = ip->i_itemp->ili_last_lsn;
236 ip->i_itemp->ili_last_lsn,
237 XFS_LOG_SYNC, &log_flushed);
238 }
239 xfs_iunlock(ip, XFS_ILOCK_SHARED); 262 xfs_iunlock(ip, XFS_ILOCK_SHARED);
240 } 263 }
241 264
265 if (!error && lsn)
266 error = _xfs_log_force_lsn(mp, lsn, XFS_LOG_SYNC, &log_flushed);
267
242 /* 268 /*
243 * If we only have a single device, and the log force about was 269 * If we only have a single device, and the log force about was
244 * a no-op we might have to flush the data device cache here. 270 * a no-op we might have to flush the data device cache here.
@@ -317,7 +343,19 @@ xfs_file_aio_read(
317 if (XFS_FORCED_SHUTDOWN(mp)) 343 if (XFS_FORCED_SHUTDOWN(mp))
318 return -EIO; 344 return -EIO;
319 345
320 if (unlikely(ioflags & IO_ISDIRECT)) { 346 /*
347 * Locking is a bit tricky here. If we take an exclusive lock
348 * for direct IO, we effectively serialise all new concurrent
349 * read IO to this file and block it behind IO that is currently in
350 * progress because IO in progress holds the IO lock shared. We only
351 * need to hold the lock exclusive to blow away the page cache, so
352 * only take lock exclusively if the page cache needs invalidation.
353 * This allows the normal direct IO case of no page cache pages to
354 * proceeed concurrently without serialisation.
355 */
356 xfs_rw_ilock(ip, XFS_IOLOCK_SHARED);
357 if ((ioflags & IO_ISDIRECT) && inode->i_mapping->nrpages) {
358 xfs_rw_iunlock(ip, XFS_IOLOCK_SHARED);
321 xfs_rw_ilock(ip, XFS_IOLOCK_EXCL); 359 xfs_rw_ilock(ip, XFS_IOLOCK_EXCL);
322 360
323 if (inode->i_mapping->nrpages) { 361 if (inode->i_mapping->nrpages) {
@@ -330,8 +368,7 @@ xfs_file_aio_read(
330 } 368 }
331 } 369 }
332 xfs_rw_ilock_demote(ip, XFS_IOLOCK_EXCL); 370 xfs_rw_ilock_demote(ip, XFS_IOLOCK_EXCL);
333 } else 371 }
334 xfs_rw_ilock(ip, XFS_IOLOCK_SHARED);
335 372
336 trace_xfs_file_read(ip, size, iocb->ki_pos, ioflags); 373 trace_xfs_file_read(ip, size, iocb->ki_pos, ioflags);
337 374
@@ -407,11 +444,13 @@ xfs_aio_write_isize_update(
407 */ 444 */
408STATIC void 445STATIC void
409xfs_aio_write_newsize_update( 446xfs_aio_write_newsize_update(
410 struct xfs_inode *ip) 447 struct xfs_inode *ip,
448 xfs_fsize_t new_size)
411{ 449{
412 if (ip->i_new_size) { 450 if (new_size == ip->i_new_size) {
413 xfs_rw_ilock(ip, XFS_ILOCK_EXCL); 451 xfs_rw_ilock(ip, XFS_ILOCK_EXCL);
414 ip->i_new_size = 0; 452 if (new_size == ip->i_new_size)
453 ip->i_new_size = 0;
415 if (ip->i_d.di_size > ip->i_size) 454 if (ip->i_d.di_size > ip->i_size)
416 ip->i_d.di_size = ip->i_size; 455 ip->i_d.di_size = ip->i_size;
417 xfs_rw_iunlock(ip, XFS_ILOCK_EXCL); 456 xfs_rw_iunlock(ip, XFS_ILOCK_EXCL);
@@ -462,7 +501,7 @@ xfs_file_splice_write(
462 ret = generic_file_splice_write(pipe, outfilp, ppos, count, flags); 501 ret = generic_file_splice_write(pipe, outfilp, ppos, count, flags);
463 502
464 xfs_aio_write_isize_update(inode, ppos, ret); 503 xfs_aio_write_isize_update(inode, ppos, ret);
465 xfs_aio_write_newsize_update(ip); 504 xfs_aio_write_newsize_update(ip, new_size);
466 xfs_iunlock(ip, XFS_IOLOCK_EXCL); 505 xfs_iunlock(ip, XFS_IOLOCK_EXCL);
467 return ret; 506 return ret;
468} 507}
@@ -500,11 +539,9 @@ xfs_zero_last_block(
500 539
501 last_fsb = XFS_B_TO_FSBT(mp, isize); 540 last_fsb = XFS_B_TO_FSBT(mp, isize);
502 nimaps = 1; 541 nimaps = 1;
503 error = xfs_bmapi(NULL, ip, last_fsb, 1, 0, NULL, 0, &imap, 542 error = xfs_bmapi_read(ip, last_fsb, 1, &imap, &nimaps, 0);
504 &nimaps, NULL); 543 if (error)
505 if (error) {
506 return error; 544 return error;
507 }
508 ASSERT(nimaps > 0); 545 ASSERT(nimaps > 0);
509 /* 546 /*
510 * If the block underlying isize is just a hole, then there 547 * If the block underlying isize is just a hole, then there
@@ -595,8 +632,8 @@ xfs_zero_eof(
595 while (start_zero_fsb <= end_zero_fsb) { 632 while (start_zero_fsb <= end_zero_fsb) {
596 nimaps = 1; 633 nimaps = 1;
597 zero_count_fsb = end_zero_fsb - start_zero_fsb + 1; 634 zero_count_fsb = end_zero_fsb - start_zero_fsb + 1;
598 error = xfs_bmapi(NULL, ip, start_zero_fsb, zero_count_fsb, 635 error = xfs_bmapi_read(ip, start_zero_fsb, zero_count_fsb,
599 0, NULL, 0, &imap, &nimaps, NULL); 636 &imap, &nimaps, 0);
600 if (error) { 637 if (error) {
601 ASSERT(xfs_isilocked(ip, XFS_ILOCK_EXCL|XFS_IOLOCK_EXCL)); 638 ASSERT(xfs_isilocked(ip, XFS_ILOCK_EXCL|XFS_IOLOCK_EXCL));
602 return error; 639 return error;
@@ -659,6 +696,7 @@ xfs_file_aio_write_checks(
659 struct file *file, 696 struct file *file,
660 loff_t *pos, 697 loff_t *pos,
661 size_t *count, 698 size_t *count,
699 xfs_fsize_t *new_sizep,
662 int *iolock) 700 int *iolock)
663{ 701{
664 struct inode *inode = file->f_mapping->host; 702 struct inode *inode = file->f_mapping->host;
@@ -666,6 +704,9 @@ xfs_file_aio_write_checks(
666 xfs_fsize_t new_size; 704 xfs_fsize_t new_size;
667 int error = 0; 705 int error = 0;
668 706
707 xfs_rw_ilock(ip, XFS_ILOCK_EXCL);
708 *new_sizep = 0;
709restart:
669 error = generic_write_checks(file, pos, count, S_ISBLK(inode->i_mode)); 710 error = generic_write_checks(file, pos, count, S_ISBLK(inode->i_mode));
670 if (error) { 711 if (error) {
671 xfs_rw_iunlock(ip, XFS_ILOCK_EXCL | *iolock); 712 xfs_rw_iunlock(ip, XFS_ILOCK_EXCL | *iolock);
@@ -673,20 +714,41 @@ xfs_file_aio_write_checks(
673 return error; 714 return error;
674 } 715 }
675 716
676 new_size = *pos + *count;
677 if (new_size > ip->i_size)
678 ip->i_new_size = new_size;
679
680 if (likely(!(file->f_mode & FMODE_NOCMTIME))) 717 if (likely(!(file->f_mode & FMODE_NOCMTIME)))
681 file_update_time(file); 718 file_update_time(file);
682 719
683 /* 720 /*
684 * If the offset is beyond the size of the file, we need to zero any 721 * If the offset is beyond the size of the file, we need to zero any
685 * blocks that fall between the existing EOF and the start of this 722 * blocks that fall between the existing EOF and the start of this
686 * write. 723 * write. There is no need to issue zeroing if another in-flght IO ends
724 * at or before this one If zeronig is needed and we are currently
725 * holding the iolock shared, we need to update it to exclusive which
726 * involves dropping all locks and relocking to maintain correct locking
727 * order. If we do this, restart the function to ensure all checks and
728 * values are still valid.
687 */ 729 */
688 if (*pos > ip->i_size) 730 if ((ip->i_new_size && *pos > ip->i_new_size) ||
731 (!ip->i_new_size && *pos > ip->i_size)) {
732 if (*iolock == XFS_IOLOCK_SHARED) {
733 xfs_rw_iunlock(ip, XFS_ILOCK_EXCL | *iolock);
734 *iolock = XFS_IOLOCK_EXCL;
735 xfs_rw_ilock(ip, XFS_ILOCK_EXCL | *iolock);
736 goto restart;
737 }
689 error = -xfs_zero_eof(ip, *pos, ip->i_size); 738 error = -xfs_zero_eof(ip, *pos, ip->i_size);
739 }
740
741 /*
742 * If this IO extends beyond EOF, we may need to update ip->i_new_size.
743 * We have already zeroed space beyond EOF (if necessary). Only update
744 * ip->i_new_size if this IO ends beyond any other in-flight writes.
745 */
746 new_size = *pos + *count;
747 if (new_size > ip->i_size) {
748 if (new_size > ip->i_new_size)
749 ip->i_new_size = new_size;
750 *new_sizep = new_size;
751 }
690 752
691 xfs_rw_iunlock(ip, XFS_ILOCK_EXCL); 753 xfs_rw_iunlock(ip, XFS_ILOCK_EXCL);
692 if (error) 754 if (error)
@@ -721,7 +783,7 @@ xfs_file_aio_write_checks(
721 * the dio layer. To avoid the problem with aio, we also need to wait for 783 * the dio layer. To avoid the problem with aio, we also need to wait for
722 * outstanding IOs to complete so that unwritten extent conversion is completed 784 * outstanding IOs to complete so that unwritten extent conversion is completed
723 * before we try to map the overlapping block. This is currently implemented by 785 * before we try to map the overlapping block. This is currently implemented by
724 * hitting it with a big hammer (i.e. xfs_ioend_wait()). 786 * hitting it with a big hammer (i.e. inode_dio_wait()).
725 * 787 *
726 * Returns with locks held indicated by @iolock and errors indicated by 788 * Returns with locks held indicated by @iolock and errors indicated by
727 * negative return values. 789 * negative return values.
@@ -733,6 +795,7 @@ xfs_file_dio_aio_write(
733 unsigned long nr_segs, 795 unsigned long nr_segs,
734 loff_t pos, 796 loff_t pos,
735 size_t ocount, 797 size_t ocount,
798 xfs_fsize_t *new_size,
736 int *iolock) 799 int *iolock)
737{ 800{
738 struct file *file = iocb->ki_filp; 801 struct file *file = iocb->ki_filp;
@@ -753,18 +816,35 @@ xfs_file_dio_aio_write(
753 if ((pos & mp->m_blockmask) || ((pos + count) & mp->m_blockmask)) 816 if ((pos & mp->m_blockmask) || ((pos + count) & mp->m_blockmask))
754 unaligned_io = 1; 817 unaligned_io = 1;
755 818
756 if (unaligned_io || mapping->nrpages || pos > ip->i_size) 819 /*
820 * We don't need to take an exclusive lock unless there page cache needs
821 * to be invalidated or unaligned IO is being executed. We don't need to
822 * consider the EOF extension case here because
823 * xfs_file_aio_write_checks() will relock the inode as necessary for
824 * EOF zeroing cases and fill out the new inode size as appropriate.
825 */
826 if (unaligned_io || mapping->nrpages)
757 *iolock = XFS_IOLOCK_EXCL; 827 *iolock = XFS_IOLOCK_EXCL;
758 else 828 else
759 *iolock = XFS_IOLOCK_SHARED; 829 *iolock = XFS_IOLOCK_SHARED;
760 xfs_rw_ilock(ip, XFS_ILOCK_EXCL | *iolock); 830 xfs_rw_ilock(ip, *iolock);
761 831
762 ret = xfs_file_aio_write_checks(file, &pos, &count, iolock); 832 /*
833 * Recheck if there are cached pages that need invalidate after we got
834 * the iolock to protect against other threads adding new pages while
835 * we were waiting for the iolock.
836 */
837 if (mapping->nrpages && *iolock == XFS_IOLOCK_SHARED) {
838 xfs_rw_iunlock(ip, *iolock);
839 *iolock = XFS_IOLOCK_EXCL;
840 xfs_rw_ilock(ip, *iolock);
841 }
842
843 ret = xfs_file_aio_write_checks(file, &pos, &count, new_size, iolock);
763 if (ret) 844 if (ret)
764 return ret; 845 return ret;
765 846
766 if (mapping->nrpages) { 847 if (mapping->nrpages) {
767 WARN_ON(*iolock != XFS_IOLOCK_EXCL);
768 ret = -xfs_flushinval_pages(ip, (pos & PAGE_CACHE_MASK), -1, 848 ret = -xfs_flushinval_pages(ip, (pos & PAGE_CACHE_MASK), -1,
769 FI_REMAPF_LOCKED); 849 FI_REMAPF_LOCKED);
770 if (ret) 850 if (ret)
@@ -776,7 +856,7 @@ xfs_file_dio_aio_write(
776 * otherwise demote the lock if we had to flush cached pages 856 * otherwise demote the lock if we had to flush cached pages
777 */ 857 */
778 if (unaligned_io) 858 if (unaligned_io)
779 xfs_ioend_wait(ip); 859 inode_dio_wait(inode);
780 else if (*iolock == XFS_IOLOCK_EXCL) { 860 else if (*iolock == XFS_IOLOCK_EXCL) {
781 xfs_rw_ilock_demote(ip, XFS_IOLOCK_EXCL); 861 xfs_rw_ilock_demote(ip, XFS_IOLOCK_EXCL);
782 *iolock = XFS_IOLOCK_SHARED; 862 *iolock = XFS_IOLOCK_SHARED;
@@ -798,6 +878,7 @@ xfs_file_buffered_aio_write(
798 unsigned long nr_segs, 878 unsigned long nr_segs,
799 loff_t pos, 879 loff_t pos,
800 size_t ocount, 880 size_t ocount,
881 xfs_fsize_t *new_size,
801 int *iolock) 882 int *iolock)
802{ 883{
803 struct file *file = iocb->ki_filp; 884 struct file *file = iocb->ki_filp;
@@ -809,9 +890,9 @@ xfs_file_buffered_aio_write(
809 size_t count = ocount; 890 size_t count = ocount;
810 891
811 *iolock = XFS_IOLOCK_EXCL; 892 *iolock = XFS_IOLOCK_EXCL;
812 xfs_rw_ilock(ip, XFS_ILOCK_EXCL | *iolock); 893 xfs_rw_ilock(ip, *iolock);
813 894
814 ret = xfs_file_aio_write_checks(file, &pos, &count, iolock); 895 ret = xfs_file_aio_write_checks(file, &pos, &count, new_size, iolock);
815 if (ret) 896 if (ret)
816 return ret; 897 return ret;
817 898
@@ -851,6 +932,7 @@ xfs_file_aio_write(
851 ssize_t ret; 932 ssize_t ret;
852 int iolock; 933 int iolock;
853 size_t ocount = 0; 934 size_t ocount = 0;
935 xfs_fsize_t new_size = 0;
854 936
855 XFS_STATS_INC(xs_write_calls); 937 XFS_STATS_INC(xs_write_calls);
856 938
@@ -870,10 +952,10 @@ xfs_file_aio_write(
870 952
871 if (unlikely(file->f_flags & O_DIRECT)) 953 if (unlikely(file->f_flags & O_DIRECT))
872 ret = xfs_file_dio_aio_write(iocb, iovp, nr_segs, pos, 954 ret = xfs_file_dio_aio_write(iocb, iovp, nr_segs, pos,
873 ocount, &iolock); 955 ocount, &new_size, &iolock);
874 else 956 else
875 ret = xfs_file_buffered_aio_write(iocb, iovp, nr_segs, pos, 957 ret = xfs_file_buffered_aio_write(iocb, iovp, nr_segs, pos,
876 ocount, &iolock); 958 ocount, &new_size, &iolock);
877 959
878 xfs_aio_write_isize_update(inode, &iocb->ki_pos, ret); 960 xfs_aio_write_isize_update(inode, &iocb->ki_pos, ret);
879 961
@@ -894,7 +976,7 @@ xfs_file_aio_write(
894 } 976 }
895 977
896out_unlock: 978out_unlock:
897 xfs_aio_write_newsize_update(ip); 979 xfs_aio_write_newsize_update(ip, new_size);
898 xfs_rw_iunlock(ip, iolock); 980 xfs_rw_iunlock(ip, iolock);
899 return ret; 981 return ret;
900} 982}
@@ -1087,7 +1169,7 @@ const struct file_operations xfs_dir_file_operations = {
1087#ifdef CONFIG_COMPAT 1169#ifdef CONFIG_COMPAT
1088 .compat_ioctl = xfs_file_compat_ioctl, 1170 .compat_ioctl = xfs_file_compat_ioctl,
1089#endif 1171#endif
1090 .fsync = xfs_file_fsync, 1172 .fsync = xfs_dir_fsync,
1091}; 1173};
1092 1174
1093static const struct vm_operations_struct xfs_file_vm_ops = { 1175static const struct vm_operations_struct xfs_file_vm_ops = {
diff --git a/fs/xfs/xfs_filestream.c b/fs/xfs/xfs_filestream.c
index 3ff3d9e23ded..5170306a1009 100644
--- a/fs/xfs/xfs_filestream.c
+++ b/fs/xfs/xfs_filestream.c
@@ -682,7 +682,7 @@ xfs_filestream_new_ag(
682 ip = ap->ip; 682 ip = ap->ip;
683 mp = ip->i_mount; 683 mp = ip->i_mount;
684 cache = mp->m_filestream; 684 cache = mp->m_filestream;
685 minlen = ap->alen; 685 minlen = ap->length;
686 *agp = NULLAGNUMBER; 686 *agp = NULLAGNUMBER;
687 687
688 /* 688 /*
@@ -761,7 +761,7 @@ xfs_filestream_new_ag(
761 */ 761 */
762 ag = (ag == NULLAGNUMBER) ? 0 : (ag + 1) % mp->m_sb.sb_agcount; 762 ag = (ag == NULLAGNUMBER) ? 0 : (ag + 1) % mp->m_sb.sb_agcount;
763 flags = (ap->userdata ? XFS_PICK_USERDATA : 0) | 763 flags = (ap->userdata ? XFS_PICK_USERDATA : 0) |
764 (ap->low ? XFS_PICK_LOWSPACE : 0); 764 (ap->flist->xbf_low ? XFS_PICK_LOWSPACE : 0);
765 765
766 err = _xfs_filestream_pick_ag(mp, ag, agp, flags, minlen); 766 err = _xfs_filestream_pick_ag(mp, ag, agp, flags, minlen);
767 if (err || *agp == NULLAGNUMBER) 767 if (err || *agp == NULLAGNUMBER)
diff --git a/fs/xfs/xfs_fsops.c b/fs/xfs/xfs_fsops.c
index 9153d2c77caf..1c6fdeb702ff 100644
--- a/fs/xfs/xfs_fsops.c
+++ b/fs/xfs/xfs_fsops.c
@@ -194,6 +194,10 @@ xfs_growfs_data_private(
194 bp = xfs_buf_get(mp->m_ddev_targp, 194 bp = xfs_buf_get(mp->m_ddev_targp,
195 XFS_AG_DADDR(mp, agno, XFS_AGF_DADDR(mp)), 195 XFS_AG_DADDR(mp, agno, XFS_AGF_DADDR(mp)),
196 XFS_FSS_TO_BB(mp, 1), XBF_LOCK | XBF_MAPPED); 196 XFS_FSS_TO_BB(mp, 1), XBF_LOCK | XBF_MAPPED);
197 if (!bp) {
198 error = ENOMEM;
199 goto error0;
200 }
197 agf = XFS_BUF_TO_AGF(bp); 201 agf = XFS_BUF_TO_AGF(bp);
198 memset(agf, 0, mp->m_sb.sb_sectsize); 202 memset(agf, 0, mp->m_sb.sb_sectsize);
199 agf->agf_magicnum = cpu_to_be32(XFS_AGF_MAGIC); 203 agf->agf_magicnum = cpu_to_be32(XFS_AGF_MAGIC);
@@ -216,16 +220,21 @@ xfs_growfs_data_private(
216 tmpsize = agsize - XFS_PREALLOC_BLOCKS(mp); 220 tmpsize = agsize - XFS_PREALLOC_BLOCKS(mp);
217 agf->agf_freeblks = cpu_to_be32(tmpsize); 221 agf->agf_freeblks = cpu_to_be32(tmpsize);
218 agf->agf_longest = cpu_to_be32(tmpsize); 222 agf->agf_longest = cpu_to_be32(tmpsize);
219 error = xfs_bwrite(mp, bp); 223 error = xfs_bwrite(bp);
220 if (error) { 224 xfs_buf_relse(bp);
225 if (error)
221 goto error0; 226 goto error0;
222 } 227
223 /* 228 /*
224 * AG inode header block 229 * AG inode header block
225 */ 230 */
226 bp = xfs_buf_get(mp->m_ddev_targp, 231 bp = xfs_buf_get(mp->m_ddev_targp,
227 XFS_AG_DADDR(mp, agno, XFS_AGI_DADDR(mp)), 232 XFS_AG_DADDR(mp, agno, XFS_AGI_DADDR(mp)),
228 XFS_FSS_TO_BB(mp, 1), XBF_LOCK | XBF_MAPPED); 233 XFS_FSS_TO_BB(mp, 1), XBF_LOCK | XBF_MAPPED);
234 if (!bp) {
235 error = ENOMEM;
236 goto error0;
237 }
229 agi = XFS_BUF_TO_AGI(bp); 238 agi = XFS_BUF_TO_AGI(bp);
230 memset(agi, 0, mp->m_sb.sb_sectsize); 239 memset(agi, 0, mp->m_sb.sb_sectsize);
231 agi->agi_magicnum = cpu_to_be32(XFS_AGI_MAGIC); 240 agi->agi_magicnum = cpu_to_be32(XFS_AGI_MAGIC);
@@ -240,10 +249,11 @@ xfs_growfs_data_private(
240 agi->agi_dirino = cpu_to_be32(NULLAGINO); 249 agi->agi_dirino = cpu_to_be32(NULLAGINO);
241 for (bucket = 0; bucket < XFS_AGI_UNLINKED_BUCKETS; bucket++) 250 for (bucket = 0; bucket < XFS_AGI_UNLINKED_BUCKETS; bucket++)
242 agi->agi_unlinked[bucket] = cpu_to_be32(NULLAGINO); 251 agi->agi_unlinked[bucket] = cpu_to_be32(NULLAGINO);
243 error = xfs_bwrite(mp, bp); 252 error = xfs_bwrite(bp);
244 if (error) { 253 xfs_buf_relse(bp);
254 if (error)
245 goto error0; 255 goto error0;
246 } 256
247 /* 257 /*
248 * BNO btree root block 258 * BNO btree root block
249 */ 259 */
@@ -251,6 +261,10 @@ xfs_growfs_data_private(
251 XFS_AGB_TO_DADDR(mp, agno, XFS_BNO_BLOCK(mp)), 261 XFS_AGB_TO_DADDR(mp, agno, XFS_BNO_BLOCK(mp)),
252 BTOBB(mp->m_sb.sb_blocksize), 262 BTOBB(mp->m_sb.sb_blocksize),
253 XBF_LOCK | XBF_MAPPED); 263 XBF_LOCK | XBF_MAPPED);
264 if (!bp) {
265 error = ENOMEM;
266 goto error0;
267 }
254 block = XFS_BUF_TO_BLOCK(bp); 268 block = XFS_BUF_TO_BLOCK(bp);
255 memset(block, 0, mp->m_sb.sb_blocksize); 269 memset(block, 0, mp->m_sb.sb_blocksize);
256 block->bb_magic = cpu_to_be32(XFS_ABTB_MAGIC); 270 block->bb_magic = cpu_to_be32(XFS_ABTB_MAGIC);
@@ -262,10 +276,11 @@ xfs_growfs_data_private(
262 arec->ar_startblock = cpu_to_be32(XFS_PREALLOC_BLOCKS(mp)); 276 arec->ar_startblock = cpu_to_be32(XFS_PREALLOC_BLOCKS(mp));
263 arec->ar_blockcount = cpu_to_be32( 277 arec->ar_blockcount = cpu_to_be32(
264 agsize - be32_to_cpu(arec->ar_startblock)); 278 agsize - be32_to_cpu(arec->ar_startblock));
265 error = xfs_bwrite(mp, bp); 279 error = xfs_bwrite(bp);
266 if (error) { 280 xfs_buf_relse(bp);
281 if (error)
267 goto error0; 282 goto error0;
268 } 283
269 /* 284 /*
270 * CNT btree root block 285 * CNT btree root block
271 */ 286 */
@@ -273,6 +288,10 @@ xfs_growfs_data_private(
273 XFS_AGB_TO_DADDR(mp, agno, XFS_CNT_BLOCK(mp)), 288 XFS_AGB_TO_DADDR(mp, agno, XFS_CNT_BLOCK(mp)),
274 BTOBB(mp->m_sb.sb_blocksize), 289 BTOBB(mp->m_sb.sb_blocksize),
275 XBF_LOCK | XBF_MAPPED); 290 XBF_LOCK | XBF_MAPPED);
291 if (!bp) {
292 error = ENOMEM;
293 goto error0;
294 }
276 block = XFS_BUF_TO_BLOCK(bp); 295 block = XFS_BUF_TO_BLOCK(bp);
277 memset(block, 0, mp->m_sb.sb_blocksize); 296 memset(block, 0, mp->m_sb.sb_blocksize);
278 block->bb_magic = cpu_to_be32(XFS_ABTC_MAGIC); 297 block->bb_magic = cpu_to_be32(XFS_ABTC_MAGIC);
@@ -285,10 +304,11 @@ xfs_growfs_data_private(
285 arec->ar_blockcount = cpu_to_be32( 304 arec->ar_blockcount = cpu_to_be32(
286 agsize - be32_to_cpu(arec->ar_startblock)); 305 agsize - be32_to_cpu(arec->ar_startblock));
287 nfree += be32_to_cpu(arec->ar_blockcount); 306 nfree += be32_to_cpu(arec->ar_blockcount);
288 error = xfs_bwrite(mp, bp); 307 error = xfs_bwrite(bp);
289 if (error) { 308 xfs_buf_relse(bp);
309 if (error)
290 goto error0; 310 goto error0;
291 } 311
292 /* 312 /*
293 * INO btree root block 313 * INO btree root block
294 */ 314 */
@@ -296,6 +316,10 @@ xfs_growfs_data_private(
296 XFS_AGB_TO_DADDR(mp, agno, XFS_IBT_BLOCK(mp)), 316 XFS_AGB_TO_DADDR(mp, agno, XFS_IBT_BLOCK(mp)),
297 BTOBB(mp->m_sb.sb_blocksize), 317 BTOBB(mp->m_sb.sb_blocksize),
298 XBF_LOCK | XBF_MAPPED); 318 XBF_LOCK | XBF_MAPPED);
319 if (!bp) {
320 error = ENOMEM;
321 goto error0;
322 }
299 block = XFS_BUF_TO_BLOCK(bp); 323 block = XFS_BUF_TO_BLOCK(bp);
300 memset(block, 0, mp->m_sb.sb_blocksize); 324 memset(block, 0, mp->m_sb.sb_blocksize);
301 block->bb_magic = cpu_to_be32(XFS_IBT_MAGIC); 325 block->bb_magic = cpu_to_be32(XFS_IBT_MAGIC);
@@ -303,10 +327,10 @@ xfs_growfs_data_private(
303 block->bb_numrecs = 0; 327 block->bb_numrecs = 0;
304 block->bb_u.s.bb_leftsib = cpu_to_be32(NULLAGBLOCK); 328 block->bb_u.s.bb_leftsib = cpu_to_be32(NULLAGBLOCK);
305 block->bb_u.s.bb_rightsib = cpu_to_be32(NULLAGBLOCK); 329 block->bb_u.s.bb_rightsib = cpu_to_be32(NULLAGBLOCK);
306 error = xfs_bwrite(mp, bp); 330 error = xfs_bwrite(bp);
307 if (error) { 331 xfs_buf_relse(bp);
332 if (error)
308 goto error0; 333 goto error0;
309 }
310 } 334 }
311 xfs_trans_agblocks_delta(tp, nfree); 335 xfs_trans_agblocks_delta(tp, nfree);
312 /* 336 /*
@@ -396,9 +420,9 @@ xfs_growfs_data_private(
396 * just issue a warning and continue. The real work is 420 * just issue a warning and continue. The real work is
397 * already done and committed. 421 * already done and committed.
398 */ 422 */
399 if (!(error = xfs_bwrite(mp, bp))) { 423 error = xfs_bwrite(bp);
400 continue; 424 xfs_buf_relse(bp);
401 } else { 425 if (error) {
402 xfs_warn(mp, 426 xfs_warn(mp,
403 "write error %d updating secondary superblock for ag %d", 427 "write error %d updating secondary superblock for ag %d",
404 error, agno); 428 error, agno);
diff --git a/fs/xfs/xfs_ialloc.c b/fs/xfs/xfs_ialloc.c
index 9f24ec28283b..169380e66057 100644
--- a/fs/xfs/xfs_ialloc.c
+++ b/fs/xfs/xfs_ialloc.c
@@ -150,7 +150,7 @@ xfs_check_agi_freecount(
150/* 150/*
151 * Initialise a new set of inodes. 151 * Initialise a new set of inodes.
152 */ 152 */
153STATIC void 153STATIC int
154xfs_ialloc_inode_init( 154xfs_ialloc_inode_init(
155 struct xfs_mount *mp, 155 struct xfs_mount *mp,
156 struct xfs_trans *tp, 156 struct xfs_trans *tp,
@@ -202,8 +202,8 @@ xfs_ialloc_inode_init(
202 fbuf = xfs_trans_get_buf(tp, mp->m_ddev_targp, d, 202 fbuf = xfs_trans_get_buf(tp, mp->m_ddev_targp, d,
203 mp->m_bsize * blks_per_cluster, 203 mp->m_bsize * blks_per_cluster,
204 XBF_LOCK); 204 XBF_LOCK);
205 ASSERT(!xfs_buf_geterror(fbuf)); 205 if (!fbuf)
206 206 return ENOMEM;
207 /* 207 /*
208 * Initialize all inodes in this buffer and then log them. 208 * Initialize all inodes in this buffer and then log them.
209 * 209 *
@@ -225,6 +225,7 @@ xfs_ialloc_inode_init(
225 } 225 }
226 xfs_trans_inode_alloc_buf(tp, fbuf); 226 xfs_trans_inode_alloc_buf(tp, fbuf);
227 } 227 }
228 return 0;
228} 229}
229 230
230/* 231/*
@@ -369,9 +370,11 @@ xfs_ialloc_ag_alloc(
369 * rather than a linear progression to prevent the next generation 370 * rather than a linear progression to prevent the next generation
370 * number from being easily guessable. 371 * number from being easily guessable.
371 */ 372 */
372 xfs_ialloc_inode_init(args.mp, tp, agno, args.agbno, args.len, 373 error = xfs_ialloc_inode_init(args.mp, tp, agno, args.agbno,
373 random32()); 374 args.len, random32());
374 375
376 if (error)
377 return error;
375 /* 378 /*
376 * Convert the results. 379 * Convert the results.
377 */ 380 */
@@ -1502,7 +1505,7 @@ xfs_read_agi(
1502 return XFS_ERROR(EFSCORRUPTED); 1505 return XFS_ERROR(EFSCORRUPTED);
1503 } 1506 }
1504 1507
1505 XFS_BUF_SET_VTYPE_REF(*bpp, B_FS_AGI, XFS_AGI_REF); 1508 xfs_buf_set_ref(*bpp, XFS_AGI_REF);
1506 1509
1507 xfs_check_agi_unlinked(agi); 1510 xfs_check_agi_unlinked(agi);
1508 return 0; 1511 return 0;
diff --git a/fs/xfs/xfs_iget.c b/fs/xfs/xfs_iget.c
index 7759812c1bbe..0fa98b1c70ea 100644
--- a/fs/xfs/xfs_iget.c
+++ b/fs/xfs/xfs_iget.c
@@ -75,7 +75,6 @@ xfs_inode_alloc(
75 return NULL; 75 return NULL;
76 } 76 }
77 77
78 ASSERT(atomic_read(&ip->i_iocount) == 0);
79 ASSERT(atomic_read(&ip->i_pincount) == 0); 78 ASSERT(atomic_read(&ip->i_pincount) == 0);
80 ASSERT(!spin_is_locked(&ip->i_flags_lock)); 79 ASSERT(!spin_is_locked(&ip->i_flags_lock));
81 ASSERT(completion_done(&ip->i_flush)); 80 ASSERT(completion_done(&ip->i_flush));
@@ -150,7 +149,6 @@ xfs_inode_free(
150 } 149 }
151 150
152 /* asserts to verify all state is correct here */ 151 /* asserts to verify all state is correct here */
153 ASSERT(atomic_read(&ip->i_iocount) == 0);
154 ASSERT(atomic_read(&ip->i_pincount) == 0); 152 ASSERT(atomic_read(&ip->i_pincount) == 0);
155 ASSERT(!spin_is_locked(&ip->i_flags_lock)); 153 ASSERT(!spin_is_locked(&ip->i_flags_lock));
156 ASSERT(completion_done(&ip->i_flush)); 154 ASSERT(completion_done(&ip->i_flush));
diff --git a/fs/xfs/xfs_inode.c b/fs/xfs/xfs_inode.c
index 0239a7c7c886..c0237c602f11 100644
--- a/fs/xfs/xfs_inode.c
+++ b/fs/xfs/xfs_inode.c
@@ -190,12 +190,6 @@ xfs_imap_to_bp(
190 } 190 }
191 191
192 xfs_inobp_check(mp, bp); 192 xfs_inobp_check(mp, bp);
193
194 /*
195 * Mark the buffer as an inode buffer now that it looks good
196 */
197 XFS_BUF_SET_VTYPE(bp, B_FS_INO);
198
199 *bpp = bp; 193 *bpp = bp;
200 return 0; 194 return 0;
201} 195}
@@ -1152,7 +1146,7 @@ xfs_ialloc(
1152 /* 1146 /*
1153 * Log the new values stuffed into the inode. 1147 * Log the new values stuffed into the inode.
1154 */ 1148 */
1155 xfs_trans_ijoin_ref(tp, ip, XFS_ILOCK_EXCL); 1149 xfs_trans_ijoin(tp, ip, XFS_ILOCK_EXCL);
1156 xfs_trans_log_inode(tp, ip, flags); 1150 xfs_trans_log_inode(tp, ip, flags);
1157 1151
1158 /* now that we have an i_mode we can setup inode ops and unlock */ 1152 /* now that we have an i_mode we can setup inode ops and unlock */
@@ -1187,6 +1181,7 @@ xfs_isize_check(
1187 xfs_fileoff_t map_first; 1181 xfs_fileoff_t map_first;
1188 int nimaps; 1182 int nimaps;
1189 xfs_bmbt_irec_t imaps[2]; 1183 xfs_bmbt_irec_t imaps[2];
1184 int error;
1190 1185
1191 if (!S_ISREG(ip->i_d.di_mode)) 1186 if (!S_ISREG(ip->i_d.di_mode))
1192 return; 1187 return;
@@ -1203,13 +1198,12 @@ xfs_isize_check(
1203 * The filesystem could be shutting down, so bmapi may return 1198 * The filesystem could be shutting down, so bmapi may return
1204 * an error. 1199 * an error.
1205 */ 1200 */
1206 if (xfs_bmapi(NULL, ip, map_first, 1201 error = xfs_bmapi_read(ip, map_first,
1207 (XFS_B_TO_FSB(mp, 1202 (XFS_B_TO_FSB(mp,
1208 (xfs_ufsize_t)XFS_MAXIOFFSET(mp)) - 1203 (xfs_ufsize_t)XFS_MAXIOFFSET(mp)) - map_first),
1209 map_first), 1204 imaps, &nimaps, XFS_BMAPI_ENTIRE);
1210 XFS_BMAPI_ENTIRE, NULL, 0, imaps, &nimaps, 1205 if (error)
1211 NULL)) 1206 return;
1212 return;
1213 ASSERT(nimaps == 1); 1207 ASSERT(nimaps == 1);
1214 ASSERT(imaps[0].br_startblock == HOLESTARTBLOCK); 1208 ASSERT(imaps[0].br_startblock == HOLESTARTBLOCK);
1215} 1209}
@@ -1297,7 +1291,7 @@ xfs_itruncate_extents(
1297 */ 1291 */
1298 error = xfs_bmap_finish(&tp, &free_list, &committed); 1292 error = xfs_bmap_finish(&tp, &free_list, &committed);
1299 if (committed) 1293 if (committed)
1300 xfs_trans_ijoin(tp, ip); 1294 xfs_trans_ijoin(tp, ip, 0);
1301 if (error) 1295 if (error)
1302 goto out_bmap_cancel; 1296 goto out_bmap_cancel;
1303 1297
@@ -1313,7 +1307,7 @@ xfs_itruncate_extents(
1313 error = xfs_trans_commit(tp, 0); 1307 error = xfs_trans_commit(tp, 0);
1314 tp = ntp; 1308 tp = ntp;
1315 1309
1316 xfs_trans_ijoin(tp, ip); 1310 xfs_trans_ijoin(tp, ip, 0);
1317 1311
1318 if (error) 1312 if (error)
1319 goto out; 1313 goto out;
@@ -1644,7 +1638,7 @@ xfs_iunlink_remove(
1644 * inodes that are in memory - they all must be marked stale and attached to 1638 * inodes that are in memory - they all must be marked stale and attached to
1645 * the cluster buffer. 1639 * the cluster buffer.
1646 */ 1640 */
1647STATIC void 1641STATIC int
1648xfs_ifree_cluster( 1642xfs_ifree_cluster(
1649 xfs_inode_t *free_ip, 1643 xfs_inode_t *free_ip,
1650 xfs_trans_t *tp, 1644 xfs_trans_t *tp,
@@ -1690,6 +1684,8 @@ xfs_ifree_cluster(
1690 mp->m_bsize * blks_per_cluster, 1684 mp->m_bsize * blks_per_cluster,
1691 XBF_LOCK); 1685 XBF_LOCK);
1692 1686
1687 if (!bp)
1688 return ENOMEM;
1693 /* 1689 /*
1694 * Walk the inodes already attached to the buffer and mark them 1690 * Walk the inodes already attached to the buffer and mark them
1695 * stale. These will all have the flush locks held, so an 1691 * stale. These will all have the flush locks held, so an
@@ -1799,6 +1795,7 @@ retry:
1799 } 1795 }
1800 1796
1801 xfs_perag_put(pag); 1797 xfs_perag_put(pag);
1798 return 0;
1802} 1799}
1803 1800
1804/* 1801/*
@@ -1878,10 +1875,10 @@ xfs_ifree(
1878 dip->di_mode = 0; 1875 dip->di_mode = 0;
1879 1876
1880 if (delete) { 1877 if (delete) {
1881 xfs_ifree_cluster(ip, tp, first_ino); 1878 error = xfs_ifree_cluster(ip, tp, first_ino);
1882 } 1879 }
1883 1880
1884 return 0; 1881 return error;
1885} 1882}
1886 1883
1887/* 1884/*
@@ -2472,11 +2469,11 @@ cluster_corrupt_out:
2472 */ 2469 */
2473 if (bp->b_iodone) { 2470 if (bp->b_iodone) {
2474 XFS_BUF_UNDONE(bp); 2471 XFS_BUF_UNDONE(bp);
2475 XFS_BUF_STALE(bp); 2472 xfs_buf_stale(bp);
2476 xfs_buf_ioerror(bp, EIO); 2473 xfs_buf_ioerror(bp, EIO);
2477 xfs_buf_ioend(bp, 0); 2474 xfs_buf_ioend(bp, 0);
2478 } else { 2475 } else {
2479 XFS_BUF_STALE(bp); 2476 xfs_buf_stale(bp);
2480 xfs_buf_relse(bp); 2477 xfs_buf_relse(bp);
2481 } 2478 }
2482 } 2479 }
@@ -2597,9 +2594,11 @@ xfs_iflush(
2597 goto cluster_corrupt_out; 2594 goto cluster_corrupt_out;
2598 2595
2599 if (flags & SYNC_WAIT) 2596 if (flags & SYNC_WAIT)
2600 error = xfs_bwrite(mp, bp); 2597 error = xfs_bwrite(bp);
2601 else 2598 else
2602 xfs_bdwrite(mp, bp); 2599 xfs_buf_delwri_queue(bp);
2600
2601 xfs_buf_relse(bp);
2603 return error; 2602 return error;
2604 2603
2605corrupt_out: 2604corrupt_out:
diff --git a/fs/xfs/xfs_inode.h b/fs/xfs/xfs_inode.h
index 2380a4bcbece..760140d1dd66 100644
--- a/fs/xfs/xfs_inode.h
+++ b/fs/xfs/xfs_inode.h
@@ -257,7 +257,6 @@ typedef struct xfs_inode {
257 257
258 xfs_fsize_t i_size; /* in-memory size */ 258 xfs_fsize_t i_size; /* in-memory size */
259 xfs_fsize_t i_new_size; /* size when write completes */ 259 xfs_fsize_t i_new_size; /* size when write completes */
260 atomic_t i_iocount; /* outstanding I/O count */
261 260
262 /* VFS inode */ 261 /* VFS inode */
263 struct inode i_vnode; /* embedded VFS inode */ 262 struct inode i_vnode; /* embedded VFS inode */
diff --git a/fs/xfs/xfs_inode_item.c b/fs/xfs/xfs_inode_item.c
index 836ad80d4f2b..b7cf21ba240f 100644
--- a/fs/xfs/xfs_inode_item.c
+++ b/fs/xfs/xfs_inode_item.c
@@ -658,10 +658,8 @@ xfs_inode_item_unlock(
658 658
659 lock_flags = iip->ili_lock_flags; 659 lock_flags = iip->ili_lock_flags;
660 iip->ili_lock_flags = 0; 660 iip->ili_lock_flags = 0;
661 if (lock_flags) { 661 if (lock_flags)
662 xfs_iunlock(ip, lock_flags); 662 xfs_iunlock(ip, lock_flags);
663 IRELE(ip);
664 }
665} 663}
666 664
667/* 665/*
diff --git a/fs/xfs/xfs_ioctl.c b/fs/xfs/xfs_ioctl.c
index f7ce7debe14c..d99a90518909 100644
--- a/fs/xfs/xfs_ioctl.c
+++ b/fs/xfs/xfs_ioctl.c
@@ -1069,7 +1069,7 @@ xfs_ioctl_setattr(
1069 } 1069 }
1070 } 1070 }
1071 1071
1072 xfs_trans_ijoin(tp, ip); 1072 xfs_trans_ijoin(tp, ip, 0);
1073 1073
1074 /* 1074 /*
1075 * Change file ownership. Must be the owner or privileged. 1075 * Change file ownership. Must be the owner or privileged.
diff --git a/fs/xfs/xfs_iomap.c b/fs/xfs/xfs_iomap.c
index 091d82b94c4d..9afa282aa937 100644
--- a/fs/xfs/xfs_iomap.c
+++ b/fs/xfs/xfs_iomap.c
@@ -208,22 +208,20 @@ xfs_iomap_write_direct(
208 if (error) 208 if (error)
209 goto error1; 209 goto error1;
210 210
211 xfs_trans_ijoin(tp, ip); 211 xfs_trans_ijoin(tp, ip, 0);
212 212
213 bmapi_flag = XFS_BMAPI_WRITE; 213 bmapi_flag = 0;
214 if (offset < ip->i_size || extsz) 214 if (offset < ip->i_size || extsz)
215 bmapi_flag |= XFS_BMAPI_PREALLOC; 215 bmapi_flag |= XFS_BMAPI_PREALLOC;
216 216
217 /* 217 /*
218 * Issue the xfs_bmapi() call to allocate the blocks.
219 *
220 * From this point onwards we overwrite the imap pointer that the 218 * From this point onwards we overwrite the imap pointer that the
221 * caller gave to us. 219 * caller gave to us.
222 */ 220 */
223 xfs_bmap_init(&free_list, &firstfsb); 221 xfs_bmap_init(&free_list, &firstfsb);
224 nimaps = 1; 222 nimaps = 1;
225 error = xfs_bmapi(tp, ip, offset_fsb, count_fsb, bmapi_flag, 223 error = xfs_bmapi_write(tp, ip, offset_fsb, count_fsb, bmapi_flag,
226 &firstfsb, 0, imap, &nimaps, &free_list); 224 &firstfsb, 0, imap, &nimaps, &free_list);
227 if (error) 225 if (error)
228 goto error0; 226 goto error0;
229 227
@@ -300,8 +298,8 @@ xfs_iomap_eof_want_preallocate(
300 while (count_fsb > 0) { 298 while (count_fsb > 0) {
301 imaps = nimaps; 299 imaps = nimaps;
302 firstblock = NULLFSBLOCK; 300 firstblock = NULLFSBLOCK;
303 error = xfs_bmapi(NULL, ip, start_fsb, count_fsb, 0, 301 error = xfs_bmapi_read(ip, start_fsb, count_fsb, imap, &imaps,
304 &firstblock, 0, imap, &imaps, NULL); 302 0);
305 if (error) 303 if (error)
306 return error; 304 return error;
307 for (n = 0; n < imaps; n++) { 305 for (n = 0; n < imaps; n++) {
@@ -381,7 +379,6 @@ xfs_iomap_write_delay(
381 xfs_fileoff_t last_fsb; 379 xfs_fileoff_t last_fsb;
382 xfs_off_t aligned_offset; 380 xfs_off_t aligned_offset;
383 xfs_fileoff_t ioalign; 381 xfs_fileoff_t ioalign;
384 xfs_fsblock_t firstblock;
385 xfs_extlen_t extsz; 382 xfs_extlen_t extsz;
386 int nimaps; 383 int nimaps;
387 xfs_bmbt_irec_t imap[XFS_WRITE_IMAPS]; 384 xfs_bmbt_irec_t imap[XFS_WRITE_IMAPS];
@@ -425,12 +422,8 @@ retry:
425 } 422 }
426 423
427 nimaps = XFS_WRITE_IMAPS; 424 nimaps = XFS_WRITE_IMAPS;
428 firstblock = NULLFSBLOCK; 425 error = xfs_bmapi_delay(ip, offset_fsb, last_fsb - offset_fsb,
429 error = xfs_bmapi(NULL, ip, offset_fsb, 426 imap, &nimaps, XFS_BMAPI_ENTIRE);
430 (xfs_filblks_t)(last_fsb - offset_fsb),
431 XFS_BMAPI_DELAY | XFS_BMAPI_WRITE |
432 XFS_BMAPI_ENTIRE, &firstblock, 1, imap,
433 &nimaps, NULL);
434 switch (error) { 427 switch (error) {
435 case 0: 428 case 0:
436 case ENOSPC: 429 case ENOSPC:
@@ -535,7 +528,7 @@ xfs_iomap_write_allocate(
535 return XFS_ERROR(error); 528 return XFS_ERROR(error);
536 } 529 }
537 xfs_ilock(ip, XFS_ILOCK_EXCL); 530 xfs_ilock(ip, XFS_ILOCK_EXCL);
538 xfs_trans_ijoin(tp, ip); 531 xfs_trans_ijoin(tp, ip, 0);
539 532
540 xfs_bmap_init(&free_list, &first_block); 533 xfs_bmap_init(&free_list, &first_block);
541 534
@@ -587,14 +580,12 @@ xfs_iomap_write_allocate(
587 } 580 }
588 581
589 /* 582 /*
590 * Go get the actual blocks.
591 *
592 * From this point onwards we overwrite the imap 583 * From this point onwards we overwrite the imap
593 * pointer that the caller gave to us. 584 * pointer that the caller gave to us.
594 */ 585 */
595 error = xfs_bmapi(tp, ip, map_start_fsb, count_fsb, 586 error = xfs_bmapi_write(tp, ip, map_start_fsb,
596 XFS_BMAPI_WRITE, &first_block, 1, 587 count_fsb, 0, &first_block, 1,
597 imap, &nimaps, &free_list); 588 imap, &nimaps, &free_list);
598 if (error) 589 if (error)
599 goto trans_cancel; 590 goto trans_cancel;
600 591
@@ -701,15 +692,15 @@ xfs_iomap_write_unwritten(
701 } 692 }
702 693
703 xfs_ilock(ip, XFS_ILOCK_EXCL); 694 xfs_ilock(ip, XFS_ILOCK_EXCL);
704 xfs_trans_ijoin(tp, ip); 695 xfs_trans_ijoin(tp, ip, 0);
705 696
706 /* 697 /*
707 * Modify the unwritten extent state of the buffer. 698 * Modify the unwritten extent state of the buffer.
708 */ 699 */
709 xfs_bmap_init(&free_list, &firstfsb); 700 xfs_bmap_init(&free_list, &firstfsb);
710 nimaps = 1; 701 nimaps = 1;
711 error = xfs_bmapi(tp, ip, offset_fsb, count_fsb, 702 error = xfs_bmapi_write(tp, ip, offset_fsb, count_fsb,
712 XFS_BMAPI_WRITE|XFS_BMAPI_CONVERT, &firstfsb, 703 XFS_BMAPI_CONVERT, &firstfsb,
713 1, &imap, &nimaps, &free_list); 704 1, &imap, &nimaps, &free_list);
714 if (error) 705 if (error)
715 goto error_on_bmapi_transaction; 706 goto error_on_bmapi_transaction;
diff --git a/fs/xfs/xfs_iops.c b/fs/xfs/xfs_iops.c
index 28856accb4fa..9ba2a07b7343 100644
--- a/fs/xfs/xfs_iops.c
+++ b/fs/xfs/xfs_iops.c
@@ -466,7 +466,7 @@ xfs_vn_getattr(
466 trace_xfs_getattr(ip); 466 trace_xfs_getattr(ip);
467 467
468 if (XFS_FORCED_SHUTDOWN(mp)) 468 if (XFS_FORCED_SHUTDOWN(mp))
469 return XFS_ERROR(EIO); 469 return -XFS_ERROR(EIO);
470 470
471 stat->size = XFS_ISIZE(ip); 471 stat->size = XFS_ISIZE(ip);
472 stat->dev = inode->i_sb->s_dev; 472 stat->dev = inode->i_sb->s_dev;
@@ -612,7 +612,7 @@ xfs_setattr_nonsize(
612 } 612 }
613 } 613 }
614 614
615 xfs_trans_ijoin(tp, ip); 615 xfs_trans_ijoin(tp, ip, 0);
616 616
617 /* 617 /*
618 * Change file ownership. Must be the owner or privileged. 618 * Change file ownership. Must be the owner or privileged.
@@ -834,16 +834,16 @@ xfs_setattr_size(
834 * care about here. 834 * care about here.
835 */ 835 */
836 if (ip->i_size != ip->i_d.di_size && iattr->ia_size > ip->i_d.di_size) { 836 if (ip->i_size != ip->i_d.di_size && iattr->ia_size > ip->i_d.di_size) {
837 error = xfs_flush_pages(ip, ip->i_d.di_size, iattr->ia_size, 837 error = xfs_flush_pages(ip, ip->i_d.di_size, iattr->ia_size, 0,
838 XBF_ASYNC, FI_NONE); 838 FI_NONE);
839 if (error) 839 if (error)
840 goto out_unlock; 840 goto out_unlock;
841 } 841 }
842 842
843 /* 843 /*
844 * Wait for all I/O to complete. 844 * Wait for all direct I/O to complete.
845 */ 845 */
846 xfs_ioend_wait(ip); 846 inode_dio_wait(inode);
847 847
848 error = -block_truncate_page(inode->i_mapping, iattr->ia_size, 848 error = -block_truncate_page(inode->i_mapping, iattr->ia_size,
849 xfs_get_blocks); 849 xfs_get_blocks);
@@ -864,7 +864,7 @@ xfs_setattr_size(
864 864
865 xfs_ilock(ip, XFS_ILOCK_EXCL); 865 xfs_ilock(ip, XFS_ILOCK_EXCL);
866 866
867 xfs_trans_ijoin(tp, ip); 867 xfs_trans_ijoin(tp, ip, 0);
868 868
869 /* 869 /*
870 * Only change the c/mtime if we are changing the size or we are 870 * Only change the c/mtime if we are changing the size or we are
diff --git a/fs/xfs/xfs_log.c b/fs/xfs/xfs_log.c
index 3a8d4f66d702..2758a6277c52 100644
--- a/fs/xfs/xfs_log.c
+++ b/fs/xfs/xfs_log.c
@@ -880,8 +880,8 @@ xlog_iodone(xfs_buf_t *bp)
880 */ 880 */
881 if (XFS_TEST_ERROR((xfs_buf_geterror(bp)), l->l_mp, 881 if (XFS_TEST_ERROR((xfs_buf_geterror(bp)), l->l_mp,
882 XFS_ERRTAG_IODONE_IOERR, XFS_RANDOM_IODONE_IOERR)) { 882 XFS_ERRTAG_IODONE_IOERR, XFS_RANDOM_IODONE_IOERR)) {
883 xfs_ioerror_alert("xlog_iodone", l->l_mp, bp, XFS_BUF_ADDR(bp)); 883 xfs_buf_ioerror_alert(bp, __func__);
884 XFS_BUF_STALE(bp); 884 xfs_buf_stale(bp);
885 xfs_force_shutdown(l->l_mp, SHUTDOWN_LOG_IO_ERROR); 885 xfs_force_shutdown(l->l_mp, SHUTDOWN_LOG_IO_ERROR);
886 /* 886 /*
887 * This flag will be propagated to the trans-committed 887 * This flag will be propagated to the trans-committed
@@ -1047,7 +1047,7 @@ xlog_alloc_log(xfs_mount_t *mp,
1047 xlog_get_iclog_buffer_size(mp, log); 1047 xlog_get_iclog_buffer_size(mp, log);
1048 1048
1049 error = ENOMEM; 1049 error = ENOMEM;
1050 bp = xfs_buf_get_empty(log->l_iclog_size, mp->m_logdev_targp); 1050 bp = xfs_buf_alloc(mp->m_logdev_targp, 0, log->l_iclog_size, 0);
1051 if (!bp) 1051 if (!bp)
1052 goto out_free_log; 1052 goto out_free_log;
1053 bp->b_iodone = xlog_iodone; 1053 bp->b_iodone = xlog_iodone;
@@ -1247,7 +1247,7 @@ xlog_bdstrat(
1247 1247
1248 if (iclog->ic_state & XLOG_STATE_IOERROR) { 1248 if (iclog->ic_state & XLOG_STATE_IOERROR) {
1249 xfs_buf_ioerror(bp, EIO); 1249 xfs_buf_ioerror(bp, EIO);
1250 XFS_BUF_STALE(bp); 1250 xfs_buf_stale(bp);
1251 xfs_buf_ioend(bp, 0); 1251 xfs_buf_ioend(bp, 0);
1252 /* 1252 /*
1253 * It would seem logical to return EIO here, but we rely on 1253 * It would seem logical to return EIO here, but we rely on
@@ -1387,9 +1387,9 @@ xlog_sync(xlog_t *log,
1387 */ 1387 */
1388 XFS_BUF_WRITE(bp); 1388 XFS_BUF_WRITE(bp);
1389 1389
1390 if ((error = xlog_bdstrat(bp))) { 1390 error = xlog_bdstrat(bp);
1391 xfs_ioerror_alert("xlog_sync", log->l_mp, bp, 1391 if (error) {
1392 XFS_BUF_ADDR(bp)); 1392 xfs_buf_ioerror_alert(bp, "xlog_sync");
1393 return error; 1393 return error;
1394 } 1394 }
1395 if (split) { 1395 if (split) {
@@ -1423,9 +1423,9 @@ xlog_sync(xlog_t *log,
1423 /* account for internal log which doesn't start at block #0 */ 1423 /* account for internal log which doesn't start at block #0 */
1424 XFS_BUF_SET_ADDR(bp, XFS_BUF_ADDR(bp) + log->l_logBBstart); 1424 XFS_BUF_SET_ADDR(bp, XFS_BUF_ADDR(bp) + log->l_logBBstart);
1425 XFS_BUF_WRITE(bp); 1425 XFS_BUF_WRITE(bp);
1426 if ((error = xlog_bdstrat(bp))) { 1426 error = xlog_bdstrat(bp);
1427 xfs_ioerror_alert("xlog_sync (split)", log->l_mp, 1427 if (error) {
1428 bp, XFS_BUF_ADDR(bp)); 1428 xfs_buf_ioerror_alert(bp, "xlog_sync (split)");
1429 return error; 1429 return error;
1430 } 1430 }
1431 } 1431 }
diff --git a/fs/xfs/xfs_log_recover.c b/fs/xfs/xfs_log_recover.c
index a199dbcee7d8..541a508adea1 100644
--- a/fs/xfs/xfs_log_recover.c
+++ b/fs/xfs/xfs_log_recover.c
@@ -183,8 +183,7 @@ xlog_bread_noalign(
183 xfsbdstrat(log->l_mp, bp); 183 xfsbdstrat(log->l_mp, bp);
184 error = xfs_buf_iowait(bp); 184 error = xfs_buf_iowait(bp);
185 if (error) 185 if (error)
186 xfs_ioerror_alert("xlog_bread", log->l_mp, 186 xfs_buf_ioerror_alert(bp, __func__);
187 bp, XFS_BUF_ADDR(bp));
188 return error; 187 return error;
189} 188}
190 189
@@ -268,9 +267,10 @@ xlog_bwrite(
268 xfs_buf_lock(bp); 267 xfs_buf_lock(bp);
269 XFS_BUF_SET_COUNT(bp, BBTOB(nbblks)); 268 XFS_BUF_SET_COUNT(bp, BBTOB(nbblks));
270 269
271 if ((error = xfs_bwrite(log->l_mp, bp))) 270 error = xfs_bwrite(bp);
272 xfs_ioerror_alert("xlog_bwrite", log->l_mp, 271 if (error)
273 bp, XFS_BUF_ADDR(bp)); 272 xfs_buf_ioerror_alert(bp, __func__);
273 xfs_buf_relse(bp);
274 return error; 274 return error;
275} 275}
276 276
@@ -361,9 +361,7 @@ xlog_recover_iodone(
361 * We're not going to bother about retrying 361 * We're not going to bother about retrying
362 * this during recovery. One strike! 362 * this during recovery. One strike!
363 */ 363 */
364 xfs_ioerror_alert("xlog_recover_iodone", 364 xfs_buf_ioerror_alert(bp, __func__);
365 bp->b_target->bt_mount, bp,
366 XFS_BUF_ADDR(bp));
367 xfs_force_shutdown(bp->b_target->bt_mount, 365 xfs_force_shutdown(bp->b_target->bt_mount,
368 SHUTDOWN_META_IO_ERROR); 366 SHUTDOWN_META_IO_ERROR);
369 } 367 }
@@ -2135,8 +2133,7 @@ xlog_recover_buffer_pass2(
2135 return XFS_ERROR(ENOMEM); 2133 return XFS_ERROR(ENOMEM);
2136 error = bp->b_error; 2134 error = bp->b_error;
2137 if (error) { 2135 if (error) {
2138 xfs_ioerror_alert("xlog_recover_do..(read#1)", mp, 2136 xfs_buf_ioerror_alert(bp, "xlog_recover_do..(read#1)");
2139 bp, buf_f->blf_blkno);
2140 xfs_buf_relse(bp); 2137 xfs_buf_relse(bp);
2141 return error; 2138 return error;
2142 } 2139 }
@@ -2171,15 +2168,16 @@ xlog_recover_buffer_pass2(
2171 be16_to_cpu(*((__be16 *)xfs_buf_offset(bp, 0))) && 2168 be16_to_cpu(*((__be16 *)xfs_buf_offset(bp, 0))) &&
2172 (XFS_BUF_COUNT(bp) != MAX(log->l_mp->m_sb.sb_blocksize, 2169 (XFS_BUF_COUNT(bp) != MAX(log->l_mp->m_sb.sb_blocksize,
2173 (__uint32_t)XFS_INODE_CLUSTER_SIZE(log->l_mp)))) { 2170 (__uint32_t)XFS_INODE_CLUSTER_SIZE(log->l_mp)))) {
2174 XFS_BUF_STALE(bp); 2171 xfs_buf_stale(bp);
2175 error = xfs_bwrite(mp, bp); 2172 error = xfs_bwrite(bp);
2176 } else { 2173 } else {
2177 ASSERT(bp->b_target->bt_mount == mp); 2174 ASSERT(bp->b_target->bt_mount == mp);
2178 bp->b_iodone = xlog_recover_iodone; 2175 bp->b_iodone = xlog_recover_iodone;
2179 xfs_bdwrite(mp, bp); 2176 xfs_buf_delwri_queue(bp);
2180 } 2177 }
2181 2178
2182 return (error); 2179 xfs_buf_relse(bp);
2180 return error;
2183} 2181}
2184 2182
2185STATIC int 2183STATIC int
@@ -2230,8 +2228,7 @@ xlog_recover_inode_pass2(
2230 } 2228 }
2231 error = bp->b_error; 2229 error = bp->b_error;
2232 if (error) { 2230 if (error) {
2233 xfs_ioerror_alert("xlog_recover_do..(read#2)", mp, 2231 xfs_buf_ioerror_alert(bp, "xlog_recover_do..(read#2)");
2234 bp, in_f->ilf_blkno);
2235 xfs_buf_relse(bp); 2232 xfs_buf_relse(bp);
2236 goto error; 2233 goto error;
2237 } 2234 }
@@ -2439,7 +2436,8 @@ xlog_recover_inode_pass2(
2439write_inode_buffer: 2436write_inode_buffer:
2440 ASSERT(bp->b_target->bt_mount == mp); 2437 ASSERT(bp->b_target->bt_mount == mp);
2441 bp->b_iodone = xlog_recover_iodone; 2438 bp->b_iodone = xlog_recover_iodone;
2442 xfs_bdwrite(mp, bp); 2439 xfs_buf_delwri_queue(bp);
2440 xfs_buf_relse(bp);
2443error: 2441error:
2444 if (need_free) 2442 if (need_free)
2445 kmem_free(in_f); 2443 kmem_free(in_f);
@@ -2537,8 +2535,7 @@ xlog_recover_dquot_pass2(
2537 XFS_FSB_TO_BB(mp, dq_f->qlf_len), 2535 XFS_FSB_TO_BB(mp, dq_f->qlf_len),
2538 0, &bp); 2536 0, &bp);
2539 if (error) { 2537 if (error) {
2540 xfs_ioerror_alert("xlog_recover_do..(read#3)", mp, 2538 xfs_buf_ioerror_alert(bp, "xlog_recover_do..(read#3)");
2541 bp, dq_f->qlf_blkno);
2542 return error; 2539 return error;
2543 } 2540 }
2544 ASSERT(bp); 2541 ASSERT(bp);
@@ -2561,7 +2558,8 @@ xlog_recover_dquot_pass2(
2561 ASSERT(dq_f->qlf_size == 2); 2558 ASSERT(dq_f->qlf_size == 2);
2562 ASSERT(bp->b_target->bt_mount == mp); 2559 ASSERT(bp->b_target->bt_mount == mp);
2563 bp->b_iodone = xlog_recover_iodone; 2560 bp->b_iodone = xlog_recover_iodone;
2564 xfs_bdwrite(mp, bp); 2561 xfs_buf_delwri_queue(bp);
2562 xfs_buf_relse(bp);
2565 2563
2566 return (0); 2564 return (0);
2567} 2565}
@@ -3656,7 +3654,7 @@ xlog_do_recover(
3656 return error; 3654 return error;
3657 } 3655 }
3658 3656
3659 XFS_bflush(log->l_mp->m_ddev_targp); 3657 xfs_flush_buftarg(log->l_mp->m_ddev_targp, 1);
3660 3658
3661 /* 3659 /*
3662 * If IO errors happened during recovery, bail out. 3660 * If IO errors happened during recovery, bail out.
@@ -3689,8 +3687,7 @@ xlog_do_recover(
3689 xfsbdstrat(log->l_mp, bp); 3687 xfsbdstrat(log->l_mp, bp);
3690 error = xfs_buf_iowait(bp); 3688 error = xfs_buf_iowait(bp);
3691 if (error) { 3689 if (error) {
3692 xfs_ioerror_alert("xlog_do_recover", 3690 xfs_buf_ioerror_alert(bp, __func__);
3693 log->l_mp, bp, XFS_BUF_ADDR(bp));
3694 ASSERT(0); 3691 ASSERT(0);
3695 xfs_buf_relse(bp); 3692 xfs_buf_relse(bp);
3696 return error; 3693 return error;
diff --git a/fs/xfs/xfs_mount.c b/fs/xfs/xfs_mount.c
index 0081657ad985..d06afbc3540d 100644
--- a/fs/xfs/xfs_mount.c
+++ b/fs/xfs/xfs_mount.c
@@ -44,9 +44,6 @@
44#include "xfs_trace.h" 44#include "xfs_trace.h"
45 45
46 46
47STATIC void xfs_unmountfs_wait(xfs_mount_t *);
48
49
50#ifdef HAVE_PERCPU_SB 47#ifdef HAVE_PERCPU_SB
51STATIC void xfs_icsb_balance_counter(xfs_mount_t *, xfs_sb_field_t, 48STATIC void xfs_icsb_balance_counter(xfs_mount_t *, xfs_sb_field_t,
52 int); 49 int);
@@ -1484,7 +1481,7 @@ xfs_unmountfs(
1484 * state as much as possible. 1481 * state as much as possible.
1485 */ 1482 */
1486 xfs_reclaim_inodes(mp, 0); 1483 xfs_reclaim_inodes(mp, 0);
1487 XFS_bflush(mp->m_ddev_targp); 1484 xfs_flush_buftarg(mp->m_ddev_targp, 1);
1488 xfs_reclaim_inodes(mp, SYNC_WAIT); 1485 xfs_reclaim_inodes(mp, SYNC_WAIT);
1489 1486
1490 xfs_qm_unmount(mp); 1487 xfs_qm_unmount(mp);
@@ -1496,11 +1493,6 @@ xfs_unmountfs(
1496 */ 1493 */
1497 xfs_log_force(mp, XFS_LOG_SYNC); 1494 xfs_log_force(mp, XFS_LOG_SYNC);
1498 1495
1499 xfs_binval(mp->m_ddev_targp);
1500 if (mp->m_rtdev_targp) {
1501 xfs_binval(mp->m_rtdev_targp);
1502 }
1503
1504 /* 1496 /*
1505 * Unreserve any blocks we have so that when we unmount we don't account 1497 * Unreserve any blocks we have so that when we unmount we don't account
1506 * the reserved free space as used. This is really only necessary for 1498 * the reserved free space as used. This is really only necessary for
@@ -1526,7 +1518,16 @@ xfs_unmountfs(
1526 xfs_warn(mp, "Unable to update superblock counters. " 1518 xfs_warn(mp, "Unable to update superblock counters. "
1527 "Freespace may not be correct on next mount."); 1519 "Freespace may not be correct on next mount.");
1528 xfs_unmountfs_writesb(mp); 1520 xfs_unmountfs_writesb(mp);
1529 xfs_unmountfs_wait(mp); /* wait for async bufs */ 1521
1522 /*
1523 * Make sure all buffers have been flushed and completed before
1524 * unmounting the log.
1525 */
1526 error = xfs_flush_buftarg(mp->m_ddev_targp, 1);
1527 if (error)
1528 xfs_warn(mp, "%d busy buffers during unmount.", error);
1529 xfs_wait_buftarg(mp->m_ddev_targp);
1530
1530 xfs_log_unmount_write(mp); 1531 xfs_log_unmount_write(mp);
1531 xfs_log_unmount(mp); 1532 xfs_log_unmount(mp);
1532 xfs_uuid_unmount(mp); 1533 xfs_uuid_unmount(mp);
@@ -1537,16 +1538,6 @@ xfs_unmountfs(
1537 xfs_free_perag(mp); 1538 xfs_free_perag(mp);
1538} 1539}
1539 1540
1540STATIC void
1541xfs_unmountfs_wait(xfs_mount_t *mp)
1542{
1543 if (mp->m_logdev_targp != mp->m_ddev_targp)
1544 xfs_wait_buftarg(mp->m_logdev_targp);
1545 if (mp->m_rtdev_targp)
1546 xfs_wait_buftarg(mp->m_rtdev_targp);
1547 xfs_wait_buftarg(mp->m_ddev_targp);
1548}
1549
1550int 1541int
1551xfs_fs_writable(xfs_mount_t *mp) 1542xfs_fs_writable(xfs_mount_t *mp)
1552{ 1543{
@@ -1612,15 +1603,14 @@ xfs_unmountfs_writesb(xfs_mount_t *mp)
1612 1603
1613 XFS_BUF_UNDONE(sbp); 1604 XFS_BUF_UNDONE(sbp);
1614 XFS_BUF_UNREAD(sbp); 1605 XFS_BUF_UNREAD(sbp);
1615 XFS_BUF_UNDELAYWRITE(sbp); 1606 xfs_buf_delwri_dequeue(sbp);
1616 XFS_BUF_WRITE(sbp); 1607 XFS_BUF_WRITE(sbp);
1617 XFS_BUF_UNASYNC(sbp); 1608 XFS_BUF_UNASYNC(sbp);
1618 ASSERT(sbp->b_target == mp->m_ddev_targp); 1609 ASSERT(sbp->b_target == mp->m_ddev_targp);
1619 xfsbdstrat(mp, sbp); 1610 xfsbdstrat(mp, sbp);
1620 error = xfs_buf_iowait(sbp); 1611 error = xfs_buf_iowait(sbp);
1621 if (error) 1612 if (error)
1622 xfs_ioerror_alert("xfs_unmountfs_writesb", 1613 xfs_buf_ioerror_alert(sbp, __func__);
1623 mp, sbp, XFS_BUF_ADDR(sbp));
1624 xfs_buf_relse(sbp); 1614 xfs_buf_relse(sbp);
1625 } 1615 }
1626 return error; 1616 return error;
diff --git a/fs/xfs/xfs_qm.c b/fs/xfs/xfs_qm.c
index 9a0aa76facdf..5cff443f6cdb 100644
--- a/fs/xfs/xfs_qm.c
+++ b/fs/xfs/xfs_qm.c
@@ -1296,7 +1296,8 @@ xfs_qm_dqiter_bufs(
1296 break; 1296 break;
1297 1297
1298 xfs_qm_reset_dqcounts(mp, bp, firstid, type); 1298 xfs_qm_reset_dqcounts(mp, bp, firstid, type);
1299 xfs_bdwrite(mp, bp); 1299 xfs_buf_delwri_queue(bp);
1300 xfs_buf_relse(bp);
1300 /* 1301 /*
1301 * goto the next block. 1302 * goto the next block.
1302 */ 1303 */
@@ -1346,11 +1347,8 @@ xfs_qm_dqiterate(
1346 * the inode is never added to the transaction. 1347 * the inode is never added to the transaction.
1347 */ 1348 */
1348 xfs_ilock(qip, XFS_ILOCK_SHARED); 1349 xfs_ilock(qip, XFS_ILOCK_SHARED);
1349 error = xfs_bmapi(NULL, qip, lblkno, 1350 error = xfs_bmapi_read(qip, lblkno, maxlblkcnt - lblkno,
1350 maxlblkcnt - lblkno, 1351 map, &nmaps, 0);
1351 XFS_BMAPI_METADATA,
1352 NULL,
1353 0, map, &nmaps, NULL);
1354 xfs_iunlock(qip, XFS_ILOCK_SHARED); 1352 xfs_iunlock(qip, XFS_ILOCK_SHARED);
1355 if (error) 1353 if (error)
1356 break; 1354 break;
@@ -1683,7 +1681,7 @@ xfs_qm_quotacheck(
1683 * quotacheck'd stamp on the superblock. So, here we do a synchronous 1681 * quotacheck'd stamp on the superblock. So, here we do a synchronous
1684 * flush. 1682 * flush.
1685 */ 1683 */
1686 XFS_bflush(mp->m_ddev_targp); 1684 xfs_flush_buftarg(mp->m_ddev_targp, 1);
1687 1685
1688 /* 1686 /*
1689 * If one type of quotas is off, then it will lose its 1687 * If one type of quotas is off, then it will lose its
diff --git a/fs/xfs/xfs_qm_syscalls.c b/fs/xfs/xfs_qm_syscalls.c
index 609246f42e6c..5cc3dde1bc90 100644
--- a/fs/xfs/xfs_qm_syscalls.c
+++ b/fs/xfs/xfs_qm_syscalls.c
@@ -261,7 +261,7 @@ xfs_qm_scall_trunc_qfile(
261 } 261 }
262 262
263 xfs_ilock(ip, XFS_ILOCK_EXCL); 263 xfs_ilock(ip, XFS_ILOCK_EXCL);
264 xfs_trans_ijoin(tp, ip); 264 xfs_trans_ijoin(tp, ip, 0);
265 265
266 error = xfs_itruncate_data(&tp, ip, 0); 266 error = xfs_itruncate_data(&tp, ip, 0);
267 if (error) { 267 if (error) {
diff --git a/fs/xfs/xfs_rename.c b/fs/xfs/xfs_rename.c
index df78c297d1a1..866de277079a 100644
--- a/fs/xfs/xfs_rename.c
+++ b/fs/xfs/xfs_rename.c
@@ -170,12 +170,12 @@ xfs_rename(
170 * we can rely on either trans_commit or trans_cancel to unlock 170 * we can rely on either trans_commit or trans_cancel to unlock
171 * them. 171 * them.
172 */ 172 */
173 xfs_trans_ijoin_ref(tp, src_dp, XFS_ILOCK_EXCL); 173 xfs_trans_ijoin(tp, src_dp, XFS_ILOCK_EXCL);
174 if (new_parent) 174 if (new_parent)
175 xfs_trans_ijoin_ref(tp, target_dp, XFS_ILOCK_EXCL); 175 xfs_trans_ijoin(tp, target_dp, XFS_ILOCK_EXCL);
176 xfs_trans_ijoin_ref(tp, src_ip, XFS_ILOCK_EXCL); 176 xfs_trans_ijoin(tp, src_ip, XFS_ILOCK_EXCL);
177 if (target_ip) 177 if (target_ip)
178 xfs_trans_ijoin_ref(tp, target_ip, XFS_ILOCK_EXCL); 178 xfs_trans_ijoin(tp, target_ip, XFS_ILOCK_EXCL);
179 179
180 /* 180 /*
181 * If we are using project inheritance, we only allow renames 181 * If we are using project inheritance, we only allow renames
diff --git a/fs/xfs/xfs_rtalloc.c b/fs/xfs/xfs_rtalloc.c
index 35561a511b57..87323f1ded64 100644
--- a/fs/xfs/xfs_rtalloc.c
+++ b/fs/xfs/xfs_rtalloc.c
@@ -112,7 +112,7 @@ xfs_growfs_rt_alloc(
112 * Lock the inode. 112 * Lock the inode.
113 */ 113 */
114 xfs_ilock(ip, XFS_ILOCK_EXCL); 114 xfs_ilock(ip, XFS_ILOCK_EXCL);
115 xfs_trans_ijoin_ref(tp, ip, XFS_ILOCK_EXCL); 115 xfs_trans_ijoin(tp, ip, XFS_ILOCK_EXCL);
116 116
117 xfs_bmap_init(&flist, &firstblock); 117 xfs_bmap_init(&flist, &firstblock);
118 /* 118 /*
@@ -120,9 +120,9 @@ xfs_growfs_rt_alloc(
120 */ 120 */
121 nmap = 1; 121 nmap = 1;
122 cancelflags |= XFS_TRANS_ABORT; 122 cancelflags |= XFS_TRANS_ABORT;
123 error = xfs_bmapi(tp, ip, oblocks, nblocks - oblocks, 123 error = xfs_bmapi_write(tp, ip, oblocks, nblocks - oblocks,
124 XFS_BMAPI_WRITE | XFS_BMAPI_METADATA, &firstblock, 124 XFS_BMAPI_METADATA, &firstblock,
125 resblks, &map, &nmap, &flist); 125 resblks, &map, &nmap, &flist);
126 if (!error && nmap < 1) 126 if (!error && nmap < 1)
127 error = XFS_ERROR(ENOSPC); 127 error = XFS_ERROR(ENOSPC);
128 if (error) 128 if (error)
@@ -155,7 +155,7 @@ xfs_growfs_rt_alloc(
155 * Lock the bitmap inode. 155 * Lock the bitmap inode.
156 */ 156 */
157 xfs_ilock(ip, XFS_ILOCK_EXCL); 157 xfs_ilock(ip, XFS_ILOCK_EXCL);
158 xfs_trans_ijoin_ref(tp, ip, XFS_ILOCK_EXCL); 158 xfs_trans_ijoin(tp, ip, XFS_ILOCK_EXCL);
159 /* 159 /*
160 * Get a buffer for the block. 160 * Get a buffer for the block.
161 */ 161 */
@@ -856,33 +856,23 @@ xfs_rtbuf_get(
856 xfs_buf_t **bpp) /* output: buffer for the block */ 856 xfs_buf_t **bpp) /* output: buffer for the block */
857{ 857{
858 xfs_buf_t *bp; /* block buffer, result */ 858 xfs_buf_t *bp; /* block buffer, result */
859 xfs_daddr_t d; /* disk addr of block */
860 int error; /* error value */
861 xfs_fsblock_t fsb; /* fs block number for block */
862 xfs_inode_t *ip; /* bitmap or summary inode */ 859 xfs_inode_t *ip; /* bitmap or summary inode */
860 xfs_bmbt_irec_t map;
861 int nmap;
862 int error; /* error value */
863 863
864 ip = issum ? mp->m_rsumip : mp->m_rbmip; 864 ip = issum ? mp->m_rsumip : mp->m_rbmip;
865 /* 865
866 * Map from the file offset (block) and inode number to the 866 error = xfs_bmapi_read(ip, block, 1, &map, &nmap, XFS_DATA_FORK);
867 * file system block. 867 if (error)
868 */
869 error = xfs_bmapi_single(tp, ip, XFS_DATA_FORK, &fsb, block);
870 if (error) {
871 return error; 868 return error;
872 } 869
873 ASSERT(fsb != NULLFSBLOCK); 870 ASSERT(map.br_startblock != NULLFSBLOCK);
874 /* 871 error = xfs_trans_read_buf(mp, tp, mp->m_ddev_targp,
875 * Convert to disk address for buffer cache. 872 XFS_FSB_TO_DADDR(mp, map.br_startblock),
876 */
877 d = XFS_FSB_TO_DADDR(mp, fsb);
878 /*
879 * Read the buffer.
880 */
881 error = xfs_trans_read_buf(mp, tp, mp->m_ddev_targp, d,
882 mp->m_bsize, 0, &bp); 873 mp->m_bsize, 0, &bp);
883 if (error) { 874 if (error)
884 return error; 875 return error;
885 }
886 ASSERT(!xfs_buf_geterror(bp)); 876 ASSERT(!xfs_buf_geterror(bp));
887 *bpp = bp; 877 *bpp = bp;
888 return 0; 878 return 0;
@@ -1970,7 +1960,7 @@ xfs_growfs_rt(
1970 * Lock out other callers by grabbing the bitmap inode lock. 1960 * Lock out other callers by grabbing the bitmap inode lock.
1971 */ 1961 */
1972 xfs_ilock(mp->m_rbmip, XFS_ILOCK_EXCL); 1962 xfs_ilock(mp->m_rbmip, XFS_ILOCK_EXCL);
1973 xfs_trans_ijoin_ref(tp, mp->m_rbmip, XFS_ILOCK_EXCL); 1963 xfs_trans_ijoin(tp, mp->m_rbmip, XFS_ILOCK_EXCL);
1974 /* 1964 /*
1975 * Update the bitmap inode's size. 1965 * Update the bitmap inode's size.
1976 */ 1966 */
@@ -1982,7 +1972,7 @@ xfs_growfs_rt(
1982 * Get the summary inode into the transaction. 1972 * Get the summary inode into the transaction.
1983 */ 1973 */
1984 xfs_ilock(mp->m_rsumip, XFS_ILOCK_EXCL); 1974 xfs_ilock(mp->m_rsumip, XFS_ILOCK_EXCL);
1985 xfs_trans_ijoin_ref(tp, mp->m_rsumip, XFS_ILOCK_EXCL); 1975 xfs_trans_ijoin(tp, mp->m_rsumip, XFS_ILOCK_EXCL);
1986 /* 1976 /*
1987 * Update the summary inode's size. 1977 * Update the summary inode's size.
1988 */ 1978 */
@@ -2153,7 +2143,7 @@ xfs_rtfree_extent(
2153 * Synchronize by locking the bitmap inode. 2143 * Synchronize by locking the bitmap inode.
2154 */ 2144 */
2155 xfs_ilock(mp->m_rbmip, XFS_ILOCK_EXCL); 2145 xfs_ilock(mp->m_rbmip, XFS_ILOCK_EXCL);
2156 xfs_trans_ijoin_ref(tp, mp->m_rbmip, XFS_ILOCK_EXCL); 2146 xfs_trans_ijoin(tp, mp->m_rbmip, XFS_ILOCK_EXCL);
2157 2147
2158#if defined(__KERNEL__) && defined(DEBUG) 2148#if defined(__KERNEL__) && defined(DEBUG)
2159 /* 2149 /*
diff --git a/fs/xfs/xfs_rw.c b/fs/xfs/xfs_rw.c
index c96a8a05ac03..597d044a09a1 100644
--- a/fs/xfs/xfs_rw.c
+++ b/fs/xfs/xfs_rw.c
@@ -92,24 +92,6 @@ xfs_do_force_shutdown(
92} 92}
93 93
94/* 94/*
95 * Prints out an ALERT message about I/O error.
96 */
97void
98xfs_ioerror_alert(
99 char *func,
100 struct xfs_mount *mp,
101 xfs_buf_t *bp,
102 xfs_daddr_t blkno)
103{
104 xfs_alert(mp,
105 "I/O error occurred: meta-data dev %s block 0x%llx"
106 " (\"%s\") error %d buf count %zd",
107 xfs_buf_target_name(bp->b_target),
108 (__uint64_t)blkno, func,
109 bp->b_error, XFS_BUF_COUNT(bp));
110}
111
112/*
113 * This isn't an absolute requirement, but it is 95 * This isn't an absolute requirement, but it is
114 * just a good idea to call xfs_read_buf instead of 96 * just a good idea to call xfs_read_buf instead of
115 * directly doing a read_buf call. For one, we shouldn't 97 * directly doing a read_buf call. For one, we shouldn't
@@ -143,14 +125,13 @@ xfs_read_buf(
143 } else { 125 } else {
144 *bpp = NULL; 126 *bpp = NULL;
145 if (error) { 127 if (error) {
146 xfs_ioerror_alert("xfs_read_buf", mp, bp, XFS_BUF_ADDR(bp)); 128 xfs_buf_ioerror_alert(bp, __func__);
147 } else { 129 } else {
148 error = XFS_ERROR(EIO); 130 error = XFS_ERROR(EIO);
149 } 131 }
150 if (bp) { 132 if (bp) {
151 XFS_BUF_UNDONE(bp); 133 XFS_BUF_UNDONE(bp);
152 XFS_BUF_UNDELAYWRITE(bp); 134 xfs_buf_stale(bp);
153 XFS_BUF_STALE(bp);
154 /* 135 /*
155 * brelse clears B_ERROR and b_error 136 * brelse clears B_ERROR and b_error
156 */ 137 */
diff --git a/fs/xfs/xfs_rw.h b/fs/xfs/xfs_rw.h
index 11c41ec6ed75..bbdb9ad6a4ba 100644
--- a/fs/xfs/xfs_rw.h
+++ b/fs/xfs/xfs_rw.h
@@ -42,8 +42,6 @@ xfs_fsb_to_db(struct xfs_inode *ip, xfs_fsblock_t fsb)
42extern int xfs_read_buf(struct xfs_mount *mp, xfs_buftarg_t *btp, 42extern int xfs_read_buf(struct xfs_mount *mp, xfs_buftarg_t *btp,
43 xfs_daddr_t blkno, int len, uint flags, 43 xfs_daddr_t blkno, int len, uint flags,
44 struct xfs_buf **bpp); 44 struct xfs_buf **bpp);
45extern void xfs_ioerror_alert(char *func, struct xfs_mount *mp,
46 xfs_buf_t *bp, xfs_daddr_t blkno);
47extern xfs_extlen_t xfs_get_extsz_hint(struct xfs_inode *ip); 45extern xfs_extlen_t xfs_get_extsz_hint(struct xfs_inode *ip);
48 46
49#endif /* __XFS_RW_H__ */ 47#endif /* __XFS_RW_H__ */
diff --git a/fs/xfs/xfs_super.c b/fs/xfs/xfs_super.c
index 5cf06b85fd9d..3eca58f51ae9 100644
--- a/fs/xfs/xfs_super.c
+++ b/fs/xfs/xfs_super.c
@@ -796,8 +796,6 @@ xfs_fs_destroy_inode(
796 if (is_bad_inode(inode)) 796 if (is_bad_inode(inode))
797 goto out_reclaim; 797 goto out_reclaim;
798 798
799 xfs_ioend_wait(ip);
800
801 ASSERT(XFS_FORCED_SHUTDOWN(ip->i_mount) || ip->i_delayed_blks == 0); 799 ASSERT(XFS_FORCED_SHUTDOWN(ip->i_mount) || ip->i_delayed_blks == 0);
802 800
803 /* 801 /*
@@ -837,7 +835,6 @@ xfs_fs_inode_init_once(
837 inode_init_once(VFS_I(ip)); 835 inode_init_once(VFS_I(ip));
838 836
839 /* xfs inode */ 837 /* xfs inode */
840 atomic_set(&ip->i_iocount, 0);
841 atomic_set(&ip->i_pincount, 0); 838 atomic_set(&ip->i_pincount, 0);
842 spin_lock_init(&ip->i_flags_lock); 839 spin_lock_init(&ip->i_flags_lock);
843 init_waitqueue_head(&ip->i_ipin_wait); 840 init_waitqueue_head(&ip->i_ipin_wait);
@@ -887,7 +884,7 @@ xfs_log_inode(
887 } 884 }
888 885
889 xfs_ilock(ip, XFS_ILOCK_EXCL); 886 xfs_ilock(ip, XFS_ILOCK_EXCL);
890 xfs_trans_ijoin_ref(tp, ip, XFS_ILOCK_EXCL); 887 xfs_trans_ijoin(tp, ip, XFS_ILOCK_EXCL);
891 xfs_trans_log_inode(tp, ip, XFS_ILOG_CORE); 888 xfs_trans_log_inode(tp, ip, XFS_ILOG_CORE);
892 return xfs_trans_commit(tp, 0); 889 return xfs_trans_commit(tp, 0);
893} 890}
@@ -914,9 +911,8 @@ xfs_fs_write_inode(
914 * of forcing it all the way to stable storage using a 911 * of forcing it all the way to stable storage using a
915 * synchronous transaction we let the log force inside the 912 * synchronous transaction we let the log force inside the
916 * ->sync_fs call do that for thus, which reduces the number 913 * ->sync_fs call do that for thus, which reduces the number
917 * of synchronous log foces dramatically. 914 * of synchronous log forces dramatically.
918 */ 915 */
919 xfs_ioend_wait(ip);
920 error = xfs_log_inode(ip); 916 error = xfs_log_inode(ip);
921 if (error) 917 if (error)
922 goto out; 918 goto out;
@@ -1019,7 +1015,7 @@ xfs_fs_put_super(
1019 */ 1015 */
1020 xfs_filestream_unmount(mp); 1016 xfs_filestream_unmount(mp);
1021 1017
1022 XFS_bflush(mp->m_ddev_targp); 1018 xfs_flush_buftarg(mp->m_ddev_targp, 1);
1023 1019
1024 xfs_unmountfs(mp); 1020 xfs_unmountfs(mp);
1025 xfs_freesb(mp); 1021 xfs_freesb(mp);
@@ -1443,7 +1439,7 @@ xfs_fs_fill_super(
1443 */ 1439 */
1444 xfs_filestream_unmount(mp); 1440 xfs_filestream_unmount(mp);
1445 1441
1446 XFS_bflush(mp->m_ddev_targp); 1442 xfs_flush_buftarg(mp->m_ddev_targp, 1);
1447 1443
1448 xfs_unmountfs(mp); 1444 xfs_unmountfs(mp);
1449 goto out_free_sb; 1445 goto out_free_sb;
@@ -1670,7 +1666,6 @@ init_xfs_fs(void)
1670 printk(KERN_INFO XFS_VERSION_STRING " with " 1666 printk(KERN_INFO XFS_VERSION_STRING " with "
1671 XFS_BUILD_OPTIONS " enabled\n"); 1667 XFS_BUILD_OPTIONS " enabled\n");
1672 1668
1673 xfs_ioend_init();
1674 xfs_dir_startup(); 1669 xfs_dir_startup();
1675 1670
1676 error = xfs_init_zones(); 1671 error = xfs_init_zones();
diff --git a/fs/xfs/xfs_sync.c b/fs/xfs/xfs_sync.c
index 4604f90f86a3..aa3dc1a4d53d 100644
--- a/fs/xfs/xfs_sync.c
+++ b/fs/xfs/xfs_sync.c
@@ -227,21 +227,17 @@ xfs_sync_inode_data(
227 int error = 0; 227 int error = 0;
228 228
229 if (!mapping_tagged(mapping, PAGECACHE_TAG_DIRTY)) 229 if (!mapping_tagged(mapping, PAGECACHE_TAG_DIRTY))
230 goto out_wait; 230 return 0;
231 231
232 if (!xfs_ilock_nowait(ip, XFS_IOLOCK_SHARED)) { 232 if (!xfs_ilock_nowait(ip, XFS_IOLOCK_SHARED)) {
233 if (flags & SYNC_TRYLOCK) 233 if (flags & SYNC_TRYLOCK)
234 goto out_wait; 234 return 0;
235 xfs_ilock(ip, XFS_IOLOCK_SHARED); 235 xfs_ilock(ip, XFS_IOLOCK_SHARED);
236 } 236 }
237 237
238 error = xfs_flush_pages(ip, 0, -1, (flags & SYNC_WAIT) ? 238 error = xfs_flush_pages(ip, 0, -1, (flags & SYNC_WAIT) ?
239 0 : XBF_ASYNC, FI_NONE); 239 0 : XBF_ASYNC, FI_NONE);
240 xfs_iunlock(ip, XFS_IOLOCK_SHARED); 240 xfs_iunlock(ip, XFS_IOLOCK_SHARED);
241
242 out_wait:
243 if (flags & SYNC_WAIT)
244 xfs_ioend_wait(ip);
245 return error; 241 return error;
246} 242}
247 243
@@ -322,6 +318,7 @@ xfs_sync_fsdata(
322 struct xfs_mount *mp) 318 struct xfs_mount *mp)
323{ 319{
324 struct xfs_buf *bp; 320 struct xfs_buf *bp;
321 int error;
325 322
326 /* 323 /*
327 * If the buffer is pinned then push on the log so we won't get stuck 324 * If the buffer is pinned then push on the log so we won't get stuck
@@ -334,8 +331,9 @@ xfs_sync_fsdata(
334 bp = xfs_getsb(mp, 0); 331 bp = xfs_getsb(mp, 0);
335 if (xfs_buf_ispinned(bp)) 332 if (xfs_buf_ispinned(bp))
336 xfs_log_force(mp, 0); 333 xfs_log_force(mp, 0);
337 334 error = xfs_bwrite(bp);
338 return xfs_bwrite(mp, bp); 335 xfs_buf_relse(bp);
336 return error;
339} 337}
340 338
341/* 339/*
@@ -379,7 +377,7 @@ xfs_quiesce_data(
379 377
380 /* flush data-only devices */ 378 /* flush data-only devices */
381 if (mp->m_rtdev_targp) 379 if (mp->m_rtdev_targp)
382 XFS_bflush(mp->m_rtdev_targp); 380 xfs_flush_buftarg(mp->m_rtdev_targp, 1);
383 381
384 return error ? error : error2; 382 return error ? error : error2;
385} 383}
diff --git a/fs/xfs/xfs_trace.h b/fs/xfs/xfs_trace.h
index 690fc7a7bd72..f1d2802b2f07 100644
--- a/fs/xfs/xfs_trace.h
+++ b/fs/xfs/xfs_trace.h
@@ -30,6 +30,7 @@ struct xfs_buf_log_item;
30struct xfs_da_args; 30struct xfs_da_args;
31struct xfs_da_node_entry; 31struct xfs_da_node_entry;
32struct xfs_dquot; 32struct xfs_dquot;
33struct xfs_log_item;
33struct xlog_ticket; 34struct xlog_ticket;
34struct log; 35struct log;
35struct xlog_recover; 36struct xlog_recover;
@@ -320,7 +321,6 @@ DEFINE_BUF_EVENT(xfs_buf_rele);
320DEFINE_BUF_EVENT(xfs_buf_iodone); 321DEFINE_BUF_EVENT(xfs_buf_iodone);
321DEFINE_BUF_EVENT(xfs_buf_iorequest); 322DEFINE_BUF_EVENT(xfs_buf_iorequest);
322DEFINE_BUF_EVENT(xfs_buf_bawrite); 323DEFINE_BUF_EVENT(xfs_buf_bawrite);
323DEFINE_BUF_EVENT(xfs_buf_bdwrite);
324DEFINE_BUF_EVENT(xfs_buf_lock); 324DEFINE_BUF_EVENT(xfs_buf_lock);
325DEFINE_BUF_EVENT(xfs_buf_lock_done); 325DEFINE_BUF_EVENT(xfs_buf_lock_done);
326DEFINE_BUF_EVENT(xfs_buf_trylock); 326DEFINE_BUF_EVENT(xfs_buf_trylock);
@@ -577,6 +577,7 @@ DEFINE_INODE_EVENT(xfs_vm_bmap);
577DEFINE_INODE_EVENT(xfs_file_ioctl); 577DEFINE_INODE_EVENT(xfs_file_ioctl);
578DEFINE_INODE_EVENT(xfs_file_compat_ioctl); 578DEFINE_INODE_EVENT(xfs_file_compat_ioctl);
579DEFINE_INODE_EVENT(xfs_ioctl_setattr); 579DEFINE_INODE_EVENT(xfs_ioctl_setattr);
580DEFINE_INODE_EVENT(xfs_dir_fsync);
580DEFINE_INODE_EVENT(xfs_file_fsync); 581DEFINE_INODE_EVENT(xfs_file_fsync);
581DEFINE_INODE_EVENT(xfs_destroy_inode); 582DEFINE_INODE_EVENT(xfs_destroy_inode);
582DEFINE_INODE_EVENT(xfs_write_inode); 583DEFINE_INODE_EVENT(xfs_write_inode);
@@ -853,6 +854,42 @@ DEFINE_LOGGRANT_EVENT(xfs_log_ungrant_enter);
853DEFINE_LOGGRANT_EVENT(xfs_log_ungrant_exit); 854DEFINE_LOGGRANT_EVENT(xfs_log_ungrant_exit);
854DEFINE_LOGGRANT_EVENT(xfs_log_ungrant_sub); 855DEFINE_LOGGRANT_EVENT(xfs_log_ungrant_sub);
855 856
857DECLARE_EVENT_CLASS(xfs_log_item_class,
858 TP_PROTO(struct xfs_log_item *lip),
859 TP_ARGS(lip),
860 TP_STRUCT__entry(
861 __field(dev_t, dev)
862 __field(void *, lip)
863 __field(uint, type)
864 __field(uint, flags)
865 __field(xfs_lsn_t, lsn)
866 ),
867 TP_fast_assign(
868 __entry->dev = lip->li_mountp->m_super->s_dev;
869 __entry->lip = lip;
870 __entry->type = lip->li_type;
871 __entry->flags = lip->li_flags;
872 __entry->lsn = lip->li_lsn;
873 ),
874 TP_printk("dev %d:%d lip 0x%p lsn %d/%d type %s flags %s",
875 MAJOR(__entry->dev), MINOR(__entry->dev),
876 __entry->lip,
877 CYCLE_LSN(__entry->lsn), BLOCK_LSN(__entry->lsn),
878 __print_symbolic(__entry->type, XFS_LI_TYPE_DESC),
879 __print_flags(__entry->flags, "|", XFS_LI_FLAGS))
880)
881
882#define DEFINE_LOG_ITEM_EVENT(name) \
883DEFINE_EVENT(xfs_log_item_class, name, \
884 TP_PROTO(struct xfs_log_item *lip), \
885 TP_ARGS(lip))
886DEFINE_LOG_ITEM_EVENT(xfs_ail_push);
887DEFINE_LOG_ITEM_EVENT(xfs_ail_pushbuf);
888DEFINE_LOG_ITEM_EVENT(xfs_ail_pushbuf_pinned);
889DEFINE_LOG_ITEM_EVENT(xfs_ail_pinned);
890DEFINE_LOG_ITEM_EVENT(xfs_ail_locked);
891
892
856DECLARE_EVENT_CLASS(xfs_file_class, 893DECLARE_EVENT_CLASS(xfs_file_class,
857 TP_PROTO(struct xfs_inode *ip, size_t count, loff_t offset, int flags), 894 TP_PROTO(struct xfs_inode *ip, size_t count, loff_t offset, int flags),
858 TP_ARGS(ip, count, offset, flags), 895 TP_ARGS(ip, count, offset, flags),
diff --git a/fs/xfs/xfs_trans.c b/fs/xfs/xfs_trans.c
index efc147f0e9b6..1f35b2feca97 100644
--- a/fs/xfs/xfs_trans.c
+++ b/fs/xfs/xfs_trans.c
@@ -1790,9 +1790,7 @@ xfs_trans_commit_cil(
1790} 1790}
1791 1791
1792/* 1792/*
1793 * xfs_trans_commit 1793 * Commit the given transaction to the log.
1794 *
1795 * Commit the given transaction to the log a/synchronously.
1796 * 1794 *
1797 * XFS disk error handling mechanism is not based on a typical 1795 * XFS disk error handling mechanism is not based on a typical
1798 * transaction abort mechanism. Logically after the filesystem 1796 * transaction abort mechanism. Logically after the filesystem
@@ -1804,10 +1802,9 @@ xfs_trans_commit_cil(
1804 * Do not reference the transaction structure after this call. 1802 * Do not reference the transaction structure after this call.
1805 */ 1803 */
1806int 1804int
1807_xfs_trans_commit( 1805xfs_trans_commit(
1808 struct xfs_trans *tp, 1806 struct xfs_trans *tp,
1809 uint flags, 1807 uint flags)
1810 int *log_flushed)
1811{ 1808{
1812 struct xfs_mount *mp = tp->t_mountp; 1809 struct xfs_mount *mp = tp->t_mountp;
1813 xfs_lsn_t commit_lsn = -1; 1810 xfs_lsn_t commit_lsn = -1;
@@ -1866,7 +1863,7 @@ _xfs_trans_commit(
1866 if (sync) { 1863 if (sync) {
1867 if (!error) { 1864 if (!error) {
1868 error = _xfs_log_force_lsn(mp, commit_lsn, 1865 error = _xfs_log_force_lsn(mp, commit_lsn,
1869 XFS_LOG_SYNC, log_flushed); 1866 XFS_LOG_SYNC, NULL);
1870 } 1867 }
1871 XFS_STATS_INC(xs_trans_sync); 1868 XFS_STATS_INC(xs_trans_sync);
1872 } else { 1869 } else {
@@ -2021,6 +2018,6 @@ xfs_trans_roll(
2021 if (error) 2018 if (error)
2022 return error; 2019 return error;
2023 2020
2024 xfs_trans_ijoin(trans, dp); 2021 xfs_trans_ijoin(trans, dp, 0);
2025 return 0; 2022 return 0;
2026} 2023}
diff --git a/fs/xfs/xfs_trans.h b/fs/xfs/xfs_trans.h
index 53597f4db9b5..603f3eb52041 100644
--- a/fs/xfs/xfs_trans.h
+++ b/fs/xfs/xfs_trans.h
@@ -470,8 +470,7 @@ void xfs_trans_stale_inode_buf(xfs_trans_t *, struct xfs_buf *);
470void xfs_trans_dquot_buf(xfs_trans_t *, struct xfs_buf *, uint); 470void xfs_trans_dquot_buf(xfs_trans_t *, struct xfs_buf *, uint);
471void xfs_trans_inode_alloc_buf(xfs_trans_t *, struct xfs_buf *); 471void xfs_trans_inode_alloc_buf(xfs_trans_t *, struct xfs_buf *);
472void xfs_trans_ichgtime(struct xfs_trans *, struct xfs_inode *, int); 472void xfs_trans_ichgtime(struct xfs_trans *, struct xfs_inode *, int);
473void xfs_trans_ijoin_ref(struct xfs_trans *, struct xfs_inode *, uint); 473void xfs_trans_ijoin(struct xfs_trans *, struct xfs_inode *, uint);
474void xfs_trans_ijoin(struct xfs_trans *, struct xfs_inode *);
475void xfs_trans_log_buf(xfs_trans_t *, struct xfs_buf *, uint, uint); 474void xfs_trans_log_buf(xfs_trans_t *, struct xfs_buf *, uint, uint);
476void xfs_trans_log_inode(xfs_trans_t *, struct xfs_inode *, uint); 475void xfs_trans_log_inode(xfs_trans_t *, struct xfs_inode *, uint);
477struct xfs_efi_log_item *xfs_trans_get_efi(xfs_trans_t *, uint); 476struct xfs_efi_log_item *xfs_trans_get_efi(xfs_trans_t *, uint);
@@ -487,10 +486,7 @@ void xfs_trans_log_efd_extent(xfs_trans_t *,
487 struct xfs_efd_log_item *, 486 struct xfs_efd_log_item *,
488 xfs_fsblock_t, 487 xfs_fsblock_t,
489 xfs_extlen_t); 488 xfs_extlen_t);
490int _xfs_trans_commit(xfs_trans_t *, 489int xfs_trans_commit(xfs_trans_t *, uint flags);
491 uint flags,
492 int *);
493#define xfs_trans_commit(tp, flags) _xfs_trans_commit(tp, flags, NULL)
494void xfs_trans_cancel(xfs_trans_t *, int); 490void xfs_trans_cancel(xfs_trans_t *, int);
495int xfs_trans_ail_init(struct xfs_mount *); 491int xfs_trans_ail_init(struct xfs_mount *);
496void xfs_trans_ail_destroy(struct xfs_mount *); 492void xfs_trans_ail_destroy(struct xfs_mount *);
diff --git a/fs/xfs/xfs_trans_ail.c b/fs/xfs/xfs_trans_ail.c
index 3a1e7ca54c2d..ed9252bcdac9 100644
--- a/fs/xfs/xfs_trans_ail.c
+++ b/fs/xfs/xfs_trans_ail.c
@@ -26,6 +26,7 @@
26#include "xfs_ag.h" 26#include "xfs_ag.h"
27#include "xfs_mount.h" 27#include "xfs_mount.h"
28#include "xfs_trans_priv.h" 28#include "xfs_trans_priv.h"
29#include "xfs_trace.h"
29#include "xfs_error.h" 30#include "xfs_error.h"
30 31
31#ifdef DEBUG 32#ifdef DEBUG
@@ -364,12 +365,24 @@ xfsaild_push(
364 xfs_lsn_t lsn; 365 xfs_lsn_t lsn;
365 xfs_lsn_t target; 366 xfs_lsn_t target;
366 long tout = 10; 367 long tout = 10;
367 int flush_log = 0;
368 int stuck = 0; 368 int stuck = 0;
369 int count = 0; 369 int count = 0;
370 int push_xfsbufd = 0; 370 int push_xfsbufd = 0;
371 371
372 /*
373 * If last time we ran we encountered pinned items, force the log first
374 * and wait for it before pushing again.
375 */
372 spin_lock(&ailp->xa_lock); 376 spin_lock(&ailp->xa_lock);
377 if (ailp->xa_last_pushed_lsn == 0 && ailp->xa_log_flush &&
378 !list_empty(&ailp->xa_ail)) {
379 ailp->xa_log_flush = 0;
380 spin_unlock(&ailp->xa_lock);
381 XFS_STATS_INC(xs_push_ail_flush);
382 xfs_log_force(mp, XFS_LOG_SYNC);
383 spin_lock(&ailp->xa_lock);
384 }
385
373 target = ailp->xa_target; 386 target = ailp->xa_target;
374 lip = xfs_trans_ail_cursor_first(ailp, &cur, ailp->xa_last_pushed_lsn); 387 lip = xfs_trans_ail_cursor_first(ailp, &cur, ailp->xa_last_pushed_lsn);
375 if (!lip || XFS_FORCED_SHUTDOWN(mp)) { 388 if (!lip || XFS_FORCED_SHUTDOWN(mp)) {
@@ -413,16 +426,20 @@ xfsaild_push(
413 switch (lock_result) { 426 switch (lock_result) {
414 case XFS_ITEM_SUCCESS: 427 case XFS_ITEM_SUCCESS:
415 XFS_STATS_INC(xs_push_ail_success); 428 XFS_STATS_INC(xs_push_ail_success);
429 trace_xfs_ail_push(lip);
430
416 IOP_PUSH(lip); 431 IOP_PUSH(lip);
417 ailp->xa_last_pushed_lsn = lsn; 432 ailp->xa_last_pushed_lsn = lsn;
418 break; 433 break;
419 434
420 case XFS_ITEM_PUSHBUF: 435 case XFS_ITEM_PUSHBUF:
421 XFS_STATS_INC(xs_push_ail_pushbuf); 436 XFS_STATS_INC(xs_push_ail_pushbuf);
437 trace_xfs_ail_pushbuf(lip);
422 438
423 if (!IOP_PUSHBUF(lip)) { 439 if (!IOP_PUSHBUF(lip)) {
440 trace_xfs_ail_pushbuf_pinned(lip);
424 stuck++; 441 stuck++;
425 flush_log = 1; 442 ailp->xa_log_flush++;
426 } else { 443 } else {
427 ailp->xa_last_pushed_lsn = lsn; 444 ailp->xa_last_pushed_lsn = lsn;
428 } 445 }
@@ -431,12 +448,15 @@ xfsaild_push(
431 448
432 case XFS_ITEM_PINNED: 449 case XFS_ITEM_PINNED:
433 XFS_STATS_INC(xs_push_ail_pinned); 450 XFS_STATS_INC(xs_push_ail_pinned);
451 trace_xfs_ail_pinned(lip);
452
434 stuck++; 453 stuck++;
435 flush_log = 1; 454 ailp->xa_log_flush++;
436 break; 455 break;
437 456
438 case XFS_ITEM_LOCKED: 457 case XFS_ITEM_LOCKED:
439 XFS_STATS_INC(xs_push_ail_locked); 458 XFS_STATS_INC(xs_push_ail_locked);
459 trace_xfs_ail_locked(lip);
440 stuck++; 460 stuck++;
441 break; 461 break;
442 462
@@ -476,16 +496,6 @@ xfsaild_push(
476 xfs_trans_ail_cursor_done(ailp, &cur); 496 xfs_trans_ail_cursor_done(ailp, &cur);
477 spin_unlock(&ailp->xa_lock); 497 spin_unlock(&ailp->xa_lock);
478 498
479 if (flush_log) {
480 /*
481 * If something we need to push out was pinned, then
482 * push out the log so it will become unpinned and
483 * move forward in the AIL.
484 */
485 XFS_STATS_INC(xs_push_ail_flush);
486 xfs_log_force(mp, 0);
487 }
488
489 if (push_xfsbufd) { 499 if (push_xfsbufd) {
490 /* we've got delayed write buffers to flush */ 500 /* we've got delayed write buffers to flush */
491 wake_up_process(mp->m_ddev_targp->bt_task); 501 wake_up_process(mp->m_ddev_targp->bt_task);
@@ -496,6 +506,7 @@ out_done:
496 if (!count) { 506 if (!count) {
497 /* We're past our target or empty, so idle */ 507 /* We're past our target or empty, so idle */
498 ailp->xa_last_pushed_lsn = 0; 508 ailp->xa_last_pushed_lsn = 0;
509 ailp->xa_log_flush = 0;
499 510
500 tout = 50; 511 tout = 50;
501 } else if (XFS_LSN_CMP(lsn, target) >= 0) { 512 } else if (XFS_LSN_CMP(lsn, target) >= 0) {
@@ -514,9 +525,13 @@ out_done:
514 * were stuck. 525 * were stuck.
515 * 526 *
516 * Backoff a bit more to allow some I/O to complete before 527 * Backoff a bit more to allow some I/O to complete before
517 * continuing from where we were. 528 * restarting from the start of the AIL. This prevents us
529 * from spinning on the same items, and if they are pinned will
530 * all the restart to issue a log force to unpin the stuck
531 * items.
518 */ 532 */
519 tout = 20; 533 tout = 20;
534 ailp->xa_last_pushed_lsn = 0;
520 } 535 }
521 536
522 return tout; 537 return tout;
diff --git a/fs/xfs/xfs_trans_buf.c b/fs/xfs/xfs_trans_buf.c
index 137e2b9e2948..475a4ded4f41 100644
--- a/fs/xfs/xfs_trans_buf.c
+++ b/fs/xfs/xfs_trans_buf.c
@@ -160,8 +160,10 @@ xfs_trans_get_buf(xfs_trans_t *tp,
160 bp = xfs_trans_buf_item_match(tp, target_dev, blkno, len); 160 bp = xfs_trans_buf_item_match(tp, target_dev, blkno, len);
161 if (bp != NULL) { 161 if (bp != NULL) {
162 ASSERT(xfs_buf_islocked(bp)); 162 ASSERT(xfs_buf_islocked(bp));
163 if (XFS_FORCED_SHUTDOWN(tp->t_mountp)) 163 if (XFS_FORCED_SHUTDOWN(tp->t_mountp)) {
164 XFS_BUF_SUPER_STALE(bp); 164 xfs_buf_stale(bp);
165 XFS_BUF_DONE(bp);
166 }
165 167
166 /* 168 /*
167 * If the buffer is stale then it was binval'ed 169 * If the buffer is stale then it was binval'ed
@@ -294,8 +296,7 @@ xfs_trans_read_buf(
294 296
295 if (bp->b_error) { 297 if (bp->b_error) {
296 error = bp->b_error; 298 error = bp->b_error;
297 xfs_ioerror_alert("xfs_trans_read_buf", mp, 299 xfs_buf_ioerror_alert(bp, __func__);
298 bp, blkno);
299 xfs_buf_relse(bp); 300 xfs_buf_relse(bp);
300 return error; 301 return error;
301 } 302 }
@@ -337,8 +338,7 @@ xfs_trans_read_buf(
337 xfsbdstrat(tp->t_mountp, bp); 338 xfsbdstrat(tp->t_mountp, bp);
338 error = xfs_buf_iowait(bp); 339 error = xfs_buf_iowait(bp);
339 if (error) { 340 if (error) {
340 xfs_ioerror_alert("xfs_trans_read_buf", mp, 341 xfs_buf_ioerror_alert(bp, __func__);
341 bp, blkno);
342 xfs_buf_relse(bp); 342 xfs_buf_relse(bp);
343 /* 343 /*
344 * We can gracefully recover from most read 344 * We can gracefully recover from most read
@@ -387,9 +387,9 @@ xfs_trans_read_buf(
387 } 387 }
388 if (bp->b_error) { 388 if (bp->b_error) {
389 error = bp->b_error; 389 error = bp->b_error;
390 XFS_BUF_SUPER_STALE(bp); 390 xfs_buf_stale(bp);
391 xfs_ioerror_alert("xfs_trans_read_buf", mp, 391 XFS_BUF_DONE(bp);
392 bp, blkno); 392 xfs_buf_ioerror_alert(bp, __func__);
393 if (tp->t_flags & XFS_TRANS_DIRTY) 393 if (tp->t_flags & XFS_TRANS_DIRTY)
394 xfs_force_shutdown(tp->t_mountp, SHUTDOWN_META_IO_ERROR); 394 xfs_force_shutdown(tp->t_mountp, SHUTDOWN_META_IO_ERROR);
395 xfs_buf_relse(bp); 395 xfs_buf_relse(bp);
@@ -643,13 +643,14 @@ xfs_trans_log_buf(xfs_trans_t *tp,
643 * inside the b_bdstrat callback so that this won't get written to 643 * inside the b_bdstrat callback so that this won't get written to
644 * disk. 644 * disk.
645 */ 645 */
646 XFS_BUF_DELAYWRITE(bp);
647 XFS_BUF_DONE(bp); 646 XFS_BUF_DONE(bp);
648 647
649 ASSERT(atomic_read(&bip->bli_refcount) > 0); 648 ASSERT(atomic_read(&bip->bli_refcount) > 0);
650 bp->b_iodone = xfs_buf_iodone_callbacks; 649 bp->b_iodone = xfs_buf_iodone_callbacks;
651 bip->bli_item.li_cb = xfs_buf_iodone; 650 bip->bli_item.li_cb = xfs_buf_iodone;
652 651
652 xfs_buf_delwri_queue(bp);
653
653 trace_xfs_trans_log_buf(bip); 654 trace_xfs_trans_log_buf(bip);
654 655
655 /* 656 /*
@@ -738,8 +739,7 @@ xfs_trans_binval(
738 * We set the stale bit in the buffer as well since we're getting 739 * We set the stale bit in the buffer as well since we're getting
739 * rid of it. 740 * rid of it.
740 */ 741 */
741 XFS_BUF_UNDELAYWRITE(bp); 742 xfs_buf_stale(bp);
742 XFS_BUF_STALE(bp);
743 bip->bli_flags |= XFS_BLI_STALE; 743 bip->bli_flags |= XFS_BLI_STALE;
744 bip->bli_flags &= ~(XFS_BLI_INODE_BUF | XFS_BLI_LOGGED | XFS_BLI_DIRTY); 744 bip->bli_flags &= ~(XFS_BLI_INODE_BUF | XFS_BLI_LOGGED | XFS_BLI_DIRTY);
745 bip->bli_format.blf_flags &= ~XFS_BLF_INODE_BUF; 745 bip->bli_format.blf_flags &= ~XFS_BLF_INODE_BUF;
diff --git a/fs/xfs/xfs_trans_inode.c b/fs/xfs/xfs_trans_inode.c
index c8dea2fd7e68..32f0288ae10f 100644
--- a/fs/xfs/xfs_trans_inode.c
+++ b/fs/xfs/xfs_trans_inode.c
@@ -47,11 +47,13 @@ xfs_trans_inode_broot_debug(
47 * Add a locked inode to the transaction. 47 * Add a locked inode to the transaction.
48 * 48 *
49 * The inode must be locked, and it cannot be associated with any transaction. 49 * The inode must be locked, and it cannot be associated with any transaction.
50 * If lock_flags is non-zero the inode will be unlocked on transaction commit.
50 */ 51 */
51void 52void
52xfs_trans_ijoin( 53xfs_trans_ijoin(
53 struct xfs_trans *tp, 54 struct xfs_trans *tp,
54 struct xfs_inode *ip) 55 struct xfs_inode *ip,
56 uint lock_flags)
55{ 57{
56 xfs_inode_log_item_t *iip; 58 xfs_inode_log_item_t *iip;
57 59
@@ -59,7 +61,9 @@ xfs_trans_ijoin(
59 if (ip->i_itemp == NULL) 61 if (ip->i_itemp == NULL)
60 xfs_inode_item_init(ip, ip->i_mount); 62 xfs_inode_item_init(ip, ip->i_mount);
61 iip = ip->i_itemp; 63 iip = ip->i_itemp;
64
62 ASSERT(iip->ili_lock_flags == 0); 65 ASSERT(iip->ili_lock_flags == 0);
66 iip->ili_lock_flags = lock_flags;
63 67
64 /* 68 /*
65 * Get a log_item_desc to point at the new item. 69 * Get a log_item_desc to point at the new item.
@@ -70,25 +74,6 @@ xfs_trans_ijoin(
70} 74}
71 75
72/* 76/*
73 * Add a locked inode to the transaction.
74 *
75 *
76 * Grabs a reference to the inode which will be dropped when the transaction
77 * is committed. The inode will also be unlocked at that point. The inode
78 * must be locked, and it cannot be associated with any transaction.
79 */
80void
81xfs_trans_ijoin_ref(
82 struct xfs_trans *tp,
83 struct xfs_inode *ip,
84 uint lock_flags)
85{
86 xfs_trans_ijoin(tp, ip);
87 IHOLD(ip);
88 ip->i_itemp->ili_lock_flags = lock_flags;
89}
90
91/*
92 * Transactional inode timestamp update. Requires the inode to be locked and 77 * Transactional inode timestamp update. Requires the inode to be locked and
93 * joined to the transaction supplied. Relies on the transaction subsystem to 78 * joined to the transaction supplied. Relies on the transaction subsystem to
94 * track dirty state and update/writeback the inode accordingly. 79 * track dirty state and update/writeback the inode accordingly.
diff --git a/fs/xfs/xfs_trans_priv.h b/fs/xfs/xfs_trans_priv.h
index 22750b5e4a8f..44820b9fcb43 100644
--- a/fs/xfs/xfs_trans_priv.h
+++ b/fs/xfs/xfs_trans_priv.h
@@ -70,6 +70,7 @@ struct xfs_ail {
70 struct list_head xa_cursors; 70 struct list_head xa_cursors;
71 spinlock_t xa_lock; 71 spinlock_t xa_lock;
72 xfs_lsn_t xa_last_pushed_lsn; 72 xfs_lsn_t xa_last_pushed_lsn;
73 int xa_log_flush;
73}; 74};
74 75
75/* 76/*
diff --git a/fs/xfs/xfs_vnodeops.c b/fs/xfs/xfs_vnodeops.c
index 51fc429527bc..4ecf2a549060 100644
--- a/fs/xfs/xfs_vnodeops.c
+++ b/fs/xfs/xfs_vnodeops.c
@@ -72,8 +72,8 @@ xfs_readlink_bmap(
72 xfs_buf_t *bp; 72 xfs_buf_t *bp;
73 int error = 0; 73 int error = 0;
74 74
75 error = xfs_bmapi(NULL, ip, 0, XFS_B_TO_FSB(mp, pathlen), 0, NULL, 0, 75 error = xfs_bmapi_read(ip, 0, XFS_B_TO_FSB(mp, pathlen), mval, &nmaps,
76 mval, &nmaps, NULL); 76 0);
77 if (error) 77 if (error)
78 goto out; 78 goto out;
79 79
@@ -87,8 +87,7 @@ xfs_readlink_bmap(
87 return XFS_ERROR(ENOMEM); 87 return XFS_ERROR(ENOMEM);
88 error = bp->b_error; 88 error = bp->b_error;
89 if (error) { 89 if (error) {
90 xfs_ioerror_alert("xfs_readlink", 90 xfs_buf_ioerror_alert(bp, __func__);
91 ip->i_mount, bp, XFS_BUF_ADDR(bp));
92 xfs_buf_relse(bp); 91 xfs_buf_relse(bp);
93 goto out; 92 goto out;
94 } 93 }
@@ -178,8 +177,7 @@ xfs_free_eofblocks(
178 177
179 nimaps = 1; 178 nimaps = 1;
180 xfs_ilock(ip, XFS_ILOCK_SHARED); 179 xfs_ilock(ip, XFS_ILOCK_SHARED);
181 error = xfs_bmapi(NULL, ip, end_fsb, map_len, 0, 180 error = xfs_bmapi_read(ip, end_fsb, map_len, &imap, &nimaps, 0);
182 NULL, 0, &imap, &nimaps, NULL);
183 xfs_iunlock(ip, XFS_ILOCK_SHARED); 181 xfs_iunlock(ip, XFS_ILOCK_SHARED);
184 182
185 if (!error && (nimaps != 0) && 183 if (!error && (nimaps != 0) &&
@@ -220,7 +218,7 @@ xfs_free_eofblocks(
220 } 218 }
221 219
222 xfs_ilock(ip, XFS_ILOCK_EXCL); 220 xfs_ilock(ip, XFS_ILOCK_EXCL);
223 xfs_trans_ijoin(tp, ip); 221 xfs_trans_ijoin(tp, ip, 0);
224 222
225 error = xfs_itruncate_data(&tp, ip, ip->i_size); 223 error = xfs_itruncate_data(&tp, ip, ip->i_size);
226 if (error) { 224 if (error) {
@@ -289,7 +287,7 @@ xfs_inactive_symlink_rmt(
289 xfs_ilock(ip, XFS_IOLOCK_EXCL | XFS_ILOCK_EXCL); 287 xfs_ilock(ip, XFS_IOLOCK_EXCL | XFS_ILOCK_EXCL);
290 size = (int)ip->i_d.di_size; 288 size = (int)ip->i_d.di_size;
291 ip->i_d.di_size = 0; 289 ip->i_d.di_size = 0;
292 xfs_trans_ijoin(tp, ip); 290 xfs_trans_ijoin(tp, ip, 0);
293 xfs_trans_log_inode(tp, ip, XFS_ILOG_CORE); 291 xfs_trans_log_inode(tp, ip, XFS_ILOG_CORE);
294 /* 292 /*
295 * Find the block(s) so we can inval and unmap them. 293 * Find the block(s) so we can inval and unmap them.
@@ -297,9 +295,9 @@ xfs_inactive_symlink_rmt(
297 done = 0; 295 done = 0;
298 xfs_bmap_init(&free_list, &first_block); 296 xfs_bmap_init(&free_list, &first_block);
299 nmaps = ARRAY_SIZE(mval); 297 nmaps = ARRAY_SIZE(mval);
300 if ((error = xfs_bmapi(tp, ip, 0, XFS_B_TO_FSB(mp, size), 298 error = xfs_bmapi_read(ip, 0, XFS_B_TO_FSB(mp, size),
301 XFS_BMAPI_METADATA, &first_block, 0, mval, &nmaps, 299 mval, &nmaps, 0);
302 &free_list))) 300 if (error)
303 goto error0; 301 goto error0;
304 /* 302 /*
305 * Invalidate the block(s). 303 * Invalidate the block(s).
@@ -308,6 +306,10 @@ xfs_inactive_symlink_rmt(
308 bp = xfs_trans_get_buf(tp, mp->m_ddev_targp, 306 bp = xfs_trans_get_buf(tp, mp->m_ddev_targp,
309 XFS_FSB_TO_DADDR(mp, mval[i].br_startblock), 307 XFS_FSB_TO_DADDR(mp, mval[i].br_startblock),
310 XFS_FSB_TO_BB(mp, mval[i].br_blockcount), 0); 308 XFS_FSB_TO_BB(mp, mval[i].br_blockcount), 0);
309 if (!bp) {
310 error = ENOMEM;
311 goto error1;
312 }
311 xfs_trans_binval(tp, bp); 313 xfs_trans_binval(tp, bp);
312 } 314 }
313 /* 315 /*
@@ -333,7 +335,7 @@ xfs_inactive_symlink_rmt(
333 * Mark it dirty so it will be logged and moved forward in the log as 335 * Mark it dirty so it will be logged and moved forward in the log as
334 * part of every commit. 336 * part of every commit.
335 */ 337 */
336 xfs_trans_ijoin(tp, ip); 338 xfs_trans_ijoin(tp, ip, 0);
337 xfs_trans_log_inode(tp, ip, XFS_ILOG_CORE); 339 xfs_trans_log_inode(tp, ip, XFS_ILOG_CORE);
338 /* 340 /*
339 * Get a new, empty transaction to return to our caller. 341 * Get a new, empty transaction to return to our caller.
@@ -466,7 +468,7 @@ xfs_inactive_attrs(
466 goto error_cancel; 468 goto error_cancel;
467 469
468 xfs_ilock(ip, XFS_ILOCK_EXCL); 470 xfs_ilock(ip, XFS_ILOCK_EXCL);
469 xfs_trans_ijoin(tp, ip); 471 xfs_trans_ijoin(tp, ip, 0);
470 xfs_idestroy_fork(ip, XFS_ATTR_FORK); 472 xfs_idestroy_fork(ip, XFS_ATTR_FORK);
471 473
472 ASSERT(ip->i_d.di_anextents == 0); 474 ASSERT(ip->i_d.di_anextents == 0);
@@ -647,8 +649,6 @@ xfs_inactive(
647 if (truncate) { 649 if (truncate) {
648 xfs_ilock(ip, XFS_IOLOCK_EXCL); 650 xfs_ilock(ip, XFS_IOLOCK_EXCL);
649 651
650 xfs_ioend_wait(ip);
651
652 error = xfs_trans_reserve(tp, 0, 652 error = xfs_trans_reserve(tp, 0,
653 XFS_ITRUNCATE_LOG_RES(mp), 653 XFS_ITRUNCATE_LOG_RES(mp),
654 0, XFS_TRANS_PERM_LOG_RES, 654 0, XFS_TRANS_PERM_LOG_RES,
@@ -662,7 +662,7 @@ xfs_inactive(
662 } 662 }
663 663
664 xfs_ilock(ip, XFS_ILOCK_EXCL); 664 xfs_ilock(ip, XFS_ILOCK_EXCL);
665 xfs_trans_ijoin(tp, ip); 665 xfs_trans_ijoin(tp, ip, 0);
666 666
667 error = xfs_itruncate_data(&tp, ip, 0); 667 error = xfs_itruncate_data(&tp, ip, 0);
668 if (error) { 668 if (error) {
@@ -686,7 +686,7 @@ xfs_inactive(
686 return VN_INACTIVE_CACHE; 686 return VN_INACTIVE_CACHE;
687 } 687 }
688 688
689 xfs_trans_ijoin(tp, ip); 689 xfs_trans_ijoin(tp, ip, 0);
690 } else { 690 } else {
691 error = xfs_trans_reserve(tp, 0, 691 error = xfs_trans_reserve(tp, 0,
692 XFS_IFREE_LOG_RES(mp), 692 XFS_IFREE_LOG_RES(mp),
@@ -699,7 +699,7 @@ xfs_inactive(
699 } 699 }
700 700
701 xfs_ilock(ip, XFS_ILOCK_EXCL | XFS_IOLOCK_EXCL); 701 xfs_ilock(ip, XFS_ILOCK_EXCL | XFS_IOLOCK_EXCL);
702 xfs_trans_ijoin(tp, ip); 702 xfs_trans_ijoin(tp, ip, 0);
703 } 703 }
704 704
705 /* 705 /*
@@ -939,7 +939,7 @@ xfs_create(
939 * the transaction cancel unlocking dp so don't do it explicitly in the 939 * the transaction cancel unlocking dp so don't do it explicitly in the
940 * error path. 940 * error path.
941 */ 941 */
942 xfs_trans_ijoin_ref(tp, dp, XFS_ILOCK_EXCL); 942 xfs_trans_ijoin(tp, dp, XFS_ILOCK_EXCL);
943 unlock_dp_on_error = B_FALSE; 943 unlock_dp_on_error = B_FALSE;
944 944
945 error = xfs_dir_createname(tp, dp, name, ip->i_ino, 945 error = xfs_dir_createname(tp, dp, name, ip->i_ino,
@@ -1260,8 +1260,8 @@ xfs_remove(
1260 1260
1261 xfs_lock_two_inodes(dp, ip, XFS_ILOCK_EXCL); 1261 xfs_lock_two_inodes(dp, ip, XFS_ILOCK_EXCL);
1262 1262
1263 xfs_trans_ijoin_ref(tp, dp, XFS_ILOCK_EXCL); 1263 xfs_trans_ijoin(tp, dp, XFS_ILOCK_EXCL);
1264 xfs_trans_ijoin_ref(tp, ip, XFS_ILOCK_EXCL); 1264 xfs_trans_ijoin(tp, ip, XFS_ILOCK_EXCL);
1265 1265
1266 /* 1266 /*
1267 * If we're removing a directory perform some additional validation. 1267 * If we're removing a directory perform some additional validation.
@@ -1406,8 +1406,8 @@ xfs_link(
1406 1406
1407 xfs_lock_two_inodes(sip, tdp, XFS_ILOCK_EXCL); 1407 xfs_lock_two_inodes(sip, tdp, XFS_ILOCK_EXCL);
1408 1408
1409 xfs_trans_ijoin_ref(tp, sip, XFS_ILOCK_EXCL); 1409 xfs_trans_ijoin(tp, sip, XFS_ILOCK_EXCL);
1410 xfs_trans_ijoin_ref(tp, tdp, XFS_ILOCK_EXCL); 1410 xfs_trans_ijoin(tp, tdp, XFS_ILOCK_EXCL);
1411 1411
1412 /* 1412 /*
1413 * If the source has too many links, we can't make any more to it. 1413 * If the source has too many links, we can't make any more to it.
@@ -1601,7 +1601,7 @@ xfs_symlink(
1601 * transaction cancel unlocking dp so don't do it explicitly in the 1601 * transaction cancel unlocking dp so don't do it explicitly in the
1602 * error path. 1602 * error path.
1603 */ 1603 */
1604 xfs_trans_ijoin_ref(tp, dp, XFS_ILOCK_EXCL); 1604 xfs_trans_ijoin(tp, dp, XFS_ILOCK_EXCL);
1605 unlock_dp_on_error = B_FALSE; 1605 unlock_dp_on_error = B_FALSE;
1606 1606
1607 /* 1607 /*
@@ -1632,10 +1632,9 @@ xfs_symlink(
1632 first_fsb = 0; 1632 first_fsb = 0;
1633 nmaps = SYMLINK_MAPS; 1633 nmaps = SYMLINK_MAPS;
1634 1634
1635 error = xfs_bmapi(tp, ip, first_fsb, fs_blocks, 1635 error = xfs_bmapi_write(tp, ip, first_fsb, fs_blocks,
1636 XFS_BMAPI_WRITE | XFS_BMAPI_METADATA, 1636 XFS_BMAPI_METADATA, &first_block, resblks,
1637 &first_block, resblks, mval, &nmaps, 1637 mval, &nmaps, &free_list);
1638 &free_list);
1639 if (error) 1638 if (error)
1640 goto error2; 1639 goto error2;
1641 1640
@@ -1650,7 +1649,10 @@ xfs_symlink(
1650 byte_cnt = XFS_FSB_TO_B(mp, mval[n].br_blockcount); 1649 byte_cnt = XFS_FSB_TO_B(mp, mval[n].br_blockcount);
1651 bp = xfs_trans_get_buf(tp, mp->m_ddev_targp, d, 1650 bp = xfs_trans_get_buf(tp, mp->m_ddev_targp, d,
1652 BTOBB(byte_cnt), 0); 1651 BTOBB(byte_cnt), 0);
1653 ASSERT(!xfs_buf_geterror(bp)); 1652 if (!bp) {
1653 error = ENOMEM;
1654 goto error2;
1655 }
1654 if (pathlen < byte_cnt) { 1656 if (pathlen < byte_cnt) {
1655 byte_cnt = pathlen; 1657 byte_cnt = pathlen;
1656 } 1658 }
@@ -1732,7 +1734,7 @@ xfs_set_dmattrs(
1732 return error; 1734 return error;
1733 } 1735 }
1734 xfs_ilock(ip, XFS_ILOCK_EXCL); 1736 xfs_ilock(ip, XFS_ILOCK_EXCL);
1735 xfs_trans_ijoin_ref(tp, ip, XFS_ILOCK_EXCL); 1737 xfs_trans_ijoin(tp, ip, XFS_ILOCK_EXCL);
1736 1738
1737 ip->i_d.di_dmevmask = evmask; 1739 ip->i_d.di_dmevmask = evmask;
1738 ip->i_d.di_dmstate = state; 1740 ip->i_d.di_dmstate = state;
@@ -1778,7 +1780,6 @@ xfs_alloc_file_space(
1778 xfs_fileoff_t startoffset_fsb; 1780 xfs_fileoff_t startoffset_fsb;
1779 xfs_fsblock_t firstfsb; 1781 xfs_fsblock_t firstfsb;
1780 int nimaps; 1782 int nimaps;
1781 int bmapi_flag;
1782 int quota_flag; 1783 int quota_flag;
1783 int rt; 1784 int rt;
1784 xfs_trans_t *tp; 1785 xfs_trans_t *tp;
@@ -1806,7 +1807,6 @@ xfs_alloc_file_space(
1806 count = len; 1807 count = len;
1807 imapp = &imaps[0]; 1808 imapp = &imaps[0];
1808 nimaps = 1; 1809 nimaps = 1;
1809 bmapi_flag = XFS_BMAPI_WRITE | alloc_type;
1810 startoffset_fsb = XFS_B_TO_FSBT(mp, offset); 1810 startoffset_fsb = XFS_B_TO_FSBT(mp, offset);
1811 allocatesize_fsb = XFS_B_TO_FSB(mp, count); 1811 allocatesize_fsb = XFS_B_TO_FSB(mp, count);
1812 1812
@@ -1877,16 +1877,12 @@ xfs_alloc_file_space(
1877 if (error) 1877 if (error)
1878 goto error1; 1878 goto error1;
1879 1879
1880 xfs_trans_ijoin(tp, ip); 1880 xfs_trans_ijoin(tp, ip, 0);
1881 1881
1882 /*
1883 * Issue the xfs_bmapi() call to allocate the blocks
1884 */
1885 xfs_bmap_init(&free_list, &firstfsb); 1882 xfs_bmap_init(&free_list, &firstfsb);
1886 error = xfs_bmapi(tp, ip, startoffset_fsb, 1883 error = xfs_bmapi_write(tp, ip, startoffset_fsb,
1887 allocatesize_fsb, bmapi_flag, 1884 allocatesize_fsb, alloc_type, &firstfsb,
1888 &firstfsb, 0, imapp, &nimaps, 1885 0, imapp, &nimaps, &free_list);
1889 &free_list);
1890 if (error) { 1886 if (error) {
1891 goto error0; 1887 goto error0;
1892 } 1888 }
@@ -1976,8 +1972,7 @@ xfs_zero_remaining_bytes(
1976 for (offset = startoff; offset <= endoff; offset = lastoffset + 1) { 1972 for (offset = startoff; offset <= endoff; offset = lastoffset + 1) {
1977 offset_fsb = XFS_B_TO_FSBT(mp, offset); 1973 offset_fsb = XFS_B_TO_FSBT(mp, offset);
1978 nimap = 1; 1974 nimap = 1;
1979 error = xfs_bmapi(NULL, ip, offset_fsb, 1, 0, 1975 error = xfs_bmapi_read(ip, offset_fsb, 1, &imap, &nimap, 0);
1980 NULL, 0, &imap, &nimap, NULL);
1981 if (error || nimap < 1) 1976 if (error || nimap < 1)
1982 break; 1977 break;
1983 ASSERT(imap.br_blockcount >= 1); 1978 ASSERT(imap.br_blockcount >= 1);
@@ -1997,8 +1992,8 @@ xfs_zero_remaining_bytes(
1997 xfsbdstrat(mp, bp); 1992 xfsbdstrat(mp, bp);
1998 error = xfs_buf_iowait(bp); 1993 error = xfs_buf_iowait(bp);
1999 if (error) { 1994 if (error) {
2000 xfs_ioerror_alert("xfs_zero_remaining_bytes(read)", 1995 xfs_buf_ioerror_alert(bp,
2001 mp, bp, XFS_BUF_ADDR(bp)); 1996 "xfs_zero_remaining_bytes(read)");
2002 break; 1997 break;
2003 } 1998 }
2004 memset(bp->b_addr + 1999 memset(bp->b_addr +
@@ -2010,8 +2005,8 @@ xfs_zero_remaining_bytes(
2010 xfsbdstrat(mp, bp); 2005 xfsbdstrat(mp, bp);
2011 error = xfs_buf_iowait(bp); 2006 error = xfs_buf_iowait(bp);
2012 if (error) { 2007 if (error) {
2013 xfs_ioerror_alert("xfs_zero_remaining_bytes(write)", 2008 xfs_buf_ioerror_alert(bp,
2014 mp, bp, XFS_BUF_ADDR(bp)); 2009 "xfs_zero_remaining_bytes(write)");
2015 break; 2010 break;
2016 } 2011 }
2017 } 2012 }
@@ -2076,7 +2071,7 @@ xfs_free_file_space(
2076 if (need_iolock) { 2071 if (need_iolock) {
2077 xfs_ilock(ip, XFS_IOLOCK_EXCL); 2072 xfs_ilock(ip, XFS_IOLOCK_EXCL);
2078 /* wait for the completion of any pending DIOs */ 2073 /* wait for the completion of any pending DIOs */
2079 xfs_ioend_wait(ip); 2074 inode_dio_wait(VFS_I(ip));
2080 } 2075 }
2081 2076
2082 rounding = max_t(uint, 1 << mp->m_sb.sb_blocklog, PAGE_CACHE_SIZE); 2077 rounding = max_t(uint, 1 << mp->m_sb.sb_blocklog, PAGE_CACHE_SIZE);
@@ -2096,8 +2091,8 @@ xfs_free_file_space(
2096 */ 2091 */
2097 if (rt && !xfs_sb_version_hasextflgbit(&mp->m_sb)) { 2092 if (rt && !xfs_sb_version_hasextflgbit(&mp->m_sb)) {
2098 nimap = 1; 2093 nimap = 1;
2099 error = xfs_bmapi(NULL, ip, startoffset_fsb, 2094 error = xfs_bmapi_read(ip, startoffset_fsb, 1,
2100 1, 0, NULL, 0, &imap, &nimap, NULL); 2095 &imap, &nimap, 0);
2101 if (error) 2096 if (error)
2102 goto out_unlock_iolock; 2097 goto out_unlock_iolock;
2103 ASSERT(nimap == 0 || nimap == 1); 2098 ASSERT(nimap == 0 || nimap == 1);
@@ -2111,8 +2106,8 @@ xfs_free_file_space(
2111 startoffset_fsb += mp->m_sb.sb_rextsize - mod; 2106 startoffset_fsb += mp->m_sb.sb_rextsize - mod;
2112 } 2107 }
2113 nimap = 1; 2108 nimap = 1;
2114 error = xfs_bmapi(NULL, ip, endoffset_fsb - 1, 2109 error = xfs_bmapi_read(ip, endoffset_fsb - 1, 1,
2115 1, 0, NULL, 0, &imap, &nimap, NULL); 2110 &imap, &nimap, 0);
2116 if (error) 2111 if (error)
2117 goto out_unlock_iolock; 2112 goto out_unlock_iolock;
2118 ASSERT(nimap == 0 || nimap == 1); 2113 ASSERT(nimap == 0 || nimap == 1);
@@ -2180,7 +2175,7 @@ xfs_free_file_space(
2180 if (error) 2175 if (error)
2181 goto error1; 2176 goto error1;
2182 2177
2183 xfs_trans_ijoin(tp, ip); 2178 xfs_trans_ijoin(tp, ip, 0);
2184 2179
2185 /* 2180 /*
2186 * issue the bunmapi() call to free the blocks 2181 * issue the bunmapi() call to free the blocks
@@ -2353,8 +2348,7 @@ xfs_change_file_space(
2353 } 2348 }
2354 2349
2355 xfs_ilock(ip, XFS_ILOCK_EXCL); 2350 xfs_ilock(ip, XFS_ILOCK_EXCL);
2356 2351 xfs_trans_ijoin(tp, ip, XFS_ILOCK_EXCL);
2357 xfs_trans_ijoin(tp, ip);
2358 2352
2359 if ((attr_flags & XFS_ATTR_DMI) == 0) { 2353 if ((attr_flags & XFS_ATTR_DMI) == 0) {
2360 ip->i_d.di_mode &= ~S_ISUID; 2354 ip->i_d.di_mode &= ~S_ISUID;
@@ -2379,10 +2373,5 @@ xfs_change_file_space(
2379 xfs_trans_log_inode(tp, ip, XFS_ILOG_CORE); 2373 xfs_trans_log_inode(tp, ip, XFS_ILOG_CORE);
2380 if (attr_flags & XFS_ATTR_SYNC) 2374 if (attr_flags & XFS_ATTR_SYNC)
2381 xfs_trans_set_sync(tp); 2375 xfs_trans_set_sync(tp);
2382 2376 return xfs_trans_commit(tp, 0);
2383 error = xfs_trans_commit(tp, 0);
2384
2385 xfs_iunlock(ip, XFS_ILOCK_EXCL);
2386
2387 return error;
2388} 2377}
generated by cgit v1.2.2 (git 2.25.0) at 2024-12-19 11:54:28 -0500