2 * Copyright (c) 2000-2006 Silicon Graphics, Inc.
5 * This program is free software; you can redistribute it and/or
6 * modify it under the terms of the GNU General Public License as
7 * published by the Free Software Foundation.
9 * This program is distributed in the hope that it would be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 * GNU General Public License for more details.
14 * You should have received a copy of the GNU General Public License
15 * along with this program; if not, write the Free Software Foundation,
16 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
20 #include "xfs_shared.h"
21 #include "xfs_format.h"
22 #include "xfs_log_format.h"
23 #include "xfs_trans_resv.h"
24 #include "xfs_mount.h"
25 #include "xfs_inode.h"
26 #include "xfs_btree.h"
27 #include "xfs_bmap_btree.h"
29 #include "xfs_bmap_util.h"
30 #include "xfs_error.h"
31 #include "xfs_trans.h"
32 #include "xfs_trans_space.h"
33 #include "xfs_iomap.h"
34 #include "xfs_trace.h"
35 #include "xfs_icache.h"
36 #include "xfs_quota.h"
37 #include "xfs_dquot_item.h"
38 #include "xfs_dquot.h"
41 #define XFS_WRITEIO_ALIGN(mp,off) (((off) >> mp->m_writeio_log) \
43 #define XFS_WRITE_IMAPS XFS_BMAP_MAX_NMAP
46 xfs_iomap_eof_align_last_fsb(
50 xfs_fileoff_t
*last_fsb
)
52 xfs_extlen_t align
= 0;
55 if (!XFS_IS_REALTIME_INODE(ip
)) {
57 * Round up the allocation request to a stripe unit
58 * (m_dalign) boundary if the file size is >= stripe unit
59 * size, and we are allocating past the allocation eof.
61 * If mounted with the "-o swalloc" option the alignment is
62 * increased from the strip unit size to the stripe width.
64 if (mp
->m_swidth
&& (mp
->m_flags
& XFS_MOUNT_SWALLOC
))
66 else if (mp
->m_dalign
)
69 if (align
&& XFS_ISIZE(ip
) < XFS_FSB_TO_B(mp
, align
))
74 * Always round up the allocation request to an extent boundary
75 * (when file on a real-time subvolume or has di_extsize hint).
79 align
= roundup_64(align
, extsize
);
85 xfs_fileoff_t new_last_fsb
= roundup_64(*last_fsb
, align
);
86 error
= xfs_bmap_eof(ip
, new_last_fsb
, XFS_DATA_FORK
, &eof
);
90 *last_fsb
= new_last_fsb
;
96 xfs_alert_fsblock_zero(
98 xfs_bmbt_irec_t
*imap
)
100 xfs_alert_tag(ip
->i_mount
, XFS_PTAG_FSBLOCK_ZERO
,
101 "Access to block zero in inode %llu "
102 "start_block: %llx start_off: %llx "
103 "blkcnt: %llx extent-state: %x",
104 (unsigned long long)ip
->i_ino
,
105 (unsigned long long)imap
->br_startblock
,
106 (unsigned long long)imap
->br_startoff
,
107 (unsigned long long)imap
->br_blockcount
,
109 return -EFSCORRUPTED
;
113 xfs_iomap_write_direct(
117 xfs_bmbt_irec_t
*imap
,
120 xfs_mount_t
*mp
= ip
->i_mount
;
121 xfs_fileoff_t offset_fsb
;
122 xfs_fileoff_t last_fsb
;
123 xfs_filblks_t count_fsb
, resaligned
;
124 xfs_fsblock_t firstfsb
;
125 xfs_extlen_t extsz
, temp
;
130 xfs_bmap_free_t free_list
;
131 uint qblocks
, resblks
, resrtextents
;
134 int bmapi_flags
= XFS_BMAPI_PREALLOC
;
137 rt
= XFS_IS_REALTIME_INODE(ip
);
138 extsz
= xfs_get_extsz_hint(ip
);
139 lockmode
= XFS_ILOCK_SHARED
; /* locked by caller */
141 ASSERT(xfs_isilocked(ip
, lockmode
));
143 offset_fsb
= XFS_B_TO_FSBT(mp
, offset
);
144 last_fsb
= XFS_B_TO_FSB(mp
, ((xfs_ufsize_t
)(offset
+ count
)));
145 if ((offset
+ count
) > XFS_ISIZE(ip
)) {
147 * Assert that the in-core extent list is present since this can
148 * call xfs_iread_extents() and we only have the ilock shared.
149 * This should be safe because the lock was held around a bmapi
150 * call in the caller and we only need it to access the in-core
153 ASSERT(XFS_IFORK_PTR(ip
, XFS_DATA_FORK
)->if_flags
&
155 error
= xfs_iomap_eof_align_last_fsb(mp
, ip
, extsz
, &last_fsb
);
159 if (nmaps
&& (imap
->br_startblock
== HOLESTARTBLOCK
))
160 last_fsb
= MIN(last_fsb
, (xfs_fileoff_t
)
161 imap
->br_blockcount
+
164 count_fsb
= last_fsb
- offset_fsb
;
165 ASSERT(count_fsb
> 0);
167 resaligned
= count_fsb
;
168 if (unlikely(extsz
)) {
169 if ((temp
= do_mod(offset_fsb
, extsz
)))
171 if ((temp
= do_mod(resaligned
, extsz
)))
172 resaligned
+= extsz
- temp
;
176 resrtextents
= qblocks
= resaligned
;
177 resrtextents
/= mp
->m_sb
.sb_rextsize
;
178 resblks
= XFS_DIOSTRAT_SPACE_RES(mp
, 0);
179 quota_flag
= XFS_QMOPT_RES_RTBLKS
;
182 resblks
= qblocks
= XFS_DIOSTRAT_SPACE_RES(mp
, resaligned
);
183 quota_flag
= XFS_QMOPT_RES_REGBLKS
;
187 * Drop the shared lock acquired by the caller, attach the dquot if
188 * necessary and move on to transaction setup.
190 xfs_iunlock(ip
, lockmode
);
191 error
= xfs_qm_dqattach(ip
, 0);
196 * For DAX, we do not allocate unwritten extents, but instead we zero
197 * the block before we commit the transaction. Ideally we'd like to do
198 * this outside the transaction context, but if we commit and then crash
199 * we may not have zeroed the blocks and this will be exposed on
200 * recovery of the allocation. Hence we must zero before commit.
202 * Further, if we are mapping unwritten extents here, we need to zero
203 * and convert them to written so that we don't need an unwritten extent
204 * callback for DAX. This also means that we need to be able to dip into
205 * the reserve block pool for bmbt block allocation if there is no space
206 * left but we need to do unwritten extent conversion.
208 if (IS_DAX(VFS_I(ip
))) {
209 bmapi_flags
= XFS_BMAPI_CONVERT
| XFS_BMAPI_ZERO
;
210 if (ISUNWRITTEN(imap
)) {
211 tflags
|= XFS_TRANS_RESERVE
;
212 resblks
= XFS_DIOSTRAT_SPACE_RES(mp
, 0) << 1;
215 error
= xfs_trans_alloc(mp
, &M_RES(mp
)->tr_write
, resblks
, resrtextents
,
220 lockmode
= XFS_ILOCK_EXCL
;
221 xfs_ilock(ip
, lockmode
);
223 error
= xfs_trans_reserve_quota_nblks(tp
, ip
, qblocks
, 0, quota_flag
);
225 goto out_trans_cancel
;
227 xfs_trans_ijoin(tp
, ip
, 0);
230 * From this point onwards we overwrite the imap pointer that the
233 xfs_bmap_init(&free_list
, &firstfsb
);
235 error
= xfs_bmapi_write(tp
, ip
, offset_fsb
, count_fsb
,
236 bmapi_flags
, &firstfsb
, resblks
, imap
,
237 &nimaps
, &free_list
);
239 goto out_bmap_cancel
;
242 * Complete the transaction
244 error
= xfs_bmap_finish(&tp
, &free_list
, NULL
);
246 goto out_bmap_cancel
;
248 error
= xfs_trans_commit(tp
);
253 * Copy any maps to caller's array and return any error.
260 if (!(imap
->br_startblock
|| XFS_IS_REALTIME_INODE(ip
)))
261 error
= xfs_alert_fsblock_zero(ip
, imap
);
264 xfs_iunlock(ip
, lockmode
);
268 xfs_bmap_cancel(&free_list
);
269 xfs_trans_unreserve_quota_nblks(tp
, ip
, (long)qblocks
, 0, quota_flag
);
271 xfs_trans_cancel(tp
);
276 * If the caller is doing a write at the end of the file, then extend the
277 * allocation out to the file system's write iosize. We clean up any extra
278 * space left over when the file is closed in xfs_inactive().
280 * If we find we already have delalloc preallocation beyond EOF, don't do more
281 * preallocation as it it not needed.
284 xfs_iomap_eof_want_preallocate(
289 xfs_bmbt_irec_t
*imap
,
293 xfs_fileoff_t start_fsb
;
294 xfs_filblks_t count_fsb
;
296 int found_delalloc
= 0;
299 if (offset
+ count
<= XFS_ISIZE(ip
))
303 * If the file is smaller than the minimum prealloc and we are using
304 * dynamic preallocation, don't do any preallocation at all as it is
305 * likely this is the only write to the file that is going to be done.
307 if (!(mp
->m_flags
& XFS_MOUNT_DFLT_IOSIZE
) &&
308 XFS_ISIZE(ip
) < XFS_FSB_TO_B(mp
, mp
->m_writeio_blocks
))
312 * If there are any real blocks past eof, then don't
313 * do any speculative allocation.
315 start_fsb
= XFS_B_TO_FSBT(mp
, ((xfs_ufsize_t
)(offset
+ count
- 1)));
316 count_fsb
= XFS_B_TO_FSB(mp
, mp
->m_super
->s_maxbytes
);
317 while (count_fsb
> 0) {
319 error
= xfs_bmapi_read(ip
, start_fsb
, count_fsb
, imap
, &imaps
,
323 for (n
= 0; n
< imaps
; n
++) {
324 if ((imap
[n
].br_startblock
!= HOLESTARTBLOCK
) &&
325 (imap
[n
].br_startblock
!= DELAYSTARTBLOCK
))
327 start_fsb
+= imap
[n
].br_blockcount
;
328 count_fsb
-= imap
[n
].br_blockcount
;
330 if (imap
[n
].br_startblock
== DELAYSTARTBLOCK
)
340 * Determine the initial size of the preallocation. We are beyond the current
341 * EOF here, but we need to take into account whether this is a sparse write or
342 * an extending write when determining the preallocation size. Hence we need to
343 * look up the extent that ends at the current write offset and use the result
344 * to determine the preallocation size.
346 * If the extent is a hole, then preallocation is essentially disabled.
347 * Otherwise we take the size of the preceeding data extent as the basis for the
348 * preallocation size. If the size of the extent is greater than half the
349 * maximum extent length, then use the current offset as the basis. This ensures
350 * that for large files the preallocation size always extends to MAXEXTLEN
351 * rather than falling short due to things like stripe unit/width alignment of
355 xfs_iomap_eof_prealloc_initial_size(
356 struct xfs_mount
*mp
,
357 struct xfs_inode
*ip
,
359 xfs_bmbt_irec_t
*imap
,
362 xfs_fileoff_t start_fsb
;
366 ASSERT(nimaps
>= imaps
);
368 /* if we are using a specific prealloc size, return now */
369 if (mp
->m_flags
& XFS_MOUNT_DFLT_IOSIZE
)
372 /* If the file is small, then use the minimum prealloc */
373 if (XFS_ISIZE(ip
) < XFS_FSB_TO_B(mp
, mp
->m_dalign
))
377 * As we write multiple pages, the offset will always align to the
378 * start of a page and hence point to a hole at EOF. i.e. if the size is
379 * 4096 bytes, we only have one block at FSB 0, but XFS_B_TO_FSB(4096)
380 * will return FSB 1. Hence if there are blocks in the file, we want to
381 * point to the block prior to the EOF block and not the hole that maps
382 * directly at @offset.
384 start_fsb
= XFS_B_TO_FSB(mp
, offset
);
387 error
= xfs_bmapi_read(ip
, start_fsb
, 1, imap
, &imaps
, XFS_BMAPI_ENTIRE
);
392 if (imap
[0].br_startblock
== HOLESTARTBLOCK
)
394 if (imap
[0].br_blockcount
<= (MAXEXTLEN
>> 1))
395 return imap
[0].br_blockcount
<< 1;
396 return XFS_B_TO_FSB(mp
, offset
);
400 xfs_quota_need_throttle(
401 struct xfs_inode
*ip
,
403 xfs_fsblock_t alloc_blocks
)
405 struct xfs_dquot
*dq
= xfs_inode_dquot(ip
, type
);
407 if (!dq
|| !xfs_this_quota_on(ip
->i_mount
, type
))
410 /* no hi watermark, no throttle */
411 if (!dq
->q_prealloc_hi_wmark
)
414 /* under the lo watermark, no throttle */
415 if (dq
->q_res_bcount
+ alloc_blocks
< dq
->q_prealloc_lo_wmark
)
422 xfs_quota_calc_throttle(
423 struct xfs_inode
*ip
,
425 xfs_fsblock_t
*qblocks
,
431 struct xfs_dquot
*dq
= xfs_inode_dquot(ip
, type
);
433 /* no dq, or over hi wmark, squash the prealloc completely */
434 if (!dq
|| dq
->q_res_bcount
>= dq
->q_prealloc_hi_wmark
) {
440 freesp
= dq
->q_prealloc_hi_wmark
- dq
->q_res_bcount
;
441 if (freesp
< dq
->q_low_space
[XFS_QLOWSP_5_PCNT
]) {
443 if (freesp
< dq
->q_low_space
[XFS_QLOWSP_3_PCNT
])
445 if (freesp
< dq
->q_low_space
[XFS_QLOWSP_1_PCNT
])
449 if (freesp
< *qfreesp
)
452 /* only overwrite the throttle values if we are more aggressive */
453 if ((freesp
>> shift
) < (*qblocks
>> *qshift
)) {
460 * If we don't have a user specified preallocation size, dynamically increase
461 * the preallocation size as the size of the file grows. Cap the maximum size
462 * at a single extent or less if the filesystem is near full. The closer the
463 * filesystem is to full, the smaller the maximum prealocation.
466 xfs_iomap_prealloc_size(
467 struct xfs_mount
*mp
,
468 struct xfs_inode
*ip
,
470 struct xfs_bmbt_irec
*imap
,
473 xfs_fsblock_t alloc_blocks
= 0;
476 xfs_fsblock_t qblocks
;
479 alloc_blocks
= xfs_iomap_eof_prealloc_initial_size(mp
, ip
, offset
,
483 qblocks
= alloc_blocks
;
486 * MAXEXTLEN is not a power of two value but we round the prealloc down
487 * to the nearest power of two value after throttling. To prevent the
488 * round down from unconditionally reducing the maximum supported prealloc
489 * size, we round up first, apply appropriate throttling, round down and
490 * cap the value to MAXEXTLEN.
492 alloc_blocks
= XFS_FILEOFF_MIN(roundup_pow_of_two(MAXEXTLEN
),
495 freesp
= percpu_counter_read_positive(&mp
->m_fdblocks
);
496 if (freesp
< mp
->m_low_space
[XFS_LOWSP_5_PCNT
]) {
498 if (freesp
< mp
->m_low_space
[XFS_LOWSP_4_PCNT
])
500 if (freesp
< mp
->m_low_space
[XFS_LOWSP_3_PCNT
])
502 if (freesp
< mp
->m_low_space
[XFS_LOWSP_2_PCNT
])
504 if (freesp
< mp
->m_low_space
[XFS_LOWSP_1_PCNT
])
509 * Check each quota to cap the prealloc size, provide a shift value to
510 * throttle with and adjust amount of available space.
512 if (xfs_quota_need_throttle(ip
, XFS_DQ_USER
, alloc_blocks
))
513 xfs_quota_calc_throttle(ip
, XFS_DQ_USER
, &qblocks
, &qshift
,
515 if (xfs_quota_need_throttle(ip
, XFS_DQ_GROUP
, alloc_blocks
))
516 xfs_quota_calc_throttle(ip
, XFS_DQ_GROUP
, &qblocks
, &qshift
,
518 if (xfs_quota_need_throttle(ip
, XFS_DQ_PROJ
, alloc_blocks
))
519 xfs_quota_calc_throttle(ip
, XFS_DQ_PROJ
, &qblocks
, &qshift
,
523 * The final prealloc size is set to the minimum of free space available
524 * in each of the quotas and the overall filesystem.
526 * The shift throttle value is set to the maximum value as determined by
527 * the global low free space values and per-quota low free space values.
529 alloc_blocks
= MIN(alloc_blocks
, qblocks
);
530 shift
= MAX(shift
, qshift
);
533 alloc_blocks
>>= shift
;
535 * rounddown_pow_of_two() returns an undefined result if we pass in
539 alloc_blocks
= rounddown_pow_of_two(alloc_blocks
);
540 if (alloc_blocks
> MAXEXTLEN
)
541 alloc_blocks
= MAXEXTLEN
;
544 * If we are still trying to allocate more space than is
545 * available, squash the prealloc hard. This can happen if we
546 * have a large file on a small filesystem and the above
547 * lowspace thresholds are smaller than MAXEXTLEN.
549 while (alloc_blocks
&& alloc_blocks
>= freesp
)
553 if (alloc_blocks
< mp
->m_writeio_blocks
)
554 alloc_blocks
= mp
->m_writeio_blocks
;
556 trace_xfs_iomap_prealloc_size(ip
, alloc_blocks
, shift
,
557 mp
->m_writeio_blocks
);
563 xfs_iomap_write_delay(
567 xfs_bmbt_irec_t
*ret_imap
)
569 xfs_mount_t
*mp
= ip
->i_mount
;
570 xfs_fileoff_t offset_fsb
;
571 xfs_fileoff_t last_fsb
;
572 xfs_off_t aligned_offset
;
573 xfs_fileoff_t ioalign
;
576 xfs_bmbt_irec_t imap
[XFS_WRITE_IMAPS
];
580 ASSERT(xfs_isilocked(ip
, XFS_ILOCK_EXCL
));
583 * Make sure that the dquots are there. This doesn't hold
584 * the ilock across a disk read.
586 error
= xfs_qm_dqattach_locked(ip
, 0);
590 extsz
= xfs_get_extsz_hint(ip
);
591 offset_fsb
= XFS_B_TO_FSBT(mp
, offset
);
593 error
= xfs_iomap_eof_want_preallocate(mp
, ip
, offset
, count
,
594 imap
, XFS_WRITE_IMAPS
, &prealloc
);
600 xfs_fsblock_t alloc_blocks
;
602 alloc_blocks
= xfs_iomap_prealloc_size(mp
, ip
, offset
, imap
,
605 aligned_offset
= XFS_WRITEIO_ALIGN(mp
, (offset
+ count
- 1));
606 ioalign
= XFS_B_TO_FSBT(mp
, aligned_offset
);
607 last_fsb
= ioalign
+ alloc_blocks
;
609 last_fsb
= XFS_B_TO_FSB(mp
, ((xfs_ufsize_t
)(offset
+ count
)));
612 if (prealloc
|| extsz
) {
613 error
= xfs_iomap_eof_align_last_fsb(mp
, ip
, extsz
, &last_fsb
);
619 * Make sure preallocation does not create extents beyond the range we
620 * actually support in this filesystem.
622 if (last_fsb
> XFS_B_TO_FSB(mp
, mp
->m_super
->s_maxbytes
))
623 last_fsb
= XFS_B_TO_FSB(mp
, mp
->m_super
->s_maxbytes
);
625 ASSERT(last_fsb
> offset_fsb
);
627 nimaps
= XFS_WRITE_IMAPS
;
628 error
= xfs_bmapi_delay(ip
, offset_fsb
, last_fsb
- offset_fsb
,
629 imap
, &nimaps
, XFS_BMAPI_ENTIRE
);
640 * If bmapi returned us nothing, we got either ENOSPC or EDQUOT. Retry
641 * without EOF preallocation.
644 trace_xfs_delalloc_enospc(ip
, offset
, count
);
650 return error
? error
: -ENOSPC
;
653 if (!(imap
[0].br_startblock
|| XFS_IS_REALTIME_INODE(ip
)))
654 return xfs_alert_fsblock_zero(ip
, &imap
[0]);
657 * Tag the inode as speculatively preallocated so we can reclaim this
658 * space on demand, if necessary.
661 xfs_inode_set_eofblocks_tag(ip
);
668 * Pass in a delayed allocate extent, convert it to real extents;
669 * return to the caller the extent we create which maps on top of
670 * the originating callers request.
672 * Called without a lock on the inode.
674 * We no longer bother to look at the incoming map - all we have to
675 * guarantee is that whatever we allocate fills the required range.
678 xfs_iomap_write_allocate(
681 xfs_bmbt_irec_t
*imap
)
683 xfs_mount_t
*mp
= ip
->i_mount
;
684 xfs_fileoff_t offset_fsb
, last_block
;
685 xfs_fileoff_t end_fsb
, map_start_fsb
;
686 xfs_fsblock_t first_block
;
687 xfs_bmap_free_t free_list
;
688 xfs_filblks_t count_fsb
;
695 * Make sure that the dquots are there.
697 error
= xfs_qm_dqattach(ip
, 0);
701 offset_fsb
= XFS_B_TO_FSBT(mp
, offset
);
702 count_fsb
= imap
->br_blockcount
;
703 map_start_fsb
= imap
->br_startoff
;
705 XFS_STATS_ADD(mp
, xs_xstrat_bytes
, XFS_FSB_TO_B(mp
, count_fsb
));
707 while (count_fsb
!= 0) {
709 * Set up a transaction with which to allocate the
710 * backing store for the file. Do allocations in a
711 * loop until we get some space in the range we are
712 * interested in. The other space that might be allocated
713 * is in the delayed allocation extent on which we sit
714 * but before our buffer starts.
718 while (nimaps
== 0) {
719 nres
= XFS_EXTENTADD_SPACE_RES(mp
, XFS_DATA_FORK
);
721 error
= xfs_trans_alloc(mp
, &M_RES(mp
)->tr_write
, nres
,
722 0, XFS_TRANS_RESERVE
, &tp
);
726 xfs_ilock(ip
, XFS_ILOCK_EXCL
);
727 xfs_trans_ijoin(tp
, ip
, 0);
729 xfs_bmap_init(&free_list
, &first_block
);
732 * it is possible that the extents have changed since
733 * we did the read call as we dropped the ilock for a
734 * while. We have to be careful about truncates or hole
735 * punchs here - we are not allowed to allocate
736 * non-delalloc blocks here.
738 * The only protection against truncation is the pages
739 * for the range we are being asked to convert are
740 * locked and hence a truncate will block on them
743 * As a result, if we go beyond the range we really
744 * need and hit an delalloc extent boundary followed by
745 * a hole while we have excess blocks in the map, we
746 * will fill the hole incorrectly and overrun the
747 * transaction reservation.
749 * Using a single map prevents this as we are forced to
750 * check each map we look for overlap with the desired
751 * range and abort as soon as we find it. Also, given
752 * that we only return a single map, having one beyond
753 * what we can return is probably a bit silly.
755 * We also need to check that we don't go beyond EOF;
756 * this is a truncate optimisation as a truncate sets
757 * the new file size before block on the pages we
758 * currently have locked under writeback. Because they
759 * are about to be tossed, we don't need to write them
763 end_fsb
= XFS_B_TO_FSB(mp
, XFS_ISIZE(ip
));
764 error
= xfs_bmap_last_offset(ip
, &last_block
,
769 last_block
= XFS_FILEOFF_MAX(last_block
, end_fsb
);
770 if ((map_start_fsb
+ count_fsb
) > last_block
) {
771 count_fsb
= last_block
- map_start_fsb
;
772 if (count_fsb
== 0) {
779 * From this point onwards we overwrite the imap
780 * pointer that the caller gave to us.
782 error
= xfs_bmapi_write(tp
, ip
, map_start_fsb
,
783 count_fsb
, 0, &first_block
,
789 error
= xfs_bmap_finish(&tp
, &free_list
, NULL
);
793 error
= xfs_trans_commit(tp
);
797 xfs_iunlock(ip
, XFS_ILOCK_EXCL
);
801 * See if we were able to allocate an extent that
802 * covers at least part of the callers request
804 if (!(imap
->br_startblock
|| XFS_IS_REALTIME_INODE(ip
)))
805 return xfs_alert_fsblock_zero(ip
, imap
);
807 if ((offset_fsb
>= imap
->br_startoff
) &&
808 (offset_fsb
< (imap
->br_startoff
+
809 imap
->br_blockcount
))) {
810 XFS_STATS_INC(mp
, xs_xstrat_quick
);
815 * So far we have not mapped the requested part of the
816 * file, just surrounding data, try again.
818 count_fsb
-= imap
->br_blockcount
;
819 map_start_fsb
= imap
->br_startoff
+ imap
->br_blockcount
;
823 xfs_bmap_cancel(&free_list
);
824 xfs_trans_cancel(tp
);
826 xfs_iunlock(ip
, XFS_ILOCK_EXCL
);
831 xfs_iomap_write_unwritten(
836 xfs_mount_t
*mp
= ip
->i_mount
;
837 xfs_fileoff_t offset_fsb
;
838 xfs_filblks_t count_fsb
;
839 xfs_filblks_t numblks_fsb
;
840 xfs_fsblock_t firstfsb
;
843 xfs_bmbt_irec_t imap
;
844 xfs_bmap_free_t free_list
;
849 trace_xfs_unwritten_convert(ip
, offset
, count
);
851 offset_fsb
= XFS_B_TO_FSBT(mp
, offset
);
852 count_fsb
= XFS_B_TO_FSB(mp
, (xfs_ufsize_t
)offset
+ count
);
853 count_fsb
= (xfs_filblks_t
)(count_fsb
- offset_fsb
);
856 * Reserve enough blocks in this transaction for two complete extent
857 * btree splits. We may be converting the middle part of an unwritten
858 * extent and in this case we will insert two new extents in the btree
859 * each of which could cause a full split.
861 * This reservation amount will be used in the first call to
862 * xfs_bmbt_split() to select an AG with enough space to satisfy the
863 * rest of the operation.
865 resblks
= XFS_DIOSTRAT_SPACE_RES(mp
, 0) << 1;
869 * Set up a transaction to convert the range of extents
870 * from unwritten to real. Do allocations in a loop until
871 * we have covered the range passed in.
873 * Note that we can't risk to recursing back into the filesystem
874 * here as we might be asked to write out the same inode that we
875 * complete here and might deadlock on the iolock.
877 error
= xfs_trans_alloc(mp
, &M_RES(mp
)->tr_write
, resblks
, 0,
878 XFS_TRANS_RESERVE
| XFS_TRANS_NOFS
, &tp
);
882 xfs_ilock(ip
, XFS_ILOCK_EXCL
);
883 xfs_trans_ijoin(tp
, ip
, 0);
886 * Modify the unwritten extent state of the buffer.
888 xfs_bmap_init(&free_list
, &firstfsb
);
890 error
= xfs_bmapi_write(tp
, ip
, offset_fsb
, count_fsb
,
891 XFS_BMAPI_CONVERT
, &firstfsb
, resblks
,
892 &imap
, &nimaps
, &free_list
);
894 goto error_on_bmapi_transaction
;
897 * Log the updated inode size as we go. We have to be careful
898 * to only log it up to the actual write offset if it is
899 * halfway into a block.
901 i_size
= XFS_FSB_TO_B(mp
, offset_fsb
+ count_fsb
);
902 if (i_size
> offset
+ count
)
903 i_size
= offset
+ count
;
905 i_size
= xfs_new_eof(ip
, i_size
);
907 ip
->i_d
.di_size
= i_size
;
908 xfs_trans_log_inode(tp
, ip
, XFS_ILOG_CORE
);
911 error
= xfs_bmap_finish(&tp
, &free_list
, NULL
);
913 goto error_on_bmapi_transaction
;
915 error
= xfs_trans_commit(tp
);
916 xfs_iunlock(ip
, XFS_ILOCK_EXCL
);
920 if (!(imap
.br_startblock
|| XFS_IS_REALTIME_INODE(ip
)))
921 return xfs_alert_fsblock_zero(ip
, &imap
);
923 if ((numblks_fsb
= imap
.br_blockcount
) == 0) {
925 * The numblks_fsb value should always get
926 * smaller, otherwise the loop is stuck.
928 ASSERT(imap
.br_blockcount
);
931 offset_fsb
+= numblks_fsb
;
932 count_fsb
-= numblks_fsb
;
933 } while (count_fsb
> 0);
937 error_on_bmapi_transaction
:
938 xfs_bmap_cancel(&free_list
);
939 xfs_trans_cancel(tp
);
940 xfs_iunlock(ip
, XFS_ILOCK_EXCL
);