hollalinux
/
linux-sg2042
mirror of https://github.com/sophgo/linux-riscv.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

[XFS] kill xfs_iocore_t 

xfs_iocore_t is a structure embedded in xfs_inode. Except for one field it
just duplicates fields already in xfs_inode, and there is nothing this
abstraction buys us on XFS/Linux. This patch removes it and shrinks source
and binary size of xfs aswell as shrinking the size of xfs_inode by 60/44
bytes in debug/non-debug builds.

SGI-PV: 970852
SGI-Modid: xfs-linux-melb:xfs-kern:29754a

Signed-off-by: Christoph Hellwig <hch@infradead.org>
Signed-off-by: Lachlan McIlroy <lachlan@sgi.com>
Signed-off-by: Tim Shimmin <tes@sgi.com>
This commit is contained in:
Christoph Hellwig 2007-10-11 17:44:08 +10:00 committed by Lachlan McIlroy
parent 007c61c686
commit 613d70436c
13 changed files with 54 additions and 211 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
fs/xfs/Makefile-linux-2.6
View File

@ -70,7 +70,6 @@ xfs-y += xfs_alloc.o \
xfs_iget.o \ xfs_iget.o \
xfs_inode.o \ xfs_inode.o \
xfs_inode_item.o \ xfs_inode_item.o \
xfs_iocore.o \
xfs_iomap.o \ xfs_iomap.o \
xfs_itable.o \ xfs_itable.o \
xfs_dfrag.o \ xfs_dfrag.o \

4
fs/xfs/linux-2.6/xfs_aops.c
View File

@ -163,7 +163,7 @@ xfs_destroy_ioend(
/* /*
* Update on-disk file size now that data has been written to disk. * Update on-disk file size now that data has been written to disk.
* The current in-memory file size is i_size. If a write is beyond * The current in-memory file size is i_size. If a write is beyond
* eof io_new_size will be the intended file size until i_size is * eof i_new_size will be the intended file size until i_size is
* updated. If this write does not extend all the way to the valid * updated. If this write does not extend all the way to the valid
* file size then restrict this update to the end of the write. * file size then restrict this update to the end of the write.
*/ */
@ -185,7 +185,7 @@ xfs_setfilesize(
xfs_ilock(ip, XFS_ILOCK_EXCL); xfs_ilock(ip, XFS_ILOCK_EXCL);
isize = MAX(ip->i_size, ip->i_iocore.io_new_size); isize = MAX(ip->i_size, ip->i_new_size);
isize = MIN(isize, bsize); isize = MIN(isize, bsize);
if (ip->i_d.di_size < isize) { if (ip->i_d.di_size < isize) {

55
fs/xfs/linux-2.6/xfs_lrw.c
View File

@ -58,14 +58,12 @@
void void
xfs_rw_enter_trace( xfs_rw_enter_trace(
int tag, int tag,
xfs_iocore_t *io, xfs_inode_t *ip,
void *data, void *data,
size_t segs, size_t segs,
loff_t offset, loff_t offset,
int ioflags) int ioflags)
{ {
xfs_inode_t *ip = XFS_IO_INODE(io);
if (ip->i_rwtrace == NULL) if (ip->i_rwtrace == NULL)
return; return;
ktrace_enter(ip->i_rwtrace, ktrace_enter(ip->i_rwtrace,
@ -78,8 +76,8 @@ xfs_rw_enter_trace(
(void *)((unsigned long)((offset >> 32) & 0xffffffff)), (void *)((unsigned long)((offset >> 32) & 0xffffffff)),
(void *)((unsigned long)(offset & 0xffffffff)), (void *)((unsigned long)(offset & 0xffffffff)),
(void *)((unsigned long)ioflags), (void *)((unsigned long)ioflags),
(void *)((unsigned long)((io->io_new_size >> 32) & 0xffffffff)), (void *)((unsigned long)((ip->i_new_size >> 32) & 0xffffffff)),
(void *)((unsigned long)(io->io_new_size & 0xffffffff)), (void *)((unsigned long)(ip->i_new_size & 0xffffffff)),
(void *)((unsigned long)current_pid()), (void *)((unsigned long)current_pid()),
(void *)NULL, (void *)NULL,
(void *)NULL, (void *)NULL,
@ -89,13 +87,12 @@ xfs_rw_enter_trace(
void void
xfs_inval_cached_trace( xfs_inval_cached_trace(
xfs_iocore_t *io, xfs_inode_t *ip,
xfs_off_t offset, xfs_off_t offset,
xfs_off_t len, xfs_off_t len,
xfs_off_t first, xfs_off_t first,
xfs_off_t last) xfs_off_t last)
{ {
xfs_inode_t *ip = XFS_IO_INODE(io);
if (ip->i_rwtrace == NULL) if (ip->i_rwtrace == NULL)
return; return;
@ -256,7 +253,7 @@ xfs_read(
} }
} }
xfs_rw_enter_trace(XFS_READ_ENTER, &ip->i_iocore, xfs_rw_enter_trace(XFS_READ_ENTER, ip,
(void *)iovp, segs, *offset, ioflags); (void *)iovp, segs, *offset, ioflags);
iocb->ki_pos = *offset; iocb->ki_pos = *offset;
@ -301,7 +298,7 @@ xfs_splice_read(
return -error; return -error;
} }
} }
xfs_rw_enter_trace(XFS_SPLICE_READ_ENTER, &ip->i_iocore, xfs_rw_enter_trace(XFS_SPLICE_READ_ENTER, ip,
pipe, count, *ppos, ioflags); pipe, count, *ppos, ioflags);
ret = generic_file_splice_read(infilp, ppos, pipe, count, flags); ret = generic_file_splice_read(infilp, ppos, pipe, count, flags);
if (ret > 0) if (ret > 0)
@ -323,7 +320,6 @@ xfs_splice_write(
{ {
bhv_vnode_t *vp = XFS_ITOV(ip); bhv_vnode_t *vp = XFS_ITOV(ip);
xfs_mount_t *mp = ip->i_mount; xfs_mount_t *mp = ip->i_mount;
xfs_iocore_t *io = &ip->i_iocore;
ssize_t ret; ssize_t ret;
struct inode *inode = outfilp->f_mapping->host; struct inode *inode = outfilp->f_mapping->host;
xfs_fsize_t isize, new_size; xfs_fsize_t isize, new_size;
@ -350,10 +346,10 @@ xfs_splice_write(
xfs_ilock(ip, XFS_ILOCK_EXCL); xfs_ilock(ip, XFS_ILOCK_EXCL);
if (new_size > ip->i_size) if (new_size > ip->i_size)
io->io_new_size = new_size; ip->i_new_size = new_size;
xfs_iunlock(ip, XFS_ILOCK_EXCL); xfs_iunlock(ip, XFS_ILOCK_EXCL);
xfs_rw_enter_trace(XFS_SPLICE_WRITE_ENTER, &ip->i_iocore, xfs_rw_enter_trace(XFS_SPLICE_WRITE_ENTER, ip,
pipe, count, *ppos, ioflags); pipe, count, *ppos, ioflags);
ret = generic_file_splice_write(pipe, outfilp, ppos, count, flags); ret = generic_file_splice_write(pipe, outfilp, ppos, count, flags);
if (ret > 0) if (ret > 0)
@ -370,9 +366,9 @@ xfs_splice_write(
xfs_iunlock(ip, XFS_ILOCK_EXCL); xfs_iunlock(ip, XFS_ILOCK_EXCL);
} }
if (io->io_new_size) { if (ip->i_new_size) {
xfs_ilock(ip, XFS_ILOCK_EXCL); xfs_ilock(ip, XFS_ILOCK_EXCL);
io->io_new_size = 0; ip->i_new_size = 0;
if (ip->i_d.di_size > ip->i_size) if (ip->i_d.di_size > ip->i_size)
ip->i_d.di_size = ip->i_size; ip->i_d.di_size = ip->i_size;
xfs_iunlock(ip, XFS_ILOCK_EXCL); xfs_iunlock(ip, XFS_ILOCK_EXCL);
@ -461,20 +457,19 @@ xfs_zero_eof(
xfs_off_t offset, /* starting I/O offset */ xfs_off_t offset, /* starting I/O offset */
xfs_fsize_t isize) /* current inode size */ xfs_fsize_t isize) /* current inode size */
{ {
xfs_iocore_t *io = &ip->i_iocore; xfs_mount_t *mp = ip->i_mount;
xfs_fileoff_t start_zero_fsb; xfs_fileoff_t start_zero_fsb;
xfs_fileoff_t end_zero_fsb; xfs_fileoff_t end_zero_fsb;
xfs_fileoff_t zero_count_fsb; xfs_fileoff_t zero_count_fsb;
xfs_fileoff_t last_fsb; xfs_fileoff_t last_fsb;
xfs_fileoff_t zero_off; xfs_fileoff_t zero_off;
xfs_fsize_t zero_len; xfs_fsize_t zero_len;
xfs_mount_t *mp = io->io_mount;
int nimaps; int nimaps;
int error = 0; int error = 0;
xfs_bmbt_irec_t imap; xfs_bmbt_irec_t imap;
ASSERT(ismrlocked(io->io_lock, MR_UPDATE)); ASSERT(ismrlocked(&ip->i_lock, MR_UPDATE));
ASSERT(ismrlocked(io->io_iolock, MR_UPDATE)); ASSERT(ismrlocked(&ip->i_iolock, MR_UPDATE));
ASSERT(offset > isize); ASSERT(offset > isize);
/* /*
@ -483,8 +478,8 @@ xfs_zero_eof(
*/ */
error = xfs_zero_last_block(ip, offset, isize); error = xfs_zero_last_block(ip, offset, isize);
if (error) { if (error) {
ASSERT(ismrlocked(io->io_lock, MR_UPDATE)); ASSERT(ismrlocked(&ip->i_lock, MR_UPDATE));
ASSERT(ismrlocked(io->io_iolock, MR_UPDATE)); ASSERT(ismrlocked(&ip->i_iolock, MR_UPDATE));
return error; return error;
} }
@ -515,8 +510,8 @@ xfs_zero_eof(
error = xfs_bmapi(NULL, ip, start_zero_fsb, zero_count_fsb, error = xfs_bmapi(NULL, ip, start_zero_fsb, zero_count_fsb,
0, NULL, 0, &imap, &nimaps, NULL, NULL); 0, NULL, 0, &imap, &nimaps, NULL, NULL);
if (error) { if (error) {
ASSERT(ismrlocked(io->io_lock, MR_UPDATE)); ASSERT(ismrlocked(&ip->i_lock, MR_UPDATE));
ASSERT(ismrlocked(io->io_iolock, MR_UPDATE)); ASSERT(ismrlocked(&ip->i_iolock, MR_UPDATE));
return error; return error;
} }
ASSERT(nimaps > 0); ASSERT(nimaps > 0);
@ -584,7 +579,6 @@ xfs_write(
xfs_mount_t *mp; xfs_mount_t *mp;
ssize_t ret = 0, error = 0; ssize_t ret = 0, error = 0;
xfs_fsize_t isize, new_size; xfs_fsize_t isize, new_size;
xfs_iocore_t *io;
int iolock; int iolock;
int eventsent = 0; int eventsent = 0;
bhv_vrwlock_t locktype; bhv_vrwlock_t locktype;
@ -604,8 +598,7 @@ xfs_write(
if (count == 0) if (count == 0)
return 0; return 0;
io = &xip->i_iocore; mp = xip->i_mount;
mp = io->io_mount;
xfs_wait_for_freeze(mp, SB_FREEZE_WRITE); xfs_wait_for_freeze(mp, SB_FREEZE_WRITE);
@ -685,7 +678,7 @@ start:
new_size = pos + count; new_size = pos + count;
if (new_size > xip->i_size) if (new_size > xip->i_size)
io->io_new_size = new_size; xip->i_new_size = new_size;
if (likely(!(ioflags & IO_INVIS))) { if (likely(!(ioflags & IO_INVIS))) {
file_update_time(file); file_update_time(file);
@ -737,7 +730,7 @@ retry:
if ((ioflags & IO_ISDIRECT)) { if ((ioflags & IO_ISDIRECT)) {
if (VN_CACHED(vp)) { if (VN_CACHED(vp)) {
WARN_ON(need_i_mutex == 0); WARN_ON(need_i_mutex == 0);
xfs_inval_cached_trace(io, pos, -1, xfs_inval_cached_trace(xip, pos, -1,
ctooff(offtoct(pos)), -1); ctooff(offtoct(pos)), -1);
error = xfs_flushinval_pages(xip, error = xfs_flushinval_pages(xip,
ctooff(offtoct(pos)), ctooff(offtoct(pos)),
@ -756,7 +749,7 @@ retry:
need_i_mutex = 0; need_i_mutex = 0;
} }
xfs_rw_enter_trace(XFS_DIOWR_ENTER, io, (void *)iovp, segs, xfs_rw_enter_trace(XFS_DIOWR_ENTER, xip, (void *)iovp, segs,
*offset, ioflags); *offset, ioflags);
ret = generic_file_direct_write(iocb, iovp, ret = generic_file_direct_write(iocb, iovp,
&segs, pos, offset, count, ocount); &segs, pos, offset, count, ocount);
@ -776,7 +769,7 @@ retry:
goto relock; goto relock;
} }
} else { } else {
xfs_rw_enter_trace(XFS_WRITE_ENTER, io, (void *)iovp, segs, xfs_rw_enter_trace(XFS_WRITE_ENTER, xip, (void *)iovp, segs,
*offset, ioflags); *offset, ioflags);
ret = generic_file_buffered_write(iocb, iovp, segs, ret = generic_file_buffered_write(iocb, iovp, segs,
pos, offset, count, ret); pos, offset, count, ret);
@ -840,9 +833,9 @@ retry:
} }
out_unlock_internal: out_unlock_internal:
if (io->io_new_size) { if (xip->i_new_size) {
xfs_ilock(xip, XFS_ILOCK_EXCL); xfs_ilock(xip, XFS_ILOCK_EXCL);
io->io_new_size = 0; xip->i_new_size = 0;
/* /*
* If this was a direct or synchronous I/O that failed (such * If this was a direct or synchronous I/O that failed (such
* as ENOSPC) then part of the I/O may have been written to * as ENOSPC) then part of the I/O may have been written to

9
fs/xfs/linux-2.6/xfs_lrw.h
View File

@ -19,7 +19,6 @@
#define __XFS_LRW_H__ #define __XFS_LRW_H__
struct xfs_mount; struct xfs_mount;
struct xfs_iocore;
struct xfs_inode; struct xfs_inode;
struct xfs_bmbt_irec; struct xfs_bmbt_irec;
struct xfs_buf; struct xfs_buf;
@ -60,13 +59,13 @@ struct xfs_iomap;
#define XFS_IOMAP_UNWRITTEN 27 #define XFS_IOMAP_UNWRITTEN 27
#define XFS_SPLICE_READ_ENTER 28 #define XFS_SPLICE_READ_ENTER 28
#define XFS_SPLICE_WRITE_ENTER 29 #define XFS_SPLICE_WRITE_ENTER 29
extern void xfs_rw_enter_trace(int, struct xfs_iocore *, extern void xfs_rw_enter_trace(int, struct xfs_inode *,
void *, size_t, loff_t, int); void *, size_t, loff_t, int);
extern void xfs_inval_cached_trace(struct xfs_iocore *, extern void xfs_inval_cached_trace(struct xfs_inode *,
xfs_off_t, xfs_off_t, xfs_off_t, xfs_off_t); xfs_off_t, xfs_off_t, xfs_off_t, xfs_off_t);
#else #else
#define xfs_rw_enter_trace(tag, io, data, size, offset, ioflags) #define xfs_rw_enter_trace(tag, ip, data, size, offset, ioflags)
#define xfs_inval_cached_trace(io, offset, len, first, last) #define xfs_inval_cached_trace(ip, offset, len, first, last)
#endif #endif
extern int xfsbdstrat(struct xfs_mount *, struct xfs_buf *); extern int xfsbdstrat(struct xfs_mount *, struct xfs_buf *);

2
fs/xfs/xfs_dfrag.c
View File

@ -199,7 +199,7 @@ xfs_swap_extents(
} }
if (VN_CACHED(tvp) != 0) { if (VN_CACHED(tvp) != 0) {
xfs_inval_cached_trace(&tip->i_iocore, 0, -1, 0, -1); xfs_inval_cached_trace(tip, 0, -1, 0, -1);
error = xfs_flushinval_pages(tip, 0, -1, error = xfs_flushinval_pages(tip, 0, -1,
FI_REMAPF_LOCKED); FI_REMAPF_LOCKED);
if (error) if (error)

9
fs/xfs/xfs_iget.c
View File

@ -199,13 +199,10 @@ again:
XFS_STATS_INC(xs_ig_found); XFS_STATS_INC(xs_ig_found);
finish_inode: finish_inode:
if (ip->i_d.di_mode == 0) { if (ip->i_d.di_mode == 0 && !(flags & XFS_IGET_CREATE)) {
if (!(flags & XFS_IGET_CREATE)) {
xfs_put_perag(mp, pag); xfs_put_perag(mp, pag);
return ENOENT; return ENOENT;
} }
xfs_iocore_inode_reinit(ip);
}
if (lock_flags != 0) if (lock_flags != 0)
xfs_ilock(ip, lock_flags); xfs_ilock(ip, lock_flags);
@ -235,7 +232,6 @@ finish_inode:
xfs_itrace_exit_tag(ip, "xfs_iget.alloc"); xfs_itrace_exit_tag(ip, "xfs_iget.alloc");
xfs_inode_lock_init(ip, vp); xfs_inode_lock_init(ip, vp);
xfs_iocore_inode_init(ip);
if (lock_flags) if (lock_flags)
xfs_ilock(ip, lock_flags); xfs_ilock(ip, lock_flags);
@ -331,9 +327,6 @@ finish_inode:
ASSERT(ip->i_df.if_ext_max == ASSERT(ip->i_df.if_ext_max ==
XFS_IFORK_DSIZE(ip) / sizeof(xfs_bmbt_rec_t)); XFS_IFORK_DSIZE(ip) / sizeof(xfs_bmbt_rec_t));
ASSERT(((ip->i_d.di_flags & XFS_DIFLAG_REALTIME) != 0) ==
((ip->i_iocore.io_flags & XFS_IOCORE_RT) != 0));
xfs_iflags_set(ip, XFS_IMODIFIED); xfs_iflags_set(ip, XFS_IMODIFIED);
*ipp = ip; *ipp = ip;

4
fs/xfs/xfs_inode.c
View File

@ -1220,10 +1220,8 @@ xfs_ialloc(
ip->i_d.di_extsize = pip->i_d.di_extsize; ip->i_d.di_extsize = pip->i_d.di_extsize;
} }
} else if ((mode & S_IFMT) == S_IFREG) { } else if ((mode & S_IFMT) == S_IFREG) {
if (pip->i_d.di_flags & XFS_DIFLAG_RTINHERIT) { if (pip->i_d.di_flags & XFS_DIFLAG_RTINHERIT)
di_flags |= XFS_DIFLAG_REALTIME; di_flags |= XFS_DIFLAG_REALTIME;
ip->i_iocore.io_flags |= XFS_IOCORE_RT;
}
if (pip->i_d.di_flags & XFS_DIFLAG_EXTSZINHERIT) { if (pip->i_d.di_flags & XFS_DIFLAG_EXTSZINHERIT) {
di_flags |= XFS_DIFLAG_EXTSIZE; di_flags |= XFS_DIFLAG_EXTSIZE;
ip->i_d.di_extsize = pip->i_d.di_extsize; ip->i_d.di_extsize = pip->i_d.di_extsize;

43
fs/xfs/xfs_inode.h
View File

@ -132,45 +132,6 @@ typedef struct dm_attrs_s {
__uint16_t da_pad; /* DMIG extra padding */ __uint16_t da_pad; /* DMIG extra padding */
} dm_attrs_t; } dm_attrs_t;
typedef struct xfs_iocore {
void *io_obj; /* pointer to container
* inode or dcxvn structure */
struct xfs_mount *io_mount; /* fs mount struct ptr */
#ifdef DEBUG
mrlock_t *io_lock; /* inode IO lock */
mrlock_t *io_iolock; /* inode IO lock */
#endif
/* I/O state */
xfs_fsize_t io_new_size; /* sz when write completes */
/* Miscellaneous state. */
unsigned int io_flags; /* IO related flags */
/* DMAPI state */
dm_attrs_t io_dmattrs;
} xfs_iocore_t;
#define io_dmevmask io_dmattrs.da_dmevmask
#define io_dmstate io_dmattrs.da_dmstate
#define XFS_IO_INODE(io) ((xfs_inode_t *) ((io)->io_obj))
#define XFS_IO_DCXVN(io) ((dcxvn_t *) ((io)->io_obj))
/*
* Flags in the flags field
*/
#define XFS_IOCORE_RT 0x1
/*
* xfs_iocore prototypes
*/
extern void xfs_iocore_inode_init(struct xfs_inode *);
extern void xfs_iocore_inode_reinit(struct xfs_inode *);
/* /*
* This is the xfs inode cluster structure. This structure is used by * This is the xfs inode cluster structure. This structure is used by
* xfs_iflush to find inodes that share a cluster and can be flushed to disk at * xfs_iflush to find inodes that share a cluster and can be flushed to disk at
@ -283,9 +244,6 @@ typedef struct xfs_inode {
struct xfs_inode **i_refcache; /* ptr to entry in ref cache */ struct xfs_inode **i_refcache; /* ptr to entry in ref cache */
struct xfs_inode *i_release; /* inode to unref */ struct xfs_inode *i_release; /* inode to unref */
#endif #endif
/* I/O state */
xfs_iocore_t i_iocore; /* I/O core */
/* Miscellaneous state. */ /* Miscellaneous state. */
unsigned short i_flags; /* see defined flags below */ unsigned short i_flags; /* see defined flags below */
unsigned char i_update_core; /* timestamps/size is dirty */ unsigned char i_update_core; /* timestamps/size is dirty */
@ -298,6 +256,7 @@ typedef struct xfs_inode {
struct hlist_node i_cnode; /* cluster link node */ struct hlist_node i_cnode; /* cluster link node */
xfs_fsize_t i_size; /* in-memory size */ xfs_fsize_t i_size; /* in-memory size */
xfs_fsize_t i_new_size; /* size when write completes */
atomic_t i_iocount; /* outstanding I/O count */ atomic_t i_iocount; /* outstanding I/O count */
/* Trace buffers per inode. */ /* Trace buffers per inode. */
#ifdef XFS_INODE_TRACE #ifdef XFS_INODE_TRACE

79
fs/xfs/xfs_iocore.c
View File

@ -1,79 +0,0 @@
/*
* Copyright (c) 2000-2003,2005 Silicon Graphics, Inc.
* All Rights Reserved.
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License as
* published by the Free Software Foundation.
*
* This program is distributed in the hope that it would be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write the Free Software Foundation,
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
*/
#include "xfs.h"
#include "xfs_fs.h"
#include "xfs_types.h"
#include "xfs_bit.h"
#include "xfs_log.h"
#include "xfs_inum.h"
#include "xfs_trans.h"
#include "xfs_sb.h"
#include "xfs_ag.h"
#include "xfs_dir2.h"
#include "xfs_dfrag.h"
#include "xfs_dmapi.h"
#include "xfs_mount.h"
#include "xfs_bmap_btree.h"
#include "xfs_alloc_btree.h"
#include "xfs_ialloc_btree.h"
#include "xfs_dir2_sf.h"
#include "xfs_attr_sf.h"
#include "xfs_dinode.h"
#include "xfs_inode.h"
#include "xfs_inode_item.h"
#include "xfs_itable.h"
#include "xfs_btree.h"
#include "xfs_alloc.h"
#include "xfs_ialloc.h"
#include "xfs_bmap.h"
#include "xfs_error.h"
#include "xfs_rw.h"
#include "xfs_quota.h"
#include "xfs_trans_space.h"
#include "xfs_iomap.h"
void
xfs_iocore_inode_reinit(
xfs_inode_t *ip)
{
xfs_iocore_t *io = &ip->i_iocore;
io->io_flags = 0;
if (ip->i_d.di_flags & XFS_DIFLAG_REALTIME)
io->io_flags |= XFS_IOCORE_RT;
io->io_dmevmask = ip->i_d.di_dmevmask;
io->io_dmstate = ip->i_d.di_dmstate;
}
void
xfs_iocore_inode_init(
xfs_inode_t *ip)
{
xfs_iocore_t *io = &ip->i_iocore;
xfs_mount_t *mp = ip->i_mount;
io->io_mount = mp;
#ifdef DEBUG
io->io_lock = &ip->i_lock;
io->io_iolock = &ip->i_iolock;
#endif
io->io_obj = (void *)ip;
xfs_iocore_inode_reinit(ip);
}

30
fs/xfs/xfs_iomap.c
View File

@ -57,8 +57,6 @@ xfs_iomap_enter_trace(
xfs_off_t offset, xfs_off_t offset,
ssize_t count) ssize_t count)
{ {
xfs_iocore_t *io = &ip->i_iocore;
if (!ip->i_rwtrace) if (!ip->i_rwtrace)
return; return;
@ -70,8 +68,8 @@ xfs_iomap_enter_trace(
(void *)((unsigned long)((offset >> 32) & 0xffffffff)), (void *)((unsigned long)((offset >> 32) & 0xffffffff)),
(void *)((unsigned long)(offset & 0xffffffff)), (void *)((unsigned long)(offset & 0xffffffff)),
(void *)((unsigned long)count), (void *)((unsigned long)count),
(void *)((unsigned long)((io->io_new_size >> 32) & 0xffffffff)), (void *)((unsigned long)((ip->i_new_size >> 32) & 0xffffffff)),
(void *)((unsigned long)(io->io_new_size & 0xffffffff)), (void *)((unsigned long)(ip->i_new_size & 0xffffffff)),
(void *)((unsigned long)current_pid()), (void *)((unsigned long)current_pid()),
(void *)NULL, (void *)NULL,
(void *)NULL, (void *)NULL,
@ -186,8 +184,6 @@ xfs_iomap(
int iomap_flags = 0; int iomap_flags = 0;
ASSERT((ip->i_d.di_mode & S_IFMT) == S_IFREG); ASSERT((ip->i_d.di_mode & S_IFMT) == S_IFREG);
ASSERT(((ip->i_d.di_flags & XFS_DIFLAG_REALTIME) != 0) ==
((ip->i_iocore.io_flags & XFS_IOCORE_RT) != 0));
if (XFS_FORCED_SHUTDOWN(mp)) if (XFS_FORCED_SHUTDOWN(mp))
return XFS_ERROR(EIO); return XFS_ERROR(EIO);
@ -402,7 +398,6 @@ xfs_iomap_write_direct(
int found) int found)
{ {
xfs_mount_t *mp = ip->i_mount; xfs_mount_t *mp = ip->i_mount;
xfs_iocore_t *io = &ip->i_iocore;
xfs_fileoff_t offset_fsb; xfs_fileoff_t offset_fsb;
xfs_fileoff_t last_fsb; xfs_fileoff_t last_fsb;
xfs_filblks_t count_fsb, resaligned; xfs_filblks_t count_fsb, resaligned;
@ -432,8 +427,8 @@ xfs_iomap_write_direct(
extsz = xfs_get_extsz_hint(ip); extsz = xfs_get_extsz_hint(ip);
isize = ip->i_size; isize = ip->i_size;
if (io->io_new_size > isize) if (ip->i_new_size > isize)
isize = io->io_new_size; isize = ip->i_new_size;
offset_fsb = XFS_B_TO_FSBT(mp, offset); offset_fsb = XFS_B_TO_FSBT(mp, offset);
last_fsb = XFS_B_TO_FSB(mp, ((xfs_ufsize_t)(offset + count))); last_fsb = XFS_B_TO_FSB(mp, ((xfs_ufsize_t)(offset + count)));
@ -528,7 +523,8 @@ xfs_iomap_write_direct(
goto error_out; goto error_out;
} }
if (unlikely(!imap.br_startblock && !(io->io_flags & XFS_IOCORE_RT))) { if (unlikely(!imap.br_startblock &&
!(ip->i_d.di_flags & XFS_DIFLAG_REALTIME))) {
error = xfs_cmn_err_fsblock_zero(ip, &imap); error = xfs_cmn_err_fsblock_zero(ip, &imap);
goto error_out; goto error_out;
} }
@ -616,7 +612,6 @@ xfs_iomap_write_delay(
int *nmaps) int *nmaps)
{ {
xfs_mount_t *mp = ip->i_mount; xfs_mount_t *mp = ip->i_mount;
xfs_iocore_t *io = &ip->i_iocore;
xfs_fileoff_t offset_fsb; xfs_fileoff_t offset_fsb;
xfs_fileoff_t last_fsb; xfs_fileoff_t last_fsb;
xfs_off_t aligned_offset; xfs_off_t aligned_offset;
@ -644,8 +639,8 @@ xfs_iomap_write_delay(
retry: retry:
isize = ip->i_size; isize = ip->i_size;
if (io->io_new_size > isize) if (ip->i_new_size > isize)
isize = io->io_new_size; isize = ip->i_new_size;
error = xfs_iomap_eof_want_preallocate(mp, ip, isize, offset, count, error = xfs_iomap_eof_want_preallocate(mp, ip, isize, offset, count,
ioflag, imap, XFS_WRITE_IMAPS, &prealloc); ioflag, imap, XFS_WRITE_IMAPS, &prealloc);
@ -691,7 +686,8 @@ retry:
goto retry; goto retry;
} }
if (unlikely(!imap[0].br_startblock && !(io->io_flags & XFS_IOCORE_RT))) if (unlikely(!imap[0].br_startblock &&
!(ip->i_d.di_flags & XFS_DIFLAG_REALTIME)))
return xfs_cmn_err_fsblock_zero(ip, &imap[0]); return xfs_cmn_err_fsblock_zero(ip, &imap[0]);
*ret_imap = imap[0]; *ret_imap = imap[0];
@ -716,7 +712,6 @@ xfs_iomap_write_allocate(
int *retmap) int *retmap)
{ {
xfs_mount_t *mp = ip->i_mount; xfs_mount_t *mp = ip->i_mount;
xfs_iocore_t *io = &ip->i_iocore;
xfs_fileoff_t offset_fsb, last_block; xfs_fileoff_t offset_fsb, last_block;
xfs_fileoff_t end_fsb, map_start_fsb; xfs_fileoff_t end_fsb, map_start_fsb;
xfs_fsblock_t first_block; xfs_fsblock_t first_block;
@ -814,7 +809,7 @@ xfs_iomap_write_allocate(
*/ */
for (i = 0; i < nimaps; i++) { for (i = 0; i < nimaps; i++) {
if (unlikely(!imap[i].br_startblock && if (unlikely(!imap[i].br_startblock &&
!(io->io_flags & XFS_IOCORE_RT))) !(ip->i_d.di_flags & XFS_DIFLAG_REALTIME)))
return xfs_cmn_err_fsblock_zero(ip, &imap[i]); return xfs_cmn_err_fsblock_zero(ip, &imap[i]);
if ((offset_fsb >= imap[i].br_startoff) && if ((offset_fsb >= imap[i].br_startoff) &&
(offset_fsb < (imap[i].br_startoff + (offset_fsb < (imap[i].br_startoff +
@ -850,7 +845,6 @@ xfs_iomap_write_unwritten(
size_t count) size_t count)
{ {
xfs_mount_t *mp = ip->i_mount; xfs_mount_t *mp = ip->i_mount;
xfs_iocore_t *io = &ip->i_iocore;
xfs_fileoff_t offset_fsb; xfs_fileoff_t offset_fsb;
xfs_filblks_t count_fsb; xfs_filblks_t count_fsb;
xfs_filblks_t numblks_fsb; xfs_filblks_t numblks_fsb;
@ -913,7 +907,7 @@ xfs_iomap_write_unwritten(
return XFS_ERROR(error); return XFS_ERROR(error);
if (unlikely(!imap.br_startblock && if (unlikely(!imap.br_startblock &&
!(io->io_flags & XFS_IOCORE_RT))) !(ip->i_d.di_flags & XFS_DIFLAG_REALTIME)))
return xfs_cmn_err_fsblock_zero(ip, &imap); return xfs_cmn_err_fsblock_zero(ip, &imap);
if ((numblks_fsb = imap.br_blockcount) == 0) { if ((numblks_fsb = imap.br_blockcount) == 0) {

1
fs/xfs/xfs_mount.h
View File

@ -56,7 +56,6 @@ struct cred;
struct log; struct log;
struct xfs_mount_args; struct xfs_mount_args;
struct xfs_inode; struct xfs_inode;
struct xfs_iocore;
struct xfs_bmbt_irec; struct xfs_bmbt_irec;
struct xfs_bmap_free; struct xfs_bmap_free;
struct xfs_extdelta; struct xfs_extdelta;

8
fs/xfs/xfs_rw.h
View File

@ -36,14 +36,6 @@ xfs_fsb_to_db(struct xfs_inode *ip, xfs_fsblock_t fsb)
(xfs_daddr_t)XFS_FSB_TO_BB((ip)->i_mount, (fsb)) : \ (xfs_daddr_t)XFS_FSB_TO_BB((ip)->i_mount, (fsb)) : \
XFS_FSB_TO_DADDR((ip)->i_mount, (fsb))); XFS_FSB_TO_DADDR((ip)->i_mount, (fsb)));
} }
#define XFS_FSB_TO_DB_IO(io,fsb) xfs_fsb_to_db_io(io,fsb)
static inline xfs_daddr_t
xfs_fsb_to_db_io(struct xfs_iocore *io, xfs_fsblock_t fsb)
{
return (((io)->io_flags & XFS_IOCORE_RT) ? \
XFS_FSB_TO_BB((io)->io_mount, (fsb)) : \
XFS_FSB_TO_DADDR((io)->io_mount, (fsb)));
}
/* /*
* Flags for xfs_free_eofblocks * Flags for xfs_free_eofblocks

12
fs/xfs/xfs_vnodeops.c
View File

@ -804,12 +804,8 @@ xfs_setattr(
if (vap->va_xflags & XFS_XFLAG_EXTSZINHERIT) if (vap->va_xflags & XFS_XFLAG_EXTSZINHERIT)
di_flags |= XFS_DIFLAG_EXTSZINHERIT; di_flags |= XFS_DIFLAG_EXTSZINHERIT;
} else if ((ip->i_d.di_mode & S_IFMT) == S_IFREG) { } else if ((ip->i_d.di_mode & S_IFMT) == S_IFREG) {
if (vap->va_xflags & XFS_XFLAG_REALTIME) { if (vap->va_xflags & XFS_XFLAG_REALTIME)
di_flags |= XFS_DIFLAG_REALTIME; di_flags |= XFS_DIFLAG_REALTIME;
ip->i_iocore.io_flags |= XFS_IOCORE_RT;
} else {
ip->i_iocore.io_flags &= ~XFS_IOCORE_RT;
}
if (vap->va_xflags & XFS_XFLAG_EXTSIZE) if (vap->va_xflags & XFS_XFLAG_EXTSIZE)
di_flags |= XFS_DIFLAG_EXTSIZE; di_flags |= XFS_DIFLAG_EXTSIZE;
} }
@ -3633,8 +3629,8 @@ xfs_set_dmattrs(
xfs_ilock(ip, XFS_ILOCK_EXCL); xfs_ilock(ip, XFS_ILOCK_EXCL);
xfs_trans_ijoin(tp, ip, XFS_ILOCK_EXCL); xfs_trans_ijoin(tp, ip, XFS_ILOCK_EXCL);
ip->i_iocore.io_dmevmask = ip->i_d.di_dmevmask = evmask; ip->i_d.di_dmevmask = evmask;
ip->i_iocore.io_dmstate = ip->i_d.di_dmstate = state; ip->i_d.di_dmstate = state;
xfs_trans_log_inode(tp, ip, XFS_ILOG_CORE); xfs_trans_log_inode(tp, ip, XFS_ILOG_CORE);
IHOLD(ip); IHOLD(ip);
@ -4172,7 +4168,7 @@ xfs_free_file_space(
ioffset = offset & ~(rounding - 1); ioffset = offset & ~(rounding - 1);
if (VN_CACHED(vp) != 0) { if (VN_CACHED(vp) != 0) {
xfs_inval_cached_trace(&ip->i_iocore, ioffset, -1, xfs_inval_cached_trace(ip, ioffset, -1,
ctooff(offtoct(ioffset)), -1); ctooff(offtoct(ioffset)), -1);
error = xfs_flushinval_pages(ip, error = xfs_flushinval_pages(ip,
ctooff(offtoct(ioffset)), ctooff(offtoct(ioffset)),