File: [Development] / xfs-linux / xfs_rw.c (download)
Revision 1.100, Tue Nov 8 03:00:51 1994 UTC (22 years, 11 months ago) by orosz
Branch: MAIN
Changes since 1.99: +1 -1
lines
Put the kernel-only content of sys/dmi.h into io/dmi/dmi_kern.h.
|
#ifdef SIM
#define _KERNEL 1
#endif
#include <sys/param.h>
#include <sys/buf.h>
#include <sys/uio.h>
#include <sys/vfs.h>
#include <sys/vnode.h>
#include <sys/cred.h>
#include <sys/sysmacros.h>
#include <sys/pfdat.h>
#include <sys/proc.h>
#include <sys/user.h>
#include <sys/grio.h>
#include <sys/pda.h>
#ifdef SIM
#undef _KERNEL
#endif
#include <sys/cmn_err.h>
#include <sys/debug.h>
#include <sys/errno.h>
#include <sys/fcntl.h>
#include <sys/var.h>
#ifdef SIM
#include <bstring.h>
#include <stdio.h>
#else
#include <sys/conf.h>
#include <sys/systm.h>
#endif
#include <sys/kmem.h>
#include <sys/sema.h>
#include <sys/file.h>
#include <io/dmi/dmi_kern.h>
#include <sys/region.h>
#include <sys/runq.h>
#include <sys/schedctl.h>
#include <sys/atomic_ops.h>
#include <sys/ktrace.h>
#include <sys/sysinfo.h>
#include <sys/ksa.h>
#include "xfs_types.h"
#include "xfs_inum.h"
#include "xfs_log.h"
#include "xfs_trans.h"
#include "xfs_sb.h"
#include "xfs_ag.h"
#include "xfs_mount.h"
#include "xfs_alloc_btree.h"
#include "xfs_bmap_btree.h"
#include "xfs_ialloc_btree.h"
#include "xfs_btree.h"
#include "xfs_alloc.h"
#include "xfs_bmap.h"
#include "xfs_ialloc.h"
#include "xfs_dinode.h"
#include "xfs_inode_item.h"
#include "xfs_inode.h"
#include "xfs_error.h"
#include "xfs_rw.h"
#ifdef SIM
#include "sim.h"
#endif
/*
* This lock is used by xfs_strat_write().
* The xfs_strat_lock is initialized in xfs_init().
*/
lock_t xfs_strat_lock;
/*
* Variables for coordination with the xfsd daemons.
* The xfsd_lock and xfsd_wait variables are initialized
* in xfs_init();
*/
static int xfsd_count;
static buf_t *xfsd_list;
static int xfsd_bufcount;
lock_t xfsd_lock;
sema_t xfsd_wait;
/*
* Zone allocator for arrays of xfs_bmbt_irec_t used
* for calls to xfs_bmapi().
*/
zone_t *xfs_irec_zone;
/*
* Zone allocator for arrays of bmapval structures
* used in calls to xfs_iomap_XXX routines.
*/
zone_t *xfs_bmap_zone;
/*
* Zone allocator for local variables in xfs_strat_write().
* This routine is a real problem so we take extreme measures.
*/
zone_t *xfs_strat_write_zone;
/*
* Global trace buffer for xfs_strat_write() tracing.
*/
ktrace_t *xfs_strat_trace_buf;
#ifndef DEBUG
#define xfs_strat_write_bp_trace(tag, ip, bp)
#define xfs_strat_write_subbp_trace(tag, ip, bp, rbp, loff, lcnt, lblk)
#endif /* !DEBUG */
STATIC void
xfs_zero_last_block(
xfs_inode_t *ip,
off_t offset,
xfs_fsize_t isize,
cred_t *credp);
STATIC void
xfs_zero_bp(
buf_t *bp,
int data_offset,
int data_len);
STATIC int
xfs_retrieved(
int available,
off_t offset,
int count,
uint *total_retrieved,
xfs_fsize_t isize);
#ifndef DEBUG
#define xfs_strat_write_check(ip,off,count,imap,nimap)
#define xfs_check_rbp(ip,bp,rbp,locked)
#define xfs_check_bp(ip,bp)
#define xfs_check_gap_list(ip)
#else /* DEBUG */
STATIC void
xfs_strat_write_check(
xfs_inode_t *ip,
xfs_fileoff_t offset_fsb,
xfs_extlen_t buf_fsb,
xfs_bmbt_irec_t *imap,
int imap_count);
STATIC void
xfs_check_rbp(
xfs_inode_t *ip,
buf_t *bp,
buf_t *rbp,
int locked);
STATIC void
xfs_check_bp(
xfs_inode_t *ip,
buf_t *bp);
STATIC void
xfs_check_gap_list(
xfs_inode_t *ip);
#endif /* DEBUG */
STATIC void
xfs_build_gap_list(
xfs_inode_t *ip,
off_t offset,
size_t count);
STATIC void
xfs_free_gap_list(
xfs_inode_t *ip);
STATIC void
xfs_cmp_gap_list_and_zero(
xfs_inode_t *ip,
buf_t *bp);
STATIC void
xfs_delete_gap_list(
xfs_inode_t *ip,
xfs_fileoff_t offset_fsb,
xfs_extlen_t count_fsb);
STATIC int
xfsd(void);
int
xfs_diordwr(
vnode_t *vp,
uio_t *uiop,
int ioflag,
cred_t *credp,
int rw);
extern int
xfs_grio_req(
xfs_inode_t *,
struct reservation_id *,
uio_t *,
int,
cred_t *,
off_t,
int);
/*
* Round the given file offset down to the nearest read/write
* size boundary.
*/
#define XFS_READIO_ALIGN(mp,off) (((off) >> mp->m_readio_log) \
<< mp->m_readio_log)
#define XFS_WRITEIO_ALIGN(mp,off) (((off) >> mp->m_writeio_log) \
<< mp->m_writeio_log)
#ifndef DEBUG
#define xfs_rw_enter_trace(tag, ip, uiop, ioflags)
#define xfs_iomap_enter_trace(tag, ip, offset, count);
#define xfs_iomap_map_trace(tag, ip, offset, count, bmapp, imapp)
#else
/*
* Trace routine for the read/write path. This is the routine entry trace.
*/
void
xfs_rw_enter_trace(
int tag,
xfs_inode_t *ip,
uio_t *uiop,
int ioflags)
{
if (ip->i_rwtrace == NULL) {
return;
}
ktrace_enter(ip->i_rwtrace,
(void*)tag,
(void*)ip,
(void*)((ip->i_d.di_size >> 32) & 0xffffffff),
(void*)(ip->i_d.di_size & 0xffffffff),
(void*)(((__uint64_t)uiop->uio_offset > 32) & 0xffffffff),
(void*)(uiop->uio_offset & 0xffffffff),
(void*)uiop->uio_resid,
(void*)ioflags,
(void*)((ip->i_next_offset > 32) & 0xffffffff),
(void*)(ip->i_next_offset & 0xffffffff),
(void*)((ip->i_io_offset > 32) & 0xffffffff),
(void*)(ip->i_io_offset & 0xffffffff),
(void*)(ip->i_io_size),
(void*)(ip->i_last_req_sz),
(void*)((ip->i_new_size > 32) & 0xffffffff),
(void*)(ip->i_new_size & 0xffffffff));
}
void
xfs_iomap_enter_trace(
int tag,
xfs_inode_t *ip,
off_t offset,
int count)
{
if (ip->i_rwtrace == NULL) {
return;
}
ktrace_enter(ip->i_rwtrace,
(void*)tag,
(void*)ip,
(void*)((ip->i_d.di_size >> 32) & 0xffffffff),
(void*)(ip->i_d.di_size & 0xffffffff),
(void*)(((__uint64_t)offset >> 32) & 0xffffffff),
(void*)(offset & 0xffffffff),
(void*)count,
(void*)((ip->i_next_offset >> 32) & 0xffffffff),
(void*)(ip->i_next_offset & 0xffffffff),
(void*)((ip->i_io_offset >> 32) & 0xffffffff),
(void*)(ip->i_io_offset & 0xffffffff),
(void*)(ip->i_io_size),
(void*)(ip->i_last_req_sz),
(void*)((ip->i_new_size >> 32) & 0xffffffff),
(void*)(ip->i_new_size & 0xffffffff),
(void*)0);
}
void
xfs_iomap_map_trace(
int tag,
xfs_inode_t *ip,
off_t offset,
int count,
struct bmapval *bmapp,
xfs_bmbt_irec_t *imapp)
{
if (ip->i_rwtrace == NULL) {
return;
}
ktrace_enter(ip->i_rwtrace,
(void*)tag,
(void*)ip,
(void*)((ip->i_d.di_size >> 32) & 0xffffffff),
(void*)(ip->i_d.di_size & 0xffffffff),
(void*)(((__uint64_t)offset >> 32) & 0xffffffff),
(void*)(offset & 0xffffffff),
(void*)count,
(void*)((bmapp->offset >> 32) & 0xffffffff),
(void*)(bmapp->offset & 0xffffffff),
(void*)(bmapp->length),
(void*)(bmapp->pboff),
(void*)(bmapp->pbsize),
(void*)(bmapp->bn),
(void*)(imapp->br_startoff),
(void*)(imapp->br_blockcount),
(void*)(imapp->br_startblock));
}
#endif /* DEBUG */
/*
* Fill in the bmap structure to indicate how the next bp
* should fit over the given extent.
*
* Everything here is in terms of file system blocks, not BBs.
*/
void
xfs_next_bmap(
xfs_mount_t *mp,
xfs_bmbt_irec_t *imapp,
struct bmapval *bmapp,
int iosize,
int last_iosize,
xfs_fileoff_t ioalign,
xfs_fileoff_t last_offset,
xfs_fileoff_t req_offset,
xfs_fsize_t isize)
{
__int64_t extra_blocks;
xfs_fileoff_t size_diff;
xfs_fileoff_t ext_offset;
xfs_fileoff_t last_file_fsb;
xfs_fsblock_t start_block;
/*
* Make sure that the request offset lies in the extent given.
*/
ASSERT(req_offset >= imapp->br_startoff);
ASSERT(req_offset < (imapp->br_startoff + imapp->br_blockcount));
if (last_offset == -1) {
ASSERT(ioalign != -1);
if (ioalign < imapp->br_startoff) {
/*
* The alignment we guessed at can't
* happen on this extent, so align
* to the beginning of this extent.
* Subtract whatever we drop from the
* iosize so that we stay aligned on
* our iosize boundaries.
*/
size_diff = imapp->br_startoff - ioalign;
iosize -= size_diff;
ASSERT(iosize > 0);
ext_offset = 0;
bmapp->offset = imapp->br_startoff;
ASSERT(bmapp->offset <= req_offset);
} else {
/*
* The alignment requested fits on this
* extent, so use it.
*/
ext_offset = ioalign - imapp->br_startoff;
bmapp->offset = ioalign;
ASSERT(bmapp->offset <= req_offset);
}
} else {
/*
* This is one of a series of sequential access to the
* file. Make sure to line up the buffer we specify
* so that it doesn't overlap the last one. It should
* either be the same as the last one (if we need data
* from it) or follow immediately after the last one.
*/
ASSERT(ioalign == -1);
if (last_offset >= imapp->br_startoff) {
/*
* The last I/O was from the same extent
* that this one will at least start on.
* This assumes that we're going sequentially.
*/
if (req_offset < (last_offset + last_iosize)) {
/*
* This request overlaps the buffer
* we used for the last request. Just
* get that buffer again.
*/
ext_offset = last_offset -
imapp->br_startoff;
bmapp->offset = last_offset;
iosize = last_iosize;
} else {
/*
* This request does not overlap the buffer
* used for the last one. Get it its own.
*/
ext_offset = req_offset - imapp->br_startoff;
bmapp->offset = req_offset;
}
} else {
/*
* The last I/O was on a different extent than
* this one. We start at the beginning of this one.
* This assumes that we're going sequentially.
*/
ext_offset = 0;
bmapp->offset = req_offset;
ASSERT(bmapp->offset == imapp->br_startoff);
}
}
start_block = imapp->br_startblock;
if (start_block == HOLESTARTBLOCK) {
bmapp->bn = -1;
bmapp->eof = BMAP_HOLE;
} else if (start_block == DELAYSTARTBLOCK) {
bmapp->bn = -1;
bmapp->eof = BMAP_DELAY;
} else {
bmapp->bn = start_block + ext_offset;
bmapp->eof = 0;
}
bmapp->length = iosize;
/*
* If the iosize from our offset extends beyond the
* end of the extent, then trim down the length
* to match that of the extent.
*/
extra_blocks = (off_t)(bmapp->offset + bmapp->length) -
(__uint64_t)(imapp->br_startoff +
imapp->br_blockcount);
if (extra_blocks > 0) {
bmapp->length -= extra_blocks;
ASSERT(bmapp->length > 0);
}
/*
* If the iosize from our offset extends beyond the end
* of the file, then trim down the length to match the
* size of the file. The extent may go beyond the end,
* but all data beyond the EOF must be inaccessible.
*/
last_file_fsb = XFS_B_TO_FSB(mp, isize);
extra_blocks = (off_t)(bmapp->offset + bmapp->length) -
(__uint64_t)last_file_fsb;
if (extra_blocks > 0) {
bmapp->length -= extra_blocks;
ASSERT(bmapp->length > 0);
}
ASSERT((bmapp->offset + bmapp->length) <= last_file_fsb);
bmapp->bsize = XFS_FSB_TO_B(mp, bmapp->length);
}
/*
* xfs_retrieved() is a utility function used to calculate the
* value of bmap.pbsize.
*
* Available is the number of bytes mapped by the current bmap.
* Offset is the file offset of the current request by the user.
* Count is the size of the current request by the user.
* Total_retrieved is a running total of the number of bytes
* which have been setup for the user in this call so far.
* Isize is the current size of the file being read.
*/
STATIC int
xfs_retrieved(
int available,
off_t offset,
int count,
uint *total_retrieved,
xfs_fsize_t isize)
{
int retrieved;
xfs_fsize_t file_bytes_left;
if ((available + *total_retrieved) > count) {
/*
* This buffer will return more bytes
* than we asked for. Trim retrieved
* so we can set bmapp->pbsize correctly.
*/
retrieved = count - *total_retrieved;
} else {
retrieved = available;
}
file_bytes_left = isize - (offset + *total_retrieved);
if (file_bytes_left < retrieved) {
/*
* The user has requested more bytes
* than there are in the file. Trim
* down the number to those left in
* the file.
*/
retrieved = file_bytes_left;
}
*total_retrieved += retrieved;
return retrieved;
}
/*
* xfs_iomap_extra()
*
* This is called to fill in the bmapval for a page which overlaps
* the end of the file and the fs block size is less than the page
* size. We fill in the bmapval with zero sizes and offsets to
* indicate that there is nothing here to read since we're beyond
* the end of the file.
*/
STATIC void
xfs_iomap_extra(
xfs_inode_t *ip,
off_t offset,
size_t count,
struct bmapval *bmapp,
int *nbmaps)
{
xfs_fileoff_t offset_fsb;
xfs_fsize_t nisize;
xfs_mount_t *mp;
nisize = ip->i_new_size;
if (nisize < ip->i_d.di_size) {
nisize = ip->i_d.di_size;
}
ASSERT((offset == BBTOOFF(OFFTOBB(nisize))) && (count < NBPP));
ASSERT(ip->i_mount->m_sb.sb_blocksize < NBPP);
mp = ip->i_mount;
offset_fsb = XFS_B_TO_FSBT(mp, offset);
*nbmaps = 1;
bmapp->eof = BMAP_EOF;
bmapp->bn = -1;
bmapp->offset = XFS_FSB_TO_BB(mp, offset_fsb);
bmapp->length = 0;
bmapp->bsize = 0;
bmapp->pboff = 0;
bmapp->pbsize = 0;
if (ip->i_d.di_flags & XFS_DIFLAG_REALTIME) {
bmapp->pbdev = mp->m_rtdev;
} else {
bmapp->pbdev = mp->m_dev;
}
}
/*
* xfs_iomap_read()
*
* This is the main I/O policy routine for reads. It fills in
* the given bmapval structures to indicate what I/O requests
* should be used to read in the portion of the file for the given
* offset and count.
*
* The inode's I/O lock may be held SHARED here, but the inode lock
* must be held EXCL because it protects the read ahead state variables
* in the inode.
*/
void
xfs_iomap_read(
xfs_inode_t *ip,
off_t offset,
size_t count,
struct bmapval *bmapp,
int *nbmaps)
{
xfs_fileoff_t offset_fsb;
xfs_fileoff_t ioalign;
xfs_fileoff_t last_offset;
xfs_fileoff_t last_required_offset;
xfs_fileoff_t next_offset;
xfs_fileoff_t last_fsb;
xfs_fsize_t nisize;
off_t offset_page;
off_t aligned_offset;
int nimaps;
unsigned int iosize;
unsigned int last_iosize;
unsigned int retrieved_bytes;
unsigned int total_retrieved_bytes;
short filled_bmaps;
short read_aheads;
int x;
xfs_mount_t *mp;
struct bmapval *curr_bmapp;
struct bmapval *next_bmapp;
struct bmapval *last_bmapp;
struct bmapval *first_read_ahead_bmapp;
struct bmapval *next_read_ahead_bmapp;
xfs_bmbt_irec_t *curr_imapp;
xfs_bmbt_irec_t *last_imapp;
xfs_bmbt_irec_t *imap;
#define XFS_READ_IMAPS XFS_BMAP_MAX_NMAP
ASSERT(ismrlocked(&ip->i_lock, MR_UPDATE) != 0);
ASSERT(ismrlocked(&ip->i_iolock, MR_UPDATE | MR_ACCESS) != 0);
xfs_iomap_enter_trace(XFS_IOMAP_READ_ENTER, ip, offset, count);
mp = ip->i_mount;
nisize = ip->i_new_size;
if (nisize < ip->i_d.di_size) {
nisize = ip->i_d.di_size;
}
offset_fsb = XFS_B_TO_FSBT(mp, offset);
nimaps = XFS_READ_IMAPS;
last_fsb = XFS_B_TO_FSB(mp, nisize);
if (last_fsb <= offset_fsb) {
/*
* The VM/chunk code is trying to map a page to be
* pushed out which contains the last file block
* and byte. Since the file ended, we did not map
* the entire page, and now it is calling back to
* map the rest of it. Handle it here so that it
* does not interfere with the normal path code.
* This can only happen if the fs block size is
* less than the page size.
*/
xfs_iomap_extra(ip, offset, count, bmapp, nbmaps);
return;
}
imap = (xfs_bmbt_irec_t *)kmem_zone_alloc(xfs_irec_zone, KM_SLEEP);
(void)xfs_bmapi(NULL, ip, offset_fsb,
(xfs_extlen_t)(last_fsb - offset_fsb),
XFS_BMAPI_ENTIRE, NULLFSBLOCK, 0, imap,
&nimaps, NULL);
if ((offset == ip->i_next_offset) &&
(count <= ip->i_last_req_sz)) {
/*
* Sequential I/O of same size as last time.
*/
ASSERT(ip->i_io_size > 0);
iosize = ip->i_io_size;
ASSERT(iosize <= XFS_BB_TO_FSBT(mp, XFS_MAX_BMAP_LEN_BB));
last_offset = ip->i_io_offset;
ioalign = -1;
} else {
/*
* The I/O size for the file has not yet been
* determined, so figure it out.
*/
if (XFS_B_TO_FSB(mp, count) <= mp->m_readio_blocks) {
/*
* The request is smaller than our
* minimum I/O size, so default to
* the minimum. For these size requests
* we always want to align the requests
* to XFS_READ_SIZE boundaries as well.
*/
iosize = mp->m_readio_blocks;
ASSERT(iosize <=
XFS_BB_TO_FSBT(mp, XFS_MAX_BMAP_LEN_BB));
aligned_offset = XFS_READIO_ALIGN(mp, offset);
ioalign = XFS_B_TO_FSBT(mp, aligned_offset);
} else {
/*
* The request is bigger than our
* minimum I/O size and it's the
* first one in this sequence, so
* set the I/O size for the file
* now.
*
* In calculating the offset rounded down
* to a page, make sure to round down the
* fs block offset rather than the byte
* offset for the case where our block size
* is greater than the page size. This way
* offset_page will always align to a fs block
* as well as a page.
*
* For the end of the I/O we need to round
* offset + count up to a page boundary and
* then round that up to a file system block
* boundary.
*/
offset_page = ctooff(offtoct(XFS_FSB_TO_B(mp,
offset_fsb)));
last_fsb = XFS_B_TO_FSB(mp,
ctooff(offtoc(offset + count)));
iosize = last_fsb - XFS_B_TO_FSBT(mp, offset_page);
if (iosize >
XFS_BB_TO_FSBT(mp, XFS_MAX_BMAP_LEN_BB)) {
iosize = XFS_BB_TO_FSBT(mp,
XFS_MAX_BMAP_LEN_BB);
}
ioalign = XFS_B_TO_FSB(mp, offset_page);
}
last_offset = -1;
}
/*
* Now we've got the I/O size and the last offset,
* so start figuring out how to align our
* buffers.
*/
xfs_next_bmap(mp, imap, bmapp, iosize, iosize, ioalign,
last_offset, offset_fsb, nisize);
ASSERT((bmapp->length > 0) &&
(offset >= XFS_FSB_TO_B(mp, bmapp->offset)));
if (XFS_FSB_TO_B(mp, bmapp->offset + bmapp->length) >= nisize) {
bmapp->eof |= BMAP_EOF;
}
bmapp->pboff = offset - XFS_FSB_TO_B(mp, bmapp->offset);
retrieved_bytes = bmapp->bsize - bmapp->pboff;
total_retrieved_bytes = 0;
bmapp->pbsize = xfs_retrieved(retrieved_bytes, offset, count,
&total_retrieved_bytes, nisize);
xfs_iomap_map_trace(XFS_IOMAP_READ_MAP,
ip, offset, count, bmapp, imap);
/*
* Only map additional buffers if they've been asked for
* and the I/O being done is sequential and has reached the
* point where we need to initiate more read ahead or we didn't get
* the whole request in the first bmap.
*/
last_fsb = XFS_B_TO_FSB(mp, nisize);
ASSERT((bmapp->offset + bmapp->length) <= last_fsb);
filled_bmaps = 1;
last_required_offset = bmapp[0].offset;
first_read_ahead_bmapp = NULL;
if ((*nbmaps > 1) &&
(((offset == ip->i_next_offset) &&
(offset_fsb >= ip->i_reada_blkno)) ||
(retrieved_bytes < count))) {
curr_bmapp = &bmapp[0];
next_bmapp = &bmapp[1];
last_bmapp = &bmapp[*nbmaps - 1];
curr_imapp = &imap[0];
last_imapp = &imap[nimaps - 1];
/*
* curr_bmap is always the last one we filled
* in, and next_bmapp is always the next one
* to be filled in.
*/
while (next_bmapp <= last_bmapp) {
next_offset = curr_bmapp->offset +
curr_bmapp->length;
if (next_offset >= last_fsb) {
/*
* We've mapped all the way to the EOF.
* Everything beyond there is inaccessible,
* so get out now.
*/
break;
}
last_iosize = curr_bmapp->length;
if (next_offset <
(curr_imapp->br_startoff +
curr_imapp->br_blockcount)) {
xfs_next_bmap(mp, curr_imapp,
next_bmapp, iosize, last_iosize, -1,
curr_bmapp->offset, next_offset,
nisize);
} else {
curr_imapp++;
if (curr_imapp <= last_imapp) {
xfs_next_bmap(mp,
curr_imapp, next_bmapp,
iosize, last_iosize, -1,
curr_bmapp->offset, next_offset,
nisize);
} else {
/*
* We're out of imaps. We
* either hit the end of
* file or just didn't give
* enough of them to bmapi.
* The caller will just come
* back if we haven't done
* enough yet.
*/
break;
}
}
filled_bmaps++;
curr_bmapp = next_bmapp;
next_bmapp++;
ASSERT(curr_bmapp->length > 0);
/*
* Make sure to fill in the pboff and pbsize
* fields as long as the bmaps are required for
* the request (as opposed to strictly read-ahead).
*/
if (total_retrieved_bytes < count) {
curr_bmapp->pboff = 0;
curr_bmapp->pbsize =
xfs_retrieved(curr_bmapp->bsize,
offset, count,
&total_retrieved_bytes,
nisize);
}
if (XFS_FSB_TO_B(mp, curr_bmapp->offset +
curr_bmapp->length) >= nisize) {
curr_bmapp->eof |= BMAP_EOF;
}
xfs_iomap_map_trace(XFS_IOMAP_READ_MAP, ip, offset,
count, curr_bmapp, curr_imapp);
/*
* Keep track of the offset of the last buffer
* needed to satisfy the I/O request. This will
* be used for i_io_offset later. Also record
* the first bmapp used to track a read ahead.
*/
if (XFS_FSB_TO_B(mp, curr_bmapp->offset) <
(offset + count)) {
last_required_offset = curr_bmapp->offset;
} else if (first_read_ahead_bmapp == NULL) {
first_read_ahead_bmapp = curr_bmapp;
}
}
/*
* If we're describing any read-ahead here, then move
* the read-ahead blkno up to the point where we've
* gone through half the read-ahead described here.
* This way we don't issue more read-ahead until we
* are half-way through the last read-ahead.
*
* If we're not describing any read-ahead because the
* request is just fragmented, then move up the
* read-ahead blkno to just past what we're returning
* so that we can maybe start it on the next request.
*/
if (first_read_ahead_bmapp != NULL) {
read_aheads = curr_bmapp - first_read_ahead_bmapp +1;
next_read_ahead_bmapp = first_read_ahead_bmapp +
(read_aheads / 2);
ip->i_reada_blkno = next_read_ahead_bmapp->offset;
} else {
ip->i_reada_blkno = curr_bmapp->offset +
curr_bmapp->length;
}
} else if ((*nbmaps > 1) && (offset != ip->i_io_offset)) {
/*
* In this case the caller is not yet accessing the
* file sequentially, but set the read-ahead blkno
* so that we can tell if they start doing so.
*/
ip->i_reada_blkno = bmapp[0].offset + bmapp[0].length;
}
ASSERT(iosize <= XFS_BB_TO_FSBT(mp, XFS_MAX_BMAP_LEN_BB));
ip->i_io_size = iosize;
ip->i_io_offset = last_required_offset;
if (count > ip->i_last_req_sz) {
/*
* Record the "last request size" for the file.
* We don't let it shrink so that big requests
* that are not satisfied in one call here still
* record the full request size (not the smaller
* one that comes in to finish mapping the request).
*/
ip->i_last_req_sz = count;
}
if (total_retrieved_bytes >= count) {
/*
* We've mapped all of the caller's request, so
* the next request in a sequential read will
* come in the block this one ended on or the
* next if we consumed up to the very end of
* a block.
*/
ip->i_next_offset = offset + count;
} else {
/*
* We didn't satisfy the entire request, so we
* can expect xfs_read_file() to come back with
* what is left of the request.
*/
ip->i_next_offset = offset + total_retrieved_bytes;
}
*nbmaps = filled_bmaps;
for (x = 0; x < filled_bmaps; x++) {
curr_bmapp = &bmapp[x];
if (ip->i_d.di_flags & XFS_DIFLAG_REALTIME) {
curr_bmapp->pbdev = mp->m_rtdev;
} else {
curr_bmapp->pbdev = mp->m_dev;
}
curr_bmapp->offset = XFS_FSB_TO_BB(mp, curr_bmapp->offset);
curr_bmapp->length = XFS_FSB_TO_BB(mp, curr_bmapp->length);
ASSERT(curr_bmapp->length > 0);
ASSERT((x == 0) ||
((bmapp[x - 1].offset + bmapp[x - 1].length) ==
curr_bmapp->offset));
if (curr_bmapp->bn != -1) {
curr_bmapp->bn = XFS_FSB_TO_DB(mp, ip,
curr_bmapp->bn);
}
}
kmem_zone_free(xfs_irec_zone, imap);
return;
}
int
xfs_read_file(
vnode_t *vp,
uio_t *uiop,
int ioflag,
cred_t *credp)
{
#define XFS_READ_BMAPS XFS_ZONE_NBMAPS
struct bmapval *bmaps;
struct bmapval *bmapp;
int nbmaps;
buf_t *bp;
int read_bmaps;
int buffer_bytes_ok;
xfs_inode_t *ip;
int error;
ip = XFS_VTOI(vp);
error = 0;
buffer_bytes_ok = 0;
bmaps = (struct bmapval *)kmem_zone_alloc(xfs_bmap_zone, KM_SLEEP);
XFSSTATS.xs_read_calls++;
XFSSTATS.xs_read_bytes += uiop->uio_resid;
/*
* Loop until uio->uio_resid, which is the number of bytes the
* caller has requested, goes to 0 or we get an error. Each
* call to xfs_iomap_read tries to map as much of the request
* plus read-ahead as it can. We must hold the inode lock
* exclusively when calling xfs_iomap_read.
*/
do {
xfs_ilock(ip, XFS_ILOCK_EXCL);
xfs_rw_enter_trace(XFS_READ_ENTER, ip, uiop, ioflag);
/*
* We've fallen off the end of the file, so
* just return with what we've done so far.
*/
if (uiop->uio_offset >= ip->i_d.di_size) {
xfs_iunlock(ip, XFS_ILOCK_EXCL);
break;
}
nbmaps = XFS_READ_BMAPS;
xfs_iomap_read(ip, uiop->uio_offset, uiop->uio_resid,
bmaps, &nbmaps);
xfs_iunlock(ip, XFS_ILOCK_EXCL);
if (error || (bmaps[0].pbsize == 0)) {
break;
}
bmapp = &bmaps[0];
read_bmaps = nbmaps;
ASSERT(BBTOOFF(bmapp->offset) <= uiop->uio_offset);
/*
* The first time through this loop we kick off I/O on
* all the bmaps described by the iomap_read call.
* Subsequent passes just wait for each buffer needed
* to satisfy this request to complete. Buffers which
* are started in the first pass but are actually just
* read ahead buffers are never waited for, since uio_resid
* will go to 0 before we get to them.
*
* This works OK because iomap_read always tries to
* describe all the buffers we need to satisfy this
* read call plus the necessary read-ahead in the
* first call to it.
*/
while ((uiop->uio_resid != 0) && (nbmaps > 0)) {
bp = chunkread(vp, bmapp, read_bmaps, credp);
if (bp->b_flags & B_ERROR) {
error = geterror(bp);
ASSERT(error != EINVAL);
brelse(bp);
break;
} else if (bp->b_resid != 0) {
buffer_bytes_ok = 0;
brelse(bp);
break;
} else {
buffer_bytes_ok = 1;
ASSERT((BBTOOFF(bmapp->offset) + bmapp->pboff)
== uiop->uio_offset);
error = biomove(bp, bmapp->pboff,
bmapp->pbsize, UIO_READ,
uiop);
if (error) {
brelse(bp);
break;
}
}
brelse(bp);
XFSSTATS.xs_read_bufs++;
read_bmaps = 1;
nbmaps--;
bmapp++;
}
} while (!error && (uiop->uio_resid != 0) && buffer_bytes_ok);
kmem_zone_free(xfs_bmap_zone, bmaps);
return error;
}
/*
* xfs_read
*
* This is the xFS VOP_READ entry point. It does some minimal
* error checking and then switches out based on the file type.
*/
int
xfs_read(
vnode_t *vp,
uio_t *uiop,
int ioflag,
cred_t *credp)
{
struct reservation_id id;
xfs_inode_t *ip;
int type;
off_t offset;
size_t count;
int error;
timestruc_t tv;
ip = XFS_VTOI(vp);
ASSERT(ismrlocked(&ip->i_iolock, MR_ACCESS | MR_UPDATE) != 0);
type = ip->i_d.di_mode & IFMT;
ASSERT(type == IFREG || type == IFDIR ||
type == IFLNK || type == IFSOCK);
offset = uiop->uio_offset;
count = uiop->uio_resid;
#ifndef SIM
if (MANDLOCK(vp, ip->i_d.di_mode) &&
(error = chklock(vp, FREAD, offset, count, uiop->uio_fmode))) {
return error;
}
#endif
if (offset < 0)
return XFS_ERROR(EINVAL);
if (count <= 0)
return 0;
switch (type) {
case IFREG:
/*
* Not ready for in-line files yet.
*/
ASSERT((ip->i_d.di_format == XFS_DINODE_FMT_EXTENTS) ||
(ip->i_d.di_format == XFS_DINODE_FMT_BTREE));
#ifdef SIM
/*
* Need pid of client not of simulator process.
* This may not always be correct.
*/
id.pid = MAKE_REQ_PID(u.u_procp->p_pid - 1, 0);
#else
id.pid = MAKE_REQ_PID(u.u_procp->p_pid, 0);
#endif
id.ino = ip->i_ino;
if (DM_EVENT_ENABLED(vp->v_vfsp, ip, DM_READ) &&
!(ioflag & IO_INVIS)) {
if (error = dm_data_event(vp, DM_READ, offset, count))
return error;
}
error = xfs_grio_req(ip, &id, uiop, ioflag, credp, offset,
UIO_READ);
ASSERT(ismrlocked(&ip->i_iolock, MR_ACCESS | MR_UPDATE) != 0);
/* don't update timestamps if doing invisible I/O */
if (!(ioflag & IO_INVIS)) {
nanotime (&tv);
ip->i_d.di_atime.t_sec = tv.tv_sec;
ip->i_update_core = 1;
}
break;
case IFDIR:
error = XFS_ERROR(EISDIR);
break;
case IFLNK:
error = XFS_ERROR(EINVAL);
break;
case IFSOCK:
error = XFS_ERROR(ENODEV);
break;
default:
ASSERT(0);
error = XFS_ERROR(EINVAL);
break;
}
return error;
}
/*
* Map the given I/O size and I/O alignment over the given extent.
* If we're at the end of the file and the underlying extent is
* delayed alloc, make sure we extend out to the
* next m_writeio_blocks boundary. Otherwise make sure that we
* are confined to the given extent.
*/
STATIC void
xfs_write_bmap(
xfs_mount_t *mp,
xfs_bmbt_irec_t *imapp,
struct bmapval *bmapp,
int iosize,
xfs_fileoff_t ioalign,
xfs_fsize_t isize)
{
__int64_t extra_blocks;
xfs_fileoff_t size_diff;
xfs_fileoff_t ext_offset;
xfs_fileoff_t last_file_fsb;
xfs_fsblock_t start_block;
off_t last_imap_byte;
if (ioalign < imapp->br_startoff) {
/*
* The desired alignment doesn't end up on this
* extent. Move up to the beginning of the extent.
* Subtract whatever we drop from the iosize so that
* we stay aligned on iosize boundaries.
*/
size_diff = imapp->br_startoff - ioalign;
iosize -= (int)size_diff;
ASSERT(iosize > 0);
ext_offset = 0;
bmapp->offset = imapp->br_startoff;
} else {
/*
* The alignment requested fits on this extent,
* so use it.
*/
ext_offset = ioalign - imapp->br_startoff;
bmapp->offset = ioalign;
}
start_block = imapp->br_startblock;
ASSERT(start_block != HOLESTARTBLOCK);
if (start_block != DELAYSTARTBLOCK) {
bmapp->bn = start_block + ext_offset;
bmapp->eof = 0;
} else {
bmapp->bn = -1;
bmapp->eof = BMAP_DELAY;
}
bmapp->length = iosize;
/*
* If the iosize from our offset extends beyond the end of
* the extent, then trim down length to match that of the extent.
*/
extra_blocks = (off_t)(bmapp->offset + bmapp->length) -
(__uint64_t)(imapp->br_startoff +
imapp->br_blockcount);
last_imap_byte = XFS_FSB_TO_B(mp, imapp->br_startoff +
imapp->br_blockcount);
if (extra_blocks > 0) {
bmapp->length -= extra_blocks;
ASSERT(bmapp->length > 0);
}
/*
* If the iosize from our offset extends beyond the last block
* covered by isize, then trim down the length to match the
* file size. This counts on the given size being new_size
* rather than the old size.
*/
last_file_fsb = XFS_B_TO_FSB(mp, isize);
extra_blocks = (off_t)(bmapp->offset + bmapp->length) -
(__uint64_t)last_file_fsb;
if (extra_blocks > 0) {
bmapp->length -= extra_blocks;
ASSERT(bmapp->length > 0);
}
ASSERT((bmapp->offset + bmapp->length) <= last_file_fsb);
bmapp->bsize = XFS_FSB_TO_B(mp, bmapp->length);
}
/*
* This routine is called to handle zeroing any space in the last
* block of the file that is beyond the EOF. We do this since the
* size is being increased without writing anything to that block
* and we don't want anyone to read the garbage on the disk.
*/
STATIC void
xfs_zero_last_block(
xfs_inode_t *ip,
off_t offset,
xfs_fsize_t isize,
cred_t *credp)
{
xfs_fileoff_t last_fsb;
xfs_mount_t *mp;
buf_t *bp;
int iosize;
vnode_t *vp;
int nimaps;
int zero_offset;
int zero_len;
int isize_fsb_offset;
int i;
pfd_t *pfdp;
xfs_bmbt_irec_t imap;
struct bmapval bmap;
ASSERT(ismrlocked(&ip->i_lock, MR_UPDATE) != 0);
ASSERT(offset > isize);
mp = ip->i_mount;
vp = XFS_ITOV(ip);
/*
* If the file system block size is less than the page size,
* then there could be bytes in the last page after the last
* fsblock containing isize which have not been initialized.
* Since if such a page is in memory it will be marked P_DONE
* and my now be fully accessible, we need to zero any part of
* it which is beyond the old file size. We don't need to send
* this out to disk, we're just iniitializing it to zeroes like
* we would have done in xfs_strat_read() had the size been bigger.
*/
if ((mp->m_sb.sb_blocksize < NBPP) && ((i = poff(isize)) != 0)) {
pfdp = pfind(XFS_ITOV(ip), offtoct(isize), VM_ATTACH);
if (pfdp != NULL) {
page_zero(pfdp, NOCOLOR, i, (NBPP - i));
pagefree(pfdp);
}
}
isize_fsb_offset = XFS_B_FSB_OFFSET(mp, isize);
if (isize_fsb_offset == 0) {
/*
* There are not extra bytes in the last block to
* zero, so return.
*/
return;
}
last_fsb = XFS_B_TO_FSBT(mp, isize);
nimaps = 1;
(void) xfs_bmapi(NULL, ip, last_fsb, 1, 0, NULLFSBLOCK, 0, &imap,
&nimaps, NULL);
ASSERT(nimaps > 0);
/*
* If the block underlying isize is just a hole, then there
* is nothing to zero.
*/
if (imap.br_startblock == HOLESTARTBLOCK) {
return;
}
/*
* Get a buffer for the last block, zero the part beyond the
* EOF, and write it out async. We need to drop the ilock
* while we do this so we don't deadlock when the buffer cache
* calls back to us.
*/
xfs_iunlock(ip, XFS_ILOCK_EXCL);
bmap.offset = XFS_FSB_TO_BB(mp, last_fsb);
bmap.length = XFS_FSB_TO_BB(mp, 1);
bmap.bsize = BBTOB(bmap.length);
bmap.pboff = 0;
bmap.pbsize = bmap.bsize;
if (ip->i_d.di_flags & XFS_DIFLAG_REALTIME) {
bmap.pbdev = mp->m_rtdev;
} else {
bmap.pbdev = mp->m_dev;
}
bmap.eof = BMAP_EOF;
if (imap.br_startblock != DELAYSTARTBLOCK) {
bmap.bn = XFS_FSB_TO_DB(mp, ip, imap.br_startblock);
} else {
bmap.bn = -1;
bmap.eof |= BMAP_DELAY;
}
bp = chunkread(XFS_ITOV(ip), &bmap, 1, credp);
zero_offset = isize_fsb_offset;
zero_len = mp->m_sb.sb_blocksize - isize_fsb_offset;
xfs_zero_bp(bp, zero_offset, zero_len);
/*
* We don't want to start a transaction here, so don't
* push out a buffer over a delayed allocation extent.
* Also, we can get away with it since the space isn't
* allocated so it's faster anyway.
*/
if (imap.br_startblock == DELAYSTARTBLOCK) {
bdwrite(bp);
} else {
bwrite(bp);
}
xfs_ilock(ip, XFS_ILOCK_EXCL);
return;
}
/*
* Zero any on disk space between the current EOF and the new,
* larger EOF. This handles the normal case of zeroing the remainder
* of the last block in the file and the unusual case of zeroing blocks
* out beyond the size of the file. This second case only happens
* with fixed size extents and when the system crashes before the inode
* size was updated but after blocks were allocated.
*/
void
xfs_zero_eof(
xfs_inode_t *ip,
off_t offset,
xfs_fsize_t isize,
cred_t *credp)
{
xfs_fileoff_t start_zero_fsb;
xfs_fileoff_t end_zero_fsb;
xfs_fileoff_t zero_count_fsb;
xfs_fileoff_t last_fsb;
xfs_extlen_t buf_len_fsb;
xfs_mount_t *mp;
buf_t *bp;
int nimaps;
xfs_bmbt_irec_t imap;
ASSERT(ismrlocked(&(ip->i_lock), MR_UPDATE));
ASSERT(ismrlocked(&(ip->i_iolock), MR_UPDATE));
mp = ip->i_mount;
/*
* First handle zeroing the block on which isize resides.
* We only zero a part of that block so it is handled specially.
*/
xfs_zero_last_block(ip, offset, isize, credp);
/*
* Calculate the range between the new size and the old
* where blocks needing to be zeroed may exist. To get the
* block where the last byte in the file currently resides,
* we need to subtrace one from the size and truncate back
* to a block boundary. We subtract 1 in case the size is
* exactly on a block boundary.
*/
last_fsb = XFS_B_TO_FSBT(mp, isize - 1);
start_zero_fsb = XFS_B_TO_FSB(mp, isize);
end_zero_fsb = XFS_B_TO_FSBT(mp, offset - 1);
ASSERT(last_fsb < start_zero_fsb);
if (last_fsb == end_zero_fsb) {
/*
* The size was only incremented on its last block.
* We took care of that above, so just return.
*/
return;
}
ASSERT(start_zero_fsb <= end_zero_fsb);
while (start_zero_fsb <= end_zero_fsb) {
nimaps = 1;
zero_count_fsb = end_zero_fsb - start_zero_fsb + 1;
(void) xfs_bmapi(NULL, ip, start_zero_fsb, zero_count_fsb,
0, NULLFSBLOCK, 0, &imap, &nimaps, NULL);
ASSERT(nimaps > 0);
ASSERT(imap.br_startblock != DELAYSTARTBLOCK);
if (imap.br_startblock == HOLESTARTBLOCK) {
start_zero_fsb = imap.br_startoff +
imap.br_blockcount;
ASSERT(start_zero_fsb <= (end_zero_fsb + 1));
continue;
}
/*
* Drop the inode lock while we're doing the I/O.
* We'll still have the iolock to protect us.
*/
xfs_iunlock(ip, XFS_ILOCK_EXCL);
/*
* There are real blocks in the range requested.
* Zero them a single write at a time. We actually
* don't zero the entire range returned if it is
* too big and simply loop around to get the rest.
* That is not the most efficient thing to do, but it
* is simple and this path should not be exercised often.
*/
buf_len_fsb = XFS_EXTLEN_MIN(imap.br_blockcount,
mp->m_writeio_blocks);
bp = ngetrbuf(XFS_FSB_TO_B(mp, buf_len_fsb));
bzero(bp->b_un.b_addr, bp->b_bcount);
bp->b_blkno = XFS_FSB_TO_DB(mp, ip, imap.br_startblock);
if (ip->i_d.di_flags & XFS_DIFLAG_REALTIME) {
bp->b_edev = mp->m_rtdev;
} else {
bp->b_edev = mp->m_dev;
}
bp->b_flags |= B_HOLD;
bwrite(bp);
nfreerbuf(bp);
start_zero_fsb = imap.br_startoff + buf_len_fsb;
ASSERT(start_zero_fsb <= (end_zero_fsb + 1));
xfs_ilock(ip, XFS_ILOCK_EXCL);
}
}
STATIC int
xfs_iomap_write(
xfs_inode_t *ip,
off_t offset,
size_t count,
struct bmapval *bmapp,
int *nbmaps)
{
xfs_fileoff_t offset_fsb;
xfs_fileoff_t ioalign;
xfs_fileoff_t next_offset_fsb;
xfs_fileoff_t last_fsb;
xfs_fileoff_t bmap_end_fsb;
xfs_fileoff_t last_file_fsb;
off_t next_offset;
off_t aligned_offset;
xfs_fsize_t isize;
int nimaps;
unsigned int iosize;
unsigned int writing_bytes;
short filled_bmaps;
short x;
size_t count_remaining;
xfs_mount_t *mp;
struct bmapval *curr_bmapp;
struct bmapval *next_bmapp;
struct bmapval *last_bmapp;
xfs_bmbt_irec_t *curr_imapp;
xfs_bmbt_irec_t *last_imapp;
xfs_bmbt_irec_t *imap;
#define XFS_WRITE_IMAPS XFS_BMAP_MAX_NMAP
ASSERT(ismrlocked(&ip->i_lock, MR_UPDATE) != 0);
xfs_iomap_enter_trace(XFS_IOMAP_WRITE_ENTER, ip, offset, count);
mp = ip->i_mount;
if (ip->i_new_size > ip->i_d.di_size) {
isize = ip->i_new_size;
} else {
isize = ip->i_d.di_size;
}
offset_fsb = XFS_B_TO_FSBT(mp, offset);
nimaps = XFS_WRITE_IMAPS;
imap = (xfs_bmbt_irec_t *)kmem_zone_alloc(xfs_irec_zone, KM_SLEEP);
last_fsb = XFS_B_TO_FSB(mp, offset + count);
(void) xfs_bmapi(NULL, ip, offset_fsb,
(xfs_extlen_t)(last_fsb - offset_fsb),
XFS_BMAPI_DELAY | XFS_BMAPI_WRITE |
XFS_BMAPI_ENTIRE, NULLFSBLOCK, 1, imap,
&nimaps, NULL);
/*
* If bmapi returned us nothing, then we must have run out of space.
*/
if (nimaps == 0) {
xfs_iomap_enter_trace(XFS_IOMAP_WRITE_NOSPACE,
ip, offset, count);
kmem_zone_free(xfs_irec_zone, (void *)imap);
return ENOSPC;
}
iosize = mp->m_writeio_blocks;
aligned_offset= XFS_WRITEIO_ALIGN(mp, offset);
ioalign = XFS_B_TO_FSBT(mp, aligned_offset);
/*
* Now map our desired I/O size and alignment over the
* extents returned by xfs_bmapi().
*/
xfs_write_bmap(mp, imap, bmapp, iosize, ioalign, isize);
ASSERT((bmapp->length > 0) &&
(offset >= XFS_FSB_TO_B(mp, bmapp->offset)));
/*
* A bmap is the EOF bmap when it reaches to or beyond the new
* inode size.
*/
bmap_end_fsb = bmapp->offset + bmapp->length;
if (XFS_FSB_TO_B(mp, bmap_end_fsb) >= isize) {
bmapp->eof |= BMAP_EOF;
}
bmapp->pboff = offset - XFS_FSB_TO_B(mp, bmapp->offset);
writing_bytes = bmapp->bsize - bmapp->pboff;
if (writing_bytes > count) {
/*
* The mapping is for more bytes than we're actually
* going to write, so trim writing_bytes so we can
* get bmapp->pbsize right.
*/
writing_bytes = count;
}
bmapp->pbsize = writing_bytes;
xfs_iomap_map_trace(XFS_IOMAP_WRITE_MAP,
ip, offset, count, bmapp, imap);
/*
* Map more buffers if the first does not map the entire
* request. We do this until we run out of bmaps, imaps,
* or bytes to write. We also stop if the mappings go beyond
* the end of the file. There may be more blocks beyond the
* EOF for which we have imaps, but they are inaccessible.
*/
last_file_fsb = XFS_B_TO_FSB(mp, isize);
ASSERT((bmapp->offset + bmapp->length) <= last_file_fsb);
filled_bmaps = 1;
if ((*nbmaps > 1) &&
((nimaps > 1) || (bmapp->offset + bmapp->length <
imap[0].br_startoff + imap[0].br_blockcount)) &&
(writing_bytes < count)) {
curr_bmapp = &bmapp[0];
next_bmapp = &bmapp[1];
last_bmapp = &bmapp[*nbmaps - 1];
curr_imapp = &imap[0];
last_imapp = &imap[nimaps - 1];
count_remaining = count - writing_bytes;
/*
* curr_bmapp is always the last one we filled
* in, and next_bmapp is always the next one to
* be filled in.
*/
while (next_bmapp <= last_bmapp) {
next_offset_fsb = curr_bmapp->offset +
curr_bmapp->length;
ASSERT(next_offset_fsb <= last_file_fsb);
if (next_offset_fsb == last_file_fsb) {
/*
* Anything left is beyond the EOF
* and therefore inaccessible, so
* get out now.
*/
break;
}
if (next_offset_fsb <
(curr_imapp->br_startoff +
curr_imapp->br_blockcount)) {
/*
* I'm still on the same extent, so
* the last bmap must have ended on
* a writeio_blocks boundary. Thus,
* we just start where the last one
* left off.
*/
ASSERT((XFS_FSB_TO_B(mp, next_offset_fsb) &
((1 << mp->m_writeio_log) - 1))==0);
xfs_write_bmap(mp, curr_imapp, next_bmapp,
iosize, next_offset_fsb,
isize);
} else {
curr_imapp++;
if (curr_imapp <= last_imapp) {
/*
* We're moving on to the next
* extent. Since we try to end
* all buffers on writeio_blocks
* boundaries, round next_offset
* down to a writeio_blocks boundary
* before calling xfs_write_bmap().
*
* XXXajs
* Adding a macro to writeio align
* fsblocks would be good to reduce
* the bit shifting here.
*/
aligned_offset = XFS_FSB_TO_B(mp,
next_offset_fsb);
aligned_offset =
XFS_WRITEIO_ALIGN(mp,
aligned_offset);
ioalign = XFS_B_TO_FSBT(mp,
aligned_offset);
xfs_write_bmap(mp, curr_imapp,
next_bmapp, iosize,
ioalign, isize);
} else {
/*
* We're out of imaps. The caller
* will have to call again to map
* the rest of the write request.
*/
break;
}
}
/*
* The write must start at offset 0 in this bmap
* since we're just continuing from the last
* buffer. Thus the request offset in the buffer
* indicated by pboff must be 0.
*/
next_bmapp->pboff = 0;
/*
* The request size within this buffer is the
* entire buffer unless the count of bytes to
* write runs out.
*/
next_offset = XFS_FSB_TO_B(mp, next_offset_fsb);
writing_bytes = next_bmapp->bsize;
if (writing_bytes > count_remaining) {
writing_bytes = count_remaining;
}
next_bmapp->pbsize = writing_bytes;
count_remaining -= writing_bytes;
ASSERT(count_remaining >= 0);
filled_bmaps++;
curr_bmapp++;
next_bmapp++;
/*
* A bmap is the EOF bmap when it reaches to
* or beyond the new inode size.
*/
bmap_end_fsb = curr_bmapp->offset +
curr_bmapp->length;
if (XFS_FSB_TO_B(mp, bmap_end_fsb) >= isize) {
curr_bmapp->eof |= BMAP_EOF;
}
xfs_iomap_map_trace(XFS_IOMAP_WRITE_MAP, ip, offset,
count, curr_bmapp, curr_imapp);
}
}
*nbmaps = filled_bmaps;
for (x = 0; x < filled_bmaps; x++) {
curr_bmapp = &bmapp[x];
if (ip->i_d.di_flags & XFS_DIFLAG_REALTIME) {
curr_bmapp->pbdev = mp->m_rtdev;
} else {
curr_bmapp->pbdev = mp->m_dev;
}
curr_bmapp->offset = XFS_FSB_TO_BB(mp, curr_bmapp->offset);
curr_bmapp->length = XFS_FSB_TO_BB(mp, curr_bmapp->length);
ASSERT((x == 0) ||
((bmapp[x - 1].offset + bmapp[x - 1].length) ==
curr_bmapp->offset));
if (curr_bmapp->bn != -1) {
curr_bmapp->bn = XFS_FSB_TO_DB(mp, ip,
curr_bmapp->bn);
}
}
/*
* Clear out any read-ahead info since the write may
* have made it invalid.
*/
XFS_INODE_CLEAR_READ_AHEAD(ip);
kmem_zone_free(xfs_irec_zone, imap);
return 0;
}
int
xfs_write_file(
vnode_t *vp,
uio_t *uiop,
int ioflag,
cred_t *credp)
{
#define XFS_WRITE_BMAPS XFS_ZONE_NBMAPS
struct bmapval *bmaps;
struct bmapval *bmapp;
int nbmaps;
buf_t *bp;
int buffer_bytes_ok;
xfs_inode_t *ip;
int error;
int eof_zeroed;
int gaps_mapped;
xfs_fsize_t isize;
xfs_fsize_t new_size;
xfs_mount_t *mp;
ip = XFS_VTOI(vp);
mp = ip->i_mount;
/*
* If the file has fixed size extents or is a real time file,
* buffered I/O cannot be performed.
* This check will be removed in the future.
*/
if ( (ip->i_d.di_extsize) ||
(ip->i_d.di_flags & XFS_DIFLAG_REALTIME)) {
return( EINVAL );
}
error = 0;
buffer_bytes_ok = 0;
eof_zeroed = 0;
gaps_mapped = 0;
bmaps = (struct bmapval *)kmem_zone_alloc(xfs_bmap_zone, KM_SLEEP);
XFSSTATS.xs_write_calls++;
XFSSTATS.xs_write_bytes += uiop->uio_resid;
/*
* i_new_size is used by xfs_iomap_read() when the chunk
* cache code calls back into the file system through
* xfs_bmap(). This way we can tell where the end of
* file is going to be even though we haven't yet updated
* ip->i_d.di_size. This is guarded by the iolock and the
* inode lock. Either is sufficient for reading the value.
*/
new_size = uiop->uio_offset + uiop->uio_resid;
/*
* i_write_offset is used by xfs_strat_read() when the chunk
* cache code calls back into the file system through
* xfs_strategy() to initialize a buffer. We use it there
* to know how much of the buffer needs to be zeroed and how
* much will be initialize here by the write or not need to
* be initialized because it will be beyond the inode size.
* This is protected by the io lock.
*/
ip->i_write_offset = uiop->uio_offset;
/*
* Loop until uiop->uio_resid, which is the number of bytes the
* caller has requested to write, goes to 0 or we get an error.
* Each call to xfs_iomap_write() tries to map as much of the
* request as it can in mp->m_writeio_blks sized chunks.
*/
do {
xfs_ilock(ip, XFS_ILOCK_EXCL);
isize = ip->i_d.di_size;
if (new_size > isize) {
ip->i_new_size = new_size;
}
xfs_rw_enter_trace(XFS_WRITE_ENTER, ip, uiop, ioflag);
/*
* If this is the first pass through the loop, then map
* out all of the holes we might fill in with this write
* and list them in the inode's gap list. This is for
* use by xfs_strat_read() in determining if the real
* blocks underlying a delalloc buffer have been initialized
* or not. Since writes are single threaded, if the blocks
* were holes when we started and xfs_strat_read() is asked
* to read one in while we're still here in xfs_write_file(),
* then the block is not initialized. Only we can
* initialize it and once we write out a buffer we remove
* any entries in the gap list which overlap that buffer.
*/
if (!gaps_mapped) {
xfs_build_gap_list(ip, uiop->uio_offset,
uiop->uio_resid);
gaps_mapped = 1;
}
/*
* If we've seeked passed the EOF to do this write,
* then we need to make sure that any buffer overlapping
* the EOF is zeroed beyond the EOF.
*/
if (!eof_zeroed &&
(uiop->uio_offset > isize) &&
(isize != 0)) {
xfs_zero_eof(ip, uiop->uio_offset, isize, credp);
eof_zeroed = 1;
}
nbmaps = XFS_WRITE_BMAPS;
error = xfs_iomap_write(ip, uiop->uio_offset,
uiop->uio_resid, bmaps, &nbmaps);
xfs_iunlock(ip, XFS_ILOCK_EXCL);
if (error || (bmaps[0].pbsize == 0)) {
break;
}
bmapp = &bmaps[0];
/*
* Each pass through the loop writes another buffer
* to the file. For big requests, iomap_write will
* have given up multiple bmaps to use so we make fewer
* calls to it on big requests than if it only gave
* us one at a time.
*
* Error handling is a bit tricky because of delayed
* allocation. We need to make sure that we create
* dirty buffers over all the delayed allocation
* extents created in xfs_iomap_write(). Thus, when
* we get an error we continue to process each of
* the bmaps returned by xfs_iomap_write(). Each is
* read in so that it is fully initialized and then
* written out without actually copying in the user's
* data.
*/
while (((uiop->uio_resid != 0) || (error != 0)) &&
(nbmaps > 0)) {
/*
* If the write doesn't completely overwrite
* the buffer and we're not writing from
* the beginning of the buffer to the end
* of the file then we need to read the
* buffer. We also always want to read the
* buffer if we've encountered an error and
* we're just cleaning up.
*
* Reading the buffer will send it to xfs_strategy
* which will take care of zeroing the holey
* parts of the buffer and coordinating with
* other, simultaneous writers.
*/
if ((error != 0) ||
((bmapp->pbsize != bmapp->bsize) &&
!((bmapp->pboff == 0) &&
(uiop->uio_offset >= isize)))) {
bp = chunkread(vp, bmapp, 1, credp);
} else {
bp = getchunk(vp, bmapp, credp);
}
/*
* There is not much we can do with buffer errors.
* The assumption here is that the space underlying
* the buffer must now be allocated (even if it
* wasn't when we mapped the buffer) and we got an
* error reading from it. In this case the blocks
* will remain unreadable, so we just toss the buffer
* and its associated pages.
*/
if (bp->b_flags & B_ERROR) {
error = geterror(bp);
ASSERT(error != EINVAL);
brelse(bp);
bmapp++;
nbmaps--;
continue;
}
/*
* If we've already encountered an error, then
* write the buffers out without copying the user's
* data into them. This way we get dirty buffers
* over our delayed allocation extents which
* have been initialized by xfs_strategy() since
* we forced the chunkread() above.
* We write the data out synchronously here so that
* we don't have to worry about having buffers
* possibly out beyond the EOF when we later flush
* or truncate the file. We set the B_STALE bit so
* that the buffer will be decommissioned after it
* is synced out.
*/
if (error != 0) {
bp->b_flags |= B_STALE;
bwrite(bp);
bmapp++;
nbmaps--;
continue;
}
ASSERT((BBTOOFF(bmapp->offset) + bmapp->pboff) ==
uiop->uio_offset);
if (error = biomove(bp, bmapp->pboff, bmapp->pbsize,
UIO_WRITE, uiop)) {
/*
* If the buffer is already done then just
* mark it dirty without copying any more
* data into it. It is already fully
* initialized.
* Otherwise, we must have getchunk()'d
* the buffer above. Use chunkreread()
* to get it initialized by xfs_strategy()
* and then write it out.
* We write the data out synchronously here
* so that we don't have to worry about
* having buffers possibly out beyond the
* EOF when we later flush or truncate
* the file. We set the B_STALE bit so
* that the buffer will be decommissioned
* after it is synced out.
*/
if (!(bp->b_flags & B_DONE)) {
chunkreread(bp);
}
bp->b_flags |= B_STALE;
bwrite(bp);
bmapp++;
nbmaps--;
continue;
}
/*
* If we've grown the file, get back the
* inode lock and move di_size up to the
* new size. It may be that someone else
* made it even bigger, so be careful not
* to shrink it.
*
* Noone could have shrunken the file, because
* we are holding the iolock shared.
*/
if (uiop->uio_offset > isize) {
xfs_ilock(ip, XFS_ILOCK_EXCL);
if (uiop->uio_offset > ip->i_d.di_size) {
ip->i_d.di_size = uiop->uio_offset;
ip->i_update_core = 1;
isize = uiop->uio_offset;
}
xfs_iunlock(ip, XFS_ILOCK_EXCL);
}
/*
* Make sure that any gap list entries overlapping
* the buffer being written are removed now that
* we know that the blocks underlying the buffer
* will be initialized. We don't need the inode
* lock to manipulate the gap list here, because
* we have the io lock held exclusively so noone
* else can get to xfs_strat_read() where we look
* at the list.
*/
xfs_delete_gap_list(ip,
XFS_BB_TO_FSBT(mp, bp->b_offset),
XFS_B_TO_FSBT(mp, bp->b_bcount));
if (ioflag & IO_SYNC) {
bwrite(bp);
} else {
bdwrite(bp);
}
XFSSTATS.xs_write_bufs++;
bmapp++;
nbmaps--;
}
} while ((uiop->uio_resid > 0) && !error);
/*
* Free up any remaining entries in the gap list, because the
* list only applies to this write call. Also clear the new_size
* field of the inode while we've go it locked.
*/
xfs_ilock(ip, XFS_ILOCK_EXCL);
xfs_free_gap_list(ip);
ip->i_new_size = 0;
xfs_iunlock(ip, XFS_ILOCK_EXCL);
ip->i_write_offset = 0;
kmem_zone_free(xfs_bmap_zone, bmaps);
return error;
}
/*
* xfs_write
*
* This is the xFS VOP_WRITE entry point. It does some minimal error
* checking and then switches out based on the file type.
*/
int
xfs_write(
vnode_t *vp,
uio_t *uiop,
int ioflag,
cred_t *credp)
{
struct reservation_id id;
xfs_inode_t *ip;
int type;
off_t offset;
size_t count;
int error;
off_t n;
int resid;
timestruc_t tv;
off_t savedsize;
int eventsent = 0;
ip = XFS_VTOI(vp);
ASSERT(ismrlocked(&ip->i_iolock, MR_UPDATE) != 0);
type = ip->i_d.di_mode & IFMT;
ASSERT(type == IFREG || type == IFDIR ||
type == IFLNK || type == IFSOCK);
start:
if (ioflag & IO_APPEND) {
/*
* In append mode, start at the end of the file.
* Since I've got the iolock exclusive I can look
* at di_size.
*/
uiop->uio_offset = savedsize = ip->i_d.di_size;
}
offset = uiop->uio_offset;
count = uiop->uio_resid;
#ifndef SIM
if (MANDLOCK(vp, ip->i_d.di_mode) &&
(error = chklock(vp, FWRITE, offset, count, uiop->uio_fmode))) {
return error;
}
#endif
if ((offset < 0) || ((offset + count) > XFS_MAX_FILE_OFFSET)) {
return XFS_ERROR(EINVAL);
}
if (count <= 0) {
return 0;
}
switch (type) {
case IFREG:
n = uiop->uio_limit - uiop->uio_offset;
if (n <= 0) {
return XFS_ERROR(EFBIG);
}
if (n < uiop->uio_resid) {
resid = uiop->uio_resid - n;
uiop->uio_resid = n;
} else {
resid = 0;
}
#ifdef SIM
/*
* Need pid of client not of simulator process.
* This may not always be correct.
*/
id.pid = MAKE_REQ_PID(u.u_procp->p_pid - 1, 0);
#else
id.pid = MAKE_REQ_PID(u.u_procp->p_pid, 0);
#endif
id.ino = ip->i_ino;
if (DM_EVENT_ENABLED(vp->v_vfsp, ip, DM_WRITE) &&
!(ioflag & IO_INVIS) &&
!eventsent) {
if (error = dm_data_event(vp, DM_WRITE, offset, count))
return error;
eventsent = 1;
}
/*
* The iolock is dropped and reaquired in dm_data_event(),
* so we have to recheck the size when appending. Will
* only "goto start;" once, since having sent the event
* prevents another call to dm_data_event, which is what
* allows the size to change in the first place.
*/
if ((ioflag & IO_APPEND) && savedsize != ip->i_d.di_size)
goto start;
retry:
error = xfs_grio_req(ip, &id, uiop, ioflag, credp, offset,
UIO_WRITE);
if (error == ENOSPC &&
DM_EVENT_ENABLED(vp->v_vfsp, ip, DM_NOSPACE) &&
!(ioflag & IO_INVIS)) {
error = dm_data_event(vp, DM_NOSPACE, 0, 0);
if (error)
return error;
offset = uiop->uio_offset;
goto retry;
}
/*
* Add back whatever we refused to do because of
* uio_limit.
*/
uiop->uio_resid += resid;
/*
* We've done at least a partial write, so don't
* return an error on this call. Also update the
* timestamps since we changed the file.
*
* XXXajs
* Are these the right timestamps?
*/
if (count != uiop->uio_resid) {
error = 0;
/* don't update timestamps if doing invisible I/O */
if (!(ioflag & IO_INVIS)) {
nanotime(&tv);
ip->i_d.di_mtime.t_sec = tv.tv_sec;
ip->i_d.di_ctime.t_sec = tv.tv_sec;
ip->i_update_core = 1;
}
}
/*
* If the write was synchronous then flush the log
* to make sure that everything is permanent.
* As you can tell the modification time will not
* be permanent, but it's not clear that it needs
* to be. We could also probably be smarter about
* whether or not this is necessary, but it should
* work for a first cut.
*/
if (ioflag & IO_SYNC) {
xfs_log_force(ip->i_mount, (xfs_lsn_t)0,
XFS_LOG_FORCE | XFS_LOG_SYNC);
}
break;
case IFDIR:
return XFS_ERROR(EISDIR);
case IFLNK:
return XFS_ERROR(EINVAL);
case IFSOCK:
return XFS_ERROR(ENODEV);
default:
ASSERT(0);
return XFS_ERROR(EINVAL);
}
return error;
}
/*
* This is the xFS entry point for VOP_BMAP().
* It simply switches based on the given flags
* to either xfs_iomap_read() or xfs_iomap_write().
* This cannot be used to grow a file or to read
* beyond the end of the file.
*
* The caller is required to be holding the inode's
* iolock in at least shared mode for a read mapping
* and exclusively for a write mapping.
*/
int
xfs_bmap(
vnode_t *vp,
off_t offset,
ssize_t count,
int flags,
cred_t *credp,
struct bmapval *bmapp,
int *nbmaps)
{
xfs_inode_t *ip;
int error;
ip = XFS_VTOI(vp);
ASSERT((ip->i_d.di_mode & IFMT) == IFREG);
ASSERT((flags == B_READ) || (flags == B_WRITE));
xfs_ilock(ip, XFS_ILOCK_EXCL);
if (flags == B_READ) {
ASSERT(ismrlocked(&ip->i_iolock, MR_ACCESS | MR_UPDATE) != 0);
xfs_iomap_read(ip, offset, count, bmapp, nbmaps);
error = 0;
} else {
ASSERT(ismrlocked(&ip->i_iolock, MR_UPDATE) != 0);
ASSERT(ip->i_d.di_size >= (offset + count));
error = xfs_iomap_write(ip, offset, count, bmapp, nbmaps);
}
xfs_iunlock(ip, XFS_ILOCK_EXCL);
return error;
}
/*
* Set up rbp so that it points to the memory attached to bp
* from rbp_offset from the start of bp for rbp_len bytes.
*/
STATIC void
xfs_overlap_bp(
buf_t *bp,
buf_t *rbp,
uint rbp_offset,
uint rbp_len)
{
int pgbboff;
int bytes_off;
pfd_t *pfdp;
if (BP_ISMAPPED(bp)) {
/*
* The real buffer is already mapped, so just use
* its virtual memory for ourselves.
*/
rbp->b_un.b_addr = bp->b_un.b_addr + rbp_offset;
rbp->b_bcount = rbp_len;
rbp->b_bufsize = rbp_len;
} else {
/*
* The real buffer is not yet mapped to virtual memory.
* Just get the subordinate buffer's page pointers
* set up and make it a PAGEIO buffer like the real one.
*
* First find the first page of rbp. We do this by
* walking the list of pages in bp until we find the
* one containing the start of rbp. Note that neither
* bp nor rbp are required to start on page boundaries.
*/
bytes_off = rbp_offset + BBTOOFF(dpoff(bp->b_offset));
pfdp = NULL;
pfdp = getnextpg(bp, pfdp);
ASSERT(pfdp != NULL);
while (bytes_off >= NBPP) {
pfdp = getnextpg(bp, pfdp);
ASSERT(pfdp != NULL);
bytes_off -= NBPP;
}
rbp->b_pages = pfdp;
rbp->b_bcount = rbp_len;
rbp->b_offset = bp->b_offset + BTOBB(rbp_offset);
pgbboff = dpoff(rbp->b_offset);
rbp->b_bufsize = ctob(dtop(pgbboff + BTOBB(rbp_len)));
rbp->b_flags |= B_PAGEIO;
#ifndef SIM
if (pgbboff != 0) {
bp_mapin(rbp);
}
#endif
}
rbp->b_blkno = bp->b_blkno + BTOBB(rbp_offset);
rbp->b_remain = 0;
rbp->b_vp = bp->b_vp;
rbp->b_edev = bp->b_edev;
rbp->b_flags |= (bp->b_flags & (B_UNCACHED | B_ASYNC));
}
/*
* Zero the given bp from data_offset from the start of it for data_len
* bytes.
*/
STATIC void
xfs_zero_bp(
buf_t *bp,
int data_offset,
int data_len)
{
pfd_t *pfdp;
caddr_t page_addr;
int len;
if (BP_ISMAPPED(bp)) {
bzero(bp->b_un.b_addr + data_offset, data_len);
return;
}
data_offset += BBTOOFF(dpoff(bp->b_offset));
pfdp = NULL;
pfdp = getnextpg(bp, pfdp);
ASSERT(pfdp != NULL);
while (data_offset >= NBPP) {
pfdp = getnextpg(bp, pfdp);
ASSERT(pfdp != NULL);
data_offset -= NBPP;
}
ASSERT(data_offset >= 0);
while (data_len > 0) {
page_addr = page_mapin(pfdp, (bp->b_flags & B_UNCACHED ?
VM_UNCACHED : 0), 0);
len = MIN(data_len, NBPP - data_offset);
bzero(page_addr + data_offset, len);
data_len -= len;
data_offset = 0;
page_mapout(page_addr);
pfdp = getnextpg(bp, pfdp);
}
}
/*
* Verify that the gap list is properly sorted and that no entries
* overlap.
*/
#ifdef DEBUG
STATIC void
xfs_check_gap_list(
xfs_inode_t *ip)
{
xfs_gap_t *last_gap;
xfs_gap_t *curr_gap;
int loops;
last_gap = NULL;
curr_gap = ip->i_gap_list;
loops = 0;
while (curr_gap != NULL) {
ASSERT(curr_gap->xg_count_fsb > 0);
if (last_gap != NULL) {
ASSERT((last_gap->xg_offset_fsb +
last_gap->xg_count_fsb) <
curr_gap->xg_offset_fsb);
}
last_gap = curr_gap;
curr_gap = curr_gap->xg_next;
ASSERT(loops++ < 1000);
}
}
#endif
/*
* For the given inode, offset, and count of bytes, build a list
* of xfs_gap_t structures in the inode's gap list describing the
* holes in the file in the range described by the offset and count.
*
* The list must be empty when we start, and the inode lock must
* be held exclusively.
*/
STATIC void
xfs_build_gap_list(
xfs_inode_t *ip,
off_t offset,
size_t count)
{
xfs_fileoff_t offset_fsb;
xfs_fileoff_t last_fsb;
xfs_extlen_t count_fsb;
xfs_gap_t *new_gap;
xfs_gap_t *last_gap;
xfs_mount_t *mp;
int i;
int nimaps;
#define XFS_BGL_NIMAPS 8
xfs_bmbt_irec_t imaps[XFS_BGL_NIMAPS];
xfs_bmbt_irec_t *imapp;
ASSERT(ismrlocked(&(ip->i_lock), MR_UPDATE) != 0);
ASSERT(ip->i_gap_list == NULL);
mp = ip->i_mount;
offset_fsb = XFS_B_TO_FSBT(mp, offset);
last_fsb = XFS_B_TO_FSB(mp, (offset + count));
count_fsb = (xfs_extlen_t)(last_fsb - offset_fsb);
ASSERT(count_fsb > 0);
last_gap = NULL;
while (count_fsb > 0) {
nimaps = XFS_BGL_NIMAPS;
(void) xfs_bmapi(NULL, ip, offset_fsb, count_fsb,
0, NULLFSBLOCK, 0, imaps, &nimaps, NULL);
ASSERT(nimaps != 0);
/*
* Look for the holes in the mappings returned by bmapi.
* Decrement count_fsb and increment offset_fsb as we go.
*/
for (i = 0; i < nimaps; i++) {
imapp = &imaps[i];
count_fsb -= imapp->br_blockcount;
ASSERT(count_fsb >= 0);
ASSERT(offset_fsb == imapp->br_startoff);
offset_fsb += imapp->br_blockcount;
ASSERT(offset_fsb <= last_fsb);
ASSERT((offset_fsb < last_fsb) || (count_fsb == 0));
/*
* Skip anything that is not a hole.
*/
if (imapp->br_startblock != HOLESTARTBLOCK) {
continue;
}
/*
* We found a hole. Now add an entry to the inode's
* gap list corresponding to it. The list is
* a singly linked, NULL terminated list. We add
* each entry to the end of the list so that it is
* sorted by file offset.
*/
new_gap = kmem_alloc(sizeof(xfs_gap_t), KM_SLEEP);
new_gap->xg_offset_fsb = imapp->br_startoff;
new_gap->xg_count_fsb = imapp->br_blockcount;
new_gap->xg_next = NULL;
if (last_gap == NULL) {
ip->i_gap_list = new_gap;
} else {
last_gap->xg_next = new_gap;
}
last_gap = new_gap;
}
}
xfs_check_gap_list(ip);
}
/*
* Remove or trim any entries in the inode's gap list which overlap
* the given range. I'm going to assume for now that we never give
* a range which is actually in the middle of an entry (i.e. we'd need
* to split it in two). This is a valid assumption for now given the
* use of this in xfs_write_file() where we start at the front and
* move sequentially forward.
*/
STATIC void
xfs_delete_gap_list(
xfs_inode_t *ip,
xfs_fileoff_t offset_fsb,
xfs_extlen_t count_fsb)
{
xfs_gap_t *curr_gap;
xfs_gap_t *last_gap;
xfs_gap_t *next_gap;
xfs_fileoff_t gap_offset_fsb;
xfs_extlen_t gap_count_fsb;
xfs_fileoff_t gap_end_fsb;
xfs_fileoff_t end_fsb;
last_gap = NULL;
curr_gap = ip->i_gap_list;
while (curr_gap != NULL) {
gap_offset_fsb = curr_gap->xg_offset_fsb;
gap_count_fsb = curr_gap->xg_count_fsb;
/*
* The entries are sorted by offset, so if we see
* one beyond our range we're done.
*/
end_fsb = offset_fsb + count_fsb;
if (gap_offset_fsb >= end_fsb) {
return;
}
gap_end_fsb = gap_offset_fsb + gap_count_fsb;
if (gap_end_fsb <= offset_fsb) {
/*
* This shouldn't be able to happen for now.
*/
ASSERT(0);
last_gap = curr_gap;
curr_gap = curr_gap->xg_next;
continue;
}
/*
* We've go an overlap. If the gap is entirely contained
* in the region then remove it. If not, then shrink it
* by the amount overlapped.
*/
if (gap_end_fsb > end_fsb) {
/*
* The region does not extend to the end of the gap.
* Shorten the gap by the amount in the region,
* and then we're done since we've reached the
* end of the region.
*/
ASSERT(gap_offset_fsb >= offset_fsb);
curr_gap->xg_offset_fsb = end_fsb;
curr_gap->xg_count_fsb = gap_end_fsb - end_fsb;
return;
}
next_gap = curr_gap->xg_next;
if (last_gap == NULL) {
ip->i_gap_list = next_gap;
} else {
ASSERT(0);
ASSERT(last_gap->xg_next == curr_gap);
last_gap->xg_next = next_gap;
}
kmem_free(curr_gap, sizeof(xfs_gap_t));
curr_gap = next_gap;
}
}
/*
* Free up all of the entries in the inode's gap list. This requires
* the inode lock to be held exclusively.
*/
STATIC void
xfs_free_gap_list(
xfs_inode_t *ip)
{
xfs_gap_t *curr_gap;
xfs_gap_t *next_gap;
ASSERT(ismrlocked(&(ip->i_lock), MR_UPDATE) != 0);
xfs_check_gap_list(ip);
curr_gap = ip->i_gap_list;
while (curr_gap != NULL) {
next_gap = curr_gap->xg_next;
kmem_free(curr_gap, sizeof(xfs_gap_t));
curr_gap = next_gap;
}
ip->i_gap_list = NULL;
}
/*
* Zero the parts of the buffer which overlap gaps in the inode's gap list.
* Deal with everything in BBs since the buffer is not guaranteed to be block
* aligned.
*/
STATIC void
xfs_cmp_gap_list_and_zero(
xfs_inode_t *ip,
buf_t *bp)
{
off_t bp_offset_bb;
int bp_len_bb;
off_t gap_offset_bb;
int gap_len_bb;
int zero_offset_bb;
int zero_len_bb;
xfs_gap_t *curr_gap;
xfs_mount_t *mp;
ASSERT(ismrlocked(&(ip->i_lock), MR_UPDATE | MR_ACCESS) != 0);
xfs_check_gap_list(ip);
bp_offset_bb = bp->b_offset;
bp_len_bb = BTOBB(bp->b_bcount);
mp = ip->i_mount;
curr_gap = ip->i_gap_list;
while (curr_gap != NULL) {
gap_offset_bb = XFS_FSB_TO_BB(mp, curr_gap->xg_offset_fsb);
gap_len_bb = XFS_FSB_TO_BB(mp, curr_gap->xg_count_fsb);
/*
* Check to see if this gap is before the buffer starts.
*/
if ((gap_offset_bb + gap_len_bb) <= bp_offset_bb) {
curr_gap = curr_gap->xg_next;
continue;
}
/*
* Check to see if this gap is after th buffer ends.
* If it is then we're done since the list is sorted
* by gap offset.
*/
if (gap_offset_bb >= (bp_offset_bb + bp_len_bb)) {
break;
}
/*
* We found a gap which overlaps the buffer. Zero
* the portion of the buffer overlapping the gap.
*/
if (gap_offset_bb < bp_offset_bb) {
/*
* The gap starts before the buffer, so we start
* zeroing from the start of the buffer.
*/
zero_offset_bb = 0;
/*
* To calculate the amount of overlap. First
* subtract the portion of the gap which is before
* the buffer. If the length is still longer than
* the buffer, then just zero the entire buffer.
*/
zero_len_bb = gap_len_bb -
(bp_offset_bb - gap_offset_bb);
if (zero_len_bb > bp_len_bb) {
zero_len_bb = bp_len_bb;
}
ASSERT(zero_len_bb > 0);
} else {
/*
* The gap starts at the beginning or in the middle
* of the buffer. The offset into the buffer is
* the difference between the two offsets.
*/
zero_offset_bb = gap_offset_bb - bp_offset_bb;
/*
* Figure out the length of the overlap. If the
* gap extends beyond the end of the buffer, then
* just zero to the end of the buffer. Otherwise
* just zero the length of the gap.
*/
if ((gap_offset_bb + gap_len_bb) >
(bp_offset_bb + bp_len_bb)) {
zero_len_bb = bp_len_bb - zero_offset_bb;
} else {
zero_len_bb = gap_len_bb;
}
}
/*
* Now that we've calculated the range of the buffer to
* zero, do it.
*/
xfs_zero_bp(bp, BBTOB(zero_offset_bb), BBTOB(zero_len_bb));
curr_gap = curr_gap->xg_next;
}
}
/*
* "Read" in a buffer whose b_blkno is -1. This means that
* at the time the buffer was created there was no underlying
* backing store for the range of the file covered by the bp.
* To figure out the current state of things, we lock the inode
* and call xfs_bmapi() to look at the current extents format.
* If we're over a hole or delayed allocation space we simply
* zero the corresponding portions of the buffer. For parts
* over real disk space we need to read in the stuff from disk.
*
* We know that we can just use xfs_ilock(SHARED) rather than
* xfs_ilock_map_shared() here, because the extents had to be
* read in in order to create the buffer we're trying to write out.
*/
STATIC void
xfs_strat_read(
vnode_t *vp,
buf_t *bp)
{
xfs_fileoff_t offset_fsb;
xfs_fileoff_t map_start_fsb;
xfs_fileoff_t imap_offset;
xfs_fsblock_t last_bp_bb;
xfs_fsblock_t last_map_bb;
xfs_extlen_t count_fsb;
xfs_extlen_t imap_blocks;
xfs_fsize_t isize;
off_t offset;
off_t end_offset;
off_t init_limit;
int x;
caddr_t datap;
buf_t *rbp;
xfs_mount_t *mp;
xfs_inode_t *ip;
int count;
int block_off;
int data_bytes;
int data_offset;
int data_len;
int nimaps;
xfs_bmbt_irec_t *imap;
#define XFS_STRAT_READ_IMAPS XFS_BMAP_MAX_NMAP
ASSERT(bp->b_blkno == -1);
ip = XFS_VTOI(vp);
mp = XFS_VFSTOM(vp->v_vfsp);
offset_fsb = XFS_BB_TO_FSBT(mp, bp->b_offset);
/*
* Only read up to the EOF or the current write offset.
* The idea here is to avoid initializing pages which are
* going to be immediately overwritten in xfs_write_file().
* The most important case is the sequential write case, where
* the new pages at the end of the file are sent here by
* chunk_patch(). We don't want to zero them since they
* are about to be overwritten.
*
* The ip->i_write_off tells us the offset of any write in
* progress. If it is 0 then we assume that no write is
* in progress. If the write offset is within the file size,
* the the file size is the upper limit. If the write offset
* is beyond the file size, then we only want to initialize the
* buffer up to the write offset. Beyond that will either be
* overwritten or be beyond the new EOF.
*/
isize = ip->i_d.di_size;
offset = BBTOOFF(bp->b_offset);
end_offset = offset + bp->b_bcount;
if (ip->i_write_offset == 0) {
init_limit = isize;
} else if (ip->i_write_offset <= isize) {
init_limit = isize;
} else {
init_limit = ip->i_write_offset;
}
if (end_offset <= init_limit) {
count = bp->b_bcount;
} else {
count = init_limit - offset;
}
if (count <= 0) {
iodone(bp);
return;
}
/*
* Since the buffer may not be file system block aligned, we
* can't do a simple shift to find the number of blocks underlying
* it. Instead we subtract the last block it sits on from the first.
*/
count_fsb = XFS_B_TO_FSB(mp, (offset + count)) -
XFS_B_TO_FSBT(mp, offset);
map_start_fsb = offset_fsb;
imap = (xfs_bmbt_irec_t *)kmem_zone_alloc(xfs_irec_zone, KM_SLEEP);
xfs_ilock(ip, XFS_ILOCK_SHARED);
while (count_fsb != 0) {
nimaps = XFS_STRAT_READ_IMAPS;
(void) xfs_bmapi(NULL, ip, map_start_fsb, count_fsb, 0,
NULLFSBLOCK, 0, imap, &nimaps, NULL);
ASSERT(nimaps >= 1);
for (x = 0; x < nimaps; x++) {
imap_offset = imap[x].br_startoff;
ASSERT(imap_offset == map_start_fsb);
imap_blocks = imap[x].br_blockcount;
ASSERT(imap_blocks <= count_fsb);
/*
* Calculate the offset of this mapping in the
* buffer and the number of bytes of this mapping
* that are in the buffer. If the block size is
* greater than the page size, then the buffer may
* not line up on file system block boundaries
* (e.g. pages being read in from chunk_patch()).
* In that case we need to account for the space
* in the file system blocks underlying the buffer
* that is not actually a part of the buffer. This
* space is the space in the first block before the
* start of the buffer and the space in the last
* block after the end of the buffer.
*/
data_offset = XFS_FSB_TO_B(mp,
imap_offset - offset_fsb);
data_bytes = XFS_FSB_TO_B(mp, imap_blocks);
block_off = 0;
if (mp->m_sb.sb_blocksize > NBPP) {
/*
* If the buffer is actually fsb
* aligned then this will simply
* subtract 0 and do no harm. If the
* current mapping is for the start of
* the buffer, then data offset will be
* zero so we don't need to subtract out
* any space at the beginning.
*/
if (data_offset > 0) {
data_offset -= BBTOB(
XFS_BB_FSB_OFFSET(mp,
bp->b_offset));
}
if (map_start_fsb == offset_fsb) {
ASSERT(data_offset == 0);
/*
* This is on the first block
* mapped, so it must be the start
* of the buffer. Subtract out from
* the number of bytes the bytes
* between the start of the block
* and the start of the buffer.
*/
data_bytes -=
BBTOB(XFS_BB_FSB_OFFSET(
mp, bp->b_offset));
/*
* Set block_off to the number of
* BBs that the buffer is offset
* from the start of this mapping.
*/
block_off = XFS_BB_FSB_OFFSET(mp,
bp->b_offset);
ASSERT(block_off >= 0);
}
if (imap_blocks == count_fsb) {
/*
* This mapping includes the last
* block to be mapped. Subtract out
* from the number of bytes the bytes
* between the end of the buffer and
* the end of the block. It may
* be the case that the buffer
* extends beyond the mapping (if
* it is beyond the end of the file),
* in which case no adjustment
* is necessary.
*/
last_bp_bb = bp->b_offset +
BTOBB(bp->b_bcount);
last_map_bb =
XFS_FSB_TO_BB(mp,
(imap_offset +
imap_blocks));
if (last_map_bb > last_bp_bb) {
data_bytes -=
BBTOB(last_map_bb -
last_bp_bb);
}
}
}
ASSERT(data_bytes > 0);
ASSERT(data_offset >= 0);
if ((imap[x].br_startblock == DELAYSTARTBLOCK) ||
(imap[x].br_startblock == HOLESTARTBLOCK)) {
/*
* This is either a hole or a delayed
* alloc extent. Either way, just fill
* it with zeroes.
*/
datap = bp_mapin(bp);
datap += data_offset;
bzero(datap, data_bytes);
if (!dpoff(bp->b_offset)) {
bp_mapout(bp);
}
} else {
/*
* The extent really exists on disk, so
* read it in.
*/
rbp = getrbuf(KM_SLEEP);
xfs_overlap_bp(bp, rbp, data_offset,
data_bytes);
rbp->b_blkno = XFS_FSB_TO_DB(mp, ip,
imap[x].br_startblock) +
block_off;
rbp->b_offset = XFS_FSB_TO_BB(mp,
imap_offset) +
block_off;
rbp->b_flags |= B_READ;
rbp->b_flags &= ~B_ASYNC;
xfs_check_rbp(ip, bp, rbp, 1);
bdstrat(bmajor(rbp->b_edev), rbp);
iowait(rbp);
if (rbp->b_flags & B_ERROR) {
bp->b_flags |= B_ERROR;
bp->b_error = XFS_ERROR(rbp->b_error);
ASSERT(bp->b_error != EINVAL);
}
/*
* Check to see if the block extent (or parts
* of it) have not yet been initialized and
* should therefore be zeroed.
*/
xfs_cmp_gap_list_and_zero(ip, rbp);
if (BP_ISMAPPED(rbp)) {
bp_mapout(rbp);
}
freerbuf(rbp);
}
count_fsb -= imap_blocks;
map_start_fsb += imap_blocks;
}
}
xfs_iunlock(ip, XFS_ILOCK_SHARED);
iodone(bp);
kmem_zone_free(xfs_irec_zone, imap);
}
#ifdef DEBUG
void
xfs_strat_write_bp_trace(
int tag,
xfs_inode_t *ip,
buf_t *bp)
{
if (ip->i_strat_trace == NULL) {
return;
}
ktrace_enter(ip->i_strat_trace,
(void*)tag,
(void*)ip,
(void*)((ip->i_d.di_size > 32) & 0xffffffff),
(void*)(ip->i_d.di_size & 0xffffffff),
(void*)bp,
(void*)((bp->b_offset > 32) & 0xffffffff),
(void*)(bp->b_offset & 0xffffffff),
(void*)(bp->b_bcount),
(void*)(bp->b_bufsize),
(void*)(bp->b_blkno),
(void*)(bp->b_flags),
(void*)(bp->b_pages),
(void*)(bp->b_pages->pf_pageno),
(void*)0,
(void*)0,
(void*)0);
ktrace_enter(xfs_strat_trace_buf,
(void*)tag,
(void*)ip,
(void*)((ip->i_d.di_size > 32) & 0xffffffff),
(void*)(ip->i_d.di_size & 0xffffffff),
(void*)bp,
(void*)((bp->b_offset > 32) & 0xffffffff),
(void*)(bp->b_offset & 0xffffffff),
(void*)(bp->b_bcount),
(void*)(bp->b_bufsize),
(void*)(bp->b_blkno),
(void*)(bp->b_flags),
(void*)(bp->b_pages),
(void*)(bp->b_pages->pf_pageno),
(void*)0,
(void*)0,
(void*)0);
}
void
xfs_strat_write_subbp_trace(
int tag,
xfs_inode_t *ip,
buf_t *bp,
buf_t *rbp,
off_t last_off,
int last_bcount,
daddr_t last_blkno)
{
if (ip->i_strat_trace == NULL) {
return;
}
ktrace_enter(ip->i_strat_trace,
(void*)tag,
(void*)ip,
(void*)((ip->i_d.di_size > 32) & 0xffffffff),
(void*)(ip->i_d.di_size & 0xffffffff),
(void*)bp,
(void*)rbp,
(void*)((rbp->b_offset > 32) & 0xffffffff),
(void*)(rbp->b_offset & 0xffffffff),
(void*)(rbp->b_bcount),
(void*)(rbp->b_blkno),
(void*)(rbp->b_flags),
(void*)(rbp->b_un.b_addr),
(void*)(bp->b_pages),
(void*)(last_off),
(void*)(last_bcount),
(void*)(last_blkno));
ktrace_enter(xfs_strat_trace_buf,
(void*)tag,
(void*)ip,
(void*)((ip->i_d.di_size > 32) & 0xffffffff),
(void*)(ip->i_d.di_size & 0xffffffff),
(void*)bp,
(void*)rbp,
(void*)((rbp->b_offset > 32) & 0xffffffff),
(void*)(rbp->b_offset & 0xffffffff),
(void*)(rbp->b_bcount),
(void*)(rbp->b_blkno),
(void*)(rbp->b_flags),
(void*)(rbp->b_un.b_addr),
(void*)(bp->b_pages),
(void*)(last_off),
(void*)(last_bcount),
(void*)(last_blkno));
}
/*
* xfs_strat_write_check
*
* Make sure that there are blocks or delayed allocation blocks
* underlying the entire area given. The imap parameter is simply
* given as a scratch area in order to reduce stack space. No
* values are returned within it.
*/
STATIC void
xfs_strat_write_check(
xfs_inode_t *ip,
xfs_fileoff_t offset_fsb,
xfs_extlen_t buf_fsb,
xfs_bmbt_irec_t *imap,
int imap_count)
{
xfs_extlen_t count_fsb;
boolean_t done;
int nimaps;
int n;
xfs_ilock(ip, XFS_ILOCK_SHARED);
count_fsb = 0;
done = B_FALSE;
while (count_fsb < buf_fsb) {
nimaps = imap_count;
(void) xfs_bmapi(NULL, ip, (offset_fsb + count_fsb),
(buf_fsb - count_fsb), 0, NULLFSBLOCK, 0,
imap, &nimaps, NULL);
ASSERT(nimaps > 0);
n = 0;
while (n < nimaps) {
ASSERT(imap[n].br_startblock != HOLESTARTBLOCK);
count_fsb += imap[n].br_blockcount;
ASSERT(count_fsb <= buf_fsb);
n++;
}
}
xfs_iunlock(ip, XFS_ILOCK_SHARED);
return;
}
#endif /* DEBUG */
/*
* This is the completion routine for the heap-allocated buffers
* used to write out a buffer which becomes fragmented during
* xfs_strat_write(). It must coordinate with xfs_strat_write()
* to properly mark the lead buffer as done when necessary and
* to free the subordinate buffer.
*/
STATIC void
xfs_strat_write_relse(
buf_t *rbp)
{
int s;
buf_t *leader;
buf_t *forw;
buf_t *back;
s = splockspl(xfs_strat_lock, splhi);
ASSERT(rbp->b_flags & B_DONE);
forw = (buf_t*)rbp->b_fsprivate2;
back = (buf_t*)rbp->b_fsprivate;
ASSERT(back != NULL);
ASSERT(back->b_fsprivate2 == rbp);
ASSERT((forw == NULL) || (forw->b_fsprivate == rbp));
/*
* Pull ourselves from the list.
*/
back->b_fsprivate2 = forw;
if (forw != NULL) {
forw->b_fsprivate = back;
}
if ((forw == NULL) &&
(back->b_flags & B_LEADER) &&
!(back->b_flags & B_PARTIAL)) {
/*
* We are the only buffer in the list and the lead buffer
* has cleared the B_PARTIAL bit to indicate that all
* subordinate buffers have been issued. That means it
* is time to finish off the lead buffer.
*/
leader = back;
if (rbp->b_flags & B_ERROR) {
leader->b_flags |= B_ERROR;
leader->b_error = XFS_ERROR(rbp->b_error);
ASSERT(leader->b_error != EINVAL);
}
leader->b_flags &= ~B_LEADER;
spunlockspl(xfs_strat_lock, s);
iodone(leader);
} else {
/*
* Either there are still other buffers in the list or
* not all of the subordinate buffers have yet been issued.
* In this case just pass any errors on to the lead buffer.
*/
while (!(back->b_flags & B_LEADER)) {
back = (buf_t*)back->b_fsprivate;
}
ASSERT(back != NULL);
ASSERT(back->b_flags & B_LEADER);
leader = back;
if (rbp->b_flags & B_ERROR) {
leader->b_flags |= B_ERROR;
leader->b_error = XFS_ERROR(rbp->b_error);
ASSERT(leader->b_error != EINVAL);
}
spunlockspl(xfs_strat_lock, s);
}
rbp->b_fsprivate = NULL;
rbp->b_fsprivate2 = NULL;
rbp->b_relse = NULL;
#ifndef SIM
if (BP_ISMAPPED(rbp)) {
bp_mapout(rbp);
}
#endif
freerbuf(rbp);
}
#ifdef DEBUG
void
xfs_check_rbp(
xfs_inode_t *ip,
buf_t *bp,
buf_t *rbp,
int locked)
{
xfs_mount_t *mp;
int nimaps;
xfs_bmbt_irec_t imap;
xfs_fileoff_t rbp_offset_fsb;
xfs_extlen_t rbp_len_fsb;
pfd_t *pfdp;
mp = ip->i_mount;
rbp_offset_fsb = XFS_BB_TO_FSBT(mp, rbp->b_offset);
rbp_len_fsb = XFS_BB_TO_FSB(mp, rbp->b_offset+BTOBB(rbp->b_bcount)) -
XFS_BB_TO_FSBT(mp, rbp->b_offset);
nimaps = 1;
if (!locked) {
xfs_ilock(ip, XFS_ILOCK_SHARED);
}
(void) xfs_bmapi(NULL, ip, rbp_offset_fsb, rbp_len_fsb, 0,
NULLFSBLOCK, 0, &imap, &nimaps, NULL);
if (!locked) {
xfs_iunlock(ip, XFS_ILOCK_SHARED);
}
ASSERT(imap.br_startoff == rbp_offset_fsb);
ASSERT(imap.br_blockcount == rbp_len_fsb);
ASSERT((XFS_FSB_TO_DB(mp, ip, imap.br_startblock) +
XFS_BB_FSB_OFFSET(mp, rbp->b_offset)) ==
rbp->b_blkno);
if (rbp->b_flags & B_PAGEIO) {
pfdp = NULL;
pfdp = getnextpg(rbp, pfdp);
ASSERT(pfdp != NULL);
ASSERT(dtopt(rbp->b_offset) == pfdp->pf_pageno);
if (dpoff(rbp->b_offset)) {
ASSERT(rbp->b_flags & B_MAPPED);
}
}
if (rbp->b_flags & B_MAPPED) {
ASSERT(BTOBB(poff(rbp->b_un.b_addr)) ==
dpoff(rbp->b_offset));
}
}
/*
* Verify that the given buffer is going to the right place in its
* file. Also check that it is properly mapped and points to the
* right page. We can only do a trylock from here in order to prevent
* deadlocks, since this is called from the strategy routine.
*/
void
xfs_check_bp(
xfs_inode_t *ip,
buf_t *bp)
{
xfs_mount_t *mp;
int nimaps;
xfs_bmbt_irec_t imap;
xfs_fileoff_t bp_offset_fsb;
xfs_extlen_t bp_len_fsb;
pfd_t *pfdp;
int locked;
mp = ip->i_mount;
if (bp->b_flags & B_PAGEIO) {
pfdp = NULL;
pfdp = getnextpg(bp, pfdp);
ASSERT(pfdp != NULL);
ASSERT(dtopt(bp->b_offset) == pfdp->pf_pageno);
if (dpoff(bp->b_offset)) {
ASSERT(bp->b_flags & B_MAPPED);
}
}
if (bp->b_flags & B_MAPPED) {
ASSERT(BTOBB(poff(bp->b_un.b_addr)) ==
dpoff(bp->b_offset));
}
bp_offset_fsb = XFS_BB_TO_FSBT(mp, bp->b_offset);
bp_len_fsb = XFS_BB_TO_FSB(mp, bp->b_offset + BTOBB(bp->b_bcount)) -
XFS_BB_TO_FSBT(mp, bp->b_offset);
ASSERT(bp_len_fsb > 0);
nimaps = 1;
locked = xfs_ilock_nowait(ip, XFS_ILOCK_SHARED);
if (!locked) {
return;
}
(void) xfs_bmapi(NULL, ip, bp_offset_fsb, bp_len_fsb, 0,
NULLFSBLOCK, 0, &imap, &nimaps, NULL);
xfs_iunlock(ip, XFS_ILOCK_SHARED);
ASSERT(nimaps == 1);
ASSERT(imap.br_startoff == bp_offset_fsb);
ASSERT(imap.br_blockcount == bp_len_fsb);
ASSERT((XFS_FSB_TO_DB(mp, ip, imap.br_startblock) +
XFS_BB_FSB_OFFSET(mp, bp->b_offset)) ==
bp->b_blkno);
}
#endif /* DEBUG */
STATIC void
xfs_strat_write(
vnode_t *vp,
buf_t *bp)
{
xfs_strat_write_locals_t *locals;
#define XFS_STRAT_WRITE_IMAPS 2
/*
* If XFS_STRAT_WRITE_IMAPS is changed then the definition
* of XFS_STRATW_LOG_RES in xfs_trans.h must be changed to
* reflect the new number of extents that can actually be
* allocated in a single transaction.
*/
XFSSTATS.xs_xstrat_bytes += bp->b_bcount;
locals = (xfs_strat_write_locals_t *)
kmem_zone_alloc(xfs_strat_write_zone, KM_SLEEP);
locals->ip = XFS_VTOI(vp);
locals->mp = locals->ip->i_mount;
locals->set_lead = 0;
locals->rbp_count = 0;
bp->b_flags |= B_STALE;
ASSERT(bp->b_blkno == -1);
locals->offset_fsb = XFS_BB_TO_FSBT(locals->mp, bp->b_offset);
locals->count_fsb = XFS_B_TO_FSB(locals->mp, bp->b_bcount);
xfs_strat_write_check(locals->ip, locals->offset_fsb,
locals->count_fsb, locals->imap,
XFS_STRAT_WRITE_IMAPS);
locals->map_start_fsb = locals->offset_fsb;
while (locals->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.
*/
locals->nimaps = 0;
locals->loops = 0;
while (locals->nimaps == 0) {
locals->tp = xfs_trans_alloc(locals->mp,
XFS_TRANS_STRAT_WRITE);
locals->error = xfs_trans_reserve(locals->tp, 0,
XFS_WRITE_LOG_RES(locals->mp),
0, XFS_TRANS_PERM_LOG_RES,
XFS_WRITE_LOG_COUNT);
ASSERT(locals->error == 0);
xfs_ilock(locals->ip, XFS_ILOCK_EXCL);
xfs_trans_ijoin(locals->tp, locals->ip,
XFS_ILOCK_EXCL);
xfs_trans_ihold(locals->tp, locals->ip);
xfs_strat_write_bp_trace(XFS_STRAT_ENTER,
locals->ip, bp);
/*
* Allocate the backing store for the file.
*/
XFS_BMAP_INIT(&(locals->free_list),
&(locals->first_block));
locals->nimaps = XFS_STRAT_WRITE_IMAPS;
locals->first_block = xfs_bmapi(locals->tp,
locals->ip,
locals->map_start_fsb,
locals->count_fsb,
XFS_BMAPI_WRITE,
locals->first_block, 1,
locals->imap,
&(locals->nimaps),
&(locals->free_list));
ASSERT(locals->loops++ <=
(locals->offset_fsb +
XFS_B_TO_FSB(locals->mp, bp->b_bcount)));
(void) xfs_bmap_finish(&(locals->tp),
&(locals->free_list),
locals->first_block);
xfs_trans_commit(locals->tp,
XFS_TRANS_RELEASE_LOG_RES);
/*
* Before dropping the lock, clear any read-ahead
* state since in allocating space here we may have
* made it invalid.
*/
XFS_INODE_CLEAR_READ_AHEAD(locals->ip);
xfs_iunlock(locals->ip, XFS_ILOCK_EXCL);
}
/*
* This is a quick check to see if the first time through
* was able to allocate a single extent over which to
* write.
*/
if ((locals->map_start_fsb == locals->offset_fsb) &&
(locals->imap[0].br_blockcount == locals->count_fsb)) {
ASSERT(locals->nimaps == 1);
bp->b_blkno = XFS_FSB_TO_DB(locals->mp, locals->ip,
locals->imap[0].br_startblock);
bp->b_bcount = XFS_FSB_TO_B(locals->mp,
locals->count_fsb);
xfs_strat_write_bp_trace(XFS_STRAT_FAST,
locals->ip, bp);
xfs_check_bp(locals->ip, bp);
bdstrat(bmajor(bp->b_edev), bp);
/*
* Drop the count of queued buffers.
*/
atomicAddInt(&(locals->ip->i_queued_bufs), -1);
ASSERT(locals->ip->i_queued_bufs >= 0);
kmem_zone_free(xfs_strat_write_zone, (void *)locals);
XFSSTATS.xs_xstrat_quick++;
return;
}
/*
* Bmap couldn't manage to lay the buffer out as
* one extent, so we need to do multiple writes
* to push the data to the multiple extents.
* Write out the subordinate bps asynchronously
* and have their completion functions coordinate
* with the code at the end of this function to
* deal with marking our bp as done when they have
* ALL completed.
*/
XFSSTATS.xs_xstrat_split++;
locals->imap_index = 0;
if (!locals->set_lead) {
bp->b_flags |= B_LEADER | B_PARTIAL;
locals->set_lead = 1;
}
while (locals->imap_index < locals->nimaps) {
locals->rbp = getrbuf(KM_SLEEP);
locals->imapp = &(locals->imap[locals->imap_index]);
ASSERT((locals->imapp->br_startblock !=
DELAYSTARTBLOCK) &&
(locals->imapp->br_startblock !=
HOLESTARTBLOCK));
locals->imap_offset = locals->imapp->br_startoff;
locals->rbp_offset = XFS_FSB_TO_B(locals->mp,
locals->imap_offset -
locals->offset_fsb);
locals->imap_blocks = locals->imapp->br_blockcount;
ASSERT((locals->imap_offset + locals->imap_blocks) <=
(locals->offset_fsb +
XFS_B_TO_FSB(locals->mp, bp->b_bcount)));
locals->rbp_len = XFS_FSB_TO_B(locals->mp,
locals->imap_blocks);
xfs_overlap_bp(bp, locals->rbp, locals->rbp_offset,
locals->rbp_len);
locals->rbp->b_blkno =
XFS_FSB_TO_DB(locals->mp, locals->ip,
locals->imapp->br_startblock);
locals->rbp->b_offset = XFS_FSB_TO_BB(locals->mp,
locals->imap_offset);
xfs_strat_write_subbp_trace(XFS_STRAT_SUB,
locals->ip, bp,
locals->rbp,
locals->last_rbp_offset,
locals->last_rbp_bcount,
locals->last_rbp_blkno);
#ifdef DEBUG
xfs_check_rbp(locals->ip, bp, locals->rbp, 0);
if (locals->rbp_count > 0) {
ASSERT((locals->last_rbp_offset +
BTOBB(locals->last_rbp_bcount)) ==
locals->rbp->b_offset);
ASSERT((locals->rbp->b_blkno <
locals->last_rbp_blkno) ||
(locals->rbp->b_blkno >=
(locals->last_rbp_blkno +
BTOBB(locals->last_rbp_bcount))));
if (locals->rbp->b_blkno <
locals->last_rbp_blkno) {
ASSERT((locals->rbp->b_blkno +
BTOBB(locals->rbp->b_bcount)) <
locals->last_rbp_blkno);
}
}
locals->last_rbp_offset = locals->rbp->b_offset;
locals->last_rbp_bcount = locals->rbp->b_bcount;
locals->last_rbp_blkno = locals->rbp->b_blkno;
#endif
/*
* Link the buffer into the list of subordinate
* buffers started at bp->b_fsprivate2. The
* subordinate buffers use b_fsprivate and
* b_fsprivate2 for back and forw pointers, but
* the lead buffer cannot use b_fsprivate.
* A subordinate buffer can always find the lead
* buffer by searching back through the fsprivate
* fields until it finds the buffer marked with
* B_LEADER.
*/
locals->s = splockspl(xfs_strat_lock, splhi);
locals->rbp->b_fsprivate = bp;
locals->rbp->b_fsprivate2 = bp->b_fsprivate2;
if (bp->b_fsprivate2 != NULL) {
((buf_t*)(bp->b_fsprivate2))->b_fsprivate =
locals->rbp;
}
bp->b_fsprivate2 = locals->rbp;
spunlockspl(xfs_strat_lock, locals->s);
locals->rbp->b_relse = xfs_strat_write_relse;
locals->rbp->b_flags |= B_ASYNC;
bdstrat(bmajor(locals->rbp->b_edev), locals->rbp);
locals->map_start_fsb +=
locals->imapp->br_blockcount;
locals->count_fsb -= locals->imapp->br_blockcount;
ASSERT(locals->count_fsb >= 0);
locals->imap_index++;
}
}
/*
* Now that we've issued all the partial I/Os, check to see
* if they've all completed. If they have then mark the buffer
* as done, otherwise clear the B_PARTIAL flag in the buffer to
* indicate that the last subordinate buffer to complete should
* mark the buffer done. Also, drop the count of queued buffers
* now that we know that all the space underlying the buffer has
* been allocated and it has really been sent out to disk.
*/
atomicAddInt(&(locals->ip->i_queued_bufs), -1);
ASSERT(locals->ip->i_queued_bufs >= 0);
locals->s = splockspl(xfs_strat_lock, splhi);
ASSERT((bp->b_flags & (B_DONE | B_PARTIAL)) == B_PARTIAL);
ASSERT(bp->b_flags & B_LEADER);
if (bp->b_fsprivate2 == NULL) {
/*
* All of the subordinate buffers have completed.
* Call iodone() to note that the I/O has completed.
*/
bp->b_flags &= ~(B_PARTIAL | B_LEADER);
spunlockspl(xfs_strat_lock, locals->s);
iodone(bp);
kmem_zone_free(xfs_strat_write_zone, (void *)locals);
return;
}
bp->b_flags &= ~B_PARTIAL;
spunlockspl(xfs_strat_lock, locals->s);
kmem_zone_free(xfs_strat_write_zone, (void *)locals);
return;
}
/*
* xfs_strategy
*
* This is where all the I/O and all the REAL allocations take
* place. For buffers with -1 for their b_blkno field, we need
* to do a bmap to figure out what to do with them. If it's a
* write we may need to do an allocation, while if it's a read
* we may either need to read from disk or do some block zeroing.
* If b_blkno specifies a real block, then all we need to do
* is pass the buffer on to the underlying driver.
*/
void
xfs_strategy(
vnode_t *vp,
buf_t *bp)
{
xfs_mount_t *mp;
int s;
mp = XFS_VFSTOM(vp->v_vfsp);
/*
* If this is just a buffer whose underlying disk space
* is already allocated, then just do the requested I/O.
*/
if (bp->b_blkno >= 0) {
xfs_check_bp(XFS_VTOI(vp), bp);
bdstrat(bmajor(bp->b_edev), bp);
return;
}
/*
* If we're reading, then we need to find out how the
* portion of the file required for this buffer is layed
* out and zero/read in the appropriate data.
*/
if (bp->b_flags & B_READ) {
xfs_strat_read(vp, bp);
return;
}
/*
* Here we're writing the file and probably need to allocate
* some underlying disk space. If the buffer is being written
* asynchronously by bdflush() then we queue if for the xfsds
* so that we won't put bdflush() to sleep.
*/
if ((bp->b_flags & (B_ASYNC | B_BDFLUSH)) == (B_ASYNC | B_BDFLUSH) &&
(xfsd_count > 0)) {
s = splock(xfsd_lock);
/*
* Queue the buffer at the end of the list.
* Bump the inode count of the number of queued buffers.
*/
if (xfsd_list == NULL) {
bp->av_forw = bp;
bp->av_back = bp;
xfsd_list = bp;
} else {
bp->av_back = xfsd_list->av_back;
xfsd_list->av_back->av_forw = bp;
xfsd_list->av_back = bp;
bp->av_forw = xfsd_list;
}
xfsd_bufcount++;
ASSERT(XFS_VTOI(vp)->i_queued_bufs >= 0);
atomicAddInt(&(XFS_VTOI(vp)->i_queued_bufs), 1);
cvsema(&xfsd_wait);
spunlock(xfsd_lock, s);
} else {
/*
* We're not going to queue it for the xfsds, but bump the
* inode's count anyway so that we can tell that this
* buffer is still on its way out.
*/
ASSERT(XFS_VTOI(vp)->i_queued_bufs >= 0);
atomicAddInt(&(XFS_VTOI(vp)->i_queued_bufs), 1);
xfs_strat_write(vp, bp);
}
}
#ifndef SIM
/*
* This is called from main() to start the xfs daemons.
* We'll start with a minimum of 4 of them, and add 1
* for each 128 MB of memory up to 1 GB. That should
* be enough.
*/
void
xfs_start_daemons(void)
{
int num_daemons;
int i;
int num_pages;
num_daemons = 4;
num_pages = (int)physmem - 32768;
while ((num_pages > 0) && (num_daemons < 13)) {
num_pages -= 32768;
num_daemons++;
}
ASSERT(num_daemons <= 13);
for (i = 0; i < num_daemons; i++) {
if (newproc(NP_SYSPROC, 0)) {
#if !STAT_TIME
ASSERT(private.p_activetimer ==
&u.u_ptimer[PTIMER_INDEX(AS_SYS_RUN)]);
/* u_utime, u_stime are evaluated on exit */
/* u_cutime, u_cstime are accumulated during wait() */
timerclear(&u.u_cutime);
timerclear(&u.u_cstime);
#else
u.u_cstime = u.u_stime = u.u_cutime = u.u_utime = 0;
#endif
bcopy("xfsd", u.u_psargs, 5);
bcopy("xfsd", u.u_comm, 4);
xfsd();
}
}
return;
}
/*
* This is the main loop for the xfs daemons.
* From here they wait in a loop for buffers which will
* require transactions to write out and process them as they come.
* This way we never force bdflush() to wait on one of our transactions,
* thereby keeping the system happier and preventing buffer deadlocks.
*/
STATIC int
xfsd(void)
{
int s;
buf_t *bp;
buf_t *forw;
buf_t *back;
/*
* Make us a high non-degrading priority process like bdflush(),
* since that is who we're relieving of work.
*/
setinfoRunq(u.u_procp, RQRTPRI, NDPHIMIN);
s = splock(xfsd_lock);
xfsd_count++;
while (1) {
while (xfsd_list == NULL) {
(void) spunlock_psema(xfsd_lock, s, &xfsd_wait,
PRIBIO);
s = splock(xfsd_lock);
}
/*
* Pull a buffer off of the list.
*/
bp = xfsd_list;
forw = bp->av_forw;
back = bp->av_back;
forw->av_back = back;
back->av_forw = forw;
if (forw == bp) {
xfsd_list = NULL;
} else {
xfsd_list = forw;
}
bp->av_forw = bp;
bp->av_back = bp;
xfsd_bufcount--;;
ASSERT(xfsd_bufcount >= 0);
spunlock(xfsd_lock, s);
ASSERT((bp->b_flags & (B_BUSY | B_ASYNC | B_READ)) ==
(B_BUSY | B_ASYNC));
XFSSTATS.xs_xfsd_bufs++;
xfs_strat_write(bp->b_vp, bp);
s = splock(xfsd_lock);
}
}
#endif /* !SIM */
struct dio_s {
struct vnode *vp;
struct cred *cr;
int ioflag;
};
/*
* xfs_diostrat()
* This routine issues the calls to the disk device strategy routine
* for file system reads and writes made using direct I/O from user
* space. In the case of a write request the I/Os are issued one
* extent at a time. In the case of a read request I/Os for each extent
* involved are issued at once.
*
* RETURNS:
* none
*/
int
xfs_diostrat( buf_t *bp)
{
struct dio_s *dp;
xfs_inode_t *ip;
xfs_trans_t *tp;
vnode_t *vp;
xfs_mount_t *mp;
xfs_bmbt_irec_t imaps[XFS_BMAP_MAX_NMAP], *imapp, *timapp;
buf_t *bps[XFS_BMAP_MAX_NMAP], *nbp;
xfs_fileoff_t offset_fsb, last_fsb;
xfs_fsblock_t firstfsb;
xfs_extlen_t blocks, count_fsb, total;
xfs_bmap_free_t free_list;
caddr_t base;
ssize_t resid, count, totxfer;
off_t offset, offset_this_req, bytes_this_req;
int i, j, error, writeflag, reccount;
int end_of_file, bufsissued, totresid, exist;
int ioflag, blk_algn, rt, numrtextents, rtextsize;
uint lock_mode;
dp = (struct dio_s *)bp->b_private;
vp = dp->vp;
ip = XFS_VTOI(vp);
mp = XFS_VFSTOM(XFS_ITOV(ip)->v_vfsp);
base = bp->b_un.b_addr;
error = resid = totxfer = end_of_file = 0;
ioflag = dp->ioflag;
offset = BBTOOFF((off_t)bp->b_blkno);
blk_algn = 0;
totresid = count = bp->b_bcount;
/*
* Determine if this file is using the realtime volume.
*/
if ( ip->i_d.di_flags & XFS_DIFLAG_REALTIME ) {
rt = 1;
rtextsize = mp->m_sb.sb_rextsize;
} else {
numrtextents = 0;
rtextsize = 0;
rt = 0;
}
ASSERT(!(bp->b_flags & B_DONE));
ASSERT(ismrlocked(&ip->i_iolock, MR_ACCESS| MR_UPDATE) != 0);
/*
* Alignment checks are done in xfs_diordwr().
* Determine if the operation is a read or a write.
*/
if (bp->b_flags & B_READ) {
writeflag = 0;
} else {
writeflag = XFS_BMAPI_WRITE;
}
/*
* Check if the request is on a file system block boundary.
*/
if ( (offset & mp->m_blockmask) != 0 ) {
/*
* The request is NOT on a file system block boundary.
*/
blk_algn = OFFTOBB(offset & mp->m_blockmask);
}
/*
* Process the request until:
* 1) an I/O error occurs
* 2) end of file is reached.
* 3) end of device (driver error) occurs
* 4) request is completed.
*/
while ( !error && !end_of_file && !resid && count ) {
offset_fsb = XFS_B_TO_FSBT( mp, offset );
last_fsb = XFS_B_TO_FSB( mp, offset + count);
count_fsb = XFS_B_TO_FSB( mp, count);
blocks = (xfs_extlen_t)(last_fsb - offset_fsb);
tp = NULL;
exist = 1;
XFS_BMAP_INIT(&free_list, &firstfsb);
if ( writeflag ) {
/*
* In the write case, need to call bmapi() with
* the read flag set first to determine the existing
* extents. This is done so that the correct amount
* of space can be reserved in the transaction
* structure.
*/
reccount = XFS_BMAP_MAX_NMAP;
xfs_ilock( ip, XFS_ILOCK_EXCL );
firstfsb = xfs_bmapi( NULL, ip, offset_fsb,
count_fsb, 0, firstfsb, 0, imaps,
&reccount, 0);
/*
* Get a pointer to the current extent map.
* Writes will always be issued one at a time.
*/
reccount = 1;
imapp = &imaps[0];
count_fsb = imapp->br_blockcount;
if ((imapp->br_startblock == DELAYSTARTBLOCK) ||
(imapp->br_startblock == HOLESTARTBLOCK)) {
exist = 0;
}
/*
* If blocks are not yet allocated for this part of
* the file, allocate space for the transactions.
*/
if (!exist) {
if (rt) {
/*
* Round up to even number of extents.
*/
numrtextents = (count_fsb+rtextsize-1)/
rtextsize;
}
/*
* Setup transactions.
*/
tp = xfs_trans_alloc( mp, XFS_TRANS_DIOSTRAT);
error = xfs_trans_reserve( tp,
XFS_BM_MAXLEVELS(mp) + count_fsb,
XFS_WRITE_LOG_RES(mp),
numrtextents,
XFS_TRANS_PERM_LOG_RES,
XFS_WRITE_LOG_COUNT );
if (error) {
/*
* Ran out of file system space.
* Free the transaction structure.
*/
ASSERT( error == ENOSPC );
xfs_trans_cancel(tp, 0);
xfs_iunlock( ip, XFS_ILOCK_EXCL);
break;
} else {
xfs_trans_ijoin(tp,ip,XFS_ILOCK_EXCL);
xfs_trans_ihold( tp, ip);
}
}
} else {
/*
* Read case.
* Read requests will be issued
* up to XFS_BMAP_MAX_MAP at a time.
*/
reccount = XFS_BMAP_MAX_NMAP;
imapp = &imaps[0];
lock_mode = xfs_ilock_map_shared( ip);
}
/*
* Issue the bmapi() call to get the extent info.
* In the case of write requests this call does the
* actual file space allocation.
*/
firstfsb = xfs_bmapi( tp, ip, offset_fsb, count_fsb,
writeflag, firstfsb, 0, imapp, &reccount, &free_list);
if ( writeflag ) {
/*
* Complete the bmapi() transactions.
*/
if (!exist) {
xfs_bmap_finish( &tp, &free_list, firstfsb );
xfs_trans_commit(tp, XFS_TRANS_RELEASE_LOG_RES );
}
xfs_iunlock( ip, XFS_ILOCK_EXCL);
} else {
xfs_iunlock_map_shared( ip, lock_mode);
}
/*
* xfs_bmapi() was unable to allocate space
*/
if (reccount == 0) {
error = XFS_ERROR(ENOSPC);
break;
}
/*
* Run through each extent.
*/
bufsissued = 0;
for (i = 0; (i < reccount) && (!end_of_file) && (count); i++){
imapp = &imaps[i];
bytes_this_req = XFS_FSB_TO_B(mp,
imapp->br_blockcount) - BBTOB(blk_algn);
ASSERT(bytes_this_req);
offset_this_req = XFS_FSB_TO_B(mp,
imapp->br_startoff) + BBTOB(blk_algn);
/*
* Reduce request size, if it
* is longer than user buffer.
*/
if ( bytes_this_req > count ) {
bytes_this_req = count;
}
/*
* Check if this is the end of the file.
*/
if (offset_this_req +bytes_this_req >ip->i_d.di_size){
if ( writeflag ) {
/*
* File is being extended on a
* write, update the file size.
*/
ASSERT((vp->v_flag & VISSWAP) == 0);
xfs_ilock(ip, XFS_ILOCK_EXCL);
ip->i_d.di_size = offset_this_req +
bytes_this_req;
ip->i_update_core = 1;
xfs_iunlock(ip, XFS_ILOCK_EXCL);
} else {
/*
* If trying to read past end of
* file, shorten the request size.
*/
bytes_this_req = ip->i_d.di_size -
offset_this_req;
end_of_file = 1;
if (!bytes_this_req) {
break;
}
}
}
/*
* Do not do I/O if there is a hole in the file.
*/
if (imapp->br_startblock != HOLESTARTBLOCK) {
/*
* Setup I/O request for this extent.
*/
bps[bufsissued++]= nbp = getphysbuf();
nbp->b_flags = bp->b_flags;
nbp->b_flags2 = bp->b_flags2;
if (ioflag & IO_GRIO) {
nbp->b_flags2 |= B_GR_BUF;
} else {
nbp->b_flags2 &= ~B_GR_BUF;
}
nbp->b_error = 0;
nbp->b_proc = bp->b_proc;
nbp->b_edev = bp->b_edev;
if (rt) {
nbp->b_blkno = XFS_FSB_TO_BB(mp,
imapp->br_startblock);
} else {
nbp->b_blkno = XFS_FSB_TO_DADDR(mp,
imapp->br_startblock) +
blk_algn;
}
ASSERT(bytes_this_req);
nbp->b_bcount = bytes_this_req;
nbp->b_un.b_addr = base;
/*
* Issue I/O request.
*/
bdstrat( bmajor(nbp->b_edev), nbp );
if (error = geterror(nbp)) {
iowait( nbp );
nbp->b_flags = 0;
nbp->b_un.b_addr = 0;
putphysbuf( nbp );
bps[bufsissued--] = 0;
break;
}
} else {
/*
* Hole in file can only happen on read case.
*/
ASSERT(!writeflag);
/*
* Physio() has already mapped user address.
*/
bzero(base, bytes_this_req);
/*
* Bump the transfer count.
*/
totxfer += bytes_this_req;
}
/*
* update pointers for next round.
*/
base += bytes_this_req;
offset += bytes_this_req;
count -= bytes_this_req;
blk_algn= 0;
} /* end of for loop */
/*
* Wait for I/O completion and recover buffers.
*/
for ( j = 0; j < bufsissued ; j++) {
nbp = bps[j];
iowait( nbp );
nbp->b_flags2 &= ~B_GR_BUF;
if (!error)
error = geterror( nbp );
if (!error && !resid) {
resid = nbp->b_resid;
totxfer += (nbp->b_bcount - resid);
}
nbp->b_flags = 0;
nbp->b_un.b_addr = 0;
nbp->b_bcount = 0;
putphysbuf( nbp );
}
} /* end of while loop */
/*
* Fill in resid count for original buffer.
*/
bp->b_resid = totresid - totxfer;
/*
* Update the inode timestamp if file was written.
*/
if ( writeflag ) {
timestruc_t tv;
xfs_ilock(ip, XFS_ILOCK_EXCL);
if ((ip->i_d.di_mode & (ISUID|ISGID)) && dp->cr->cr_uid != 0){
ip->i_d.di_mode &= ~ISUID;
if (ip->i_d.di_mode & (IEXEC >> 3))
ip->i_d.di_mode &= ~ISGID;
}
nanotime( &tv );
ip->i_d.di_mtime.t_sec = ip->i_d.di_ctime.t_sec = tv.tv_sec;
ip->i_update_core = 1;
xfs_iunlock(ip, XFS_ILOCK_EXCL);
}
/*
* Issue completion on the original buffer.
*/
bioerror( bp, error);
iodone( bp );
ASSERT(ismrlocked(&ip->i_iolock, MR_ACCESS| MR_UPDATE) != 0);
return(0);
}
/*
* xfs_diordwr()
* This routine sets up a buf structure to be used to perform
* direct I/O operations to user space. The user specified
* parameters are checked for alignment and size limitations. A buf
* structure is allocated an biophysio() is called.
*
* RETURNS:
* 0 on success
* errno on error
*/
int
xfs_diordwr(vnode_t *vp,
uio_t *uiop,
int ioflag,
cred_t *credp,
int rw)
{
xfs_inode_t *ip;
struct dio_s dp;
xfs_mount_t *mp;
buf_t *bp;
int error;
ip = XFS_VTOI(vp);
mp = XFS_VFSTOM(vp->v_vfsp);
/*
* Check that the user buffer address is on a BBISZE offset,
* while file offset, and
* request size are all multiples of file system block size.
* This prevents the need for read/modify/write operations.
*
* This enforces the alignment restrictions indicated by
* the F_DIOINFO fcntl call.
*/
if ((((int)(uiop->uio_iov->iov_base)) & BBMASK) ||
(uiop->uio_offset & mp->m_blockmask) ||
(uiop->uio_resid & mp->m_blockmask)) {
#ifndef SIM
return XFS_ERROR(EINVAL);
#endif
}
/*
* Do maxio check.
*/
if (uiop->uio_resid > ctooff(v.v_maxdmasz)) {
#ifndef SIM
return XFS_ERROR(EINVAL);
#endif
}
/*
* Use dio_s structure to pass file/credential
* information to file system strategy routine.
*/
dp.vp = vp;
dp.cr = credp;
dp.ioflag = ioflag;
/*
* Allocate local buf structure.
*/
bp = getphysbuf();
bp->b_private = &dp;
mp = XFS_VFSTOM(vp->v_vfsp);
if (ip->i_d.di_flags & XFS_DIFLAG_REALTIME) {
bp->b_edev = mp->m_rtdev;
} else {
bp->b_edev = mp->m_dev;
}
/*
* Perform I/O operation.
*/
error = biophysio(xfs_diostrat, bp, bp->b_edev, rw,
(daddr_t)OFFTOBB(uiop->uio_offset), uiop);
/*
* Free local buf structure.
*/
bp->b_flags = 0;
#ifdef SIM
bp->b_un.b_addr = 0;
#endif
putphysbuf(bp);
return( error );
}
![[BACK]](/icons/back.gif){kind=icon}
Return to xfs_rw.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [Development] / xfs-linux