Gitweb:     
http://git.kernel.org/git/?p=linux/kernel/git/torvalds/linux-2.6.git;a=commit;h=613d70436c1aeda6843ca8b70c7fab6d0484a591
Commit:     613d70436c1aeda6843ca8b70c7fab6d0484a591
Parent:     007c61c68640ea17c036785b698d05da67b4365e
Author:     Christoph Hellwig <[EMAIL PROTECTED]>
AuthorDate: Thu Oct 11 17:44:08 2007 +1000
Committer:  Lachlan McIlroy <[EMAIL PROTECTED]>
CommitDate: Thu Feb 7 16:48:58 2008 +1100

    [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 <[EMAIL PROTECTED]>
    Signed-off-by: Lachlan McIlroy <[EMAIL PROTECTED]>
    Signed-off-by: Tim Shimmin <[EMAIL PROTECTED]>
---
 fs/xfs/Makefile-linux-2.6   |    1 -
 fs/xfs/linux-2.6/xfs_aops.c |    4 +-
 fs/xfs/linux-2.6/xfs_lrw.c  |   55 +++++++++++++-----------------
 fs/xfs/linux-2.6/xfs_lrw.h  |   13 +++----
 fs/xfs/xfs_dfrag.c          |    2 +-
 fs/xfs/xfs_iget.c           |   13 ++-----
 fs/xfs/xfs_inode.c          |    4 +--
 fs/xfs/xfs_inode.h          |   43 +-----------------------
 fs/xfs/xfs_iocore.c         |   79 -------------------------------------------
 fs/xfs/xfs_iomap.c          |   30 ++++++----------
 fs/xfs/xfs_mount.h          |    1 -
 fs/xfs/xfs_rw.h             |    8 ----
 fs/xfs/xfs_vnodeops.c       |   12 ++----
 13 files changed, 54 insertions(+), 211 deletions(-)

diff --git a/fs/xfs/Makefile-linux-2.6 b/fs/xfs/Makefile-linux-2.6
index d1491aa..9731645 100644
--- a/fs/xfs/Makefile-linux-2.6
+++ b/fs/xfs/Makefile-linux-2.6
@@ -70,7 +70,6 @@ xfs-y                         += xfs_alloc.o \
                                   xfs_iget.o \
                                   xfs_inode.o \
                                   xfs_inode_item.o \
-                                  xfs_iocore.o \
                                   xfs_iomap.o \
                                   xfs_itable.o \
                                   xfs_dfrag.o \
diff --git a/fs/xfs/linux-2.6/xfs_aops.c b/fs/xfs/linux-2.6/xfs_aops.c
index d20df39..36dadc4 100644
--- a/fs/xfs/linux-2.6/xfs_aops.c
+++ b/fs/xfs/linux-2.6/xfs_aops.c
@@ -163,7 +163,7 @@ xfs_destroy_ioend(
 /*
  * 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
- * 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
  * file size then restrict this update to the end of the write.
  */
@@ -185,7 +185,7 @@ xfs_setfilesize(
 
        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);
 
        if (ip->i_d.di_size < isize) {
diff --git a/fs/xfs/linux-2.6/xfs_lrw.c b/fs/xfs/linux-2.6/xfs_lrw.c
index 0abc7d0..459d364 100644
--- a/fs/xfs/linux-2.6/xfs_lrw.c
+++ b/fs/xfs/linux-2.6/xfs_lrw.c
@@ -58,14 +58,12 @@
 void
 xfs_rw_enter_trace(
        int                     tag,
-       xfs_iocore_t            *io,
+       xfs_inode_t             *ip,
        void                    *data,
        size_t                  segs,
        loff_t                  offset,
        int                     ioflags)
 {
-       xfs_inode_t     *ip = XFS_IO_INODE(io);
-
        if (ip->i_rwtrace == NULL)
                return;
        ktrace_enter(ip->i_rwtrace,
@@ -78,8 +76,8 @@ xfs_rw_enter_trace(
                (void *)((unsigned long)((offset >> 32) & 0xffffffff)),
                (void *)((unsigned long)(offset & 0xffffffff)),
                (void *)((unsigned long)ioflags),
-               (void *)((unsigned long)((io->io_new_size >> 32) & 0xffffffff)),
-               (void *)((unsigned long)(io->io_new_size & 0xffffffff)),
+               (void *)((unsigned long)((ip->i_new_size >> 32) & 0xffffffff)),
+               (void *)((unsigned long)(ip->i_new_size & 0xffffffff)),
                (void *)((unsigned long)current_pid()),
                (void *)NULL,
                (void *)NULL,
@@ -89,13 +87,12 @@ xfs_rw_enter_trace(
 
 void
 xfs_inval_cached_trace(
-       xfs_iocore_t    *io,
+       xfs_inode_t     *ip,
        xfs_off_t       offset,
        xfs_off_t       len,
        xfs_off_t       first,
        xfs_off_t       last)
 {
-       xfs_inode_t     *ip = XFS_IO_INODE(io);
 
        if (ip->i_rwtrace == NULL)
                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);
 
        iocb->ki_pos = *offset;
@@ -301,7 +298,7 @@ xfs_splice_read(
                        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);
        ret = generic_file_splice_read(infilp, ppos, pipe, count, flags);
        if (ret > 0)
@@ -323,7 +320,6 @@ xfs_splice_write(
 {
        bhv_vnode_t             *vp = XFS_ITOV(ip);
        xfs_mount_t             *mp = ip->i_mount;
-       xfs_iocore_t            *io = &ip->i_iocore;
        ssize_t                 ret;
        struct inode            *inode = outfilp->f_mapping->host;
        xfs_fsize_t             isize, new_size;
@@ -350,10 +346,10 @@ xfs_splice_write(
 
        xfs_ilock(ip, XFS_ILOCK_EXCL);
        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_rw_enter_trace(XFS_SPLICE_WRITE_ENTER, &ip->i_iocore,
+       xfs_rw_enter_trace(XFS_SPLICE_WRITE_ENTER, ip,
                           pipe, count, *ppos, ioflags);
        ret = generic_file_splice_write(pipe, outfilp, ppos, count, flags);
        if (ret > 0)
@@ -370,9 +366,9 @@ xfs_splice_write(
                xfs_iunlock(ip, XFS_ILOCK_EXCL);
        }
 
-       if (io->io_new_size) {
+       if (ip->i_new_size) {
                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)
                        ip->i_d.di_size = ip->i_size;
                xfs_iunlock(ip, XFS_ILOCK_EXCL);
@@ -461,20 +457,19 @@ xfs_zero_eof(
        xfs_off_t       offset,         /* starting I/O offset */
        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   end_zero_fsb;
        xfs_fileoff_t   zero_count_fsb;
        xfs_fileoff_t   last_fsb;
        xfs_fileoff_t   zero_off;
        xfs_fsize_t     zero_len;
-       xfs_mount_t     *mp = io->io_mount;
        int             nimaps;
        int             error = 0;
        xfs_bmbt_irec_t imap;
 
-       ASSERT(ismrlocked(io->io_lock, MR_UPDATE));
-       ASSERT(ismrlocked(io->io_iolock, MR_UPDATE));
+       ASSERT(ismrlocked(&ip->i_lock, MR_UPDATE));
+       ASSERT(ismrlocked(&ip->i_iolock, MR_UPDATE));
        ASSERT(offset > isize);
 
        /*
@@ -483,8 +478,8 @@ xfs_zero_eof(
         */
        error = xfs_zero_last_block(ip, offset, isize);
        if (error) {
-               ASSERT(ismrlocked(io->io_lock, MR_UPDATE));
-               ASSERT(ismrlocked(io->io_iolock, MR_UPDATE));
+               ASSERT(ismrlocked(&ip->i_lock, MR_UPDATE));
+               ASSERT(ismrlocked(&ip->i_iolock, MR_UPDATE));
                return error;
        }
 
@@ -515,8 +510,8 @@ xfs_zero_eof(
                error = xfs_bmapi(NULL, ip, start_zero_fsb, zero_count_fsb,
                                  0, NULL, 0, &imap, &nimaps, NULL, NULL);
                if (error) {
-                       ASSERT(ismrlocked(io->io_lock, MR_UPDATE));
-                       ASSERT(ismrlocked(io->io_iolock, MR_UPDATE));
+                       ASSERT(ismrlocked(&ip->i_lock, MR_UPDATE));
+                       ASSERT(ismrlocked(&ip->i_iolock, MR_UPDATE));
                        return error;
                }
                ASSERT(nimaps > 0);
@@ -584,7 +579,6 @@ xfs_write(
        xfs_mount_t             *mp;
        ssize_t                 ret = 0, error = 0;
        xfs_fsize_t             isize, new_size;
-       xfs_iocore_t            *io;
        int                     iolock;
        int                     eventsent = 0;
        bhv_vrwlock_t           locktype;
@@ -604,8 +598,7 @@ xfs_write(
        if (count == 0)
                return 0;
 
-       io = &xip->i_iocore;
-       mp = io->io_mount;
+       mp = xip->i_mount;
 
        xfs_wait_for_freeze(mp, SB_FREEZE_WRITE);
 
@@ -685,7 +678,7 @@ start:
 
        new_size = pos + count;
        if (new_size > xip->i_size)
-               io->io_new_size = new_size;
+               xip->i_new_size = new_size;
 
        if (likely(!(ioflags & IO_INVIS))) {
                file_update_time(file);
@@ -737,7 +730,7 @@ retry:
        if ((ioflags & IO_ISDIRECT)) {
                if (VN_CACHED(vp)) {
                        WARN_ON(need_i_mutex == 0);
-                       xfs_inval_cached_trace(io, pos, -1,
+                       xfs_inval_cached_trace(xip, pos, -1,
                                        ctooff(offtoct(pos)), -1);
                        error = xfs_flushinval_pages(xip,
                                        ctooff(offtoct(pos)),
@@ -756,7 +749,7 @@ retry:
                        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);
                ret = generic_file_direct_write(iocb, iovp,
                                &segs, pos, offset, count, ocount);
@@ -776,7 +769,7 @@ retry:
                        goto relock;
                }
        } 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);
                ret = generic_file_buffered_write(iocb, iovp, segs,
                                pos, offset, count, ret);
@@ -840,9 +833,9 @@ retry:
        }
 
  out_unlock_internal:
-       if (io->io_new_size) {
+       if (xip->i_new_size) {
                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
                 * as ENOSPC) then part of the I/O may have been written to
diff --git a/fs/xfs/linux-2.6/xfs_lrw.h b/fs/xfs/linux-2.6/xfs_lrw.h
index a982fbc..e200253 100644
--- a/fs/xfs/linux-2.6/xfs_lrw.h
+++ b/fs/xfs/linux-2.6/xfs_lrw.h
@@ -19,7 +19,6 @@
 #define __XFS_LRW_H__
 
 struct xfs_mount;
-struct xfs_iocore;
 struct xfs_inode;
 struct xfs_bmbt_irec;
 struct xfs_buf;
@@ -60,13 +59,13 @@ struct xfs_iomap;
 #define        XFS_IOMAP_UNWRITTEN     27
 #define XFS_SPLICE_READ_ENTER  28
 #define XFS_SPLICE_WRITE_ENTER 29
-extern void xfs_rw_enter_trace(int, struct xfs_iocore *,
-                               void *, size_t, loff_t, int);
-extern void xfs_inval_cached_trace(struct xfs_iocore *,
-                               xfs_off_t, xfs_off_t, xfs_off_t, xfs_off_t);
+extern void xfs_rw_enter_trace(int, struct xfs_inode *,
+               void *, size_t, loff_t, int);
+extern void xfs_inval_cached_trace(struct xfs_inode *,
+               xfs_off_t, xfs_off_t, xfs_off_t, xfs_off_t);
 #else
-#define xfs_rw_enter_trace(tag, io, data, size, offset, ioflags)
-#define xfs_inval_cached_trace(io, offset, len, first, last)
+#define xfs_rw_enter_trace(tag, ip, data, size, offset, ioflags)
+#define xfs_inval_cached_trace(ip, offset, len, first, last)
 #endif
 
 extern int xfsbdstrat(struct xfs_mount *, struct xfs_buf *);
diff --git a/fs/xfs/xfs_dfrag.c b/fs/xfs/xfs_dfrag.c
index 39c4480..4ad29cb 100644
--- a/fs/xfs/xfs_dfrag.c
+++ b/fs/xfs/xfs_dfrag.c
@@ -199,7 +199,7 @@ xfs_swap_extents(
        }
 
        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,
                                FI_REMAPF_LOCKED);
                if (error)
diff --git a/fs/xfs/xfs_iget.c b/fs/xfs/xfs_iget.c
index f77bda1..15dba2e 100644
--- a/fs/xfs/xfs_iget.c
+++ b/fs/xfs/xfs_iget.c
@@ -199,12 +199,9 @@ again:
                XFS_STATS_INC(xs_ig_found);
 
 finish_inode:
-               if (ip->i_d.di_mode == 0) {
-                       if (!(flags & XFS_IGET_CREATE)) {
-                               xfs_put_perag(mp, pag);
-                               return ENOENT;
-                       }
-                       xfs_iocore_inode_reinit(ip);
+               if (ip->i_d.di_mode == 0 && !(flags & XFS_IGET_CREATE)) {
+                       xfs_put_perag(mp, pag);
+                       return ENOENT;
                }
 
                if (lock_flags != 0)
@@ -235,7 +232,6 @@ finish_inode:
        xfs_itrace_exit_tag(ip, "xfs_iget.alloc");
 
        xfs_inode_lock_init(ip, vp);
-       xfs_iocore_inode_init(ip);
        if (lock_flags)
                xfs_ilock(ip, lock_flags);
 
@@ -331,9 +327,6 @@ finish_inode:
        ASSERT(ip->i_df.if_ext_max ==
               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);
        *ipp = ip;
 
diff --git a/fs/xfs/xfs_inode.c b/fs/xfs/xfs_inode.c
index e793068..6d5641f 100644
--- a/fs/xfs/xfs_inode.c
+++ b/fs/xfs/xfs_inode.c
@@ -1220,10 +1220,8 @@ xfs_ialloc(
                                        ip->i_d.di_extsize = 
pip->i_d.di_extsize;
                                }
                        } 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;
-                                       ip->i_iocore.io_flags |= XFS_IOCORE_RT;
-                               }
                                if (pip->i_d.di_flags & 
XFS_DIFLAG_EXTSZINHERIT) {
                                        di_flags |= XFS_DIFLAG_EXTSIZE;
                                        ip->i_d.di_extsize = 
pip->i_d.di_extsize;
diff --git a/fs/xfs/xfs_inode.h b/fs/xfs/xfs_inode.h
index c3e21ef..88caadd 100644
--- a/fs/xfs/xfs_inode.h
+++ b/fs/xfs/xfs_inode.h
@@ -132,45 +132,6 @@ typedef struct dm_attrs_s {
        __uint16_t      da_pad;         /* DMIG extra padding */
 } 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
  * 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_release;     /* inode to unref */
 #endif
-       /* I/O state */
-       xfs_iocore_t            i_iocore;       /* I/O core */
-
        /* Miscellaneous state. */
        unsigned short          i_flags;        /* see defined flags below */
        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 */
 
        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 */
        /* Trace buffers per inode. */
 #ifdef XFS_INODE_TRACE
diff --git a/fs/xfs/xfs_iocore.c b/fs/xfs/xfs_iocore.c
deleted file mode 100644
index 336e27b..0000000
--- a/fs/xfs/xfs_iocore.c
+++ /dev/null
@@ -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);
-}
diff --git a/fs/xfs/xfs_iomap.c b/fs/xfs/xfs_iomap.c
index 4821b85..d16f40c 100644
--- a/fs/xfs/xfs_iomap.c
+++ b/fs/xfs/xfs_iomap.c
@@ -57,8 +57,6 @@ xfs_iomap_enter_trace(
        xfs_off_t       offset,
        ssize_t         count)
 {
-       xfs_iocore_t    *io = &ip->i_iocore;
-
        if (!ip->i_rwtrace)
                return;
 
@@ -70,8 +68,8 @@ xfs_iomap_enter_trace(
                (void *)((unsigned long)((offset >> 32) & 0xffffffff)),
                (void *)((unsigned long)(offset & 0xffffffff)),
                (void *)((unsigned long)count),
-               (void *)((unsigned long)((io->io_new_size >> 32) & 0xffffffff)),
-               (void *)((unsigned long)(io->io_new_size & 0xffffffff)),
+               (void *)((unsigned long)((ip->i_new_size >> 32) & 0xffffffff)),
+               (void *)((unsigned long)(ip->i_new_size & 0xffffffff)),
                (void *)((unsigned long)current_pid()),
                (void *)NULL,
                (void *)NULL,
@@ -186,8 +184,6 @@ xfs_iomap(
        int             iomap_flags = 0;
 
        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))
                return XFS_ERROR(EIO);
@@ -402,7 +398,6 @@ xfs_iomap_write_direct(
        int             found)
 {
        xfs_mount_t     *mp = ip->i_mount;
-       xfs_iocore_t    *io = &ip->i_iocore;
        xfs_fileoff_t   offset_fsb;
        xfs_fileoff_t   last_fsb;
        xfs_filblks_t   count_fsb, resaligned;
@@ -432,8 +427,8 @@ xfs_iomap_write_direct(
        extsz = xfs_get_extsz_hint(ip);
 
        isize = ip->i_size;
-       if (io->io_new_size > isize)
-               isize = io->io_new_size;
+       if (ip->i_new_size > isize)
+               isize = ip->i_new_size;
 
        offset_fsb = XFS_B_TO_FSBT(mp, offset);
        last_fsb = XFS_B_TO_FSB(mp, ((xfs_ufsize_t)(offset + count)));
@@ -528,7 +523,8 @@ xfs_iomap_write_direct(
                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);
                goto error_out;
        }
@@ -616,7 +612,6 @@ xfs_iomap_write_delay(
        int             *nmaps)
 {
        xfs_mount_t     *mp = ip->i_mount;
-       xfs_iocore_t    *io = &ip->i_iocore;
        xfs_fileoff_t   offset_fsb;
        xfs_fileoff_t   last_fsb;
        xfs_off_t       aligned_offset;
@@ -644,8 +639,8 @@ xfs_iomap_write_delay(
 
 retry:
        isize = ip->i_size;
-       if (io->io_new_size > isize)
-               isize = io->io_new_size;
+       if (ip->i_new_size > isize)
+               isize = ip->i_new_size;
 
        error = xfs_iomap_eof_want_preallocate(mp, ip, isize, offset, count,
                                ioflag, imap, XFS_WRITE_IMAPS, &prealloc);
@@ -691,7 +686,8 @@ 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]);
 
        *ret_imap = imap[0];
@@ -716,7 +712,6 @@ xfs_iomap_write_allocate(
        int             *retmap)
 {
        xfs_mount_t     *mp = ip->i_mount;
-       xfs_iocore_t    *io = &ip->i_iocore;
        xfs_fileoff_t   offset_fsb, last_block;
        xfs_fileoff_t   end_fsb, map_start_fsb;
        xfs_fsblock_t   first_block;
@@ -814,7 +809,7 @@ xfs_iomap_write_allocate(
                 */
                for (i = 0; i < nimaps; i++) {
                        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]);
                        if ((offset_fsb >= imap[i].br_startoff) &&
                            (offset_fsb < (imap[i].br_startoff +
@@ -850,7 +845,6 @@ xfs_iomap_write_unwritten(
        size_t          count)
 {
        xfs_mount_t     *mp = ip->i_mount;
-       xfs_iocore_t    *io = &ip->i_iocore;
        xfs_fileoff_t   offset_fsb;
        xfs_filblks_t   count_fsb;
        xfs_filblks_t   numblks_fsb;
@@ -913,7 +907,7 @@ xfs_iomap_write_unwritten(
                        return XFS_ERROR(error);
 
                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);
 
                if ((numblks_fsb = imap.br_blockcount) == 0) {
diff --git a/fs/xfs/xfs_mount.h b/fs/xfs/xfs_mount.h
index 169d993..15025e0 100644
--- a/fs/xfs/xfs_mount.h
+++ b/fs/xfs/xfs_mount.h
@@ -56,7 +56,6 @@ struct cred;
 struct log;
 struct xfs_mount_args;
 struct xfs_inode;
-struct xfs_iocore;
 struct xfs_bmbt_irec;
 struct xfs_bmap_free;
 struct xfs_extdelta;
diff --git a/fs/xfs/xfs_rw.h b/fs/xfs/xfs_rw.h
index 49875e1..bcfe07a 100644
--- a/fs/xfs/xfs_rw.h
+++ b/fs/xfs/xfs_rw.h
@@ -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_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
diff --git a/fs/xfs/xfs_vnodeops.c b/fs/xfs/xfs_vnodeops.c
index 7d3c4a7..d964e21 100644
--- a/fs/xfs/xfs_vnodeops.c
+++ b/fs/xfs/xfs_vnodeops.c
@@ -804,12 +804,8 @@ xfs_setattr(
                                if (vap->va_xflags & XFS_XFLAG_EXTSZINHERIT)
                                        di_flags |= XFS_DIFLAG_EXTSZINHERIT;
                        } 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;
-                                       ip->i_iocore.io_flags |= XFS_IOCORE_RT;
-                               } else {
-                                       ip->i_iocore.io_flags &= ~XFS_IOCORE_RT;
-                               }
                                if (vap->va_xflags & XFS_XFLAG_EXTSIZE)
                                        di_flags |= XFS_DIFLAG_EXTSIZE;
                        }
@@ -3633,8 +3629,8 @@ xfs_set_dmattrs(
        xfs_ilock(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_iocore.io_dmstate  = ip->i_d.di_dmstate  = state;
+       ip->i_d.di_dmevmask = evmask;
+       ip->i_d.di_dmstate  = state;
 
        xfs_trans_log_inode(tp, ip, XFS_ILOG_CORE);
        IHOLD(ip);
@@ -4172,7 +4168,7 @@ xfs_free_file_space(
        ioffset = offset & ~(rounding - 1);
 
        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);
                error = xfs_flushinval_pages(ip,
                                ctooff(offtoct(ioffset)),
-
To unsubscribe from this list: send the line "unsubscribe git-commits-head" in
the body of a message to [EMAIL PROTECTED]
More majordomo info at  http://vger.kernel.org/majordomo-info.html

Reply via email to