2005-04-17 05:20:36 +07:00
|
|
|
/*
|
2006-06-09 11:48:12 +07:00
|
|
|
* Copyright (c) 2000-2006 Silicon Graphics, Inc.
|
2005-11-02 10:58:39 +07:00
|
|
|
* All Rights Reserved.
|
2005-04-17 05:20:36 +07:00
|
|
|
*
|
2005-11-02 10:58:39 +07:00
|
|
|
* This program is free software; you can redistribute it and/or
|
|
|
|
* modify it under the terms of the GNU General Public License as
|
2005-04-17 05:20:36 +07:00
|
|
|
* published by the Free Software Foundation.
|
|
|
|
*
|
2005-11-02 10:58:39 +07:00
|
|
|
* This program is distributed in the hope that it would be useful,
|
|
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
|
|
* GNU General Public License for more details.
|
2005-04-17 05:20:36 +07:00
|
|
|
*
|
2005-11-02 10:58:39 +07:00
|
|
|
* You should have received a copy of the GNU General Public License
|
|
|
|
* along with this program; if not, write the Free Software Foundation,
|
|
|
|
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
|
2005-04-17 05:20:36 +07:00
|
|
|
*/
|
|
|
|
#include "xfs.h"
|
|
|
|
#include "xfs_fs.h"
|
2005-11-02 10:38:42 +07:00
|
|
|
#include "xfs_bit.h"
|
2005-04-17 05:20:36 +07:00
|
|
|
#include "xfs_log.h"
|
2005-11-02 10:38:42 +07:00
|
|
|
#include "xfs_inum.h"
|
2005-04-17 05:20:36 +07:00
|
|
|
#include "xfs_trans.h"
|
|
|
|
#include "xfs_sb.h"
|
|
|
|
#include "xfs_ag.h"
|
|
|
|
#include "xfs_dir2.h"
|
|
|
|
#include "xfs_alloc.h"
|
|
|
|
#include "xfs_dmapi.h"
|
|
|
|
#include "xfs_quota.h"
|
|
|
|
#include "xfs_mount.h"
|
|
|
|
#include "xfs_bmap_btree.h"
|
2005-11-02 10:38:42 +07:00
|
|
|
#include "xfs_alloc_btree.h"
|
2005-04-17 05:20:36 +07:00
|
|
|
#include "xfs_ialloc_btree.h"
|
|
|
|
#include "xfs_dir2_sf.h"
|
2005-11-02 10:38:42 +07:00
|
|
|
#include "xfs_attr_sf.h"
|
2005-04-17 05:20:36 +07:00
|
|
|
#include "xfs_dinode.h"
|
|
|
|
#include "xfs_inode.h"
|
2005-11-02 10:38:42 +07:00
|
|
|
#include "xfs_ialloc.h"
|
|
|
|
#include "xfs_btree.h"
|
2005-04-17 05:20:36 +07:00
|
|
|
#include "xfs_bmap.h"
|
|
|
|
#include "xfs_rtalloc.h"
|
|
|
|
#include "xfs_error.h"
|
|
|
|
#include "xfs_itable.h"
|
|
|
|
#include "xfs_rw.h"
|
|
|
|
#include "xfs_attr.h"
|
|
|
|
#include "xfs_buf_item.h"
|
|
|
|
#include "xfs_trans_space.h"
|
|
|
|
#include "xfs_utils.h"
|
|
|
|
#include "xfs_iomap.h"
|
|
|
|
|
|
|
|
#if defined(XFS_RW_TRACE)
|
|
|
|
void
|
|
|
|
xfs_iomap_enter_trace(
|
|
|
|
int tag,
|
2007-10-11 14:34:33 +07:00
|
|
|
xfs_inode_t *ip,
|
2005-04-17 05:20:36 +07:00
|
|
|
xfs_off_t offset,
|
|
|
|
ssize_t count)
|
|
|
|
{
|
|
|
|
if (!ip->i_rwtrace)
|
|
|
|
return;
|
|
|
|
|
|
|
|
ktrace_enter(ip->i_rwtrace,
|
|
|
|
(void *)((unsigned long)tag),
|
|
|
|
(void *)ip,
|
|
|
|
(void *)((unsigned long)((ip->i_d.di_size >> 32) & 0xffffffff)),
|
|
|
|
(void *)((unsigned long)(ip->i_d.di_size & 0xffffffff)),
|
|
|
|
(void *)((unsigned long)((offset >> 32) & 0xffffffff)),
|
|
|
|
(void *)((unsigned long)(offset & 0xffffffff)),
|
|
|
|
(void *)((unsigned long)count),
|
2007-10-11 14:44:08 +07:00
|
|
|
(void *)((unsigned long)((ip->i_new_size >> 32) & 0xffffffff)),
|
|
|
|
(void *)((unsigned long)(ip->i_new_size & 0xffffffff)),
|
2006-03-22 08:44:15 +07:00
|
|
|
(void *)((unsigned long)current_pid()),
|
2005-04-17 05:20:36 +07:00
|
|
|
(void *)NULL,
|
|
|
|
(void *)NULL,
|
|
|
|
(void *)NULL,
|
|
|
|
(void *)NULL,
|
|
|
|
(void *)NULL,
|
|
|
|
(void *)NULL);
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
xfs_iomap_map_trace(
|
|
|
|
int tag,
|
2007-10-11 14:34:33 +07:00
|
|
|
xfs_inode_t *ip,
|
2005-04-17 05:20:36 +07:00
|
|
|
xfs_off_t offset,
|
|
|
|
ssize_t count,
|
|
|
|
xfs_iomap_t *iomapp,
|
|
|
|
xfs_bmbt_irec_t *imapp,
|
|
|
|
int flags)
|
|
|
|
{
|
|
|
|
if (!ip->i_rwtrace)
|
|
|
|
return;
|
|
|
|
|
|
|
|
ktrace_enter(ip->i_rwtrace,
|
|
|
|
(void *)((unsigned long)tag),
|
|
|
|
(void *)ip,
|
|
|
|
(void *)((unsigned long)((ip->i_d.di_size >> 32) & 0xffffffff)),
|
|
|
|
(void *)((unsigned long)(ip->i_d.di_size & 0xffffffff)),
|
|
|
|
(void *)((unsigned long)((offset >> 32) & 0xffffffff)),
|
|
|
|
(void *)((unsigned long)(offset & 0xffffffff)),
|
|
|
|
(void *)((unsigned long)count),
|
|
|
|
(void *)((unsigned long)flags),
|
|
|
|
(void *)((unsigned long)((iomapp->iomap_offset >> 32) & 0xffffffff)),
|
|
|
|
(void *)((unsigned long)(iomapp->iomap_offset & 0xffffffff)),
|
|
|
|
(void *)((unsigned long)(iomapp->iomap_delta)),
|
|
|
|
(void *)((unsigned long)(iomapp->iomap_bsize)),
|
|
|
|
(void *)((unsigned long)(iomapp->iomap_bn)),
|
|
|
|
(void *)(__psint_t)(imapp->br_startoff),
|
|
|
|
(void *)((unsigned long)(imapp->br_blockcount)),
|
|
|
|
(void *)(__psint_t)(imapp->br_startblock));
|
|
|
|
}
|
|
|
|
#else
|
|
|
|
#define xfs_iomap_enter_trace(tag, io, offset, count)
|
|
|
|
#define xfs_iomap_map_trace(tag, io, offset, count, iomapp, imapp, flags)
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#define XFS_WRITEIO_ALIGN(mp,off) (((off) >> mp->m_writeio_log) \
|
|
|
|
<< mp->m_writeio_log)
|
|
|
|
#define XFS_STRAT_WRITE_IMAPS 2
|
|
|
|
#define XFS_WRITE_IMAPS XFS_BMAP_MAX_NMAP
|
|
|
|
|
|
|
|
STATIC int
|
|
|
|
xfs_imap_to_bmap(
|
2007-10-11 14:34:33 +07:00
|
|
|
xfs_inode_t *ip,
|
2005-04-17 05:20:36 +07:00
|
|
|
xfs_off_t offset,
|
|
|
|
xfs_bmbt_irec_t *imap,
|
|
|
|
xfs_iomap_t *iomapp,
|
|
|
|
int imaps, /* Number of imap entries */
|
|
|
|
int iomaps, /* Number of iomap entries */
|
|
|
|
int flags)
|
|
|
|
{
|
2007-10-11 14:34:33 +07:00
|
|
|
xfs_mount_t *mp = ip->i_mount;
|
2005-04-17 05:20:36 +07:00
|
|
|
int pbm;
|
|
|
|
xfs_fsblock_t start_block;
|
|
|
|
|
|
|
|
|
|
|
|
for (pbm = 0; imaps && pbm < iomaps; imaps--, iomapp++, imap++, pbm++) {
|
|
|
|
iomapp->iomap_offset = XFS_FSB_TO_B(mp, imap->br_startoff);
|
|
|
|
iomapp->iomap_delta = offset - iomapp->iomap_offset;
|
|
|
|
iomapp->iomap_bsize = XFS_FSB_TO_B(mp, imap->br_blockcount);
|
|
|
|
iomapp->iomap_flags = flags;
|
|
|
|
|
2007-11-23 12:29:42 +07:00
|
|
|
if (XFS_IS_REALTIME_INODE(ip)) {
|
2005-04-17 05:20:36 +07:00
|
|
|
iomapp->iomap_flags |= IOMAP_REALTIME;
|
|
|
|
iomapp->iomap_target = mp->m_rtdev_targp;
|
|
|
|
} else {
|
|
|
|
iomapp->iomap_target = mp->m_ddev_targp;
|
|
|
|
}
|
|
|
|
start_block = imap->br_startblock;
|
|
|
|
if (start_block == HOLESTARTBLOCK) {
|
|
|
|
iomapp->iomap_bn = IOMAP_DADDR_NULL;
|
|
|
|
iomapp->iomap_flags |= IOMAP_HOLE;
|
|
|
|
} else if (start_block == DELAYSTARTBLOCK) {
|
|
|
|
iomapp->iomap_bn = IOMAP_DADDR_NULL;
|
|
|
|
iomapp->iomap_flags |= IOMAP_DELAY;
|
|
|
|
} else {
|
2009-01-15 12:22:07 +07:00
|
|
|
iomapp->iomap_bn = xfs_fsb_to_db(ip, start_block);
|
2005-04-17 05:20:36 +07:00
|
|
|
if (ISUNWRITTEN(imap))
|
|
|
|
iomapp->iomap_flags |= IOMAP_UNWRITTEN;
|
|
|
|
}
|
|
|
|
|
|
|
|
offset += iomapp->iomap_bsize - iomapp->iomap_delta;
|
|
|
|
}
|
|
|
|
return pbm; /* Return the number filled */
|
|
|
|
}
|
|
|
|
|
|
|
|
int
|
|
|
|
xfs_iomap(
|
2007-10-11 14:34:33 +07:00
|
|
|
xfs_inode_t *ip,
|
2005-04-17 05:20:36 +07:00
|
|
|
xfs_off_t offset,
|
|
|
|
ssize_t count,
|
|
|
|
int flags,
|
|
|
|
xfs_iomap_t *iomapp,
|
|
|
|
int *niomaps)
|
|
|
|
{
|
2007-10-11 14:34:33 +07:00
|
|
|
xfs_mount_t *mp = ip->i_mount;
|
2005-04-17 05:20:36 +07:00
|
|
|
xfs_fileoff_t offset_fsb, end_fsb;
|
|
|
|
int error = 0;
|
|
|
|
int lockmode = 0;
|
|
|
|
xfs_bmbt_irec_t imap;
|
|
|
|
int nimaps = 1;
|
|
|
|
int bmapi_flags = 0;
|
|
|
|
int iomap_flags = 0;
|
|
|
|
|
2007-10-11 14:34:33 +07:00
|
|
|
ASSERT((ip->i_d.di_mode & S_IFMT) == S_IFREG);
|
|
|
|
|
2005-04-17 05:20:36 +07:00
|
|
|
if (XFS_FORCED_SHUTDOWN(mp))
|
|
|
|
return XFS_ERROR(EIO);
|
|
|
|
|
2007-09-14 12:23:31 +07:00
|
|
|
switch (flags & (BMAPI_READ | BMAPI_WRITE | BMAPI_ALLOCATE)) {
|
2005-04-17 05:20:36 +07:00
|
|
|
case BMAPI_READ:
|
2007-10-11 14:34:33 +07:00
|
|
|
xfs_iomap_enter_trace(XFS_IOMAP_READ_ENTER, ip, offset, count);
|
|
|
|
lockmode = xfs_ilock_map_shared(ip);
|
2005-04-17 05:20:36 +07:00
|
|
|
bmapi_flags = XFS_BMAPI_ENTIRE;
|
|
|
|
break;
|
|
|
|
case BMAPI_WRITE:
|
2007-10-11 14:34:33 +07:00
|
|
|
xfs_iomap_enter_trace(XFS_IOMAP_WRITE_ENTER, ip, offset, count);
|
2008-04-22 14:34:00 +07:00
|
|
|
lockmode = XFS_ILOCK_EXCL;
|
2005-09-05 07:06:55 +07:00
|
|
|
if (flags & BMAPI_IGNSTATE)
|
|
|
|
bmapi_flags |= XFS_BMAPI_IGSTATE|XFS_BMAPI_ENTIRE;
|
2007-10-11 14:34:33 +07:00
|
|
|
xfs_ilock(ip, lockmode);
|
2005-04-17 05:20:36 +07:00
|
|
|
break;
|
|
|
|
case BMAPI_ALLOCATE:
|
2007-10-11 14:34:33 +07:00
|
|
|
xfs_iomap_enter_trace(XFS_IOMAP_ALLOC_ENTER, ip, offset, count);
|
2008-04-22 14:34:00 +07:00
|
|
|
lockmode = XFS_ILOCK_SHARED;
|
2005-04-17 05:20:36 +07:00
|
|
|
bmapi_flags = XFS_BMAPI_ENTIRE;
|
2007-10-11 14:34:33 +07:00
|
|
|
|
2005-04-17 05:20:36 +07:00
|
|
|
/* Attempt non-blocking lock */
|
|
|
|
if (flags & BMAPI_TRYLOCK) {
|
2007-10-11 14:34:33 +07:00
|
|
|
if (!xfs_ilock_nowait(ip, lockmode))
|
2005-04-17 05:20:36 +07:00
|
|
|
return XFS_ERROR(EAGAIN);
|
|
|
|
} else {
|
2007-10-11 14:34:33 +07:00
|
|
|
xfs_ilock(ip, lockmode);
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
BUG();
|
|
|
|
}
|
|
|
|
|
|
|
|
ASSERT(offset <= mp->m_maxioffset);
|
|
|
|
if ((xfs_fsize_t)offset + count > mp->m_maxioffset)
|
|
|
|
count = mp->m_maxioffset - offset;
|
|
|
|
end_fsb = XFS_B_TO_FSB(mp, (xfs_ufsize_t)offset + count);
|
|
|
|
offset_fsb = XFS_B_TO_FSBT(mp, offset);
|
|
|
|
|
2007-10-11 14:34:33 +07:00
|
|
|
error = xfs_bmapi(NULL, ip, offset_fsb,
|
2005-04-17 05:20:36 +07:00
|
|
|
(xfs_filblks_t)(end_fsb - offset_fsb),
|
|
|
|
bmapi_flags, NULL, 0, &imap,
|
2006-06-09 11:48:12 +07:00
|
|
|
&nimaps, NULL, NULL);
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
if (error)
|
|
|
|
goto out;
|
|
|
|
|
2007-09-14 12:23:31 +07:00
|
|
|
switch (flags & (BMAPI_WRITE|BMAPI_ALLOCATE)) {
|
2005-04-17 05:20:36 +07:00
|
|
|
case BMAPI_WRITE:
|
|
|
|
/* If we found an extent, return it */
|
2005-05-06 20:42:22 +07:00
|
|
|
if (nimaps &&
|
2006-01-11 11:28:28 +07:00
|
|
|
(imap.br_startblock != HOLESTARTBLOCK) &&
|
2005-05-06 20:42:22 +07:00
|
|
|
(imap.br_startblock != DELAYSTARTBLOCK)) {
|
2007-10-11 14:34:33 +07:00
|
|
|
xfs_iomap_map_trace(XFS_IOMAP_WRITE_MAP, ip,
|
2005-04-17 05:20:36 +07:00
|
|
|
offset, count, iomapp, &imap, flags);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (flags & (BMAPI_DIRECT|BMAPI_MMAP)) {
|
2007-10-11 14:34:33 +07:00
|
|
|
error = xfs_iomap_write_direct(ip, offset, count, flags,
|
|
|
|
&imap, &nimaps, nimaps);
|
2005-04-17 05:20:36 +07:00
|
|
|
} else {
|
2007-10-11 14:34:33 +07:00
|
|
|
error = xfs_iomap_write_delay(ip, offset, count, flags,
|
|
|
|
&imap, &nimaps);
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
|
|
|
if (!error) {
|
2007-10-11 14:34:33 +07:00
|
|
|
xfs_iomap_map_trace(XFS_IOMAP_ALLOC_MAP, ip,
|
2005-04-17 05:20:36 +07:00
|
|
|
offset, count, iomapp, &imap, flags);
|
|
|
|
}
|
|
|
|
iomap_flags = IOMAP_NEW;
|
|
|
|
break;
|
|
|
|
case BMAPI_ALLOCATE:
|
|
|
|
/* If we found an extent, return it */
|
2007-10-11 14:34:33 +07:00
|
|
|
xfs_iunlock(ip, lockmode);
|
2005-04-17 05:20:36 +07:00
|
|
|
lockmode = 0;
|
|
|
|
|
2009-01-15 12:22:07 +07:00
|
|
|
if (nimaps && !isnullstartblock(imap.br_startblock)) {
|
2007-10-11 14:34:33 +07:00
|
|
|
xfs_iomap_map_trace(XFS_IOMAP_WRITE_MAP, ip,
|
2005-04-17 05:20:36 +07:00
|
|
|
offset, count, iomapp, &imap, flags);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2007-10-11 14:34:33 +07:00
|
|
|
error = xfs_iomap_write_allocate(ip, offset, count,
|
2005-05-06 03:33:20 +07:00
|
|
|
&imap, &nimaps);
|
2005-04-17 05:20:36 +07:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (nimaps) {
|
2007-10-11 14:34:33 +07:00
|
|
|
*niomaps = xfs_imap_to_bmap(ip, offset, &imap,
|
2005-04-17 05:20:36 +07:00
|
|
|
iomapp, nimaps, *niomaps, iomap_flags);
|
|
|
|
} else if (niomaps) {
|
|
|
|
*niomaps = 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
out:
|
|
|
|
if (lockmode)
|
2007-10-11 14:34:33 +07:00
|
|
|
xfs_iunlock(ip, lockmode);
|
2005-04-17 05:20:36 +07:00
|
|
|
return XFS_ERROR(error);
|
|
|
|
}
|
|
|
|
|
2007-10-11 14:34:33 +07:00
|
|
|
|
2006-01-11 11:28:28 +07:00
|
|
|
STATIC int
|
|
|
|
xfs_iomap_eof_align_last_fsb(
|
|
|
|
xfs_mount_t *mp,
|
2007-10-11 14:34:33 +07:00
|
|
|
xfs_inode_t *ip,
|
2006-01-11 11:28:28 +07:00
|
|
|
xfs_extlen_t extsize,
|
|
|
|
xfs_fileoff_t *last_fsb)
|
|
|
|
{
|
|
|
|
xfs_fileoff_t new_last_fsb = 0;
|
|
|
|
xfs_extlen_t align;
|
|
|
|
int eof, error;
|
|
|
|
|
2007-11-23 12:29:42 +07:00
|
|
|
if (XFS_IS_REALTIME_INODE(ip))
|
2006-01-11 11:28:28 +07:00
|
|
|
;
|
|
|
|
/*
|
|
|
|
* If mounted with the "-o swalloc" option, roundup the allocation
|
|
|
|
* request to a stripe width boundary if the file size is >=
|
|
|
|
* stripe width and we are allocating past the allocation eof.
|
|
|
|
*/
|
|
|
|
else if (mp->m_swidth && (mp->m_flags & XFS_MOUNT_SWALLOC) &&
|
2008-12-22 13:56:49 +07:00
|
|
|
(ip->i_size >= XFS_FSB_TO_B(mp, mp->m_swidth)))
|
2006-01-11 11:28:28 +07:00
|
|
|
new_last_fsb = roundup_64(*last_fsb, mp->m_swidth);
|
|
|
|
/*
|
|
|
|
* Roundup the allocation request to a stripe unit (m_dalign) boundary
|
|
|
|
* if the file size is >= stripe unit size, and we are allocating past
|
|
|
|
* the allocation eof.
|
|
|
|
*/
|
2008-12-22 13:56:49 +07:00
|
|
|
else if (mp->m_dalign && (ip->i_size >= XFS_FSB_TO_B(mp, mp->m_dalign)))
|
2006-01-11 11:28:28 +07:00
|
|
|
new_last_fsb = roundup_64(*last_fsb, mp->m_dalign);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Always round up the allocation request to an extent boundary
|
|
|
|
* (when file on a real-time subvolume or has di_extsize hint).
|
|
|
|
*/
|
|
|
|
if (extsize) {
|
|
|
|
if (new_last_fsb)
|
|
|
|
align = roundup_64(new_last_fsb, extsize);
|
|
|
|
else
|
|
|
|
align = extsize;
|
|
|
|
new_last_fsb = roundup_64(*last_fsb, align);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (new_last_fsb) {
|
2007-10-11 14:34:33 +07:00
|
|
|
error = xfs_bmap_eof(ip, new_last_fsb, XFS_DATA_FORK, &eof);
|
2006-01-11 11:28:28 +07:00
|
|
|
if (error)
|
|
|
|
return error;
|
|
|
|
if (eof)
|
|
|
|
*last_fsb = new_last_fsb;
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2006-09-28 08:03:20 +07:00
|
|
|
STATIC int
|
|
|
|
xfs_cmn_err_fsblock_zero(
|
|
|
|
xfs_inode_t *ip,
|
|
|
|
xfs_bmbt_irec_t *imap)
|
|
|
|
{
|
|
|
|
xfs_cmn_err(XFS_PTAG_FSBLOCK_ZERO, CE_ALERT, ip->i_mount,
|
|
|
|
"Access to block zero in inode %llu "
|
|
|
|
"start_block: %llx start_off: %llx "
|
|
|
|
"blkcnt: %llx extent-state: %x\n",
|
|
|
|
(unsigned long long)ip->i_ino,
|
|
|
|
(unsigned long long)imap->br_startblock,
|
|
|
|
(unsigned long long)imap->br_startoff,
|
|
|
|
(unsigned long long)imap->br_blockcount,
|
|
|
|
imap->br_state);
|
|
|
|
return EFSCORRUPTED;
|
|
|
|
}
|
|
|
|
|
2005-04-17 05:20:36 +07:00
|
|
|
int
|
|
|
|
xfs_iomap_write_direct(
|
|
|
|
xfs_inode_t *ip,
|
2005-05-06 03:33:40 +07:00
|
|
|
xfs_off_t offset,
|
2005-04-17 05:20:36 +07:00
|
|
|
size_t count,
|
|
|
|
int flags,
|
|
|
|
xfs_bmbt_irec_t *ret_imap,
|
|
|
|
int *nmaps,
|
|
|
|
int found)
|
|
|
|
{
|
|
|
|
xfs_mount_t *mp = ip->i_mount;
|
|
|
|
xfs_fileoff_t offset_fsb;
|
|
|
|
xfs_fileoff_t last_fsb;
|
2006-01-11 11:28:28 +07:00
|
|
|
xfs_filblks_t count_fsb, resaligned;
|
2005-04-17 05:20:36 +07:00
|
|
|
xfs_fsblock_t firstfsb;
|
2006-01-11 11:28:28 +07:00
|
|
|
xfs_extlen_t extsz, temp;
|
2005-11-02 11:00:01 +07:00
|
|
|
int nimaps;
|
2005-04-17 05:20:36 +07:00
|
|
|
int bmapi_flag;
|
2005-06-21 12:48:47 +07:00
|
|
|
int quota_flag;
|
2005-04-17 05:20:36 +07:00
|
|
|
int rt;
|
|
|
|
xfs_trans_t *tp;
|
2005-11-02 11:00:01 +07:00
|
|
|
xfs_bmbt_irec_t imap;
|
2005-04-17 05:20:36 +07:00
|
|
|
xfs_bmap_free_t free_list;
|
2006-01-11 11:28:28 +07:00
|
|
|
uint qblocks, resblks, resrtextents;
|
2005-04-17 05:20:36 +07:00
|
|
|
int committed;
|
2006-01-11 11:28:28 +07:00
|
|
|
int error;
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Make sure that the dquots are there. This doesn't hold
|
|
|
|
* the ilock across a disk read.
|
|
|
|
*/
|
2009-06-08 20:33:32 +07:00
|
|
|
error = xfs_qm_dqattach_locked(ip, 0);
|
2005-04-17 05:20:36 +07:00
|
|
|
if (error)
|
|
|
|
return XFS_ERROR(error);
|
|
|
|
|
2006-01-11 11:28:28 +07:00
|
|
|
rt = XFS_IS_REALTIME_INODE(ip);
|
2007-06-18 13:50:37 +07:00
|
|
|
extsz = xfs_get_extsz_hint(ip);
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2007-06-18 13:50:37 +07:00
|
|
|
offset_fsb = XFS_B_TO_FSBT(mp, offset);
|
|
|
|
last_fsb = XFS_B_TO_FSB(mp, ((xfs_ufsize_t)(offset + count)));
|
2008-12-22 13:56:49 +07:00
|
|
|
if ((offset + count) > ip->i_size) {
|
|
|
|
error = xfs_iomap_eof_align_last_fsb(mp, ip, extsz, &last_fsb);
|
2006-01-11 11:28:28 +07:00
|
|
|
if (error)
|
|
|
|
goto error_out;
|
2005-04-17 05:20:36 +07:00
|
|
|
} else {
|
2006-01-11 11:28:28 +07:00
|
|
|
if (found && (ret_imap->br_startblock == HOLESTARTBLOCK))
|
|
|
|
last_fsb = MIN(last_fsb, (xfs_fileoff_t)
|
|
|
|
ret_imap->br_blockcount +
|
|
|
|
ret_imap->br_startoff);
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
2006-01-11 11:28:28 +07:00
|
|
|
count_fsb = last_fsb - offset_fsb;
|
|
|
|
ASSERT(count_fsb > 0);
|
|
|
|
|
|
|
|
resaligned = count_fsb;
|
|
|
|
if (unlikely(extsz)) {
|
|
|
|
if ((temp = do_mod(offset_fsb, extsz)))
|
|
|
|
resaligned += temp;
|
|
|
|
if ((temp = do_mod(resaligned, extsz)))
|
|
|
|
resaligned += extsz - temp;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (unlikely(rt)) {
|
|
|
|
resrtextents = qblocks = resaligned;
|
|
|
|
resrtextents /= mp->m_sb.sb_rextsize;
|
2007-06-18 13:50:27 +07:00
|
|
|
resblks = XFS_DIOSTRAT_SPACE_RES(mp, 0);
|
|
|
|
quota_flag = XFS_QMOPT_RES_RTBLKS;
|
|
|
|
} else {
|
|
|
|
resrtextents = 0;
|
2006-01-11 11:28:28 +07:00
|
|
|
resblks = qblocks = XFS_DIOSTRAT_SPACE_RES(mp, resaligned);
|
2007-06-18 13:50:27 +07:00
|
|
|
quota_flag = XFS_QMOPT_RES_REGBLKS;
|
|
|
|
}
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
/*
|
2005-06-21 12:48:47 +07:00
|
|
|
* Allocate and setup the transaction
|
2005-04-17 05:20:36 +07:00
|
|
|
*/
|
|
|
|
xfs_iunlock(ip, XFS_ILOCK_EXCL);
|
|
|
|
tp = xfs_trans_alloc(mp, XFS_TRANS_DIOSTRAT);
|
|
|
|
error = xfs_trans_reserve(tp, resblks,
|
2005-09-02 13:41:32 +07:00
|
|
|
XFS_WRITE_LOG_RES(mp), resrtextents,
|
2005-04-17 05:20:36 +07:00
|
|
|
XFS_TRANS_PERM_LOG_RES,
|
|
|
|
XFS_WRITE_LOG_COUNT);
|
|
|
|
/*
|
2005-06-21 12:48:47 +07:00
|
|
|
* Check for running out of space, note: need lock to return
|
2005-04-17 05:20:36 +07:00
|
|
|
*/
|
|
|
|
if (error)
|
|
|
|
xfs_trans_cancel(tp, 0);
|
|
|
|
xfs_ilock(ip, XFS_ILOCK_EXCL);
|
|
|
|
if (error)
|
2005-06-21 12:48:47 +07:00
|
|
|
goto error_out;
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2009-06-08 20:33:32 +07:00
|
|
|
error = xfs_trans_reserve_quota_nblks(tp, ip, qblocks, 0, quota_flag);
|
2006-01-11 11:28:28 +07:00
|
|
|
if (error)
|
2005-04-17 05:20:36 +07:00
|
|
|
goto error1;
|
|
|
|
|
|
|
|
xfs_trans_ijoin(tp, ip, XFS_ILOCK_EXCL);
|
|
|
|
xfs_trans_ihold(tp, ip);
|
|
|
|
|
2006-01-11 11:28:28 +07:00
|
|
|
bmapi_flag = XFS_BMAPI_WRITE;
|
[XFS] Fix to prevent the notorious 'NULL files' problem after a crash.
The problem that has been addressed is that of synchronising updates of
the file size with writes that extend a file. Without the fix the update
of a file's size, as a result of a write beyond eof, is independent of
when the cached data is flushed to disk. Often the file size update would
be written to the filesystem log before the data is flushed to disk. When
a system crashes between these two events and the filesystem log is
replayed on mount the file's size will be set but since the contents never
made it to disk the file is full of holes. If some of the cached data was
flushed to disk then it may just be a section of the file at the end that
has holes.
There are existing fixes to help alleviate this problem, particularly in
the case where a file has been truncated, that force cached data to be
flushed to disk when the file is closed. If the system crashes while the
file(s) are still open then this flushing will never occur.
The fix that we have implemented is to introduce a second file size,
called the in-memory file size, that represents the current file size as
viewed by the user. The existing file size, called the on-disk file size,
is the one that get's written to the filesystem log and we only update it
when it is safe to do so. When we write to a file beyond eof we only
update the in- memory file size in the write operation. Later when the I/O
operation, that flushes the cached data to disk completes, an I/O
completion routine will update the on-disk file size. The on-disk file
size will be updated to the maximum offset of the I/O or to the value of
the in-memory file size if the I/O includes eof.
SGI-PV: 958522
SGI-Modid: xfs-linux-melb:xfs-kern:28322a
Signed-off-by: Lachlan McIlroy <lachlan@sgi.com>
Signed-off-by: David Chinner <dgc@sgi.com>
Signed-off-by: Tim Shimmin <tes@sgi.com>
2007-05-08 10:49:46 +07:00
|
|
|
if ((flags & BMAPI_DIRECT) && (offset < ip->i_size || extsz))
|
2005-04-17 05:20:36 +07:00
|
|
|
bmapi_flag |= XFS_BMAPI_PREALLOC;
|
|
|
|
|
|
|
|
/*
|
2006-01-11 11:28:28 +07:00
|
|
|
* Issue the xfs_bmapi() call to allocate the blocks
|
2005-04-17 05:20:36 +07:00
|
|
|
*/
|
2009-01-15 12:22:07 +07:00
|
|
|
xfs_bmap_init(&free_list, &firstfsb);
|
2005-06-21 12:48:47 +07:00
|
|
|
nimaps = 1;
|
2007-10-11 14:34:33 +07:00
|
|
|
error = xfs_bmapi(tp, ip, offset_fsb, count_fsb, bmapi_flag,
|
2006-06-09 11:48:12 +07:00
|
|
|
&firstfsb, 0, &imap, &nimaps, &free_list, NULL);
|
2005-06-21 12:48:47 +07:00
|
|
|
if (error)
|
2005-04-17 05:20:36 +07:00
|
|
|
goto error0;
|
|
|
|
|
|
|
|
/*
|
2005-06-21 12:48:47 +07:00
|
|
|
* Complete the transaction
|
2005-04-17 05:20:36 +07:00
|
|
|
*/
|
2007-02-10 14:37:16 +07:00
|
|
|
error = xfs_bmap_finish(&tp, &free_list, &committed);
|
2005-06-21 12:48:47 +07:00
|
|
|
if (error)
|
2005-04-17 05:20:36 +07:00
|
|
|
goto error0;
|
2007-05-08 10:48:42 +07:00
|
|
|
error = xfs_trans_commit(tp, XFS_TRANS_RELEASE_LOG_RES);
|
2005-06-21 12:48:47 +07:00
|
|
|
if (error)
|
2005-04-17 05:20:36 +07:00
|
|
|
goto error_out;
|
|
|
|
|
2005-06-21 12:48:47 +07:00
|
|
|
/*
|
|
|
|
* Copy any maps to caller's array and return any error.
|
|
|
|
*/
|
2005-04-17 05:20:36 +07:00
|
|
|
if (nimaps == 0) {
|
2006-09-28 08:03:20 +07:00
|
|
|
error = ENOSPC;
|
|
|
|
goto error_out;
|
|
|
|
}
|
|
|
|
|
2008-04-29 09:53:21 +07:00
|
|
|
if (!(imap.br_startblock || XFS_IS_REALTIME_INODE(ip))) {
|
2006-09-28 08:03:20 +07:00
|
|
|
error = xfs_cmn_err_fsblock_zero(ip, &imap);
|
2005-04-17 05:20:36 +07:00
|
|
|
goto error_out;
|
|
|
|
}
|
|
|
|
|
2005-11-02 11:00:01 +07:00
|
|
|
*ret_imap = imap;
|
2005-04-17 05:20:36 +07:00
|
|
|
*nmaps = 1;
|
|
|
|
return 0;
|
|
|
|
|
2005-06-21 12:48:47 +07:00
|
|
|
error0: /* Cancel bmap, unlock inode, unreserve quota blocks, cancel trans */
|
2005-04-17 05:20:36 +07:00
|
|
|
xfs_bmap_cancel(&free_list);
|
2009-06-08 20:33:32 +07:00
|
|
|
xfs_trans_unreserve_quota_nblks(tp, ip, qblocks, 0, quota_flag);
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2005-06-21 12:48:47 +07:00
|
|
|
error1: /* Just cancel transaction */
|
2005-04-17 05:20:36 +07:00
|
|
|
xfs_trans_cancel(tp, XFS_TRANS_RELEASE_LOG_RES | XFS_TRANS_ABORT);
|
|
|
|
*nmaps = 0; /* nothing set-up here */
|
|
|
|
|
|
|
|
error_out:
|
|
|
|
return XFS_ERROR(error);
|
|
|
|
}
|
|
|
|
|
2006-01-11 11:28:28 +07:00
|
|
|
/*
|
2009-04-06 23:49:12 +07:00
|
|
|
* If the caller is doing a write at the end of the file, then extend the
|
|
|
|
* allocation out to the file system's write iosize. We clean up any extra
|
|
|
|
* space left over when the file is closed in xfs_inactive().
|
2006-01-11 11:28:28 +07:00
|
|
|
*/
|
|
|
|
STATIC int
|
|
|
|
xfs_iomap_eof_want_preallocate(
|
|
|
|
xfs_mount_t *mp,
|
2007-10-11 14:34:33 +07:00
|
|
|
xfs_inode_t *ip,
|
2006-01-11 11:28:28 +07:00
|
|
|
xfs_off_t offset,
|
|
|
|
size_t count,
|
|
|
|
int ioflag,
|
|
|
|
xfs_bmbt_irec_t *imap,
|
|
|
|
int nimaps,
|
|
|
|
int *prealloc)
|
|
|
|
{
|
|
|
|
xfs_fileoff_t start_fsb;
|
|
|
|
xfs_filblks_t count_fsb;
|
|
|
|
xfs_fsblock_t firstblock;
|
|
|
|
int n, error, imaps;
|
|
|
|
|
|
|
|
*prealloc = 0;
|
2009-04-06 23:49:12 +07:00
|
|
|
if ((offset + count) <= ip->i_size)
|
2006-01-11 11:28:28 +07:00
|
|
|
return 0;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* If there are any real blocks past eof, then don't
|
|
|
|
* do any speculative allocation.
|
|
|
|
*/
|
|
|
|
start_fsb = XFS_B_TO_FSBT(mp, ((xfs_ufsize_t)(offset + count - 1)));
|
|
|
|
count_fsb = XFS_B_TO_FSB(mp, (xfs_ufsize_t)XFS_MAXIOFFSET(mp));
|
|
|
|
while (count_fsb > 0) {
|
|
|
|
imaps = nimaps;
|
2006-01-11 11:33:02 +07:00
|
|
|
firstblock = NULLFSBLOCK;
|
2007-10-11 14:34:33 +07:00
|
|
|
error = xfs_bmapi(NULL, ip, start_fsb, count_fsb, 0,
|
2006-06-09 11:48:12 +07:00
|
|
|
&firstblock, 0, imap, &imaps, NULL, NULL);
|
2006-01-11 11:28:28 +07:00
|
|
|
if (error)
|
|
|
|
return error;
|
|
|
|
for (n = 0; n < imaps; n++) {
|
|
|
|
if ((imap[n].br_startblock != HOLESTARTBLOCK) &&
|
|
|
|
(imap[n].br_startblock != DELAYSTARTBLOCK))
|
|
|
|
return 0;
|
|
|
|
start_fsb += imap[n].br_blockcount;
|
|
|
|
count_fsb -= imap[n].br_blockcount;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
*prealloc = 1;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2005-04-17 05:20:36 +07:00
|
|
|
int
|
|
|
|
xfs_iomap_write_delay(
|
|
|
|
xfs_inode_t *ip,
|
2005-05-06 03:33:40 +07:00
|
|
|
xfs_off_t offset,
|
2005-04-17 05:20:36 +07:00
|
|
|
size_t count,
|
|
|
|
int ioflag,
|
|
|
|
xfs_bmbt_irec_t *ret_imap,
|
|
|
|
int *nmaps)
|
|
|
|
{
|
|
|
|
xfs_mount_t *mp = ip->i_mount;
|
|
|
|
xfs_fileoff_t offset_fsb;
|
|
|
|
xfs_fileoff_t last_fsb;
|
2006-01-11 11:28:28 +07:00
|
|
|
xfs_off_t aligned_offset;
|
|
|
|
xfs_fileoff_t ioalign;
|
2005-04-17 05:20:36 +07:00
|
|
|
xfs_fsblock_t firstblock;
|
2006-01-11 11:28:28 +07:00
|
|
|
xfs_extlen_t extsz;
|
2005-04-17 05:20:36 +07:00
|
|
|
int nimaps;
|
|
|
|
xfs_bmbt_irec_t imap[XFS_WRITE_IMAPS];
|
2009-04-06 23:49:12 +07:00
|
|
|
int prealloc, flushed = 0;
|
2006-01-11 11:28:28 +07:00
|
|
|
int error;
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2008-04-22 14:34:00 +07:00
|
|
|
ASSERT(xfs_isilocked(ip, XFS_ILOCK_EXCL));
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Make sure that the dquots are there. This doesn't hold
|
|
|
|
* the ilock across a disk read.
|
|
|
|
*/
|
2009-06-08 20:33:32 +07:00
|
|
|
error = xfs_qm_dqattach_locked(ip, 0);
|
2005-04-17 05:20:36 +07:00
|
|
|
if (error)
|
|
|
|
return XFS_ERROR(error);
|
|
|
|
|
2007-06-18 13:50:37 +07:00
|
|
|
extsz = xfs_get_extsz_hint(ip);
|
2006-01-11 11:28:28 +07:00
|
|
|
offset_fsb = XFS_B_TO_FSBT(mp, offset);
|
|
|
|
|
2008-12-22 13:56:49 +07:00
|
|
|
error = xfs_iomap_eof_want_preallocate(mp, ip, offset, count,
|
2006-01-11 11:28:28 +07:00
|
|
|
ioflag, imap, XFS_WRITE_IMAPS, &prealloc);
|
|
|
|
if (error)
|
|
|
|
return error;
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2009-04-06 23:49:12 +07:00
|
|
|
retry:
|
2006-01-11 11:28:28 +07:00
|
|
|
if (prealloc) {
|
2005-04-17 05:20:36 +07:00
|
|
|
aligned_offset = XFS_WRITEIO_ALIGN(mp, (offset + count - 1));
|
|
|
|
ioalign = XFS_B_TO_FSBT(mp, aligned_offset);
|
2006-01-11 11:28:28 +07:00
|
|
|
last_fsb = ioalign + mp->m_writeio_blocks;
|
|
|
|
} else {
|
|
|
|
last_fsb = XFS_B_TO_FSB(mp, ((xfs_ufsize_t)(offset + count)));
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
|
|
|
|
2006-01-11 11:28:28 +07:00
|
|
|
if (prealloc || extsz) {
|
2008-12-22 13:56:49 +07:00
|
|
|
error = xfs_iomap_eof_align_last_fsb(mp, ip, extsz, &last_fsb);
|
2006-01-11 11:28:28 +07:00
|
|
|
if (error)
|
2005-04-17 05:20:36 +07:00
|
|
|
return error;
|
|
|
|
}
|
2006-01-11 11:28:28 +07:00
|
|
|
|
|
|
|
nimaps = XFS_WRITE_IMAPS;
|
|
|
|
firstblock = NULLFSBLOCK;
|
2007-10-11 14:34:33 +07:00
|
|
|
error = xfs_bmapi(NULL, ip, offset_fsb,
|
2005-04-17 05:20:36 +07:00
|
|
|
(xfs_filblks_t)(last_fsb - offset_fsb),
|
|
|
|
XFS_BMAPI_DELAY | XFS_BMAPI_WRITE |
|
|
|
|
XFS_BMAPI_ENTIRE, &firstblock, 1, imap,
|
2006-06-09 11:48:12 +07:00
|
|
|
&nimaps, NULL, NULL);
|
2006-01-11 11:28:28 +07:00
|
|
|
if (error && (error != ENOSPC))
|
2005-04-17 05:20:36 +07:00
|
|
|
return XFS_ERROR(error);
|
2006-01-11 11:28:28 +07:00
|
|
|
|
2005-04-17 05:20:36 +07:00
|
|
|
/*
|
|
|
|
* If bmapi returned us nothing, and if we didn't get back EDQUOT,
|
2009-04-06 23:49:12 +07:00
|
|
|
* then we must have run out of space - flush all other inodes with
|
|
|
|
* delalloc blocks and retry without EOF preallocation.
|
2005-04-17 05:20:36 +07:00
|
|
|
*/
|
|
|
|
if (nimaps == 0) {
|
|
|
|
xfs_iomap_enter_trace(XFS_IOMAP_WRITE_NOSPACE,
|
2007-10-11 14:34:33 +07:00
|
|
|
ip, offset, count);
|
2009-04-06 23:49:12 +07:00
|
|
|
if (flushed)
|
2005-04-17 05:20:36 +07:00
|
|
|
return XFS_ERROR(ENOSPC);
|
|
|
|
|
2009-04-06 23:49:12 +07:00
|
|
|
xfs_iunlock(ip, XFS_ILOCK_EXCL);
|
|
|
|
xfs_flush_inodes(ip);
|
|
|
|
xfs_ilock(ip, XFS_ILOCK_EXCL);
|
|
|
|
|
|
|
|
flushed = 1;
|
2005-04-17 05:20:36 +07:00
|
|
|
error = 0;
|
2009-04-06 23:49:12 +07:00
|
|
|
prealloc = 0;
|
2005-04-17 05:20:36 +07:00
|
|
|
goto retry;
|
|
|
|
}
|
|
|
|
|
2008-04-29 09:53:21 +07:00
|
|
|
if (!(imap[0].br_startblock || XFS_IS_REALTIME_INODE(ip)))
|
2006-09-28 08:03:20 +07:00
|
|
|
return xfs_cmn_err_fsblock_zero(ip, &imap[0]);
|
2006-01-11 11:28:28 +07:00
|
|
|
|
|
|
|
*ret_imap = imap[0];
|
|
|
|
*nmaps = 1;
|
|
|
|
|
2005-04-17 05:20:36 +07:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Pass in a delayed allocate extent, convert it to real extents;
|
|
|
|
* return to the caller the extent we create which maps on top of
|
|
|
|
* the originating callers request.
|
|
|
|
*
|
|
|
|
* Called without a lock on the inode.
|
2007-11-23 12:29:11 +07:00
|
|
|
*
|
|
|
|
* We no longer bother to look at the incoming map - all we have to
|
|
|
|
* guarantee is that whatever we allocate fills the required range.
|
2005-04-17 05:20:36 +07:00
|
|
|
*/
|
|
|
|
int
|
|
|
|
xfs_iomap_write_allocate(
|
|
|
|
xfs_inode_t *ip,
|
2005-05-06 03:33:40 +07:00
|
|
|
xfs_off_t offset,
|
2005-05-06 03:33:20 +07:00
|
|
|
size_t count,
|
2005-04-17 05:20:36 +07:00
|
|
|
xfs_bmbt_irec_t *map,
|
|
|
|
int *retmap)
|
|
|
|
{
|
|
|
|
xfs_mount_t *mp = ip->i_mount;
|
|
|
|
xfs_fileoff_t offset_fsb, last_block;
|
|
|
|
xfs_fileoff_t end_fsb, map_start_fsb;
|
|
|
|
xfs_fsblock_t first_block;
|
|
|
|
xfs_bmap_free_t free_list;
|
|
|
|
xfs_filblks_t count_fsb;
|
2007-11-23 12:29:11 +07:00
|
|
|
xfs_bmbt_irec_t imap;
|
2005-04-17 05:20:36 +07:00
|
|
|
xfs_trans_t *tp;
|
2007-11-23 12:29:11 +07:00
|
|
|
int nimaps, committed;
|
2005-04-17 05:20:36 +07:00
|
|
|
int error = 0;
|
|
|
|
int nres;
|
|
|
|
|
|
|
|
*retmap = 0;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Make sure that the dquots are there.
|
|
|
|
*/
|
2009-06-08 20:33:32 +07:00
|
|
|
error = xfs_qm_dqattach(ip, 0);
|
|
|
|
if (error)
|
2005-04-17 05:20:36 +07:00
|
|
|
return XFS_ERROR(error);
|
|
|
|
|
2005-05-06 03:33:20 +07:00
|
|
|
offset_fsb = XFS_B_TO_FSBT(mp, offset);
|
2005-04-17 05:20:36 +07:00
|
|
|
count_fsb = map->br_blockcount;
|
2005-05-06 03:33:20 +07:00
|
|
|
map_start_fsb = map->br_startoff;
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
XFS_STATS_ADD(xs_xstrat_bytes, XFS_FSB_TO_B(mp, count_fsb));
|
|
|
|
|
|
|
|
while (count_fsb != 0) {
|
|
|
|
/*
|
|
|
|
* Set up a transaction with which to allocate the
|
|
|
|
* backing store for the file. Do allocations in a
|
|
|
|
* loop until we get some space in the range we are
|
|
|
|
* interested in. The other space that might be allocated
|
|
|
|
* is in the delayed allocation extent on which we sit
|
|
|
|
* but before our buffer starts.
|
|
|
|
*/
|
|
|
|
|
|
|
|
nimaps = 0;
|
|
|
|
while (nimaps == 0) {
|
|
|
|
tp = xfs_trans_alloc(mp, XFS_TRANS_STRAT_WRITE);
|
2007-06-18 13:50:27 +07:00
|
|
|
tp->t_flags |= XFS_TRANS_RESERVE;
|
2005-04-17 05:20:36 +07:00
|
|
|
nres = XFS_EXTENTADD_SPACE_RES(mp, XFS_DATA_FORK);
|
|
|
|
error = xfs_trans_reserve(tp, nres,
|
|
|
|
XFS_WRITE_LOG_RES(mp),
|
|
|
|
0, XFS_TRANS_PERM_LOG_RES,
|
|
|
|
XFS_WRITE_LOG_COUNT);
|
|
|
|
if (error) {
|
|
|
|
xfs_trans_cancel(tp, 0);
|
|
|
|
return XFS_ERROR(error);
|
|
|
|
}
|
|
|
|
xfs_ilock(ip, XFS_ILOCK_EXCL);
|
|
|
|
xfs_trans_ijoin(tp, ip, XFS_ILOCK_EXCL);
|
|
|
|
xfs_trans_ihold(tp, ip);
|
|
|
|
|
2009-01-15 12:22:07 +07:00
|
|
|
xfs_bmap_init(&free_list, &first_block);
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
/*
|
2007-11-23 12:29:11 +07:00
|
|
|
* it is possible that the extents have changed since
|
|
|
|
* we did the read call as we dropped the ilock for a
|
|
|
|
* while. We have to be careful about truncates or hole
|
|
|
|
* punchs here - we are not allowed to allocate
|
|
|
|
* non-delalloc blocks here.
|
|
|
|
*
|
|
|
|
* The only protection against truncation is the pages
|
|
|
|
* for the range we are being asked to convert are
|
|
|
|
* locked and hence a truncate will block on them
|
|
|
|
* first.
|
|
|
|
*
|
|
|
|
* As a result, if we go beyond the range we really
|
|
|
|
* need and hit an delalloc extent boundary followed by
|
|
|
|
* a hole while we have excess blocks in the map, we
|
|
|
|
* will fill the hole incorrectly and overrun the
|
|
|
|
* transaction reservation.
|
|
|
|
*
|
|
|
|
* Using a single map prevents this as we are forced to
|
|
|
|
* check each map we look for overlap with the desired
|
|
|
|
* range and abort as soon as we find it. Also, given
|
|
|
|
* that we only return a single map, having one beyond
|
|
|
|
* what we can return is probably a bit silly.
|
|
|
|
*
|
|
|
|
* We also need to check that we don't go beyond EOF;
|
|
|
|
* this is a truncate optimisation as a truncate sets
|
|
|
|
* the new file size before block on the pages we
|
|
|
|
* currently have locked under writeback. Because they
|
|
|
|
* are about to be tossed, we don't need to write them
|
|
|
|
* back....
|
2005-04-17 05:20:36 +07:00
|
|
|
*/
|
2007-11-23 12:29:11 +07:00
|
|
|
nimaps = 1;
|
[XFS] Fix to prevent the notorious 'NULL files' problem after a crash.
The problem that has been addressed is that of synchronising updates of
the file size with writes that extend a file. Without the fix the update
of a file's size, as a result of a write beyond eof, is independent of
when the cached data is flushed to disk. Often the file size update would
be written to the filesystem log before the data is flushed to disk. When
a system crashes between these two events and the filesystem log is
replayed on mount the file's size will be set but since the contents never
made it to disk the file is full of holes. If some of the cached data was
flushed to disk then it may just be a section of the file at the end that
has holes.
There are existing fixes to help alleviate this problem, particularly in
the case where a file has been truncated, that force cached data to be
flushed to disk when the file is closed. If the system crashes while the
file(s) are still open then this flushing will never occur.
The fix that we have implemented is to introduce a second file size,
called the in-memory file size, that represents the current file size as
viewed by the user. The existing file size, called the on-disk file size,
is the one that get's written to the filesystem log and we only update it
when it is safe to do so. When we write to a file beyond eof we only
update the in- memory file size in the write operation. Later when the I/O
operation, that flushes the cached data to disk completes, an I/O
completion routine will update the on-disk file size. The on-disk file
size will be updated to the maximum offset of the I/O or to the value of
the in-memory file size if the I/O includes eof.
SGI-PV: 958522
SGI-Modid: xfs-linux-melb:xfs-kern:28322a
Signed-off-by: Lachlan McIlroy <lachlan@sgi.com>
Signed-off-by: David Chinner <dgc@sgi.com>
Signed-off-by: Tim Shimmin <tes@sgi.com>
2007-05-08 10:49:46 +07:00
|
|
|
end_fsb = XFS_B_TO_FSB(mp, ip->i_size);
|
2008-04-10 09:21:59 +07:00
|
|
|
error = xfs_bmap_last_offset(NULL, ip, &last_block,
|
|
|
|
XFS_DATA_FORK);
|
|
|
|
if (error)
|
|
|
|
goto trans_cancel;
|
|
|
|
|
2005-04-17 05:20:36 +07:00
|
|
|
last_block = XFS_FILEOFF_MAX(last_block, end_fsb);
|
|
|
|
if ((map_start_fsb + count_fsb) > last_block) {
|
|
|
|
count_fsb = last_block - map_start_fsb;
|
|
|
|
if (count_fsb == 0) {
|
|
|
|
error = EAGAIN;
|
|
|
|
goto trans_cancel;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Go get the actual blocks */
|
2007-10-11 14:34:33 +07:00
|
|
|
error = xfs_bmapi(tp, ip, map_start_fsb, count_fsb,
|
2005-04-17 05:20:36 +07:00
|
|
|
XFS_BMAPI_WRITE, &first_block, 1,
|
2007-11-23 12:29:11 +07:00
|
|
|
&imap, &nimaps, &free_list, NULL);
|
2005-04-17 05:20:36 +07:00
|
|
|
if (error)
|
|
|
|
goto trans_cancel;
|
|
|
|
|
2007-02-10 14:37:16 +07:00
|
|
|
error = xfs_bmap_finish(&tp, &free_list, &committed);
|
2005-04-17 05:20:36 +07:00
|
|
|
if (error)
|
|
|
|
goto trans_cancel;
|
|
|
|
|
2007-05-08 10:48:42 +07:00
|
|
|
error = xfs_trans_commit(tp, XFS_TRANS_RELEASE_LOG_RES);
|
2005-04-17 05:20:36 +07:00
|
|
|
if (error)
|
|
|
|
goto error0;
|
|
|
|
|
|
|
|
xfs_iunlock(ip, XFS_ILOCK_EXCL);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* See if we were able to allocate an extent that
|
|
|
|
* covers at least part of the callers request
|
|
|
|
*/
|
2008-04-29 09:53:21 +07:00
|
|
|
if (!(imap.br_startblock || XFS_IS_REALTIME_INODE(ip)))
|
2007-11-23 12:29:11 +07:00
|
|
|
return xfs_cmn_err_fsblock_zero(ip, &imap);
|
2008-04-29 09:53:21 +07:00
|
|
|
|
2007-11-23 12:29:11 +07:00
|
|
|
if ((offset_fsb >= imap.br_startoff) &&
|
|
|
|
(offset_fsb < (imap.br_startoff +
|
|
|
|
imap.br_blockcount))) {
|
|
|
|
*map = imap;
|
|
|
|
*retmap = 1;
|
|
|
|
XFS_STATS_INC(xs_xstrat_quick);
|
|
|
|
return 0;
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
|
|
|
|
2007-11-23 12:29:11 +07:00
|
|
|
/*
|
|
|
|
* So far we have not mapped the requested part of the
|
2005-04-17 05:20:36 +07:00
|
|
|
* file, just surrounding data, try again.
|
|
|
|
*/
|
2007-11-23 12:29:11 +07:00
|
|
|
count_fsb -= imap.br_blockcount;
|
|
|
|
map_start_fsb = imap.br_startoff + imap.br_blockcount;
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
trans_cancel:
|
|
|
|
xfs_bmap_cancel(&free_list);
|
|
|
|
xfs_trans_cancel(tp, XFS_TRANS_RELEASE_LOG_RES | XFS_TRANS_ABORT);
|
|
|
|
error0:
|
|
|
|
xfs_iunlock(ip, XFS_ILOCK_EXCL);
|
|
|
|
return XFS_ERROR(error);
|
|
|
|
}
|
|
|
|
|
|
|
|
int
|
|
|
|
xfs_iomap_write_unwritten(
|
|
|
|
xfs_inode_t *ip,
|
2005-05-06 03:33:40 +07:00
|
|
|
xfs_off_t offset,
|
2005-04-17 05:20:36 +07:00
|
|
|
size_t count)
|
|
|
|
{
|
|
|
|
xfs_mount_t *mp = ip->i_mount;
|
|
|
|
xfs_fileoff_t offset_fsb;
|
|
|
|
xfs_filblks_t count_fsb;
|
|
|
|
xfs_filblks_t numblks_fsb;
|
2006-01-11 11:28:28 +07:00
|
|
|
xfs_fsblock_t firstfsb;
|
|
|
|
int nimaps;
|
|
|
|
xfs_trans_t *tp;
|
|
|
|
xfs_bmbt_irec_t imap;
|
|
|
|
xfs_bmap_free_t free_list;
|
|
|
|
uint resblks;
|
2005-04-17 05:20:36 +07:00
|
|
|
int committed;
|
|
|
|
int error;
|
|
|
|
|
2007-10-11 14:34:33 +07:00
|
|
|
xfs_iomap_enter_trace(XFS_IOMAP_UNWRITTEN, ip, offset, count);
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
offset_fsb = XFS_B_TO_FSBT(mp, offset);
|
|
|
|
count_fsb = XFS_B_TO_FSB(mp, (xfs_ufsize_t)offset + count);
|
|
|
|
count_fsb = (xfs_filblks_t)(count_fsb - offset_fsb);
|
|
|
|
|
2008-06-27 10:32:53 +07:00
|
|
|
/*
|
|
|
|
* Reserve enough blocks in this transaction for two complete extent
|
|
|
|
* btree splits. We may be converting the middle part of an unwritten
|
|
|
|
* extent and in this case we will insert two new extents in the btree
|
|
|
|
* each of which could cause a full split.
|
|
|
|
*
|
|
|
|
* This reservation amount will be used in the first call to
|
|
|
|
* xfs_bmbt_split() to select an AG with enough space to satisfy the
|
|
|
|
* rest of the operation.
|
|
|
|
*/
|
2006-01-11 11:28:28 +07:00
|
|
|
resblks = XFS_DIOSTRAT_SPACE_RES(mp, 0) << 1;
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2006-01-11 11:28:28 +07:00
|
|
|
do {
|
2005-04-17 05:20:36 +07:00
|
|
|
/*
|
|
|
|
* set up a transaction to convert the range of extents
|
|
|
|
* from unwritten to real. Do allocations in a loop until
|
|
|
|
* we have covered the range passed in.
|
|
|
|
*/
|
|
|
|
tp = xfs_trans_alloc(mp, XFS_TRANS_STRAT_WRITE);
|
2007-06-18 13:50:27 +07:00
|
|
|
tp->t_flags |= XFS_TRANS_RESERVE;
|
2006-01-11 11:28:28 +07:00
|
|
|
error = xfs_trans_reserve(tp, resblks,
|
2005-04-17 05:20:36 +07:00
|
|
|
XFS_WRITE_LOG_RES(mp), 0,
|
|
|
|
XFS_TRANS_PERM_LOG_RES,
|
|
|
|
XFS_WRITE_LOG_COUNT);
|
|
|
|
if (error) {
|
|
|
|
xfs_trans_cancel(tp, 0);
|
2006-09-28 08:03:20 +07:00
|
|
|
return XFS_ERROR(error);
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
xfs_ilock(ip, XFS_ILOCK_EXCL);
|
|
|
|
xfs_trans_ijoin(tp, ip, XFS_ILOCK_EXCL);
|
|
|
|
xfs_trans_ihold(tp, ip);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Modify the unwritten extent state of the buffer.
|
|
|
|
*/
|
2009-01-15 12:22:07 +07:00
|
|
|
xfs_bmap_init(&free_list, &firstfsb);
|
2005-04-17 05:20:36 +07:00
|
|
|
nimaps = 1;
|
2007-10-11 14:34:33 +07:00
|
|
|
error = xfs_bmapi(tp, ip, offset_fsb, count_fsb,
|
2006-01-11 11:28:28 +07:00
|
|
|
XFS_BMAPI_WRITE|XFS_BMAPI_CONVERT, &firstfsb,
|
2006-06-09 11:48:12 +07:00
|
|
|
1, &imap, &nimaps, &free_list, NULL);
|
2005-04-17 05:20:36 +07:00
|
|
|
if (error)
|
|
|
|
goto error_on_bmapi_transaction;
|
|
|
|
|
2007-02-10 14:37:16 +07:00
|
|
|
error = xfs_bmap_finish(&(tp), &(free_list), &committed);
|
2005-04-17 05:20:36 +07:00
|
|
|
if (error)
|
|
|
|
goto error_on_bmapi_transaction;
|
|
|
|
|
2007-05-08 10:48:42 +07:00
|
|
|
error = xfs_trans_commit(tp, XFS_TRANS_RELEASE_LOG_RES);
|
2005-04-17 05:20:36 +07:00
|
|
|
xfs_iunlock(ip, XFS_ILOCK_EXCL);
|
|
|
|
if (error)
|
2006-09-28 08:03:20 +07:00
|
|
|
return XFS_ERROR(error);
|
|
|
|
|
2008-04-29 09:53:21 +07:00
|
|
|
if (!(imap.br_startblock || XFS_IS_REALTIME_INODE(ip)))
|
2006-09-28 08:03:20 +07:00
|
|
|
return xfs_cmn_err_fsblock_zero(ip, &imap);
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
if ((numblks_fsb = imap.br_blockcount) == 0) {
|
|
|
|
/*
|
|
|
|
* The numblks_fsb value should always get
|
|
|
|
* smaller, otherwise the loop is stuck.
|
|
|
|
*/
|
|
|
|
ASSERT(imap.br_blockcount);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
offset_fsb += numblks_fsb;
|
|
|
|
count_fsb -= numblks_fsb;
|
|
|
|
} while (count_fsb > 0);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
error_on_bmapi_transaction:
|
|
|
|
xfs_bmap_cancel(&free_list);
|
|
|
|
xfs_trans_cancel(tp, (XFS_TRANS_RELEASE_LOG_RES | XFS_TRANS_ABORT));
|
|
|
|
xfs_iunlock(ip, XFS_ILOCK_EXCL);
|
|
|
|
return XFS_ERROR(error);
|
|
|
|
}
|