2 * Copyright (c) 2000-2004 Silicon Graphics, Inc. All Rights Reserved.
4 * This program is free software; you can redistribute it and/or modify it
5 * under the terms of version 2 of the GNU General Public License as
6 * published by the Free Software Foundation.
8 * This program is distributed in the hope that it would be useful, but
9 * WITHOUT ANY WARRANTY; without even the implied warranty of
10 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
12 * Further, this software is distributed without any warranty that it is
13 * free of the rightful claim of any third person regarding infringement
14 * or the like. Any license provided herein, whether implied or
15 * otherwise, applies only to this software file. Patent licenses, if
16 * any, provided herein do not apply to combinations of this program with
17 * other software, or any other product whatsoever.
19 * You should have received a copy of the GNU General Public License along
20 * with this program; if not, write the Free Software Foundation, Inc., 59
21 * Temple Place - Suite 330, Boston MA 02111-1307, USA.
23 * Contact information: Silicon Graphics, Inc., 1600 Amphitheatre Pkwy,
24 * Mountain View, CA 94043, or:
28 * For further information regarding this notice, see:
30 * http://oss.sgi.com/projects/GenInfo/SGIGPLNoticeExplan/
38 #include "xfs_trans.h"
43 #include "xfs_alloc.h"
44 #include "xfs_dmapi.h"
45 #include "xfs_quota.h"
46 #include "xfs_mount.h"
47 #include "xfs_alloc_btree.h"
48 #include "xfs_bmap_btree.h"
49 #include "xfs_ialloc_btree.h"
50 #include "xfs_btree.h"
51 #include "xfs_ialloc.h"
52 #include "xfs_attr_sf.h"
53 #include "xfs_dir_sf.h"
54 #include "xfs_dir2_sf.h"
55 #include "xfs_dinode.h"
56 #include "xfs_inode.h"
59 #include "xfs_rtalloc.h"
60 #include "xfs_error.h"
61 #include "xfs_itable.h"
67 #include "xfs_buf_item.h"
68 #include "xfs_trans_space.h"
69 #include "xfs_utils.h"
70 #include "xfs_iomap.h"
72 #if defined(XFS_RW_TRACE)
74 xfs_iomap_enter_trace(
80 xfs_inode_t
*ip
= XFS_IO_INODE(io
);
85 ktrace_enter(ip
->i_rwtrace
,
86 (void *)((unsigned long)tag
),
88 (void *)((unsigned long)((ip
->i_d
.di_size
>> 32) & 0xffffffff)),
89 (void *)((unsigned long)(ip
->i_d
.di_size
& 0xffffffff)),
90 (void *)((unsigned long)((offset
>> 32) & 0xffffffff)),
91 (void *)((unsigned long)(offset
& 0xffffffff)),
92 (void *)((unsigned long)count
),
93 (void *)((unsigned long)((io
->io_new_size
>> 32) & 0xffffffff)),
94 (void *)((unsigned long)(io
->io_new_size
& 0xffffffff)),
111 xfs_bmbt_irec_t
*imapp
,
114 xfs_inode_t
*ip
= XFS_IO_INODE(io
);
119 ktrace_enter(ip
->i_rwtrace
,
120 (void *)((unsigned long)tag
),
122 (void *)((unsigned long)((ip
->i_d
.di_size
>> 32) & 0xffffffff)),
123 (void *)((unsigned long)(ip
->i_d
.di_size
& 0xffffffff)),
124 (void *)((unsigned long)((offset
>> 32) & 0xffffffff)),
125 (void *)((unsigned long)(offset
& 0xffffffff)),
126 (void *)((unsigned long)count
),
127 (void *)((unsigned long)flags
),
128 (void *)((unsigned long)((iomapp
->iomap_offset
>> 32) & 0xffffffff)),
129 (void *)((unsigned long)(iomapp
->iomap_offset
& 0xffffffff)),
130 (void *)((unsigned long)(iomapp
->iomap_delta
)),
131 (void *)((unsigned long)(iomapp
->iomap_bsize
)),
132 (void *)((unsigned long)(iomapp
->iomap_bn
)),
133 (void *)(__psint_t
)(imapp
->br_startoff
),
134 (void *)((unsigned long)(imapp
->br_blockcount
)),
135 (void *)(__psint_t
)(imapp
->br_startblock
));
138 #define xfs_iomap_enter_trace(tag, io, offset, count)
139 #define xfs_iomap_map_trace(tag, io, offset, count, iomapp, imapp, flags)
142 #define XFS_WRITEIO_ALIGN(mp,off) (((off) >> mp->m_writeio_log) \
143 << mp->m_writeio_log)
144 #define XFS_STRAT_WRITE_IMAPS 2
145 #define XFS_WRITE_IMAPS XFS_BMAP_MAX_NMAP
151 xfs_bmbt_irec_t
*imap
,
153 int imaps
, /* Number of imap entries */
154 int iomaps
, /* Number of iomap entries */
160 xfs_fsblock_t start_block
;
163 nisize
= XFS_SIZE(mp
, io
);
164 if (io
->io_new_size
> nisize
)
165 nisize
= io
->io_new_size
;
167 for (pbm
= 0; imaps
&& pbm
< iomaps
; imaps
--, iomapp
++, imap
++, pbm
++) {
168 iomapp
->iomap_offset
= XFS_FSB_TO_B(mp
, imap
->br_startoff
);
169 iomapp
->iomap_delta
= offset
- iomapp
->iomap_offset
;
170 iomapp
->iomap_bsize
= XFS_FSB_TO_B(mp
, imap
->br_blockcount
);
171 iomapp
->iomap_flags
= flags
;
173 if (io
->io_flags
& XFS_IOCORE_RT
) {
174 iomapp
->iomap_flags
|= IOMAP_REALTIME
;
175 iomapp
->iomap_target
= mp
->m_rtdev_targp
;
177 iomapp
->iomap_target
= mp
->m_ddev_targp
;
179 start_block
= imap
->br_startblock
;
180 if (start_block
== HOLESTARTBLOCK
) {
181 iomapp
->iomap_bn
= IOMAP_DADDR_NULL
;
182 iomapp
->iomap_flags
|= IOMAP_HOLE
;
183 } else if (start_block
== DELAYSTARTBLOCK
) {
184 iomapp
->iomap_bn
= IOMAP_DADDR_NULL
;
185 iomapp
->iomap_flags
|= IOMAP_DELAY
;
187 iomapp
->iomap_bn
= XFS_FSB_TO_DB_IO(io
, start_block
);
188 if (ISUNWRITTEN(imap
))
189 iomapp
->iomap_flags
|= IOMAP_UNWRITTEN
;
192 if ((iomapp
->iomap_offset
+ iomapp
->iomap_bsize
) >= nisize
) {
193 iomapp
->iomap_flags
|= IOMAP_EOF
;
196 offset
+= iomapp
->iomap_bsize
- iomapp
->iomap_delta
;
198 return pbm
; /* Return the number filled */
210 xfs_mount_t
*mp
= io
->io_mount
;
211 xfs_fileoff_t offset_fsb
, end_fsb
;
214 xfs_bmbt_irec_t imap
;
219 if (XFS_FORCED_SHUTDOWN(mp
))
220 return XFS_ERROR(EIO
);
223 (BMAPI_READ
| BMAPI_WRITE
| BMAPI_ALLOCATE
|
224 BMAPI_UNWRITTEN
| BMAPI_DEVICE
)) {
226 xfs_iomap_enter_trace(XFS_IOMAP_READ_ENTER
, io
, offset
, count
);
227 lockmode
= XFS_LCK_MAP_SHARED(mp
, io
);
228 bmapi_flags
= XFS_BMAPI_ENTIRE
;
229 if (flags
& BMAPI_IGNSTATE
)
230 bmapi_flags
|= XFS_BMAPI_IGSTATE
;
233 xfs_iomap_enter_trace(XFS_IOMAP_WRITE_ENTER
, io
, offset
, count
);
234 lockmode
= XFS_ILOCK_EXCL
|XFS_EXTSIZE_WR
;
236 XFS_ILOCK(mp
, io
, lockmode
);
239 xfs_iomap_enter_trace(XFS_IOMAP_ALLOC_ENTER
, io
, offset
, count
);
240 lockmode
= XFS_ILOCK_SHARED
|XFS_EXTSIZE_RD
;
241 bmapi_flags
= XFS_BMAPI_ENTIRE
;
242 /* Attempt non-blocking lock */
243 if (flags
& BMAPI_TRYLOCK
) {
244 if (!XFS_ILOCK_NOWAIT(mp
, io
, lockmode
))
245 return XFS_ERROR(EAGAIN
);
247 XFS_ILOCK(mp
, io
, lockmode
);
250 case BMAPI_UNWRITTEN
:
253 lockmode
= XFS_LCK_MAP_SHARED(mp
, io
);
254 iomapp
->iomap_target
= io
->io_flags
& XFS_IOCORE_RT
?
255 mp
->m_rtdev_targp
: mp
->m_ddev_targp
;
263 ASSERT(offset
<= mp
->m_maxioffset
);
264 if ((xfs_fsize_t
)offset
+ count
> mp
->m_maxioffset
)
265 count
= mp
->m_maxioffset
- offset
;
266 end_fsb
= XFS_B_TO_FSB(mp
, (xfs_ufsize_t
)offset
+ count
);
267 offset_fsb
= XFS_B_TO_FSBT(mp
, offset
);
269 error
= XFS_BMAPI(mp
, NULL
, io
, offset_fsb
,
270 (xfs_filblks_t
)(end_fsb
- offset_fsb
),
271 bmapi_flags
, NULL
, 0, &imap
,
278 switch (flags
& (BMAPI_WRITE
|BMAPI_ALLOCATE
|BMAPI_UNWRITTEN
)) {
280 /* If we found an extent, return it */
282 (imap
.br_startblock
!= HOLESTARTBLOCK
) &&
283 (imap
.br_startblock
!= DELAYSTARTBLOCK
)) {
284 xfs_iomap_map_trace(XFS_IOMAP_WRITE_MAP
, io
,
285 offset
, count
, iomapp
, &imap
, flags
);
289 if (flags
& (BMAPI_DIRECT
|BMAPI_MMAP
)) {
290 error
= XFS_IOMAP_WRITE_DIRECT(mp
, io
, offset
,
291 count
, flags
, &imap
, &nimaps
, nimaps
);
293 error
= XFS_IOMAP_WRITE_DELAY(mp
, io
, offset
, count
,
294 flags
, &imap
, &nimaps
);
297 xfs_iomap_map_trace(XFS_IOMAP_ALLOC_MAP
, io
,
298 offset
, count
, iomapp
, &imap
, flags
);
300 iomap_flags
= IOMAP_NEW
;
303 /* If we found an extent, return it */
304 XFS_IUNLOCK(mp
, io
, lockmode
);
307 if (nimaps
&& !ISNULLSTARTBLOCK(imap
.br_startblock
)) {
308 xfs_iomap_map_trace(XFS_IOMAP_WRITE_MAP
, io
,
309 offset
, count
, iomapp
, &imap
, flags
);
313 error
= XFS_IOMAP_WRITE_ALLOCATE(mp
, io
, offset
, count
,
316 case BMAPI_UNWRITTEN
:
318 error
= XFS_IOMAP_WRITE_UNWRITTEN(mp
, io
, offset
, count
);
324 *niomaps
= xfs_imap_to_bmap(io
, offset
, &imap
,
325 iomapp
, nimaps
, *niomaps
, iomap_flags
);
326 } else if (niomaps
) {
332 XFS_IUNLOCK(mp
, io
, lockmode
);
333 return XFS_ERROR(error
);
344 if (ip
->i_delayed_blks
) {
345 xfs_iunlock(ip
, XFS_ILOCK_EXCL
);
347 xfs_ilock(ip
, XFS_ILOCK_EXCL
);
350 *ioflags
|= BMAPI_SYNC
;
356 *ioflags
|= BMAPI_SYNC
;
359 xfs_iunlock(ip
, XFS_ILOCK_EXCL
);
360 xfs_flush_device(ip
);
361 xfs_ilock(ip
, XFS_ILOCK_EXCL
);
369 xfs_iomap_write_direct(
374 xfs_bmbt_irec_t
*ret_imap
,
378 xfs_mount_t
*mp
= ip
->i_mount
;
379 xfs_iocore_t
*io
= &ip
->i_iocore
;
380 xfs_fileoff_t offset_fsb
;
381 xfs_fileoff_t last_fsb
;
382 xfs_filblks_t count_fsb
;
384 xfs_fsblock_t firstfsb
;
391 xfs_bmbt_irec_t imap
[XFS_WRITE_IMAPS
], *imapp
;
392 xfs_bmap_free_t free_list
;
394 xfs_filblks_t qblocks
, resblks
;
399 * Make sure that the dquots are there. This doesn't hold
400 * the ilock across a disk read.
402 error
= XFS_QM_DQATTACH(ip
->i_mount
, ip
, XFS_QMOPT_ILOCKED
);
404 return XFS_ERROR(error
);
406 maps
= min(XFS_WRITE_IMAPS
, *nmaps
);
409 isize
= ip
->i_d
.di_size
;
410 aeof
= (offset
+ count
) > isize
;
412 if (io
->io_new_size
> isize
)
413 isize
= io
->io_new_size
;
415 offset_fsb
= XFS_B_TO_FSBT(mp
, offset
);
416 last_fsb
= XFS_B_TO_FSB(mp
, ((xfs_ufsize_t
)(offset
+ count
)));
417 count_fsb
= last_fsb
- offset_fsb
;
418 if (found
&& (ret_imap
->br_startblock
== HOLESTARTBLOCK
)) {
419 xfs_fileoff_t map_last_fsb
;
421 map_last_fsb
= ret_imap
->br_blockcount
+ ret_imap
->br_startoff
;
422 if (map_last_fsb
< last_fsb
) {
423 last_fsb
= map_last_fsb
;
424 count_fsb
= last_fsb
- offset_fsb
;
426 ASSERT(count_fsb
> 0);
430 * Determine if reserving space on the data or realtime partition.
432 if ((rt
= XFS_IS_REALTIME_INODE(ip
))) {
435 if (!(extsz
= ip
->i_d
.di_extsize
))
436 extsz
= mp
->m_sb
.sb_rextsize
;
437 resrtextents
= qblocks
= (count_fsb
+ extsz
- 1);
438 do_div(resrtextents
, mp
->m_sb
.sb_rextsize
);
439 resblks
= XFS_DIOSTRAT_SPACE_RES(mp
, 0);
440 quota_flag
= XFS_QMOPT_RES_RTBLKS
;
443 resblks
= qblocks
= XFS_DIOSTRAT_SPACE_RES(mp
, count_fsb
);
444 quota_flag
= XFS_QMOPT_RES_REGBLKS
;
448 * Allocate and setup the transaction
450 xfs_iunlock(ip
, XFS_ILOCK_EXCL
);
451 tp
= xfs_trans_alloc(mp
, XFS_TRANS_DIOSTRAT
);
452 error
= xfs_trans_reserve(tp
, resblks
,
453 XFS_WRITE_LOG_RES(mp
), resrtextents
,
454 XFS_TRANS_PERM_LOG_RES
,
455 XFS_WRITE_LOG_COUNT
);
458 * Check for running out of space, note: need lock to return
461 xfs_trans_cancel(tp
, 0);
462 xfs_ilock(ip
, XFS_ILOCK_EXCL
);
466 if (XFS_TRANS_RESERVE_QUOTA_NBLKS(mp
, tp
, ip
, qblocks
, 0, quota_flag
)) {
471 bmapi_flag
= XFS_BMAPI_WRITE
;
472 xfs_trans_ijoin(tp
, ip
, XFS_ILOCK_EXCL
);
473 xfs_trans_ihold(tp
, ip
);
475 if (!(flags
& BMAPI_MMAP
) && (offset
< ip
->i_d
.di_size
|| rt
))
476 bmapi_flag
|= XFS_BMAPI_PREALLOC
;
479 * Issue the bmapi() call to allocate the blocks
481 XFS_BMAP_INIT(&free_list
, &firstfsb
);
484 error
= xfs_bmapi(tp
, ip
, offset_fsb
, count_fsb
,
485 bmapi_flag
, &firstfsb
, 0, imapp
, &nimaps
, &free_list
);
490 * Complete the transaction
492 error
= xfs_bmap_finish(&tp
, &free_list
, firstfsb
, &committed
);
495 error
= xfs_trans_commit(tp
, XFS_TRANS_RELEASE_LOG_RES
, NULL
);
500 * Copy any maps to caller's array and return any error.
509 if ( !(io
->io_flags
& XFS_IOCORE_RT
) && !ret_imap
->br_startblock
) {
510 cmn_err(CE_PANIC
,"Access to block zero: fs <%s> inode: %lld "
511 "start_block : %llx start_off : %llx blkcnt : %llx "
512 "extent-state : %x \n",
513 (ip
->i_mount
)->m_fsname
,
514 (long long)ip
->i_ino
,
515 ret_imap
->br_startblock
, ret_imap
->br_startoff
,
516 ret_imap
->br_blockcount
,ret_imap
->br_state
);
520 error0
: /* Cancel bmap, unlock inode, unreserve quota blocks, cancel trans */
521 xfs_bmap_cancel(&free_list
);
522 XFS_TRANS_UNRESERVE_QUOTA_NBLKS(mp
, tp
, ip
, qblocks
, 0, quota_flag
);
524 error1
: /* Just cancel transaction */
525 xfs_trans_cancel(tp
, XFS_TRANS_RELEASE_LOG_RES
| XFS_TRANS_ABORT
);
526 *nmaps
= 0; /* nothing set-up here */
529 return XFS_ERROR(error
);
533 xfs_iomap_write_delay(
538 xfs_bmbt_irec_t
*ret_imap
,
541 xfs_mount_t
*mp
= ip
->i_mount
;
542 xfs_iocore_t
*io
= &ip
->i_iocore
;
543 xfs_fileoff_t offset_fsb
;
544 xfs_fileoff_t last_fsb
;
546 xfs_fsblock_t firstblock
;
549 xfs_bmbt_irec_t imap
[XFS_WRITE_IMAPS
];
553 ASSERT(ismrlocked(&ip
->i_lock
, MR_UPDATE
) != 0);
556 * Make sure that the dquots are there. This doesn't hold
557 * the ilock across a disk read.
560 error
= XFS_QM_DQATTACH(mp
, ip
, XFS_QMOPT_ILOCKED
);
562 return XFS_ERROR(error
);
565 isize
= ip
->i_d
.di_size
;
566 if (io
->io_new_size
> isize
) {
567 isize
= io
->io_new_size
;
571 offset_fsb
= XFS_B_TO_FSBT(mp
, offset
);
572 last_fsb
= XFS_B_TO_FSB(mp
, ((xfs_ufsize_t
)(offset
+ count
)));
574 * If the caller is doing a write at the end of the file,
575 * then extend the allocation (and the buffer used for the write)
576 * out to the file system's write iosize. We clean up any extra
577 * space left over when the file is closed in xfs_inactive().
579 * For sync writes, we are flushing delayed allocate space to
580 * try to make additional space available for allocation near
581 * the filesystem full boundary - preallocation hurts in that
582 * situation, of course.
584 if (!(ioflag
& BMAPI_SYNC
) && ((offset
+ count
) > ip
->i_d
.di_size
)) {
585 xfs_off_t aligned_offset
;
586 xfs_filblks_t count_fsb
;
588 xfs_fileoff_t ioalign
;
590 xfs_fileoff_t start_fsb
;
593 * If there are any real blocks past eof, then don't
594 * do any speculative allocation.
596 start_fsb
= XFS_B_TO_FSBT(mp
,
597 ((xfs_ufsize_t
)(offset
+ count
- 1)));
598 count_fsb
= XFS_B_TO_FSB(mp
, (xfs_ufsize_t
)XFS_MAXIOFFSET(mp
));
599 while (count_fsb
> 0) {
600 nimaps
= XFS_WRITE_IMAPS
;
601 error
= XFS_BMAPI(mp
, NULL
, io
, start_fsb
, count_fsb
,
602 0, &firstblock
, 0, imap
, &nimaps
, NULL
);
606 for (n
= 0; n
< nimaps
; n
++) {
607 if ( !(io
->io_flags
& XFS_IOCORE_RT
) &&
608 !imap
[n
].br_startblock
) {
609 cmn_err(CE_PANIC
,"Access to block "
610 "zero: fs <%s> inode: %lld "
611 "start_block : %llx start_off "
612 ": %llx blkcnt : %llx "
613 "extent-state : %x \n",
614 (ip
->i_mount
)->m_fsname
,
615 (long long)ip
->i_ino
,
616 imap
[n
].br_startblock
,
618 imap
[n
].br_blockcount
,
621 if ((imap
[n
].br_startblock
!= HOLESTARTBLOCK
) &&
622 (imap
[n
].br_startblock
!= DELAYSTARTBLOCK
)) {
625 start_fsb
+= imap
[n
].br_blockcount
;
626 count_fsb
-= imap
[n
].br_blockcount
;
629 iosize
= mp
->m_writeio_blocks
;
630 aligned_offset
= XFS_WRITEIO_ALIGN(mp
, (offset
+ count
- 1));
631 ioalign
= XFS_B_TO_FSBT(mp
, aligned_offset
);
632 last_fsb
= ioalign
+ iosize
;
636 nimaps
= XFS_WRITE_IMAPS
;
637 firstblock
= NULLFSBLOCK
;
640 * If mounted with the "-o swalloc" option, roundup the allocation
641 * request to a stripe width boundary if the file size is >=
642 * stripe width and we are allocating past the allocation eof.
644 if (!(io
->io_flags
& XFS_IOCORE_RT
) && mp
->m_swidth
645 && (mp
->m_flags
& XFS_MOUNT_SWALLOC
)
646 && (isize
>= XFS_FSB_TO_B(mp
, mp
->m_swidth
)) && aeof
) {
648 xfs_fileoff_t new_last_fsb
;
650 new_last_fsb
= roundup_64(last_fsb
, mp
->m_swidth
);
651 error
= xfs_bmap_eof(ip
, new_last_fsb
, XFS_DATA_FORK
, &eof
);
656 last_fsb
= new_last_fsb
;
659 * Roundup the allocation request to a stripe unit (m_dalign) boundary
660 * if the file size is >= stripe unit size, and we are allocating past
661 * the allocation eof.
663 } else if (!(io
->io_flags
& XFS_IOCORE_RT
) && mp
->m_dalign
&&
664 (isize
>= XFS_FSB_TO_B(mp
, mp
->m_dalign
)) && aeof
) {
666 xfs_fileoff_t new_last_fsb
;
667 new_last_fsb
= roundup_64(last_fsb
, mp
->m_dalign
);
668 error
= xfs_bmap_eof(ip
, new_last_fsb
, XFS_DATA_FORK
, &eof
);
673 last_fsb
= new_last_fsb
;
676 * Round up the allocation request to a real-time extent boundary
677 * if the file is on the real-time subvolume.
679 } else if (io
->io_flags
& XFS_IOCORE_RT
&& aeof
) {
681 xfs_fileoff_t new_last_fsb
;
683 new_last_fsb
= roundup_64(last_fsb
, mp
->m_sb
.sb_rextsize
);
684 error
= XFS_BMAP_EOF(mp
, io
, new_last_fsb
, XFS_DATA_FORK
, &eof
);
689 last_fsb
= new_last_fsb
;
691 error
= xfs_bmapi(NULL
, ip
, offset_fsb
,
692 (xfs_filblks_t
)(last_fsb
- offset_fsb
),
693 XFS_BMAPI_DELAY
| XFS_BMAPI_WRITE
|
694 XFS_BMAPI_ENTIRE
, &firstblock
, 1, imap
,
697 * This can be EDQUOT, if nimaps == 0
699 if (error
&& (error
!= ENOSPC
)) {
700 return XFS_ERROR(error
);
703 * If bmapi returned us nothing, and if we didn't get back EDQUOT,
704 * then we must have run out of space.
707 xfs_iomap_enter_trace(XFS_IOMAP_WRITE_NOSPACE
,
709 if (xfs_flush_space(ip
, &fsynced
, &ioflag
))
710 return XFS_ERROR(ENOSPC
);
718 if ( !(io
->io_flags
& XFS_IOCORE_RT
) && !ret_imap
->br_startblock
) {
719 cmn_err(CE_PANIC
,"Access to block zero: fs <%s> inode: %lld "
720 "start_block : %llx start_off : %llx blkcnt : %llx "
721 "extent-state : %x \n",
722 (ip
->i_mount
)->m_fsname
,
723 (long long)ip
->i_ino
,
724 ret_imap
->br_startblock
, ret_imap
->br_startoff
,
725 ret_imap
->br_blockcount
,ret_imap
->br_state
);
731 * Pass in a delayed allocate extent, convert it to real extents;
732 * return to the caller the extent we create which maps on top of
733 * the originating callers request.
735 * Called without a lock on the inode.
738 xfs_iomap_write_allocate(
742 xfs_bmbt_irec_t
*map
,
745 xfs_mount_t
*mp
= ip
->i_mount
;
746 xfs_iocore_t
*io
= &ip
->i_iocore
;
747 xfs_fileoff_t offset_fsb
, last_block
;
748 xfs_fileoff_t end_fsb
, map_start_fsb
;
749 xfs_fsblock_t first_block
;
750 xfs_bmap_free_t free_list
;
751 xfs_filblks_t count_fsb
;
752 xfs_bmbt_irec_t imap
[XFS_STRAT_WRITE_IMAPS
];
754 int i
, nimaps
, committed
;
761 * Make sure that the dquots are there.
763 if ((error
= XFS_QM_DQATTACH(mp
, ip
, 0)))
764 return XFS_ERROR(error
);
766 offset_fsb
= XFS_B_TO_FSBT(mp
, offset
);
767 count_fsb
= map
->br_blockcount
;
768 map_start_fsb
= map
->br_startoff
;
770 XFS_STATS_ADD(xs_xstrat_bytes
, XFS_FSB_TO_B(mp
, count_fsb
));
772 while (count_fsb
!= 0) {
774 * Set up a transaction with which to allocate the
775 * backing store for the file. Do allocations in a
776 * loop until we get some space in the range we are
777 * interested in. The other space that might be allocated
778 * is in the delayed allocation extent on which we sit
779 * but before our buffer starts.
783 while (nimaps
== 0) {
784 tp
= xfs_trans_alloc(mp
, XFS_TRANS_STRAT_WRITE
);
785 nres
= XFS_EXTENTADD_SPACE_RES(mp
, XFS_DATA_FORK
);
786 error
= xfs_trans_reserve(tp
, nres
,
787 XFS_WRITE_LOG_RES(mp
),
788 0, XFS_TRANS_PERM_LOG_RES
,
789 XFS_WRITE_LOG_COUNT
);
790 if (error
== ENOSPC
) {
791 error
= xfs_trans_reserve(tp
, 0,
792 XFS_WRITE_LOG_RES(mp
),
794 XFS_TRANS_PERM_LOG_RES
,
795 XFS_WRITE_LOG_COUNT
);
798 xfs_trans_cancel(tp
, 0);
799 return XFS_ERROR(error
);
801 xfs_ilock(ip
, XFS_ILOCK_EXCL
);
802 xfs_trans_ijoin(tp
, ip
, XFS_ILOCK_EXCL
);
803 xfs_trans_ihold(tp
, ip
);
805 XFS_BMAP_INIT(&free_list
, &first_block
);
807 nimaps
= XFS_STRAT_WRITE_IMAPS
;
809 * Ensure we don't go beyond eof - it is possible
810 * the extents changed since we did the read call,
811 * we dropped the ilock in the interim.
814 end_fsb
= XFS_B_TO_FSB(mp
, ip
->i_d
.di_size
);
815 xfs_bmap_last_offset(NULL
, ip
, &last_block
,
817 last_block
= XFS_FILEOFF_MAX(last_block
, end_fsb
);
818 if ((map_start_fsb
+ count_fsb
) > last_block
) {
819 count_fsb
= last_block
- map_start_fsb
;
820 if (count_fsb
== 0) {
826 /* Go get the actual blocks */
827 error
= xfs_bmapi(tp
, ip
, map_start_fsb
, count_fsb
,
828 XFS_BMAPI_WRITE
, &first_block
, 1,
829 imap
, &nimaps
, &free_list
);
833 error
= xfs_bmap_finish(&tp
, &free_list
,
834 first_block
, &committed
);
838 error
= xfs_trans_commit(tp
,
839 XFS_TRANS_RELEASE_LOG_RES
, NULL
);
843 xfs_iunlock(ip
, XFS_ILOCK_EXCL
);
847 * See if we were able to allocate an extent that
848 * covers at least part of the callers request
851 for (i
= 0; i
< nimaps
; i
++) {
852 if ( !(io
->io_flags
& XFS_IOCORE_RT
) &&
853 !imap
[i
].br_startblock
) {
854 cmn_err(CE_PANIC
,"Access to block zero: "
855 "fs <%s> inode: %lld "
856 "start_block : %llx start_off : %llx "
857 "blkcnt : %llx extent-state : %x \n",
858 (ip
->i_mount
)->m_fsname
,
859 (long long)ip
->i_ino
,
860 imap
[i
].br_startblock
,
862 imap
[i
].br_blockcount
,imap
[i
].br_state
);
864 if ((offset_fsb
>= imap
[i
].br_startoff
) &&
865 (offset_fsb
< (imap
[i
].br_startoff
+
866 imap
[i
].br_blockcount
))) {
869 XFS_STATS_INC(xs_xstrat_quick
);
872 count_fsb
-= imap
[i
].br_blockcount
;
875 /* So far we have not mapped the requested part of the
876 * file, just surrounding data, try again.
879 map_start_fsb
= imap
[nimaps
].br_startoff
+
880 imap
[nimaps
].br_blockcount
;
884 xfs_bmap_cancel(&free_list
);
885 xfs_trans_cancel(tp
, XFS_TRANS_RELEASE_LOG_RES
| XFS_TRANS_ABORT
);
887 xfs_iunlock(ip
, XFS_ILOCK_EXCL
);
888 return XFS_ERROR(error
);
892 xfs_iomap_write_unwritten(
897 xfs_mount_t
*mp
= ip
->i_mount
;
898 xfs_iocore_t
*io
= &ip
->i_iocore
;
900 xfs_fileoff_t offset_fsb
;
901 xfs_filblks_t count_fsb
;
902 xfs_filblks_t numblks_fsb
;
903 xfs_bmbt_irec_t imap
;
908 xfs_fsblock_t firstfsb
;
909 xfs_bmap_free_t free_list
;
911 xfs_iomap_enter_trace(XFS_IOMAP_UNWRITTEN
,
912 &ip
->i_iocore
, offset
, count
);
914 offset_fsb
= XFS_B_TO_FSBT(mp
, offset
);
915 count_fsb
= XFS_B_TO_FSB(mp
, (xfs_ufsize_t
)offset
+ count
);
916 count_fsb
= (xfs_filblks_t
)(count_fsb
- offset_fsb
);
919 nres
= XFS_DIOSTRAT_SPACE_RES(mp
, 0);
922 * set up a transaction to convert the range of extents
923 * from unwritten to real. Do allocations in a loop until
924 * we have covered the range passed in.
927 tp
= xfs_trans_alloc(mp
, XFS_TRANS_STRAT_WRITE
);
928 error
= xfs_trans_reserve(tp
, nres
,
929 XFS_WRITE_LOG_RES(mp
), 0,
930 XFS_TRANS_PERM_LOG_RES
,
931 XFS_WRITE_LOG_COUNT
);
933 xfs_trans_cancel(tp
, 0);
937 xfs_ilock(ip
, XFS_ILOCK_EXCL
);
938 xfs_trans_ijoin(tp
, ip
, XFS_ILOCK_EXCL
);
939 xfs_trans_ihold(tp
, ip
);
942 * Modify the unwritten extent state of the buffer.
944 XFS_BMAP_INIT(&free_list
, &firstfsb
);
946 error
= xfs_bmapi(tp
, ip
, offset_fsb
, count_fsb
,
947 XFS_BMAPI_WRITE
, &firstfsb
,
948 1, &imap
, &nimaps
, &free_list
);
950 goto error_on_bmapi_transaction
;
952 error
= xfs_bmap_finish(&(tp
), &(free_list
),
953 firstfsb
, &committed
);
955 goto error_on_bmapi_transaction
;
957 error
= xfs_trans_commit(tp
, XFS_TRANS_RELEASE_LOG_RES
, NULL
);
958 xfs_iunlock(ip
, XFS_ILOCK_EXCL
);
962 if ( !(io
->io_flags
& XFS_IOCORE_RT
) && !imap
.br_startblock
) {
963 cmn_err(CE_PANIC
,"Access to block zero: fs <%s> "
964 "inode: %lld start_block : %llx start_off : "
965 "%llx blkcnt : %llx extent-state : %x \n",
966 (ip
->i_mount
)->m_fsname
,
967 (long long)ip
->i_ino
,
968 imap
.br_startblock
,imap
.br_startoff
,
969 imap
.br_blockcount
,imap
.br_state
);
972 if ((numblks_fsb
= imap
.br_blockcount
) == 0) {
974 * The numblks_fsb value should always get
975 * smaller, otherwise the loop is stuck.
977 ASSERT(imap
.br_blockcount
);
980 offset_fsb
+= numblks_fsb
;
981 count_fsb
-= numblks_fsb
;
982 } while (count_fsb
> 0);
986 error_on_bmapi_transaction
:
987 xfs_bmap_cancel(&free_list
);
988 xfs_trans_cancel(tp
, (XFS_TRANS_RELEASE_LOG_RES
| XFS_TRANS_ABORT
));
989 xfs_iunlock(ip
, XFS_ILOCK_EXCL
);
991 return XFS_ERROR(error
);