From: Christoph Hellwig <hch@infradead.org>
To: xfs@oss.sgi.com
Subject: Re: [PATCH 20/20] xfsprogs: resync libxfs with the kernel code
Date: Thu, 22 Jan 2009 15:15:24 -0500 [thread overview]
Message-ID: <20090122201524.GA4447@infradead.org> (raw)
In-Reply-To: <20081230173935.GA31861@infradead.org>
ping
On Tue, Dec 30, 2008 at 12:39:35PM -0500, Christoph Hellwig wrote:
> I know this is a lot of churn, but can I get a review for this please?
>
> On Mon, Dec 22, 2008 at 11:38:51AM -0500, Christoph Hellwig wrote:
> > Also use the kernel xfs_iread now instead of a duplicated version.
> >
> >
> >
> > Signed-off-by: Christoph Hellwig <hch@lst.de>
> >
> > Index: xfs-cmds/xfsprogs/include/xfs_ag.h
> > ===================================================================
> > --- xfs-cmds.orig/xfsprogs/include/xfs_ag.h 2008-12-06 20:05:46.000000000 +0100
> > +++ xfs-cmds/xfsprogs/include/xfs_ag.h 2008-12-06 20:05:49.000000000 +0100
> > @@ -91,6 +91,8 @@
> > #define XFS_AGF_BLOCK(mp) XFS_HDR_BLOCK(mp, XFS_AGF_DADDR(mp))
> > #define XFS_BUF_TO_AGF(bp) ((xfs_agf_t *)XFS_BUF_PTR(bp))
> >
> > +extern int xfs_read_agf(struct xfs_mount *mp, struct xfs_trans *tp,
> > + xfs_agnumber_t agno, int flags, struct xfs_buf **bpp);
> >
> > /*
> > * Size of the unlinked inode hash table in the agi.
> > @@ -142,6 +144,9 @@
> > #define XFS_AGI_BLOCK(mp) XFS_HDR_BLOCK(mp, XFS_AGI_DADDR(mp))
> > #define XFS_BUF_TO_AGI(bp) ((xfs_agi_t *)XFS_BUF_PTR(bp))
> >
> > +extern int xfs_read_agi(struct xfs_mount *mp, struct xfs_trans *tp,
> > + xfs_agnumber_t agno, struct xfs_buf **bpp);
> > +
> > /*
> > * The third a.g. block contains the a.g. freelist, an array
> > * of block pointers to blocks owned by the allocation btree code.
> > @@ -204,6 +209,11 @@
> > #endif
> > } xfs_perag_t;
> >
> > +/*
> > + * tags for inode radix tree
> > + */
> > +#define XFS_ICI_RECLAIM_TAG 0 /* inode is to be reclaimed */
> > +
> > #define XFS_AG_MAXLEVELS(mp) ((mp)->m_ag_maxlevels)
> > #define XFS_MIN_FREELIST_RAW(bl,cl,mp) \
> > (MIN(bl + 1, XFS_AG_MAXLEVELS(mp)) + MIN(cl + 1, XFS_AG_MAXLEVELS(mp)))
> > Index: xfs-cmds/xfsprogs/include/xfs_bmap.h
> > ===================================================================
> > --- xfs-cmds.orig/xfsprogs/include/xfs_bmap.h 2008-12-06 20:05:46.000000000 +0100
> > +++ xfs-cmds/xfsprogs/include/xfs_bmap.h 2008-12-06 20:05:49.000000000 +0100
> > @@ -356,15 +356,18 @@
> > xfs_bmap_free_t *flist, /* i/o: list extents to free */
> > int *committed); /* xact committed or not */
> >
> > +/* bmap to userspace formatter - copy to user & advance pointer */
> > +typedef int (*xfs_bmap_format_t)(void **, struct getbmapx *, int *);
> > +
> > /*
> > - * Fcntl interface to xfs_bmapi.
> > + * Get inode's extents as described in bmv, and format for output.
> > */
> > int /* error code */
> > xfs_getbmap(
> > xfs_inode_t *ip,
> > - struct getbmap *bmv, /* user bmap structure */
> > - void __user *ap, /* pointer to user's array */
> > - int iflags); /* interface flags */
> > + struct getbmapx *bmv, /* user bmap structure */
> > + xfs_bmap_format_t formatter, /* format to user */
> > + void *arg); /* formatter arg */
> >
> > /*
> > * Check if the endoff is outside the last extent. If so the caller will grow
> > Index: xfs-cmds/xfsprogs/include/xfs_dfrag.h
> > ===================================================================
> > --- xfs-cmds.orig/xfsprogs/include/xfs_dfrag.h 2008-12-06 20:05:46.000000000 +0100
> > +++ xfs-cmds/xfsprogs/include/xfs_dfrag.h 2008-12-06 20:05:49.000000000 +0100
> > @@ -46,7 +46,7 @@
> > /*
> > * Syscall interface for xfs_swapext
> > */
> > -int xfs_swapext(struct xfs_swapext __user *sx);
> > +int xfs_swapext(struct xfs_swapext *sx);
> >
> > int xfs_swap_extents(struct xfs_inode *ip, struct xfs_inode *tip,
> > struct xfs_swapext *sxp);
> > Index: xfs-cmds/xfsprogs/include/xfs_dinode.h
> > ===================================================================
> > --- xfs-cmds.orig/xfsprogs/include/xfs_dinode.h 2008-12-06 20:05:46.000000000 +0100
> > +++ xfs-cmds/xfsprogs/include/xfs_dinode.h 2008-12-06 20:05:49.000000000 +0100
> > @@ -18,32 +18,29 @@
> > #ifndef __XFS_DINODE_H__
> > #define __XFS_DINODE_H__
> >
> > -struct xfs_buf;
> > -struct xfs_mount;
> > +#define XFS_DINODE_MAGIC 0x494e /* 'IN' */
> > +#define XFS_DINODE_GOOD_VERSION(v) (((v) == 1 || (v) == 2))
> >
> > -#define XFS_DINODE_VERSION_1 1
> > -#define XFS_DINODE_VERSION_2 2
> > -#define XFS_DINODE_GOOD_VERSION(v) \
> > - (((v) == XFS_DINODE_VERSION_1 || (v) == XFS_DINODE_VERSION_2))
> > -#define XFS_DINODE_MAGIC 0x494e /* 'IN' */
> > -
> > -/*
> > - * Disk inode structure.
> > - * This is just the header; the inode is expanded to fill a variable size
> > - * with the last field expanding. It is split into the core and "other"
> > - * because we only need the core part in the in-core inode.
> > - */
> > typedef struct xfs_timestamp {
> > __be32 t_sec; /* timestamp seconds */
> > __be32 t_nsec; /* timestamp nanoseconds */
> > } xfs_timestamp_t;
> >
> > /*
> > - * Note: Coordinate changes to this structure with the XFS_DI_* #defines
> > - * below, the offsets table in xfs_ialloc_log_di() and struct xfs_icdinode
> > - * in xfs_inode.h.
> > + * On-disk inode structure.
> > + *
> > + * This is just the header or "dinode core", the inode is expanded to fill a
> > + * variable size the leftover area split into a data and an attribute fork.
> > + * The format of the data and attribute fork depends on the format of the
> > + * inode as indicated by di_format and di_aformat. To access the data and
> > + * attribute use the XFS_DFORK_PTR, XFS_DFORK_DPTR, and XFS_DFORK_PTR macros
> > + * below.
> > + *
> > + * There is a very similar struct icdinode in xfs_inode which matches the
> > + * layout of the first 96 bytes of this structure, but is kept in native
> > + * format instead of big endian.
> > */
> > -typedef struct xfs_dinode_core {
> > +typedef struct xfs_dinode {
> > __be16 di_magic; /* inode magic # = XFS_DINODE_MAGIC */
> > __be16 di_mode; /* mode and type of file */
> > __u8 di_version; /* inode version */
> > @@ -69,33 +66,12 @@
> > __be16 di_dmstate; /* DMIG state info */
> > __be16 di_flags; /* random flags, XFS_DIFLAG_... */
> > __be32 di_gen; /* generation number */
> > -} xfs_dinode_core_t;
> >
> > -#define DI_MAX_FLUSH 0xffff
> > + /* di_next_unlinked is the only non-core field in the old dinode */
> > + __be32 di_next_unlinked;/* agi unlinked list ptr */
> > +} __attribute__((packed)) xfs_dinode_t;
> >
> > -typedef struct xfs_dinode
> > -{
> > - xfs_dinode_core_t di_core;
> > - /*
> > - * In adding anything between the core and the union, be
> > - * sure to update the macros like XFS_LITINO below.
> > - */
> > - __be32 di_next_unlinked;/* agi unlinked list ptr */
> > - union {
> > - xfs_bmdr_block_t di_bmbt; /* btree root block */
> > - xfs_bmbt_rec_32_t di_bmx[1]; /* extent list */
> > - xfs_dir2_sf_t di_dir2sf; /* shortform directory v2 */
> > - char di_c[1]; /* local contents */
> > - __be32 di_dev; /* device for S_IFCHR/S_IFBLK */
> > - uuid_t di_muuid; /* mount point value */
> > - char di_symlink[1]; /* local symbolic link */
> > - } di_u;
> > - union {
> > - xfs_bmdr_block_t di_abmbt; /* btree root block */
> > - xfs_bmbt_rec_32_t di_abmx[1]; /* extent list */
> > - xfs_attr_shortform_t di_attrsf; /* shortform attribute list */
> > - } di_a;
> > -} xfs_dinode_t;
> > +#define DI_MAX_FLUSH 0xffff
> >
> > /*
> > * The 32 bit link count in the inode theoretically maxes out at UINT_MAX.
> > @@ -106,50 +82,14 @@
> > #define XFS_MAXLINK_1 65535U
> >
> > /*
> > - * Bit names for logging disk inodes only
> > - */
> > -#define XFS_DI_MAGIC 0x0000001
> > -#define XFS_DI_MODE 0x0000002
> > -#define XFS_DI_VERSION 0x0000004
> > -#define XFS_DI_FORMAT 0x0000008
> > -#define XFS_DI_ONLINK 0x0000010
> > -#define XFS_DI_UID 0x0000020
> > -#define XFS_DI_GID 0x0000040
> > -#define XFS_DI_NLINK 0x0000080
> > -#define XFS_DI_PROJID 0x0000100
> > -#define XFS_DI_PAD 0x0000200
> > -#define XFS_DI_ATIME 0x0000400
> > -#define XFS_DI_MTIME 0x0000800
> > -#define XFS_DI_CTIME 0x0001000
> > -#define XFS_DI_SIZE 0x0002000
> > -#define XFS_DI_NBLOCKS 0x0004000
> > -#define XFS_DI_EXTSIZE 0x0008000
> > -#define XFS_DI_NEXTENTS 0x0010000
> > -#define XFS_DI_NAEXTENTS 0x0020000
> > -#define XFS_DI_FORKOFF 0x0040000
> > -#define XFS_DI_AFORMAT 0x0080000
> > -#define XFS_DI_DMEVMASK 0x0100000
> > -#define XFS_DI_DMSTATE 0x0200000
> > -#define XFS_DI_FLAGS 0x0400000
> > -#define XFS_DI_GEN 0x0800000
> > -#define XFS_DI_NEXT_UNLINKED 0x1000000
> > -#define XFS_DI_U 0x2000000
> > -#define XFS_DI_A 0x4000000
> > -#define XFS_DI_NUM_BITS 27
> > -#define XFS_DI_ALL_BITS ((1 << XFS_DI_NUM_BITS) - 1)
> > -#define XFS_DI_CORE_BITS (XFS_DI_ALL_BITS & ~(XFS_DI_U|XFS_DI_A))
> > -
> > -/*
> > * Values for di_format
> > */
> > -typedef enum xfs_dinode_fmt
> > -{
> > - XFS_DINODE_FMT_DEV, /* CHR, BLK: di_dev */
> > - XFS_DINODE_FMT_LOCAL, /* DIR, REG: di_c */
> > - /* LNK: di_symlink */
> > - XFS_DINODE_FMT_EXTENTS, /* DIR, REG, LNK: di_bmx */
> > - XFS_DINODE_FMT_BTREE, /* DIR, REG, LNK: di_bmbt */
> > - XFS_DINODE_FMT_UUID /* MNT: di_uuid */
> > +typedef enum xfs_dinode_fmt {
> > + XFS_DINODE_FMT_DEV, /* xfs_dev_t */
> > + XFS_DINODE_FMT_LOCAL, /* bulk data */
> > + XFS_DINODE_FMT_EXTENTS, /* struct xfs_bmbt_rec */
> > + XFS_DINODE_FMT_BTREE, /* struct xfs_bmdr_block */
> > + XFS_DINODE_FMT_UUID /* uuid_t */
> > } xfs_dinode_fmt_t;
> >
> > /*
> > @@ -170,8 +110,8 @@
> > /*
> > * Inode data & attribute fork sizes, per inode.
> > */
> > -#define XFS_DFORK_Q(dip) ((dip)->di_core.di_forkoff != 0)
> > -#define XFS_DFORK_BOFF(dip) ((int)((dip)->di_core.di_forkoff << 3))
> > +#define XFS_DFORK_Q(dip) ((dip)->di_forkoff != 0)
> > +#define XFS_DFORK_BOFF(dip) ((int)((dip)->di_forkoff << 3))
> >
> > #define XFS_DFORK_DSIZE(dip,mp) \
> > (XFS_DFORK_Q(dip) ? \
> > @@ -186,23 +126,42 @@
> > XFS_DFORK_DSIZE(dip, mp) : \
> > XFS_DFORK_ASIZE(dip, mp))
> >
> > -#define XFS_DFORK_DPTR(dip) ((dip)->di_u.di_c)
> > +/*
> > + * Return pointers to the data or attribute forks.
> > + */
> > +#define XFS_DFORK_DPTR(dip) \
> > + ((char *)(dip) + sizeof(struct xfs_dinode))
> > #define XFS_DFORK_APTR(dip) \
> > - ((dip)->di_u.di_c + XFS_DFORK_BOFF(dip))
> > + (XFS_DFORK_DPTR(dip) + XFS_DFORK_BOFF(dip))
> > #define XFS_DFORK_PTR(dip,w) \
> > ((w) == XFS_DATA_FORK ? XFS_DFORK_DPTR(dip) : XFS_DFORK_APTR(dip))
> > +
> > #define XFS_DFORK_FORMAT(dip,w) \
> > ((w) == XFS_DATA_FORK ? \
> > - (dip)->di_core.di_format : \
> > - (dip)->di_core.di_aformat)
> > + (dip)->di_format : \
> > + (dip)->di_aformat)
> > #define XFS_DFORK_NEXTENTS(dip,w) \
> > ((w) == XFS_DATA_FORK ? \
> > - be32_to_cpu((dip)->di_core.di_nextents) : \
> > - be16_to_cpu((dip)->di_core.di_anextents))
> > + be32_to_cpu((dip)->di_nextents) : \
> > + be16_to_cpu((dip)->di_anextents))
> >
> > #define XFS_BUF_TO_DINODE(bp) ((xfs_dinode_t *)XFS_BUF_PTR(bp))
> >
> > /*
> > + * For block and character special files the 32bit dev_t is stored at the
> > + * beginning of the data fork.
> > + */
> > +static inline xfs_dev_t xfs_dinode_get_rdev(struct xfs_dinode *dip)
> > +{
> > + return be32_to_cpu(*(__be32 *)XFS_DFORK_DPTR(dip));
> > +}
> > +
> > +static inline void xfs_dinode_put_rdev(struct xfs_dinode *dip, xfs_dev_t rdev)
> > +{
> > + *(__be32 *)XFS_DFORK_DPTR(dip) = cpu_to_be32(rdev);
> > +}
> > +
> > +/*
> > * Values for di_flags
> > * There should be a one-to-one correspondence between these flags and the
> > * XFS_XFLAG_s.
> > Index: xfs-cmds/xfsprogs/include/xfs_dir2_sf.h
> > ===================================================================
> > --- xfs-cmds.orig/xfsprogs/include/xfs_dir2_sf.h 2008-12-06 20:05:46.000000000 +0100
> > +++ xfs-cmds/xfsprogs/include/xfs_dir2_sf.h 2008-12-06 20:05:49.000000000 +0100
> > @@ -34,13 +34,6 @@
> > struct xfs_trans;
> >
> > /*
> > - * Maximum size of a shortform directory.
> > - */
> > -#define XFS_DIR2_SF_MAX_SIZE \
> > - (XFS_DINODE_MAX_SIZE - (uint)sizeof(xfs_dinode_core_t) - \
> > - (uint)sizeof(xfs_agino_t))
> > -
> > -/*
> > * Inode number stored as 8 8-bit values.
> > */
> > typedef struct { __uint8_t i[8]; } xfs_dir2_ino8_t;
> > Index: xfs-cmds/xfsprogs/include/xfs_fs.h
> > ===================================================================
> > --- xfs-cmds.orig/xfsprogs/include/xfs_fs.h 2008-12-06 20:05:46.000000000 +0100
> > +++ xfs-cmds/xfsprogs/include/xfs_fs.h 2008-12-06 20:05:49.000000000 +0100
> > @@ -113,22 +113,14 @@
> > #define BMV_IF_ATTRFORK 0x1 /* return attr fork rather than data */
> > #define BMV_IF_NO_DMAPI_READ 0x2 /* Do not generate DMAPI read event */
> > #define BMV_IF_PREALLOC 0x4 /* rtn status BMV_OF_PREALLOC if req */
> > -#define BMV_IF_VALID (BMV_IF_ATTRFORK|BMV_IF_NO_DMAPI_READ|BMV_IF_PREALLOC)
> > -#ifdef __KERNEL__
> > -#define BMV_IF_EXTENDED 0x40000000 /* getpmapx if set */
> > -#endif
> > +#define BMV_IF_DELALLOC 0x8 /* rtn status BMV_OF_DELALLOC if req */
> > +#define BMV_IF_VALID \
> > + (BMV_IF_ATTRFORK|BMV_IF_NO_DMAPI_READ|BMV_IF_PREALLOC|BMV_IF_DELALLOC)
> >
> > /* bmv_oflags values - returned for for each non-header segment */
> > #define BMV_OF_PREALLOC 0x1 /* segment = unwritten pre-allocation */
> > -
> > -/* Convert getbmap <-> getbmapx - move fields from p1 to p2. */
> > -#define GETBMAP_CONVERT(p1,p2) { \
> > - p2.bmv_offset = p1.bmv_offset; \
> > - p2.bmv_block = p1.bmv_block; \
> > - p2.bmv_length = p1.bmv_length; \
> > - p2.bmv_count = p1.bmv_count; \
> > - p2.bmv_entries = p1.bmv_entries; }
> > -
> > +#define BMV_OF_DELALLOC 0x2 /* segment = delayed allocation */
> > +#define BMV_OF_LAST 0x4 /* segment is the last in the file */
> >
> > /*
> > * Structure for XFS_IOC_FSSETDM.
> > @@ -426,10 +418,6 @@
> > #define XFS_IOC_GETXFLAGS FS_IOC_GETFLAGS
> > #define XFS_IOC_SETXFLAGS FS_IOC_SETFLAGS
> > #define XFS_IOC_GETVERSION FS_IOC_GETVERSION
> > -/* 32-bit compat counterparts */
> > -#define XFS_IOC32_GETXFLAGS FS_IOC32_GETFLAGS
> > -#define XFS_IOC32_SETXFLAGS FS_IOC32_SETFLAGS
> > -#define XFS_IOC32_GETVERSION FS_IOC32_GETVERSION
> >
> > /*
> > * ioctl commands that replace IRIX fcntl()'s
> > Index: xfs-cmds/xfsprogs/include/xfs_ialloc.h
> > ===================================================================
> > --- xfs-cmds.orig/xfsprogs/include/xfs_ialloc.h 2008-12-06 20:05:46.000000000 +0100
> > +++ xfs-cmds/xfsprogs/include/xfs_ialloc.h 2008-12-06 20:05:49.000000000 +0100
> > @@ -20,6 +20,7 @@
> >
> > struct xfs_buf;
> > struct xfs_dinode;
> > +struct xfs_imap;
> > struct xfs_mount;
> > struct xfs_trans;
> >
> > @@ -104,17 +105,14 @@
> > xfs_ino_t *first_ino); /* first inode in deleted cluster */
> >
> > /*
> > - * Return the location of the inode in bno/len/off,
> > - * for mapping it into a buffer.
> > + * Return the location of the inode in imap, for mapping it into a buffer.
> > */
> > int
> > -xfs_dilocate(
> > +xfs_imap(
> > struct xfs_mount *mp, /* file system mount structure */
> > struct xfs_trans *tp, /* transaction pointer */
> > xfs_ino_t ino, /* inode to locate */
> > - xfs_fsblock_t *bno, /* output: block containing inode */
> > - int *len, /* output: num blocks in cluster*/
> > - int *off, /* output: index in block of inode */
> > + struct xfs_imap *imap, /* location map structure */
> > uint flags); /* flags for inode btree lookup */
> >
> > /*
> > Index: xfs-cmds/xfsprogs/include/xfs_inode.h
> > ===================================================================
> > --- xfs-cmds.orig/xfsprogs/include/xfs_inode.h 2008-12-06 20:05:46.000000000 +0100
> > +++ xfs-cmds/xfsprogs/include/xfs_inode.h 2008-12-06 20:05:49.000000000 +0100
> > @@ -19,7 +19,6 @@
> > #define __XFS_INODE_H__
> >
> > struct xfs_dinode;
> > -struct xfs_dinode_core;
> > struct xfs_inode;
> >
> > /*
> > @@ -84,6 +83,16 @@
> > } xfs_ifork_t;
> >
> > /*
> > + * Inode location information. Stored in the inode and passed to
> > + * xfs_imap_to_bp() to get a buffer and dinode for a given inode.
> > + */
> > +struct xfs_imap {
> > + xfs_daddr_t im_blkno; /* starting BB of inode chunk */
> > + ushort im_len; /* length in BBs of inode chunk */
> > + ushort im_boffset; /* inode offset in block in bytes */
> > +};
> > +
> > +/*
> > * This is the xfs in-core inode structure.
> > * Most of the on-disk inode is embedded in the i_d field.
> > *
> > @@ -112,7 +121,7 @@
> > } xfs_ictimestamp_t;
> >
> > /*
> > - * NOTE: This structure must be kept identical to struct xfs_dinode_core
> > + * NOTE: This structure must be kept identical to struct xfs_dinode
> > * in xfs_dinode.h except for the endianess annotations.
> > */
> > typedef struct xfs_icdinode {
> > @@ -158,12 +167,6 @@
> > #define XFS_IFEXTIREC 0x08 /* Indirection array of extent blocks */
> >
> > /*
> > - * Flags for xfs_itobp(), xfs_imap() and xfs_dilocate().
> > - */
> > -#define XFS_IMAP_LOOKUP 0x1
> > -#define XFS_IMAP_BULKSTAT 0x2
> > -
> > -/*
> > * Fork handling.
> > */
> >
> > @@ -232,27 +235,15 @@
> > __uint16_t da_pad; /* DMIG extra padding */
> > } dm_attrs_t;
> >
> > -typedef struct {
> > - struct xfs_inode *ip_mnext; /* next inode in mount list */
> > - struct xfs_inode *ip_mprev; /* ptr to prev inode */
> > - struct xfs_mount *ip_mount; /* fs mount struct ptr */
> > -} xfs_iptr_t;
> > -
> > typedef struct xfs_inode {
> > /* Inode linking and identification information. */
> > - struct xfs_inode *i_mnext; /* next inode in mount list */
> > - struct xfs_inode *i_mprev; /* ptr to prev inode */
> > struct xfs_mount *i_mount; /* fs mount struct ptr */
> > - struct list_head i_reclaim; /* reclaim list */
> > - struct inode *i_vnode; /* vnode backpointer */
> > struct xfs_dquot *i_udquot; /* user dquot */
> > struct xfs_dquot *i_gdquot; /* group dquot */
> >
> > /* Inode location stuff */
> > xfs_ino_t i_ino; /* inode number (agno/agino)*/
> > - xfs_daddr_t i_blkno; /* blkno of inode buffer */
> > - ushort i_len; /* len of inode buffer */
> > - ushort i_boffset; /* off of inode in buffer */
> > + struct xfs_imap i_imap; /* location for xfs_imap() */
> >
> > /* Extent information. */
> > xfs_ifork_t *i_afp; /* attribute fork pointer */
> > @@ -271,7 +262,6 @@
> > unsigned short i_flags; /* see defined flags below */
> > unsigned char i_update_core; /* timestamps/size is dirty */
> > unsigned char i_update_size; /* di_size field is dirty */
> > - unsigned int i_gen; /* generation count */
> > unsigned int i_delayed_blks; /* count of delay alloc blks */
> >
> > xfs_icdinode_t i_d; /* most of ondisk inode */
> > @@ -279,6 +269,10 @@
> > 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 */
> > +
> > + /* VFS inode */
> > + struct inode i_vnode; /* embedded VFS inode */
> > +
> > /* Trace buffers per inode. */
> > #ifdef XFS_INODE_TRACE
> > struct ktrace *i_trace; /* general inode trace */
> > @@ -306,13 +300,30 @@
> > /* Convert from vfs inode to xfs inode */
> > static inline struct xfs_inode *XFS_I(struct inode *inode)
> > {
> > - return (struct xfs_inode *)inode->i_private;
> > + return container_of(inode, struct xfs_inode, i_vnode);
> > }
> >
> > /* convert from xfs inode to vfs inode */
> > static inline struct inode *VFS_I(struct xfs_inode *ip)
> > {
> > - return (struct inode *)ip->i_vnode;
> > + return &ip->i_vnode;
> > +}
> > +
> > +/*
> > + * Get rid of a partially initialized inode.
> > + *
> > + * We have to go through destroy_inode to make sure allocations
> > + * from init_inode_always like the security data are undone.
> > + *
> > + * We mark the inode bad so that it takes the short cut in
> > + * the reclaim path instead of going through the flush path
> > + * which doesn't make sense for an inode that has never seen the
> > + * light of day.
> > + */
> > +static inline void xfs_destroy_inode(struct xfs_inode *ip)
> > +{
> > + make_bad_inode(VFS_I(ip));
> > + return destroy_inode(VFS_I(ip));
> > }
> >
> > /*
> > @@ -392,17 +403,12 @@
> > /*
> > * In-core inode flags.
> > */
> > -#define XFS_IGRIO 0x0001 /* inode used for guaranteed rate i/o */
> > -#define XFS_IUIOSZ 0x0002 /* inode i/o sizes have been explicitly set */
> > -#define XFS_IQUIESCE 0x0004 /* we have started quiescing for this inode */
> > -#define XFS_IRECLAIM 0x0008 /* we have started reclaiming this inode */
> > -#define XFS_ISTALE 0x0010 /* inode has been staled */
> > -#define XFS_IRECLAIMABLE 0x0020 /* inode can be reclaimed */
> > -#define XFS_INEW 0x0040
> > -#define XFS_IFILESTREAM 0x0080 /* inode is in a filestream directory */
> > -#define XFS_IMODIFIED 0x0100 /* XFS inode state possibly differs */
> > - /* to the Linux inode state. */
> > -#define XFS_ITRUNCATED 0x0200 /* truncated down so flush-on-close */
> > +#define XFS_IRECLAIM 0x0001 /* we have started reclaiming this inode */
> > +#define XFS_ISTALE 0x0002 /* inode has been staled */
> > +#define XFS_IRECLAIMABLE 0x0004 /* inode can be reclaimed */
> > +#define XFS_INEW 0x0008 /* inode has just been allocated */
> > +#define XFS_IFILESTREAM 0x0010 /* inode is in a filestream directory */
> > +#define XFS_ITRUNCATED 0x0020 /* truncated down so flush-on-close */
> >
> > /*
> > * Flags for inode locking.
> > @@ -477,16 +483,8 @@
> > ((pip)->i_d.di_mode & S_ISGID))
> >
> > /*
> > - * Flags for xfs_iget()
> > - */
> > -#define XFS_IGET_CREATE 0x1
> > -#define XFS_IGET_BULKSTAT 0x2
> > -
> > -/*
> > * xfs_iget.c prototypes.
> > */
> > -void xfs_ihash_init(struct xfs_mount *);
> > -void xfs_ihash_free(struct xfs_mount *);
> > xfs_inode_t *xfs_inode_incore(struct xfs_mount *, xfs_ino_t,
> > struct xfs_trans *);
> > int xfs_iget(struct xfs_mount *, struct xfs_trans *, xfs_ino_t,
> > @@ -501,14 +499,10 @@
> > uint xfs_ilock_map_shared(xfs_inode_t *);
> > void xfs_iunlock_map_shared(xfs_inode_t *, uint);
> > void xfs_ireclaim(xfs_inode_t *);
> > -int xfs_finish_reclaim(xfs_inode_t *, int, int);
> > -int xfs_finish_reclaim_all(struct xfs_mount *, int);
> >
> > /*
> > * xfs_inode.c prototypes.
> > */
> > -int xfs_iread(struct xfs_mount *, struct xfs_trans *, xfs_ino_t,
> > - xfs_inode_t **, xfs_daddr_t, uint);
> > int xfs_ialloc(struct xfs_trans *, xfs_inode_t *, mode_t,
> > xfs_nlink_t, xfs_dev_t, struct cred *, xfs_prid_t,
> > int, struct xfs_buf **, boolean_t *, xfs_inode_t **);
> > @@ -522,14 +516,10 @@
> > xfs_fsize_t, int, int);
> > int xfs_iunlink(struct xfs_trans *, xfs_inode_t *);
> >
> > -struct xfs_inode * xfs_inode_alloc(struct xfs_mount *, xfs_ino_t);
> > -void xfs_idestroy(xfs_inode_t *);
> > -void xfs_iextract(xfs_inode_t *);
> > void xfs_iext_realloc(xfs_inode_t *, int, int);
> > void xfs_ipin(xfs_inode_t *);
> > void xfs_iunpin(xfs_inode_t *);
> > int xfs_iflush(xfs_inode_t *, uint);
> > -void xfs_iflush_all(struct xfs_mount *);
> > void xfs_ichgtime(xfs_inode_t *, int);
> > xfs_fsize_t xfs_file_last_byte(xfs_inode_t *);
> > void xfs_lock_inodes(xfs_inode_t **, int, uint);
> > @@ -538,14 +528,70 @@
> > void xfs_synchronize_atime(xfs_inode_t *);
> > void xfs_mark_inode_dirty_sync(xfs_inode_t *);
> >
> > +#if defined(XFS_INODE_TRACE)
> > +
> > +#define INODE_TRACE_SIZE 16 /* number of trace entries */
> > +#define INODE_KTRACE_ENTRY 1
> > +#define INODE_KTRACE_EXIT 2
> > +#define INODE_KTRACE_HOLD 3
> > +#define INODE_KTRACE_REF 4
> > +#define INODE_KTRACE_RELE 5
> > +
> > +extern void _xfs_itrace_entry(struct xfs_inode *, const char *, inst_t *);
> > +extern void _xfs_itrace_exit(struct xfs_inode *, const char *, inst_t *);
> > +extern void xfs_itrace_hold(struct xfs_inode *, char *, int, inst_t *);
> > +extern void _xfs_itrace_ref(struct xfs_inode *, char *, int, inst_t *);
> > +extern void xfs_itrace_rele(struct xfs_inode *, char *, int, inst_t *);
> > +#define xfs_itrace_entry(ip) \
> > + _xfs_itrace_entry(ip, __func__, (inst_t *)__return_address)
> > +#define xfs_itrace_exit(ip) \
> > + _xfs_itrace_exit(ip, __func__, (inst_t *)__return_address)
> > +#define xfs_itrace_exit_tag(ip, tag) \
> > + _xfs_itrace_exit(ip, tag, (inst_t *)__return_address)
> > +#define xfs_itrace_ref(ip) \
> > + _xfs_itrace_ref(ip, __FILE__, __LINE__, (inst_t *)__return_address)
> > +
> > +#else
> > +#define xfs_itrace_entry(a)
> > +#define xfs_itrace_exit(a)
> > +#define xfs_itrace_exit_tag(a, b)
> > +#define xfs_itrace_hold(a, b, c, d)
> > +#define xfs_itrace_ref(a)
> > +#define xfs_itrace_rele(a, b, c, d)
> > +#endif
> > +
> > +#define IHOLD(ip) \
> > +do { \
> > + ASSERT(atomic_read(&VFS_I(ip)->i_count) > 0) ; \
> > + atomic_inc(&(VFS_I(ip)->i_count)); \
> > + xfs_itrace_hold((ip), __FILE__, __LINE__, (inst_t *)__return_address); \
> > +} while (0)
> > +
> > +#define IRELE(ip) \
> > +do { \
> > + xfs_itrace_rele((ip), __FILE__, __LINE__, (inst_t *)__return_address); \
> > + iput(VFS_I(ip)); \
> > +} while (0)
> > +
> > #endif /* __KERNEL__ */
> >
> > +/*
> > + * Flags for xfs_iget()
> > + */
> > +#define XFS_IGET_CREATE 0x1
> > +#define XFS_IGET_BULKSTAT 0x2
> > +
> > +int xfs_inotobp(struct xfs_mount *, struct xfs_trans *,
> > + xfs_ino_t, struct xfs_dinode **,
> > + struct xfs_buf **, int *, uint);
> > int xfs_itobp(struct xfs_mount *, struct xfs_trans *,
> > struct xfs_inode *, struct xfs_dinode **,
> > - struct xfs_buf **, xfs_daddr_t, uint, uint);
> > + struct xfs_buf **, uint);
> > +int xfs_iread(struct xfs_mount *, struct xfs_trans *,
> > + struct xfs_inode *, xfs_daddr_t, uint);
> > void xfs_dinode_from_disk(struct xfs_icdinode *,
> > - struct xfs_dinode_core *);
> > -void xfs_dinode_to_disk(struct xfs_dinode_core *,
> > + struct xfs_dinode *);
> > +void xfs_dinode_to_disk(struct xfs_dinode *,
> > struct xfs_icdinode *);
> > void xfs_idestroy_fork(struct xfs_inode *, int);
> > void xfs_idata_realloc(struct xfs_inode *, int, int);
> > Index: xfs-cmds/xfsprogs/include/xfs_log.h
> > ===================================================================
> > --- xfs-cmds.orig/xfsprogs/include/xfs_log.h 2008-12-06 20:05:46.000000000 +0100
> > +++ xfs-cmds/xfsprogs/include/xfs_log.h 2008-12-06 20:05:49.000000000 +0100
> > @@ -134,6 +134,7 @@
> > #ifdef __KERNEL__
> > /* Log manager interfaces */
> > struct xfs_mount;
> > +struct xlog_ticket;
> > xfs_lsn_t xfs_log_done(struct xfs_mount *mp,
> > xfs_log_ticket_t ticket,
> > void **iclog,
> > @@ -177,6 +178,9 @@
> >
> > void xlog_iodone(struct xfs_buf *);
> >
> > +struct xlog_ticket * xfs_log_ticket_get(struct xlog_ticket *ticket);
> > +void xfs_log_ticket_put(struct xlog_ticket *ticket);
> > +
> > #endif
> >
> >
> > Index: xfs-cmds/xfsprogs/include/xfs_log_priv.h
> > ===================================================================
> > --- xfs-cmds.orig/xfsprogs/include/xfs_log_priv.h 2008-12-06 20:05:46.000000000 +0100
> > +++ xfs-cmds/xfsprogs/include/xfs_log_priv.h 2008-12-06 20:05:49.000000000 +0100
> > @@ -245,6 +245,7 @@
> > struct xlog_ticket *t_next; /* :4|8 */
> > struct xlog_ticket *t_prev; /* :4|8 */
> > xlog_tid_t t_tid; /* transaction identifier : 4 */
> > + atomic_t t_ref; /* ticket reference count : 4 */
> > int t_curr_res; /* current reservation in bytes : 4 */
> > int t_unit_res; /* unit reservation in bytes : 4 */
> > char t_ocnt; /* original count : 1 */
> > @@ -309,6 +310,16 @@
> > } xlog_rec_ext_header_t;
> >
> > #ifdef __KERNEL__
> > +
> > +/*
> > + * Quite misnamed, because this union lays out the actual on-disk log buffer.
> > + */
> > +typedef union xlog_in_core2 {
> > + xlog_rec_header_t hic_header;
> > + xlog_rec_ext_header_t hic_xheader;
> > + char hic_sector[XLOG_HEADER_SIZE];
> > +} xlog_in_core_2_t;
> > +
> > /*
> > * - A log record header is 512 bytes. There is plenty of room to grow the
> > * xlog_rec_header_t into the reserved space.
> > @@ -338,7 +349,7 @@
> > * We'll put all the read-only and l_icloglock fields in the first cacheline,
> > * and move everything else out to subsequent cachelines.
> > */
> > -typedef struct xlog_iclog_fields {
> > +typedef struct xlog_in_core {
> > sv_t ic_force_wait;
> > sv_t ic_write_wait;
> > struct xlog_in_core *ic_next;
> > @@ -361,41 +372,11 @@
> >
> > /* reference counts need their own cacheline */
> > atomic_t ic_refcnt ____cacheline_aligned_in_smp;
> > -} xlog_iclog_fields_t;
> > -
> > -typedef union xlog_in_core2 {
> > - xlog_rec_header_t hic_header;
> > - xlog_rec_ext_header_t hic_xheader;
> > - char hic_sector[XLOG_HEADER_SIZE];
> > -} xlog_in_core_2_t;
> > -
> > -typedef struct xlog_in_core {
> > - xlog_iclog_fields_t hic_fields;
> > - xlog_in_core_2_t *hic_data;
> > + xlog_in_core_2_t *ic_data;
> > +#define ic_header ic_data->hic_header
> > } xlog_in_core_t;
> >
> > /*
> > - * Defines to save our code from this glop.
> > - */
> > -#define ic_force_wait hic_fields.ic_force_wait
> > -#define ic_write_wait hic_fields.ic_write_wait
> > -#define ic_next hic_fields.ic_next
> > -#define ic_prev hic_fields.ic_prev
> > -#define ic_bp hic_fields.ic_bp
> > -#define ic_log hic_fields.ic_log
> > -#define ic_callback hic_fields.ic_callback
> > -#define ic_callback_lock hic_fields.ic_callback_lock
> > -#define ic_callback_tail hic_fields.ic_callback_tail
> > -#define ic_trace hic_fields.ic_trace
> > -#define ic_size hic_fields.ic_size
> > -#define ic_offset hic_fields.ic_offset
> > -#define ic_refcnt hic_fields.ic_refcnt
> > -#define ic_bwritecnt hic_fields.ic_bwritecnt
> > -#define ic_state hic_fields.ic_state
> > -#define ic_datap hic_fields.ic_datap
> > -#define ic_header hic_data->hic_header
> > -
> > -/*
> > * The reservation head lsn is not made up of a cycle number and block number.
> > * Instead, it uses a cycle number and byte number. Logs don't expect to
> > * overflow 31 bits worth of byte offset, so using a byte number will mean
> > @@ -404,6 +385,7 @@
> > typedef struct log {
> > /* The following fields don't need locking */
> > struct xfs_mount *l_mp; /* mount point */
> > + struct xfs_ail *l_ailp; /* AIL log is working with */
> > struct xfs_buf *l_xbuf; /* extra buffer for log
> > * wrapping */
> > struct xfs_buftarg *l_targ; /* buftarg of log */
> > Index: xfs-cmds/xfsprogs/include/xfs_mount.h
> > ===================================================================
> > --- xfs-cmds.orig/xfsprogs/include/xfs_mount.h 2008-12-06 20:05:46.000000000 +0100
> > +++ xfs-cmds/xfsprogs/include/xfs_mount.h 2008-12-06 20:05:49.000000000 +0100
> > @@ -18,7 +18,6 @@
> > #ifndef __XFS_MOUNT_H__
> > #define __XFS_MOUNT_H__
> >
> > -
> > typedef struct xfs_trans_reservations {
> > uint tr_write; /* extent alloc trans */
> > uint tr_itruncate; /* truncate trans */
> > @@ -52,6 +51,8 @@
> >
> > #else /* __KERNEL__ */
> >
> > +#include "xfs_sync.h"
> > +
> > struct cred;
> > struct log;
> > struct xfs_mount_args;
> > @@ -62,6 +63,7 @@
> > struct xfs_swapext;
> > struct xfs_mru_cache;
> > struct xfs_nameops;
> > +struct xfs_ail;
> >
> > /*
> > * Prototypes and functions for the Data Migration subsystem.
> > @@ -115,7 +117,7 @@
> >
> > typedef int (*xfs_qminit_t)(struct xfs_mount *, uint *, uint *);
> > typedef int (*xfs_qmmount_t)(struct xfs_mount *, uint, uint);
> > -typedef int (*xfs_qmunmount_t)(struct xfs_mount *);
> > +typedef void (*xfs_qmunmount_t)(struct xfs_mount *);
> > typedef void (*xfs_qmdone_t)(struct xfs_mount *);
> > typedef void (*xfs_dqrele_t)(struct xfs_dquot *);
> > typedef int (*xfs_dqattach_t)(struct xfs_inode *, uint);
> > @@ -132,7 +134,7 @@
> > struct xfs_dquot **, struct xfs_dquot *);
> > typedef int (*xfs_dqvopchownresv_t)(struct xfs_trans *, struct xfs_inode *,
> > struct xfs_dquot *, struct xfs_dquot *, uint);
> > -typedef void (*xfs_dqstatvfs_t)(struct xfs_inode *, bhv_statvfs_t *);
> > +typedef void (*xfs_dqstatvfs_t)(struct xfs_inode *, struct kstatfs *);
> > typedef int (*xfs_dqsync_t)(struct xfs_mount *, int flags);
> > typedef int (*xfs_quotactl_t)(struct xfs_mount *, int, int, xfs_caddr_t);
> >
> > @@ -223,18 +225,10 @@
> > #define xfs_icsb_sync_counters_locked(mp, flags) do { } while (0)
> > #endif
> >
> > -typedef struct xfs_ail {
> > - struct list_head xa_ail;
> > - uint xa_gen;
> > - struct task_struct *xa_task;
> > - xfs_lsn_t xa_target;
> > -} xfs_ail_t;
> > -
> > typedef struct xfs_mount {
> > struct super_block *m_super;
> > xfs_tid_t m_tid; /* next unused tid for fs */
> > - spinlock_t m_ail_lock; /* fs AIL mutex */
> > - xfs_ail_t m_ail; /* fs active log item list */
> > + struct xfs_ail *m_ail; /* fs active log item list */
> > xfs_sb_t m_sb; /* copy of fs superblock */
> > spinlock_t m_sb_lock; /* sb counter lock */
> > struct xfs_buf *m_sb_bp; /* buffer for superblock */
> > @@ -247,10 +241,6 @@
> > xfs_agnumber_t m_agirotor; /* last ag dir inode alloced */
> > spinlock_t m_agirotor_lock;/* .. and lock protecting it */
> > xfs_agnumber_t m_maxagi; /* highest inode alloc group */
> > - struct xfs_inode *m_inodes; /* active inode list */
> > - struct list_head m_del_inodes; /* inodes to reclaim */
> > - mutex_t m_ilock; /* inode list mutex */
> > - uint m_ireclaims; /* count of calls to reclaim*/
> > uint m_readio_log; /* min read size log bytes */
> > uint m_readio_blocks; /* min read size blocks */
> > uint m_writeio_log; /* min write size log bytes */
> > @@ -311,9 +301,6 @@
> > int m_sinoalign; /* stripe unit inode alignment */
> > int m_attr_magicpct;/* 37% of the blocksize */
> > int m_dir_magicpct; /* 37% of the dir blocksize */
> > - __uint8_t m_mk_sharedro; /* mark shared ro on unmount */
> > - __uint8_t m_inode_quiesce;/* call quiesce on new inodes.
> > - field governed by m_ilock */
> > __uint8_t m_sectbb_log; /* sectlog - BBSHIFT */
> > const struct xfs_nameops *m_dirnameops; /* vector of dir name ops */
> > int m_dirblksize; /* directory block sz--bytes */
> > @@ -340,7 +327,6 @@
> > spinlock_t m_sync_lock; /* work item list lock */
> > int m_sync_seq; /* sync thread generation no. */
> > wait_queue_head_t m_wait_single_sync_task;
> > - struct vfsmount *m_vfsmount;
> > } xfs_mount_t;
> >
> > /*
> > @@ -362,7 +348,6 @@
> > #define XFS_MOUNT_ATTR2 (1ULL << 8) /* allow use of attr2 format */
> > #define XFS_MOUNT_GRPID (1ULL << 9) /* group-ID assigned from directory */
> > #define XFS_MOUNT_NORECOVERY (1ULL << 10) /* no recovery - dirty fs */
> > -#define XFS_MOUNT_SHARED (1ULL << 11) /* shared mount */
> > #define XFS_MOUNT_DFLT_IOSIZE (1ULL << 12) /* set default i/o size */
> > #define XFS_MOUNT_OSYNCISOSYNC (1ULL << 13) /* o_sync is REALLY o_sync */
> > /* osyncisdsync is now default*/
> > @@ -439,6 +424,16 @@
> > #define xfs_force_shutdown(m,f) \
> > xfs_do_force_shutdown(m, f, __FILE__, __LINE__)
> >
> > +#define SHUTDOWN_META_IO_ERROR 0x0001 /* write attempt to metadata failed */
> > +#define SHUTDOWN_LOG_IO_ERROR 0x0002 /* write attempt to the log failed */
> > +#define SHUTDOWN_FORCE_UMOUNT 0x0004 /* shutdown from a forced unmount */
> > +#define SHUTDOWN_CORRUPT_INCORE 0x0008 /* corrupt in-memory data structures */
> > +#define SHUTDOWN_REMOTE_REQ 0x0010 /* shutdown came from remote cell */
> > +#define SHUTDOWN_DEVICE_REQ 0x0020 /* failed all paths to the device */
> > +
> > +#define xfs_test_for_freeze(mp) ((mp)->m_super->s_frozen)
> > +#define xfs_wait_for_freeze(mp,l) vfs_check_frozen((mp)->m_super, (l))
> > +
> > /*
> > * Flags for xfs_mountfs
> > */
> > @@ -514,7 +509,6 @@
> >
> > extern void xfs_unmountfs(xfs_mount_t *);
> > extern int xfs_unmountfs_writesb(xfs_mount_t *);
> > -extern int xfs_unmount_flush(xfs_mount_t *, int);
> > extern int xfs_mod_incore_sb(xfs_mount_t *, xfs_sb_field_t, int64_t, int);
> > extern int xfs_mod_incore_sb_unlocked(xfs_mount_t *, xfs_sb_field_t,
> > int64_t, int);
> > @@ -524,13 +518,11 @@
> > extern int xfs_readsb(xfs_mount_t *, int);
> > extern void xfs_freesb(xfs_mount_t *);
> > extern int xfs_fs_writable(xfs_mount_t *);
> > -extern int xfs_syncsub(xfs_mount_t *, int, int *);
> > -extern int xfs_sync_inodes(xfs_mount_t *, int, int *);
> > extern int xfs_sb_validate_fsb_count(struct xfs_sb *, __uint64_t);
> >
> > -extern int xfs_dmops_get(struct xfs_mount *, struct xfs_mount_args *);
> > +extern int xfs_dmops_get(struct xfs_mount *);
> > extern void xfs_dmops_put(struct xfs_mount *);
> > -extern int xfs_qmops_get(struct xfs_mount *, struct xfs_mount_args *);
> > +extern int xfs_qmops_get(struct xfs_mount *);
> > extern void xfs_qmops_put(struct xfs_mount *);
> >
> > extern struct xfs_dmops xfs_dmcore_xfs;
> > Index: xfs-cmds/xfsprogs/include/xfs_quota.h
> > ===================================================================
> > --- xfs-cmds.orig/xfsprogs/include/xfs_quota.h 2008-12-06 20:05:46.000000000 +0100
> > +++ xfs-cmds/xfsprogs/include/xfs_quota.h 2008-12-06 20:05:49.000000000 +0100
> > @@ -84,11 +84,9 @@
> > #define XFS_DQ_USER 0x0001 /* a user quota */
> > #define XFS_DQ_PROJ 0x0002 /* project quota */
> > #define XFS_DQ_GROUP 0x0004 /* a group quota */
> > -#define XFS_DQ_FLOCKED 0x0008 /* flush lock taken */
> > -#define XFS_DQ_DIRTY 0x0010 /* dquot is dirty */
> > -#define XFS_DQ_WANT 0x0020 /* for lookup/reclaim race */
> > -#define XFS_DQ_INACTIVE 0x0040 /* dq off mplist & hashlist */
> > -#define XFS_DQ_MARKER 0x0080 /* sentinel */
> > +#define XFS_DQ_DIRTY 0x0008 /* dquot is dirty */
> > +#define XFS_DQ_WANT 0x0010 /* for lookup/reclaim race */
> > +#define XFS_DQ_INACTIVE 0x0020 /* dq off mplist & hashlist */
> >
> > #define XFS_DQ_ALLTYPES (XFS_DQ_USER|XFS_DQ_PROJ|XFS_DQ_GROUP)
> >
> > Index: xfs-cmds/xfsprogs/include/xfs_sb.h
> > ===================================================================
> > --- xfs-cmds.orig/xfsprogs/include/xfs_sb.h 2008-12-06 20:05:46.000000000 +0100
> > +++ xfs-cmds/xfsprogs/include/xfs_sb.h 2008-12-06 20:05:49.000000000 +0100
> > @@ -297,30 +297,34 @@
> >
> > #define XFS_SB_VERSION_NUM(sbp) ((sbp)->sb_versionnum & XFS_SB_VERSION_NUMBITS)
> >
> > -#ifdef __KERNEL__
> > static inline int xfs_sb_good_version(xfs_sb_t *sbp)
> > {
> > - return (((sbp->sb_versionnum >= XFS_SB_VERSION_1) && \
> > - (sbp->sb_versionnum <= XFS_SB_VERSION_3)) || \
> > - ((XFS_SB_VERSION_NUM(sbp) == XFS_SB_VERSION_4) && \
> > - !((sbp->sb_versionnum & ~XFS_SB_VERSION_OKREALBITS) || \
> > - ((sbp->sb_versionnum & XFS_SB_VERSION_MOREBITSBIT) && \
> > - (sbp->sb_features2 & ~XFS_SB_VERSION2_OKREALBITS))) && \
> > - (sbp->sb_shared_vn <= XFS_SB_MAX_SHARED_VN)));
> > -}
> > + /* We always support version 1-3 */
> > + if (sbp->sb_versionnum >= XFS_SB_VERSION_1 &&
> > + sbp->sb_versionnum <= XFS_SB_VERSION_3)
> > + return 1;
> > +
> > + /* We support version 4 if all feature bits are supported */
> > + if (XFS_SB_VERSION_NUM(sbp) == XFS_SB_VERSION_4) {
> > + if ((sbp->sb_versionnum & ~XFS_SB_VERSION_OKREALBITS) ||
> > + ((sbp->sb_versionnum & XFS_SB_VERSION_MOREBITSBIT) &&
> > + (sbp->sb_features2 & ~XFS_SB_VERSION2_OKREALBITS)))
> > + return 0;
> > +
> > +#ifdef __KERNEL__
> > + if (sbp->sb_shared_vn > XFS_SB_MAX_SHARED_VN)
> > + return 0;
> > #else
> > -static inline int xfs_sb_good_version(xfs_sb_t *sbp)
> > -{
> > - return (((sbp->sb_versionnum >= XFS_SB_VERSION_1) && \
> > - (sbp->sb_versionnum <= XFS_SB_VERSION_3)) || \
> > - ((XFS_SB_VERSION_NUM(sbp) == XFS_SB_VERSION_4) && \
> > - !((sbp->sb_versionnum & ~XFS_SB_VERSION_OKREALBITS) || \
> > - ((sbp->sb_versionnum & XFS_SB_VERSION_MOREBITSBIT) && \
> > - (sbp->sb_features2 & ~XFS_SB_VERSION2_OKREALBITS))) && \
> > - (!(sbp->sb_versionnum & XFS_SB_VERSION_SHAREDBIT) || \
> > - (sbp->sb_shared_vn <= XFS_SB_MAX_SHARED_VN))));
> > + if ((sbp->sb_versionnum & XFS_SB_VERSION_SHAREDBIT) &&
> > + sbp->sb_shared_vn > XFS_SB_MAX_SHARED_VN)
> > + return 0;
> > +#endif
> > +
> > + return 1;
> > + }
> > +
> > + return 0;
> > }
> > -#endif /* __KERNEL__ */
> >
> > /*
> > * Detect a mismatched features2 field. Older kernels read/wrote
> > @@ -333,123 +337,127 @@
> >
> > static inline unsigned xfs_sb_version_tonew(unsigned v)
> > {
> > - return ((((v) == XFS_SB_VERSION_1) ? \
> > - 0 : \
> > - (((v) == XFS_SB_VERSION_2) ? \
> > - XFS_SB_VERSION_ATTRBIT : \
> > - (XFS_SB_VERSION_ATTRBIT | XFS_SB_VERSION_NLINKBIT))) | \
> > - XFS_SB_VERSION_4);
> > + if (v == XFS_SB_VERSION_1)
> > + return XFS_SB_VERSION_4;
> > +
> > + if (v == XFS_SB_VERSION_2)
> > + return XFS_SB_VERSION_4 | XFS_SB_VERSION_ATTRBIT;
> > +
> > + return XFS_SB_VERSION_4 | XFS_SB_VERSION_ATTRBIT |
> > + XFS_SB_VERSION_NLINKBIT;
> > }
> >
> > static inline unsigned xfs_sb_version_toold(unsigned v)
> > {
> > - return (((v) & (XFS_SB_VERSION_QUOTABIT | XFS_SB_VERSION_ALIGNBIT)) ? \
> > - 0 : \
> > - (((v) & XFS_SB_VERSION_NLINKBIT) ? \
> > - XFS_SB_VERSION_3 : \
> > - (((v) & XFS_SB_VERSION_ATTRBIT) ? \
> > - XFS_SB_VERSION_2 : \
> > - XFS_SB_VERSION_1)));
> > + if (v & (XFS_SB_VERSION_QUOTABIT | XFS_SB_VERSION_ALIGNBIT))
> > + return 0;
> > + if (v & XFS_SB_VERSION_NLINKBIT)
> > + return XFS_SB_VERSION_3;
> > + if (v & XFS_SB_VERSION_ATTRBIT)
> > + return XFS_SB_VERSION_2;
> > + return XFS_SB_VERSION_1;
> > }
> >
> > static inline int xfs_sb_version_hasattr(xfs_sb_t *sbp)
> > {
> > - return ((sbp)->sb_versionnum == XFS_SB_VERSION_2) || \
> > - ((sbp)->sb_versionnum == XFS_SB_VERSION_3) || \
> > - ((XFS_SB_VERSION_NUM(sbp) == XFS_SB_VERSION_4) && \
> > - ((sbp)->sb_versionnum & XFS_SB_VERSION_ATTRBIT));
> > + return sbp->sb_versionnum == XFS_SB_VERSION_2 ||
> > + sbp->sb_versionnum == XFS_SB_VERSION_3 ||
> > + (XFS_SB_VERSION_NUM(sbp) == XFS_SB_VERSION_4 &&
> > + (sbp->sb_versionnum & XFS_SB_VERSION_ATTRBIT));
> > }
> >
> > static inline void xfs_sb_version_addattr(xfs_sb_t *sbp)
> > {
> > - (sbp)->sb_versionnum = (((sbp)->sb_versionnum == XFS_SB_VERSION_1) ? \
> > - XFS_SB_VERSION_2 : \
> > - ((XFS_SB_VERSION_NUM(sbp) == XFS_SB_VERSION_4) ? \
> > - ((sbp)->sb_versionnum | XFS_SB_VERSION_ATTRBIT) : \
> > - (XFS_SB_VERSION_4 | XFS_SB_VERSION_ATTRBIT)));
> > + if (sbp->sb_versionnum == XFS_SB_VERSION_1)
> > + sbp->sb_versionnum = XFS_SB_VERSION_2;
> > + else if (XFS_SB_VERSION_NUM(sbp) == XFS_SB_VERSION_4)
> > + sbp->sb_versionnum |= XFS_SB_VERSION_ATTRBIT;
> > + else
> > + sbp->sb_versionnum = XFS_SB_VERSION_4 | XFS_SB_VERSION_ATTRBIT;
> > }
> >
> > static inline int xfs_sb_version_hasnlink(xfs_sb_t *sbp)
> > {
> > - return ((sbp)->sb_versionnum == XFS_SB_VERSION_3) || \
> > - ((XFS_SB_VERSION_NUM(sbp) == XFS_SB_VERSION_4) && \
> > - ((sbp)->sb_versionnum & XFS_SB_VERSION_NLINKBIT));
> > + return sbp->sb_versionnum == XFS_SB_VERSION_3 ||
> > + (XFS_SB_VERSION_NUM(sbp) == XFS_SB_VERSION_4 &&
> > + (sbp->sb_versionnum & XFS_SB_VERSION_NLINKBIT));
> > }
> >
> > static inline void xfs_sb_version_addnlink(xfs_sb_t *sbp)
> > {
> > - (sbp)->sb_versionnum = ((sbp)->sb_versionnum <= XFS_SB_VERSION_2 ? \
> > - XFS_SB_VERSION_3 : \
> > - ((sbp)->sb_versionnum | XFS_SB_VERSION_NLINKBIT));
> > + if (sbp->sb_versionnum <= XFS_SB_VERSION_2)
> > + sbp->sb_versionnum = XFS_SB_VERSION_3;
> > + else
> > + sbp->sb_versionnum |= XFS_SB_VERSION_NLINKBIT;
> > }
> >
> > static inline int xfs_sb_version_hasquota(xfs_sb_t *sbp)
> > {
> > - return (XFS_SB_VERSION_NUM(sbp) == XFS_SB_VERSION_4) && \
> > - ((sbp)->sb_versionnum & XFS_SB_VERSION_QUOTABIT);
> > + return XFS_SB_VERSION_NUM(sbp) == XFS_SB_VERSION_4 &&
> > + (sbp->sb_versionnum & XFS_SB_VERSION_QUOTABIT);
> > }
> >
> > static inline void xfs_sb_version_addquota(xfs_sb_t *sbp)
> > {
> > - (sbp)->sb_versionnum = \
> > - (XFS_SB_VERSION_NUM(sbp) == XFS_SB_VERSION_4 ? \
> > - ((sbp)->sb_versionnum | XFS_SB_VERSION_QUOTABIT) : \
> > - (xfs_sb_version_tonew((sbp)->sb_versionnum) | \
> > - XFS_SB_VERSION_QUOTABIT));
> > + if (XFS_SB_VERSION_NUM(sbp) == XFS_SB_VERSION_4)
> > + sbp->sb_versionnum |= XFS_SB_VERSION_QUOTABIT;
> > + else
> > + sbp->sb_versionnum = xfs_sb_version_tonew(sbp->sb_versionnum) |
> > + XFS_SB_VERSION_QUOTABIT;
> > }
> >
> > static inline int xfs_sb_version_hasalign(xfs_sb_t *sbp)
> > {
> > - return (XFS_SB_VERSION_NUM(sbp) == XFS_SB_VERSION_4) && \
> > - ((sbp)->sb_versionnum & XFS_SB_VERSION_ALIGNBIT);
> > + return XFS_SB_VERSION_NUM(sbp) == XFS_SB_VERSION_4 &&
> > + (sbp->sb_versionnum & XFS_SB_VERSION_ALIGNBIT);
> > }
> >
> > static inline int xfs_sb_version_hasdalign(xfs_sb_t *sbp)
> > {
> > - return (XFS_SB_VERSION_NUM(sbp) == XFS_SB_VERSION_4) && \
> > - ((sbp)->sb_versionnum & XFS_SB_VERSION_DALIGNBIT);
> > + return XFS_SB_VERSION_NUM(sbp) == XFS_SB_VERSION_4 &&
> > + (sbp->sb_versionnum & XFS_SB_VERSION_DALIGNBIT);
> > }
> >
> > static inline int xfs_sb_version_hasshared(xfs_sb_t *sbp)
> > {
> > - return (XFS_SB_VERSION_NUM(sbp) == XFS_SB_VERSION_4) && \
> > - ((sbp)->sb_versionnum & XFS_SB_VERSION_SHAREDBIT);
> > + return XFS_SB_VERSION_NUM(sbp) == XFS_SB_VERSION_4 &&
> > + (sbp->sb_versionnum & XFS_SB_VERSION_SHAREDBIT);
> > }
> >
> > static inline int xfs_sb_version_hasdirv2(xfs_sb_t *sbp)
> > {
> > - return (XFS_SB_VERSION_NUM(sbp) == XFS_SB_VERSION_4) && \
> > - ((sbp)->sb_versionnum & XFS_SB_VERSION_DIRV2BIT);
> > + return XFS_SB_VERSION_NUM(sbp) == XFS_SB_VERSION_4 &&
> > + (sbp->sb_versionnum & XFS_SB_VERSION_DIRV2BIT);
> > }
> >
> > static inline int xfs_sb_version_haslogv2(xfs_sb_t *sbp)
> > {
> > - return (XFS_SB_VERSION_NUM(sbp) == XFS_SB_VERSION_4) && \
> > - ((sbp)->sb_versionnum & XFS_SB_VERSION_LOGV2BIT);
> > + return XFS_SB_VERSION_NUM(sbp) == XFS_SB_VERSION_4 &&
> > + (sbp->sb_versionnum & XFS_SB_VERSION_LOGV2BIT);
> > }
> >
> > static inline int xfs_sb_version_hasextflgbit(xfs_sb_t *sbp)
> > {
> > - return (XFS_SB_VERSION_NUM(sbp) == XFS_SB_VERSION_4) && \
> > - ((sbp)->sb_versionnum & XFS_SB_VERSION_EXTFLGBIT);
> > + return XFS_SB_VERSION_NUM(sbp) == XFS_SB_VERSION_4 &&
> > + (sbp->sb_versionnum & XFS_SB_VERSION_EXTFLGBIT);
> > }
> >
> > static inline int xfs_sb_version_hassector(xfs_sb_t *sbp)
> > {
> > - return (XFS_SB_VERSION_NUM(sbp) == XFS_SB_VERSION_4) && \
> > - ((sbp)->sb_versionnum & XFS_SB_VERSION_SECTORBIT);
> > + return XFS_SB_VERSION_NUM(sbp) == XFS_SB_VERSION_4 &&
> > + (sbp->sb_versionnum & XFS_SB_VERSION_SECTORBIT);
> > }
> >
> > static inline int xfs_sb_version_hasasciici(xfs_sb_t *sbp)
> > {
> > - return (XFS_SB_VERSION_NUM(sbp) == XFS_SB_VERSION_4) && \
> > + return XFS_SB_VERSION_NUM(sbp) == XFS_SB_VERSION_4 &&
> > (sbp->sb_versionnum & XFS_SB_VERSION_BORGBIT);
> > }
> >
> > static inline int xfs_sb_version_hasmorebits(xfs_sb_t *sbp)
> > {
> > - return (XFS_SB_VERSION_NUM(sbp) == XFS_SB_VERSION_4) && \
> > - ((sbp)->sb_versionnum & XFS_SB_VERSION_MOREBITSBIT);
> > + return XFS_SB_VERSION_NUM(sbp) == XFS_SB_VERSION_4 &&
> > + (sbp->sb_versionnum & XFS_SB_VERSION_MOREBITSBIT);
> > }
> >
> > /*
> > @@ -464,22 +472,20 @@
> >
> > static inline int xfs_sb_version_haslazysbcount(xfs_sb_t *sbp)
> > {
> > - return (xfs_sb_version_hasmorebits(sbp) && \
> > - ((sbp)->sb_features2 & XFS_SB_VERSION2_LAZYSBCOUNTBIT));
> > + return xfs_sb_version_hasmorebits(sbp) &&
> > + (sbp->sb_features2 & XFS_SB_VERSION2_LAZYSBCOUNTBIT);
> > }
> >
> > static inline int xfs_sb_version_hasattr2(xfs_sb_t *sbp)
> > {
> > - return (xfs_sb_version_hasmorebits(sbp)) && \
> > - ((sbp)->sb_features2 & XFS_SB_VERSION2_ATTR2BIT);
> > + return xfs_sb_version_hasmorebits(sbp) &&
> > + (sbp->sb_features2 & XFS_SB_VERSION2_ATTR2BIT);
> > }
> >
> > static inline void xfs_sb_version_addattr2(xfs_sb_t *sbp)
> > {
> > - ((sbp)->sb_versionnum = \
> > - ((sbp)->sb_versionnum | XFS_SB_VERSION_MOREBITSBIT), \
> > - ((sbp)->sb_features2 = \
> > - ((sbp)->sb_features2 | XFS_SB_VERSION2_ATTR2BIT)));
> > + sbp->sb_versionnum |= XFS_SB_VERSION_MOREBITSBIT;
> > + sbp->sb_features2 |= XFS_SB_VERSION2_ATTR2BIT;
> > }
> >
> > static inline void xfs_sb_version_removeattr2(xfs_sb_t *sbp)
> > Index: xfs-cmds/xfsprogs/include/xfs_trans.h
> > ===================================================================
> > --- xfs-cmds.orig/xfsprogs/include/xfs_trans.h 2008-12-06 20:05:46.000000000 +0100
> > +++ xfs-cmds/xfsprogs/include/xfs_trans.h 2008-12-06 20:05:49.000000000 +0100
> > @@ -768,6 +768,7 @@
> > xfs_lsn_t li_lsn; /* last on-disk lsn */
> > struct xfs_log_item_desc *li_desc; /* ptr to current desc*/
> > struct xfs_mount *li_mountp; /* ptr to fs mount */
> > + struct xfs_ail *li_ailp; /* ptr to AIL */
> > uint li_type; /* item type */
> > uint li_flags; /* misc flags */
> > struct xfs_log_item *li_bio_list; /* buffer item list */
> > @@ -970,10 +971,6 @@
> > void xfs_trans_cancel(xfs_trans_t *, int);
> > int xfs_trans_ail_init(struct xfs_mount *);
> > void xfs_trans_ail_destroy(struct xfs_mount *);
> > -void xfs_trans_push_ail(struct xfs_mount *, xfs_lsn_t);
> > -xfs_lsn_t xfs_trans_tail_ail(struct xfs_mount *);
> > -void xfs_trans_unlocked_item(struct xfs_mount *,
> > - xfs_log_item_t *);
> > xfs_log_busy_slot_t *xfs_trans_add_busy(xfs_trans_t *tp,
> > xfs_agnumber_t ag,
> > xfs_extlen_t idx);
> > Index: xfs-cmds/xfsprogs/db/bmap.c
> > ===================================================================
> > --- xfs-cmds.orig/xfsprogs/db/bmap.c 2008-12-06 20:05:46.000000000 +0100
> > +++ xfs-cmds/xfsprogs/db/bmap.c 2008-12-06 20:05:49.000000000 +0100
> > @@ -171,9 +171,9 @@
> > push_cur();
> > set_cur_inode(iocur_top->ino);
> > dip = iocur_top->data;
> > - if (be32_to_cpu(dip->di_core.di_nextents))
> > + if (dip->di_nextents)
> > dfork = 1;
> > - if (be16_to_cpu(dip->di_core.di_anextents))
> > + if (dip->di_anextents)
> > afork = 1;
> > pop_cur();
> > }
> > Index: xfs-cmds/xfsprogs/db/check.c
> > ===================================================================
> > --- xfs-cmds.orig/xfsprogs/db/check.c 2008-12-06 20:05:46.000000000 +0100
> > +++ xfs-cmds/xfsprogs/db/check.c 2008-12-06 20:05:49.000000000 +0100
> > @@ -2502,23 +2502,23 @@
> > inodata_t *id,
> > xfs_ino_t *parent)
> > {
> > - xfs_fsize_t size = be64_to_cpu(dip->di_core.di_size);
> > + xfs_fsize_t size = be64_to_cpu(dip->di_size);
> >
> > if (size <= XFS_DFORK_DSIZE(dip, mp) &&
> > - dip->di_core.di_format == XFS_DINODE_FMT_LOCAL)
> > + dip->di_format == XFS_DINODE_FMT_LOCAL)
> > *parent = process_shortform_dir_v1(dip, dot, dotdot, id);
> > else if (size == XFS_LBSIZE(mp) &&
> > - (dip->di_core.di_format == XFS_DINODE_FMT_EXTENTS ||
> > - dip->di_core.di_format == XFS_DINODE_FMT_BTREE))
> > + (dip->di_format == XFS_DINODE_FMT_EXTENTS ||
> > + dip->di_format == XFS_DINODE_FMT_BTREE))
> > *parent = process_leaf_dir_v1(blkmap, dot, dotdot, id);
> > else if (size >= XFS_LBSIZE(mp) &&
> > - (dip->di_core.di_format == XFS_DINODE_FMT_EXTENTS ||
> > - dip->di_core.di_format == XFS_DINODE_FMT_BTREE))
> > + (dip->di_format == XFS_DINODE_FMT_EXTENTS ||
> > + dip->di_format == XFS_DINODE_FMT_BTREE))
> > *parent = process_node_dir_v1(blkmap, dot, dotdot, id);
> > else {
> > dbprintf("bad size (%lld) or format (%d) for directory inode "
> > "%lld\n",
> > - size, dip->di_core.di_format, id->ino);
> > + size, dip->di_format, id->ino);
> > error++;
> > return 1;
> > }
> > @@ -2535,25 +2535,25 @@
> > xfs_ino_t *parent)
> > {
> > xfs_fileoff_t last = 0;
> > - xfs_fsize_t size = be64_to_cpu(dip->di_core.di_size);
> > + xfs_fsize_t size = be64_to_cpu(dip->di_size);
> >
> > if (blkmap)
> > last = blkmap_last_off(blkmap);
> > if (size <= XFS_DFORK_DSIZE(dip, mp) &&
> > - dip->di_core.di_format == XFS_DINODE_FMT_LOCAL)
> > + dip->di_format == XFS_DINODE_FMT_LOCAL)
> > *parent = process_sf_dir_v2(dip, dot, dotdot, id);
> > else if (last == mp->m_dirblkfsbs &&
> > - (dip->di_core.di_format == XFS_DINODE_FMT_EXTENTS ||
> > - dip->di_core.di_format == XFS_DINODE_FMT_BTREE))
> > + (dip->di_format == XFS_DINODE_FMT_EXTENTS ||
> > + dip->di_format == XFS_DINODE_FMT_BTREE))
> > *parent = process_block_dir_v2(blkmap, dot, dotdot, id);
> > else if (last >= mp->m_dirleafblk + mp->m_dirblkfsbs &&
> > - (dip->di_core.di_format == XFS_DINODE_FMT_EXTENTS ||
> > - dip->di_core.di_format == XFS_DINODE_FMT_BTREE))
> > + (dip->di_format == XFS_DINODE_FMT_EXTENTS ||
> > + dip->di_format == XFS_DINODE_FMT_BTREE))
> > *parent = process_leaf_node_dir_v2(blkmap, dot, dotdot, id, size);
> > else {
> > dbprintf("bad size (%lld) or format (%d) for directory inode "
> > "%lld\n",
> > - size, dip->di_core.di_format, id->ino);
> > + size, dip->di_format, id->ino);
> > error++;
> > return 1;
> > }
> > @@ -2639,7 +2639,7 @@
> > "dev", "local", "extents", "btree", "uuid"
> > };
> >
> > - libxfs_dinode_from_disk(&idic, &dip->di_core);
> > + libxfs_dinode_from_disk(&idic, dip);
> >
> > ino = XFS_AGINO_TO_INO(mp, be32_to_cpu(agf->agf_seqno), agino);
> > if (!isfree) {
> > @@ -2669,7 +2669,7 @@
> > idic.di_nblocks, ino);
> > error++;
> > }
> > - if (idic.di_version == XFS_DINODE_VERSION_1)
> > + if (idic.di_version == 1)
> > nlink = idic.di_onlink;
> > else
> > nlink = idic.di_nlink;
> > @@ -2773,7 +2773,7 @@
> > type = DBM_UNKNOWN;
> > break;
> > }
> > - if (idic.di_version == XFS_DINODE_VERSION_1)
> > + if (idic.di_version == 1)
> > setlink_inode(id, idic.di_onlink, type == DBM_DIR, security);
> > else {
> > sbversion |= XFS_SB_VERSION_NLINKBIT;
> > @@ -2901,12 +2901,12 @@
> > xfs_fsblock_t bno;
> >
> > bno = XFS_INO_TO_FSB(mp, id->ino);
> > - if (whichfork == XFS_DATA_FORK && be64_to_cpu(dip->di_core.di_size) >
> > + if (whichfork == XFS_DATA_FORK && be64_to_cpu(dip->di_size) >
> > XFS_DFORK_DSIZE(dip, mp)) {
> > if (!sflag || id->ilist || CHECK_BLIST(bno))
> > dbprintf("local inode %lld data is too large (size "
> > "%lld)\n",
> > - id->ino, be64_to_cpu(dip->di_core.di_size));
> > + id->ino, be64_to_cpu(dip->di_size));
> > error++;
> > }
> > else if (whichfork == XFS_ATTR_FORK) {
> > @@ -3638,7 +3638,7 @@
> > offset = XFS_DIR2_DATA_FIRST_OFFSET;
> > for (i = sf->hdr.count - 1, i8 = 0; i >= 0; i--) {
> > if ((__psint_t)sfe + xfs_dir2_sf_entsize_byentry(sf, sfe) -
> > - (__psint_t)sf > be64_to_cpu(dip->di_core.di_size)) {
> > + (__psint_t)sf > be64_to_cpu(dip->di_size)) {
> > if (!sflag)
> > dbprintf("dir %llu bad size in entry at %d\n",
> > id->ino,
> > @@ -3680,10 +3680,10 @@
> > sfe = xfs_dir2_sf_nextentry(sf, sfe);
> > }
> > if (i < 0 && (__psint_t)sfe - (__psint_t)sf !=
> > - be64_to_cpu(dip->di_core.di_size)) {
> > + be64_to_cpu(dip->di_size)) {
> > if (!sflag)
> > dbprintf("dir %llu size is %lld, should be %u\n",
> > - id->ino, be64_to_cpu(dip->di_core.di_size),
> > + id->ino, be64_to_cpu(dip->di_size),
> > (uint)((char *)sfe - (char *)sf));
> > error++;
> > }
> > @@ -3760,9 +3760,9 @@
> > sfe->namelen, sfe->namelen, sfe->name, lino);
> > sfe = xfs_dir_sf_nextentry(sfe);
> > }
> > - if ((__psint_t)sfe - (__psint_t)sf != be64_to_cpu(dip->di_core.di_size))
> > + if ((__psint_t)sfe - (__psint_t)sf != be64_to_cpu(dip->di_size))
> > dbprintf("dir %llu size is %lld, should be %d\n",
> > - id->ino, be64_to_cpu(dip->di_core.di_size),
> > + id->ino, be64_to_cpu(dip->di_size),
> > (int)((char *)sfe - (char *)sf));
> > lino = XFS_GET_DIR_INO8(sf->hdr.parent);
> > cid = find_inode(lino, 1);
> > Index: xfs-cmds/xfsprogs/db/dir2sf.c
> > ===================================================================
> > --- xfs-cmds.orig/xfsprogs/db/dir2sf.c 2008-12-06 20:05:46.000000000 +0100
> > +++ xfs-cmds/xfsprogs/db/dir2sf.c 2008-12-06 20:05:49.000000000 +0100
> > @@ -73,10 +73,10 @@
> > void *obj,
> > int startoff)
> > {
> > - xfs_dir2_sf_t *sf;
> > + xfs_dinode_t *dip = obj;
> > + xfs_dir2_sf_t *sf = (xfs_dir2_sf_t *)XFS_DFORK_DPTR(dip);
> >
> > ASSERT(bitoffs(startoff) == 0);
> > - sf = &((xfs_dinode_t *)obj)->di_u.di_dir2sf;
> > return sf->hdr.i8count == 0;
> > }
> >
> > @@ -86,10 +86,10 @@
> > void *obj,
> > int startoff)
> > {
> > - xfs_dir2_sf_t *sf;
> > + xfs_dinode_t *dip = obj;
> > + xfs_dir2_sf_t *sf = (xfs_dir2_sf_t *)XFS_DFORK_DPTR(dip);
> >
> > ASSERT(bitoffs(startoff) == 0);
> > - sf = &((xfs_dinode_t *)obj)->di_u.di_dir2sf;
> > return sf->hdr.i8count != 0;
> > }
> >
> > @@ -100,11 +100,11 @@
> > int startoff,
> > int idx)
> > {
> > - xfs_dir2_sf_t *sf;
> > + xfs_dinode_t *dip = obj;
> > + xfs_dir2_sf_t *sf = (xfs_dir2_sf_t *)XFS_DFORK_DPTR(dip);
> >
> > ASSERT(bitoffs(startoff) == 0);
> > ASSERT(idx == 0);
> > - sf = &((xfs_dinode_t *)obj)->di_u.di_dir2sf;
> > return bitize(sf->hdr.i8count ?
> > (uint)sizeof(xfs_dir2_ino8_t) :
> > (uint)sizeof(xfs_dir2_ino4_t));
> > Index: xfs-cmds/xfsprogs/db/field.c
> > ===================================================================
> > --- xfs-cmds.orig/xfsprogs/db/field.c 2008-12-06 20:05:46.000000000 +0100
> > +++ xfs-cmds/xfsprogs/db/field.c 2008-12-06 20:05:49.000000000 +0100
> > @@ -150,8 +150,6 @@
> > FTARG_DONULL, fa_dfsbno, NULL },
> > { FLDT_DINODE_A, "dinode_a", NULL, (char *)inode_a_flds, inode_a_size,
> > FTARG_SIZE|FTARG_OKEMPTY, NULL, inode_a_flds },
> > - { FLDT_DINODE_CORE, "dinode_core", NULL, (char *)inode_core_flds,
> > - SI(bitsz(xfs_dinode_core_t)), 0, NULL, inode_core_flds },
> > { FLDT_DINODE_FMT, "dinode_fmt", fp_dinode_fmt, NULL,
> > SI(bitsz(__int8_t)), 0, NULL, NULL },
> > { FLDT_DINODE_U, "dinode_u", NULL, (char *)inode_u_flds, inode_u_size,
> > Index: xfs-cmds/xfsprogs/db/field.h
> > ===================================================================
> > --- xfs-cmds.orig/xfsprogs/db/field.h 2008-12-06 20:05:46.000000000 +0100
> > +++ xfs-cmds/xfsprogs/db/field.h 2008-12-06 20:05:49.000000000 +0100
> > @@ -72,7 +72,6 @@
> > FLDT_DFILOFFD,
> > FLDT_DFSBNO,
> > FLDT_DINODE_A,
> > - FLDT_DINODE_CORE,
> > FLDT_DINODE_FMT,
> > FLDT_DINODE_U,
> > FLDT_DIR,
> > Index: xfs-cmds/xfsprogs/db/frag.c
> > ===================================================================
> > --- xfs-cmds.orig/xfsprogs/db/frag.c 2008-12-06 20:05:46.000000000 +0100
> > +++ xfs-cmds/xfsprogs/db/frag.c 2008-12-06 20:05:49.000000000 +0100
> > @@ -308,20 +308,18 @@
> > xfs_dinode_t *dip)
> > {
> > __uint64_t actual;
> > - xfs_dinode_core_t *dic;
> > __uint64_t ideal;
> > xfs_ino_t ino;
> > int skipa;
> > int skipd;
> >
> > - dic = &dip->di_core;
> > ino = XFS_AGINO_TO_INO(mp, be32_to_cpu(agf->agf_seqno), agino);
> > - switch (be16_to_cpu(dic->di_mode) & S_IFMT) {
> > + switch (be16_to_cpu(dip->di_mode) & S_IFMT) {
> > case S_IFDIR:
> > skipd = !dflag;
> > break;
> > case S_IFREG:
> > - if (!rflag && (be16_to_cpu(dic->di_flags) & XFS_DIFLAG_REALTIME))
> > + if (!rflag && (be16_to_cpu(dip->di_flags) & XFS_DIFLAG_REALTIME))
> > skipd = 1;
> > else if (!Rflag &&
> > (ino == mp->m_sb.sb_rbmino ||
> > Index: xfs-cmds/xfsprogs/db/inode.c
> > ===================================================================
> > --- xfs-cmds.orig/xfsprogs/db/inode.c 2008-12-06 20:05:46.000000000 +0100
> > +++ xfs-cmds/xfsprogs/db/inode.c 2008-12-06 20:05:49.000000000 +0100
> > @@ -40,6 +40,7 @@
> > static int inode_core_projid_count(void *obj, int startoff);
> > static int inode_core_nlinkv1_count(void *obj, int startoff);
> > static int inode_f(int argc, char **argv);
> > +static int inode_u_offset(void *obj, int startoff, int idx);
> > static int inode_u_bmbt_count(void *obj, int startoff);
> > static int inode_u_bmx_count(void *obj, int startoff);
> > static int inode_u_c_count(void *obj, int startoff);
> > @@ -60,91 +61,85 @@
> >
> > #define OFF(f) bitize(offsetof(xfs_dinode_t, di_ ## f))
> > const field_t inode_flds[] = {
> > - { "core", FLDT_DINODE_CORE, OI(OFF(core)), C1, 0, TYP_NONE },
> > - { "next_unlinked", FLDT_AGINO, OI(OFF(next_unlinked)), C1, 0,
> > - TYP_INODE },
> > - { "u", FLDT_DINODE_U, OI(OFF(u)), C1, 0, TYP_NONE },
> > - { "a", FLDT_DINODE_A, inode_a_offset, inode_a_count,
> > - FLD_COUNT|FLD_OFFSET, TYP_NONE },
> > - { NULL }
> > -};
> > -
> > -#define COFF(f) bitize(offsetof(xfs_dinode_core_t, di_ ## f))
> > -const field_t inode_core_flds[] = {
> > - { "magic", FLDT_UINT16X, OI(COFF(magic)), C1, 0, TYP_NONE },
> > - { "mode", FLDT_UINT16O, OI(COFF(mode)), C1, 0, TYP_NONE },
> > - { "version", FLDT_INT8D, OI(COFF(version)), C1, 0, TYP_NONE },
> > - { "format", FLDT_DINODE_FMT, OI(COFF(format)), C1, 0, TYP_NONE },
> > - { "nlinkv1", FLDT_UINT16D, OI(COFF(onlink)), inode_core_nlinkv1_count,
> > + { "magic", FLDT_UINT16X, OI(OFF(magic)), C1, 0, TYP_NONE },
> > + { "mode", FLDT_UINT16O, OI(OFF(mode)), C1, 0, TYP_NONE },
> > + { "version", FLDT_INT8D, OI(OFF(version)), C1, 0, TYP_NONE },
> > + { "format", FLDT_DINODE_FMT, OI(OFF(format)), C1, 0, TYP_NONE },
> > + { "nlinkv1", FLDT_UINT16D, OI(OFF(onlink)), inode_core_nlinkv1_count,
> > FLD_COUNT, TYP_NONE },
> > - { "nlinkv2", FLDT_UINT32D, OI(COFF(nlink)), inode_core_nlinkv2_count,
> > + { "nlinkv2", FLDT_UINT32D, OI(OFF(nlink)), inode_core_nlinkv2_count,
> > FLD_COUNT, TYP_NONE },
> > - { "onlink", FLDT_UINT16D, OI(COFF(onlink)), inode_core_onlink_count,
> > + { "onlink", FLDT_UINT16D, OI(OFF(onlink)), inode_core_onlink_count,
> > FLD_COUNT, TYP_NONE },
> > - { "projid", FLDT_UINT16D, OI(COFF(projid)), inode_core_projid_count,
> > + { "projid", FLDT_UINT16D, OI(OFF(projid)), inode_core_projid_count,
> > FLD_COUNT, TYP_NONE },
> > - { "uid", FLDT_UINT32D, OI(COFF(uid)), C1, 0, TYP_NONE },
> > - { "gid", FLDT_UINT32D, OI(COFF(gid)), C1, 0, TYP_NONE },
> > - { "flushiter", FLDT_UINT16D, OI(COFF(flushiter)), C1, 0, TYP_NONE },
> > - { "atime", FLDT_TIMESTAMP, OI(COFF(atime)), C1, 0, TYP_NONE },
> > - { "mtime", FLDT_TIMESTAMP, OI(COFF(mtime)), C1, 0, TYP_NONE },
> > - { "ctime", FLDT_TIMESTAMP, OI(COFF(ctime)), C1, 0, TYP_NONE },
> > - { "size", FLDT_FSIZE, OI(COFF(size)), C1, 0, TYP_NONE },
> > - { "nblocks", FLDT_DRFSBNO, OI(COFF(nblocks)), C1, 0, TYP_NONE },
> > - { "extsize", FLDT_EXTLEN, OI(COFF(extsize)), C1, 0, TYP_NONE },
> > - { "nextents", FLDT_EXTNUM, OI(COFF(nextents)), C1, 0, TYP_NONE },
> > - { "naextents", FLDT_AEXTNUM, OI(COFF(anextents)), C1, 0, TYP_NONE },
> > - { "forkoff", FLDT_UINT8D, OI(COFF(forkoff)), C1, 0, TYP_NONE },
> > - { "aformat", FLDT_DINODE_FMT, OI(COFF(aformat)), C1, 0, TYP_NONE },
> > - { "dmevmask", FLDT_UINT32X, OI(COFF(dmevmask)), C1, 0, TYP_NONE },
> > - { "dmstate", FLDT_UINT16D, OI(COFF(dmstate)), C1, 0, TYP_NONE },
> > - { "flags", FLDT_UINT16X, OI(COFF(flags)), C1, FLD_SKIPALL, TYP_NONE },
> > + { "uid", FLDT_UINT32D, OI(OFF(uid)), C1, 0, TYP_NONE },
> > + { "gid", FLDT_UINT32D, OI(OFF(gid)), C1, 0, TYP_NONE },
> > + { "flushiter", FLDT_UINT16D, OI(OFF(flushiter)), C1, 0, TYP_NONE },
> > + { "atime", FLDT_TIMESTAMP, OI(OFF(atime)), C1, 0, TYP_NONE },
> > + { "mtime", FLDT_TIMESTAMP, OI(OFF(mtime)), C1, 0, TYP_NONE },
> > + { "ctime", FLDT_TIMESTAMP, OI(OFF(ctime)), C1, 0, TYP_NONE },
> > + { "size", FLDT_FSIZE, OI(OFF(size)), C1, 0, TYP_NONE },
> > + { "nblocks", FLDT_DRFSBNO, OI(OFF(nblocks)), C1, 0, TYP_NONE },
> > + { "extsize", FLDT_EXTLEN, OI(OFF(extsize)), C1, 0, TYP_NONE },
> > + { "nextents", FLDT_EXTNUM, OI(OFF(nextents)), C1, 0, TYP_NONE },
> > + { "naextents", FLDT_AEXTNUM, OI(OFF(anextents)), C1, 0, TYP_NONE },
> > + { "forkoff", FLDT_UINT8D, OI(OFF(forkoff)), C1, 0, TYP_NONE },
> > + { "aformat", FLDT_DINODE_FMT, OI(OFF(aformat)), C1, 0, TYP_NONE },
> > + { "dmevmask", FLDT_UINT32X, OI(OFF(dmevmask)), C1, 0, TYP_NONE },
> > + { "dmstate", FLDT_UINT16D, OI(OFF(dmstate)), C1, 0, TYP_NONE },
> > + { "flags", FLDT_UINT16X, OI(OFF(flags)), C1, FLD_SKIPALL, TYP_NONE },
> > { "newrtbm", FLDT_UINT1,
> > - OI(COFF(flags) + bitsz(__uint16_t) - XFS_DIFLAG_NEWRTBM_BIT - 1), C1,
> > + OI(OFF(flags) + bitsz(__uint16_t) - XFS_DIFLAG_NEWRTBM_BIT - 1), C1,
> > 0, TYP_NONE },
> > { "prealloc", FLDT_UINT1,
> > - OI(COFF(flags) + bitsz(__uint16_t) - XFS_DIFLAG_PREALLOC_BIT - 1), C1,
> > + OI(OFF(flags) + bitsz(__uint16_t) - XFS_DIFLAG_PREALLOC_BIT - 1), C1,
> > 0, TYP_NONE },
> > { "realtime", FLDT_UINT1,
> > - OI(COFF(flags) + bitsz(__uint16_t) - XFS_DIFLAG_REALTIME_BIT - 1), C1,
> > + OI(OFF(flags) + bitsz(__uint16_t) - XFS_DIFLAG_REALTIME_BIT - 1), C1,
> > 0, TYP_NONE },
> > { "immutable", FLDT_UINT1,
> > - OI(COFF(flags) + bitsz(__uint16_t) - XFS_DIFLAG_IMMUTABLE_BIT-1), C1,
> > + OI(OFF(flags) + bitsz(__uint16_t) - XFS_DIFLAG_IMMUTABLE_BIT-1), C1,
> > 0, TYP_NONE },
> > { "append", FLDT_UINT1,
> > - OI(COFF(flags) + bitsz(__uint16_t) - XFS_DIFLAG_APPEND_BIT - 1), C1,
> > + OI(OFF(flags) + bitsz(__uint16_t) - XFS_DIFLAG_APPEND_BIT - 1), C1,
> > 0, TYP_NONE },
> > { "sync", FLDT_UINT1,
> > - OI(COFF(flags) + bitsz(__uint16_t) - XFS_DIFLAG_SYNC_BIT - 1), C1,
> > + OI(OFF(flags) + bitsz(__uint16_t) - XFS_DIFLAG_SYNC_BIT - 1), C1,
> > 0, TYP_NONE },
> > { "noatime", FLDT_UINT1,
> > - OI(COFF(flags) + bitsz(__uint16_t) - XFS_DIFLAG_NOATIME_BIT - 1), C1,
> > + OI(OFF(flags) + bitsz(__uint16_t) - XFS_DIFLAG_NOATIME_BIT - 1), C1,
> > 0, TYP_NONE },
> > { "nodump", FLDT_UINT1,
> > - OI(COFF(flags) + bitsz(__uint16_t) - XFS_DIFLAG_NODUMP_BIT - 1), C1,
> > + OI(OFF(flags) + bitsz(__uint16_t) - XFS_DIFLAG_NODUMP_BIT - 1), C1,
> > 0, TYP_NONE },
> > { "rtinherit", FLDT_UINT1,
> > - OI(COFF(flags) + bitsz(__uint16_t) - XFS_DIFLAG_RTINHERIT_BIT-1), C1,
> > + OI(OFF(flags) + bitsz(__uint16_t) - XFS_DIFLAG_RTINHERIT_BIT-1), C1,
> > 0, TYP_NONE },
> > { "projinherit", FLDT_UINT1,
> > - OI(COFF(flags) + bitsz(__uint16_t) - XFS_DIFLAG_PROJINHERIT_BIT-1),C1,
> > + OI(OFF(flags) + bitsz(__uint16_t) - XFS_DIFLAG_PROJINHERIT_BIT-1),C1,
> > 0, TYP_NONE },
> > { "nosymlinks", FLDT_UINT1,
> > - OI(COFF(flags) + bitsz(__uint16_t) - XFS_DIFLAG_NOSYMLINKS_BIT-1), C1,
> > + OI(OFF(flags) + bitsz(__uint16_t) - XFS_DIFLAG_NOSYMLINKS_BIT-1), C1,
> > 0, TYP_NONE },
> > { "extsz", FLDT_UINT1,
> > - OI(COFF(flags) + bitsz(__uint16_t) - XFS_DIFLAG_EXTSIZE_BIT-1),C1,
> > + OI(OFF(flags) + bitsz(__uint16_t) - XFS_DIFLAG_EXTSIZE_BIT-1),C1,
> > 0, TYP_NONE },
> > { "extszinherit", FLDT_UINT1,
> > - OI(COFF(flags) + bitsz(__uint16_t) - XFS_DIFLAG_EXTSZINHERIT_BIT-1),C1,
> > + OI(OFF(flags) + bitsz(__uint16_t) - XFS_DIFLAG_EXTSZINHERIT_BIT-1),C1,
> > 0, TYP_NONE },
> > { "nodefrag", FLDT_UINT1,
> > - OI(COFF(flags) + bitsz(__uint16_t) - XFS_DIFLAG_NODEFRAG_BIT-1),C1,
> > + OI(OFF(flags) + bitsz(__uint16_t) - XFS_DIFLAG_NODEFRAG_BIT-1),C1,
> > 0, TYP_NONE },
> > { "filestream", FLDT_UINT1,
> > - OI(COFF(flags) + bitsz(__uint16_t) - XFS_DIFLAG_FILESTREAM_BIT-1),C1,
> > + OI(OFF(flags) + bitsz(__uint16_t) - XFS_DIFLAG_FILESTREAM_BIT-1),C1,
> > 0, TYP_NONE },
> > - { "gen", FLDT_UINT32D, OI(COFF(gen)), C1, 0, TYP_NONE },
> > + { "gen", FLDT_UINT32D, OI(OFF(gen)), C1, 0, TYP_NONE },
> > + { "next_unlinked", FLDT_AGINO, OI(OFF(next_unlinked)), C1, 0,
> > + TYP_INODE },
> > + { "u", FLDT_DINODE_U, inode_u_offset, C1, FLD_OFFSET, TYP_NONE },
> > + { "a", FLDT_DINODE_A, inode_a_offset, inode_a_count,
> > + FLD_COUNT|FLD_OFFSET, TYP_NONE },
> > { NULL }
> > };
> >
> > @@ -226,7 +221,7 @@
> > if (!XFS_DFORK_Q(dip))
> > return 0;
> > ASSERT((char *)XFS_DFORK_APTR(dip) - (char *)dip == byteize(startoff));
> > - return dip->di_core.di_aformat == XFS_DINODE_FMT_BTREE;
> > + return dip->di_aformat == XFS_DINODE_FMT_BTREE;
> > }
> >
> > static int
> > @@ -242,8 +237,8 @@
> > if (!XFS_DFORK_Q(dip))
> > return 0;
> > ASSERT((char *)XFS_DFORK_APTR(dip) - (char *)dip == byteize(startoff));
> > - return dip->di_core.di_aformat == XFS_DINODE_FMT_EXTENTS ?
> > - be16_to_cpu(dip->di_core.di_anextents) : 0;
> > + return dip->di_aformat == XFS_DINODE_FMT_EXTENTS ?
> > + be16_to_cpu(dip->di_anextents) : 0;
> > }
> >
> > static int
> > @@ -251,10 +246,9 @@
> > void *obj,
> > int startoff)
> > {
> > - xfs_dinode_t *dip;
> > + xfs_dinode_t *dip = obj;
> >
> > ASSERT(startoff == 0);
> > - dip = obj;
> > return XFS_DFORK_Q(dip);
> > }
> >
> > @@ -264,11 +258,10 @@
> > int startoff,
> > int idx)
> > {
> > - xfs_dinode_t *dip;
> > + xfs_dinode_t *dip = obj;
> >
> > ASSERT(startoff == 0);
> > ASSERT(idx == 0);
> > - dip = obj;
> > ASSERT(XFS_DFORK_Q(dip));
> > return bitize((int)((char *)XFS_DFORK_APTR(dip) - (char *)dip));
> > }
> > @@ -286,7 +279,7 @@
> > if (!XFS_DFORK_Q(dip))
> > return 0;
> > ASSERT((char *)XFS_DFORK_APTR(dip) - (char *)dip == byteize(startoff));
> > - return dip->di_core.di_aformat == XFS_DINODE_FMT_LOCAL;
> > + return dip->di_aformat == XFS_DINODE_FMT_LOCAL;
> > }
> >
> > int
> > @@ -301,12 +294,12 @@
> > ASSERT(startoff == 0);
> > ASSERT(idx == 0);
> > dip = obj;
> > - switch (dip->di_core.di_aformat) {
> > + switch (dip->di_aformat) {
> > case XFS_DINODE_FMT_LOCAL:
> > asf = (xfs_attr_shortform_t *)XFS_DFORK_APTR(dip);
> > return bitize(be16_to_cpu(asf->hdr.totsize));
> > case XFS_DINODE_FMT_EXTENTS:
> > - return (int)be16_to_cpu(dip->di_core.di_anextents) *
> > + return (int)be16_to_cpu(dip->di_anextents) *
> > bitsz(xfs_bmbt_rec_t);
> > case XFS_DINODE_FMT_BTREE:
> > return bitize((int)XFS_DFORK_ASIZE(dip, mp));
> > @@ -320,12 +313,11 @@
> > void *obj,
> > int startoff)
> > {
> > - xfs_dinode_core_t *dic;
> > + xfs_dinode_t *dip = obj;
> >
> > ASSERT(startoff == 0);
> > ASSERT(obj == iocur_top->data);
> > - dic = obj;
> > - return dic->di_version == XFS_DINODE_VERSION_1;
> > + return dip->di_version == 1;
> > }
> >
> > static int
> > @@ -333,12 +325,11 @@
> > void *obj,
> > int startoff)
> > {
> > - xfs_dinode_core_t *dic;
> > + xfs_dinode_t *dip = obj;
> >
> > ASSERT(startoff == 0);
> > ASSERT(obj == iocur_top->data);
> > - dic = obj;
> > - return dic->di_version == XFS_DINODE_VERSION_2;
> > + return dip->di_version == 2;
> > }
> >
> > static int
> > @@ -346,12 +337,11 @@
> > void *obj,
> > int startoff)
> > {
> > - xfs_dinode_core_t *dic;
> > + xfs_dinode_t *dip = obj;
> >
> > ASSERT(startoff == 0);
> > ASSERT(obj == iocur_top->data);
> > - dic = obj;
> > - return dic->di_version == XFS_DINODE_VERSION_2;
> > + return dip->di_version == 2;
> > }
> >
> > static int
> > @@ -359,12 +349,11 @@
> > void *obj,
> > int startoff)
> > {
> > - xfs_dinode_core_t *dic;
> > + xfs_dinode_t *dip = obj;
> >
> > ASSERT(startoff == 0);
> > ASSERT(obj == iocur_top->data);
> > - dic = obj;
> > - return dic->di_version == XFS_DINODE_VERSION_2;
> > + return dip->di_version == 2;
> > }
> >
> > static int
> > @@ -428,17 +417,29 @@
> > }
> >
> > static int
> > +inode_u_offset(
> > + void *obj,
> > + int startoff,
> > + int idx)
> > +{
> > + xfs_dinode_t *dip = obj;
> > +
> > + ASSERT(startoff == 0);
> > + ASSERT(idx == 0);
> > + return bitize((int)((char *)XFS_DFORK_DPTR(dip) - (char *)dip));
> > +}
> > +
> > +static int
> > inode_u_bmbt_count(
> > void *obj,
> > int startoff)
> > {
> > - xfs_dinode_t *dip;
> > + xfs_dinode_t *dip = obj;
> >
> > ASSERT(bitoffs(startoff) == 0);
> > ASSERT(obj == iocur_top->data);
> > - dip = obj;
> > - ASSERT((char *)&dip->di_u - (char *)dip == byteize(startoff));
> > - return dip->di_core.di_format == XFS_DINODE_FMT_BTREE;
> > + ASSERT(XFS_DFORK_DPTR(dip) - (char *)dip == byteize(startoff));
> > + return dip->di_format == XFS_DINODE_FMT_BTREE;
> > }
> >
> > static int
> > @@ -446,14 +447,13 @@
> > void *obj,
> > int startoff)
> > {
> > - xfs_dinode_t *dip;
> > + xfs_dinode_t *dip = obj;
> >
> > ASSERT(bitoffs(startoff) == 0);
> > ASSERT(obj == iocur_top->data);
> > - dip = obj;
> > - ASSERT((char *)&dip->di_u - (char *)dip == byteize(startoff));
> > - return dip->di_core.di_format == XFS_DINODE_FMT_EXTENTS ?
> > - be32_to_cpu(dip->di_core.di_nextents) : 0;
> > + ASSERT(XFS_DFORK_DPTR(dip) - (char *)dip == byteize(startoff));
> > + return dip->di_format == XFS_DINODE_FMT_EXTENTS ?
> > + be32_to_cpu(dip->di_nextents) : 0;
> > }
> >
> > static int
> > @@ -461,15 +461,14 @@
> > void *obj,
> > int startoff)
> > {
> > - xfs_dinode_t *dip;
> > + xfs_dinode_t *dip = obj;
> >
> > ASSERT(bitoffs(startoff) == 0);
> > ASSERT(obj == iocur_top->data);
> > - dip = obj;
> > - ASSERT((char *)&dip->di_u - (char *)dip == byteize(startoff));
> > - return dip->di_core.di_format == XFS_DINODE_FMT_LOCAL &&
> > - (be16_to_cpu(dip->di_core.di_mode) & S_IFMT) == S_IFREG ?
> > - (int)be64_to_cpu(dip->di_core.di_size) : 0;
> > + ASSERT(XFS_DFORK_DPTR(dip) - (char *)dip == byteize(startoff));
> > + return dip->di_format == XFS_DINODE_FMT_LOCAL &&
> > + (be16_to_cpu(dip->di_mode) & S_IFMT) == S_IFREG ?
> > + (int)be64_to_cpu(dip->di_size) : 0;
> > }
> >
> > static int
> > @@ -477,13 +476,12 @@
> > void *obj,
> > int startoff)
> > {
> > - xfs_dinode_t *dip;
> > + xfs_dinode_t *dip = obj;
> >
> > ASSERT(bitoffs(startoff) == 0);
> > ASSERT(obj == iocur_top->data);
> > - dip = obj;
> > - ASSERT((char *)&dip->di_u - (char *)dip == byteize(startoff));
> > - return dip->di_core.di_format == XFS_DINODE_FMT_DEV;
> > + ASSERT(XFS_DFORK_DPTR(dip) - (char *)dip == byteize(startoff));
> > + return dip->di_format == XFS_DINODE_FMT_DEV;
> > }
> >
> > static int
> > @@ -491,13 +489,12 @@
> > void *obj,
> > int startoff)
> > {
> > - xfs_dinode_t *dip;
> > + xfs_dinode_t *dip = obj;
> >
> > ASSERT(bitoffs(startoff) == 0);
> > ASSERT(obj == iocur_top->data);
> > - dip = obj;
> > - ASSERT((char *)&dip->di_u - (char *)dip == byteize(startoff));
> > - return dip->di_core.di_format == XFS_DINODE_FMT_UUID;
> > + ASSERT(XFS_DFORK_DPTR(dip) - (char *)dip == byteize(startoff));
> > + return dip->di_format == XFS_DINODE_FMT_UUID;
> > }
> >
> > static int
> > @@ -505,14 +502,13 @@
> > void *obj,
> > int startoff)
> > {
> > - xfs_dinode_t *dip;
> > + xfs_dinode_t *dip = obj;
> >
> > ASSERT(bitoffs(startoff) == 0);
> > ASSERT(obj == iocur_top->data);
> > - dip = obj;
> > - ASSERT((char *)&dip->di_u - (char *)dip == byteize(startoff));
> > - return dip->di_core.di_format == XFS_DINODE_FMT_LOCAL &&
> > - (be16_to_cpu(dip->di_core.di_mode) & S_IFMT) == S_IFDIR
> > + ASSERT(XFS_DFORK_DPTR(dip) - (char *)dip == byteize(startoff));
> > + return dip->di_format == XFS_DINODE_FMT_LOCAL &&
> > + (be16_to_cpu(dip->di_mode) & S_IFMT) == S_IFDIR
> > && !xfs_sb_version_hasdirv2(&mp->m_sb);
> > }
> >
> > @@ -521,14 +517,13 @@
> > void *obj,
> > int startoff)
> > {
> > - xfs_dinode_t *dip;
> > + xfs_dinode_t *dip = obj;
> >
> > ASSERT(bitoffs(startoff) == 0);
> > ASSERT(obj == iocur_top->data);
> > - dip = obj;
> > - ASSERT((char *)&dip->di_u - (char *)dip == byteize(startoff));
> > - return dip->di_core.di_format == XFS_DINODE_FMT_LOCAL &&
> > - (be16_to_cpu(dip->di_core.di_mode) & S_IFMT) == S_IFDIR &&
> > + ASSERT(XFS_DFORK_DPTR(dip) - (char *)dip == byteize(startoff));
> > + return dip->di_format == XFS_DINODE_FMT_LOCAL &&
> > + (be16_to_cpu(dip->di_mode) & S_IFMT) == S_IFDIR &&
> > xfs_sb_version_hasdirv2(&mp->m_sb);
> > }
> >
> > @@ -543,13 +538,13 @@
> > ASSERT(startoff == 0);
> > ASSERT(idx == 0);
> > dip = obj;
> > - switch (dip->di_core.di_format) {
> > + switch (dip->di_format) {
> > case XFS_DINODE_FMT_DEV:
> > return bitsz(xfs_dev_t);
> > case XFS_DINODE_FMT_LOCAL:
> > - return bitize((int)be64_to_cpu(dip->di_core.di_size));
> > + return bitize((int)be64_to_cpu(dip->di_size));
> > case XFS_DINODE_FMT_EXTENTS:
> > - return (int)be32_to_cpu(dip->di_core.di_nextents) *
> > + return (int)be32_to_cpu(dip->di_nextents) *
> > bitsz(xfs_bmbt_rec_t);
> > case XFS_DINODE_FMT_BTREE:
> > return bitize((int)XFS_DFORK_DSIZE(dip, mp));
> > @@ -565,15 +560,14 @@
> > void *obj,
> > int startoff)
> > {
> > - xfs_dinode_t *dip;
> > + xfs_dinode_t *dip = obj;
> >
> > ASSERT(bitoffs(startoff) == 0);
> > ASSERT(obj == iocur_top->data);
> > - dip = obj;
> > - ASSERT((char *)&dip->di_u - (char *)dip == byteize(startoff));
> > - return dip->di_core.di_format == XFS_DINODE_FMT_LOCAL &&
> > - (be16_to_cpu(dip->di_core.di_mode) & S_IFMT) == S_IFLNK ?
> > - (int)be64_to_cpu(dip->di_core.di_size) : 0;
> > + ASSERT(XFS_DFORK_DPTR(dip) - (char *)dip == byteize(startoff));
> > + return dip->di_format == XFS_DINODE_FMT_LOCAL &&
> > + (be16_to_cpu(dip->di_mode) & S_IFMT) == S_IFLNK ?
> > + (int)be64_to_cpu(dip->di_size) : 0;
> > }
> >
> > void
> > @@ -609,7 +603,7 @@
> > off_cur(offset << mp->m_sb.sb_inodelog, mp->m_sb.sb_inodesize);
> > dip = iocur_top->data;
> > iocur_top->ino = ino;
> > - iocur_top->mode = be16_to_cpu(dip->di_core.di_mode);
> > + iocur_top->mode = be16_to_cpu(dip->di_mode);
> > if ((iocur_top->mode & S_IFMT) == S_IFDIR)
> > iocur_top->dirino = ino;
> >
> > Index: xfs-cmds/xfsprogs/db/inode.h
> > ===================================================================
> > --- xfs-cmds.orig/xfsprogs/db/inode.h 2008-12-06 20:05:46.000000000 +0100
> > +++ xfs-cmds/xfsprogs/db/inode.h 2008-12-06 20:05:49.000000000 +0100
> > @@ -17,7 +17,7 @@
> > */
> >
> > extern const struct field inode_a_flds[];
> > -extern const struct field inode_core_flds[];
> > +extern const struct field inode_flds[];
> > extern const struct field inode_flds[];
> > extern const struct field inode_hfld[];
> > extern const struct field inode_u_flds[];
> > Index: xfs-cmds/xfsprogs/db/metadump.c
> > ===================================================================
> > --- xfs-cmds.orig/xfsprogs/db/metadump.c 2008-12-06 20:05:46.000000000 +0100
> > +++ xfs-cmds/xfsprogs/db/metadump.c 2008-12-06 20:05:49.000000000 +0100
> > @@ -501,8 +501,8 @@
> > __uint64_t ino_dir_size;
> > int i;
> >
> > - sfp = &dip->di_u.di_dir2sf;
> > - ino_dir_size = be64_to_cpu(dip->di_core.di_size);
> > + sfp = (xfs_dir2_sf_t *)XFS_DFORK_DPTR(dip);
> > + ino_dir_size = be64_to_cpu(dip->di_size);
> > if (ino_dir_size > XFS_DFORK_DSIZE(dip, mp)) {
> > ino_dir_size = XFS_DFORK_DSIZE(dip, mp);
> > if (show_warnings)
> > @@ -554,8 +554,9 @@
> > xfs_dinode_t *dip)
> > {
> > __uint64_t len;
> > + char *symlink = XFS_DFORK_DPTR(dip);
> >
> > - len = be64_to_cpu(dip->di_core.di_size);
> > + len = be64_to_cpu(dip->di_size);
> > if (len > XFS_DFORK_DSIZE(dip, mp)) {
> > if (show_warnings)
> > print_warning("invalid size (%d) in symlink inode %llu",
> > @@ -564,7 +565,7 @@
> > }
> >
> > while (len > 0)
> > - dip->di_u.di_symlink[--len] = random() % 127 + 1;
> > + symlink[--len] = random() % 127 + 1;
> > }
> >
> > static void
> > @@ -1142,27 +1143,24 @@
> > xfs_dinode_t *dip,
> > typnm_t itype)
> > {
> > - switch (dip->di_core.di_format) {
> > - case XFS_DINODE_FMT_LOCAL:
> > - if (!dont_obfuscate)
> > - switch (itype) {
> > - case TYP_DIR2:
> > - obfuscate_sf_dir(dip);
> > - break;
> > -
> > - case TYP_SYMLINK:
> > - obfuscate_sf_symlink(dip);
> > - break;
> > -
> > - default: ;
> > - }
> > - break;
> > -
> > - case XFS_DINODE_FMT_EXTENTS:
> > - return process_exinode(dip, itype);
> > -
> > - case XFS_DINODE_FMT_BTREE:
> > - return process_btinode(dip, itype);
> > + switch (dip->di_format) {
> > + case XFS_DINODE_FMT_LOCAL:
> > + if (!dont_obfuscate)
> > + switch (itype) {
> > + case TYP_DIR2:
> > + obfuscate_sf_dir(dip);
> > + break;
> > + case TYP_SYMLINK:
> > + obfuscate_sf_symlink(dip);
> > + break;
> > + default:
> > + ;
> > + }
> > + break;
> > + case XFS_DINODE_FMT_EXTENTS:
> > + return process_exinode(dip, itype);
> > + case XFS_DINODE_FMT_BTREE:
> > + return process_btinode(dip, itype);
> > }
> > return 1;
> > }
> > @@ -1179,7 +1177,7 @@
> > cur_ino = XFS_AGINO_TO_INO(mp, agno, agino);
> >
> > /* copy appropriate data fork metadata */
> > - switch (be16_to_cpu(dip->di_core.di_mode) & S_IFMT) {
> > + switch (be16_to_cpu(dip->di_mode) & S_IFMT) {
> > case S_IFDIR:
> > memset(&dir_data, 0, sizeof(dir_data));
> > success = process_inode_data(dip, TYP_DIR2);
> > @@ -1197,7 +1195,7 @@
> > /* copy extended attributes if they exist and forkoff is valid */
> > if (success && XFS_DFORK_DSIZE(dip, mp) < XFS_LITINO(mp)) {
> > attr_data.remote_val_count = 0;
> > - switch (dip->di_core.di_aformat) {
> > + switch (dip->di_aformat) {
> > case XFS_DINODE_FMT_LOCAL:
> > if (!dont_obfuscate)
> > obfuscate_sf_attr(dip);
> > Index: xfs-cmds/xfsprogs/libxfs/util.c
> > ===================================================================
> > --- xfs-cmds.orig/xfsprogs/libxfs/util.c 2008-12-06 20:05:45.000000000 +0100
> > +++ xfs-cmds/xfsprogs/libxfs/util.c 2008-12-06 20:05:49.000000000 +0100
> > @@ -47,126 +47,6 @@
> > }
> >
> > /*
> > - * Given a mount structure and an inode number, return a pointer
> > - * to a newly allocated in-core inode coresponding to the given
> > - * inode number.
> > - *
> > - * Initialize the inode's attributes and extent pointers if it
> > - * already has them (it will not if the inode has no links).
> > - *
> > - * NOTE: this has slightly different behaviour to the kernel in
> > - * that this version requires the already allocated *ip being
> > - * passed in while the kernel version does the allocation and
> > - * returns it in **ip.
> > - */
> > -int
> > -libxfs_iread(
> > - xfs_mount_t *mp,
> > - xfs_trans_t *tp,
> > - xfs_ino_t ino,
> > - xfs_inode_t *ip,
> > - xfs_daddr_t bno)
> > -{
> > - xfs_buf_t *bp;
> > - xfs_dinode_t *dip;
> > - int error;
> > -
> > - ip->i_ino = ino;
> > - ip->i_mount = mp;
> > -
> > - /*
> > - * Get pointer's to the on-disk inode and the buffer containing it.
> > - * If the inode number refers to a block outside the file system
> > - * then xfs_itobp() will return NULL. In this case we should
> > - * return NULL as well. Set i_blkno to 0 so that xfs_itobp() will
> > - * know that this is a new incore inode.
> > - */
> > - error = xfs_itobp(mp, tp, ip, &dip, &bp, bno, 0, XFS_BUF_LOCK);
> > - if (error)
> > - return error;
> > -
> > - /*
> > - * If we got something that isn't an inode it means someone
> > - * (nfs or dmi) has a stale handle.
> > - */
> > - if (be16_to_cpu(dip->di_core.di_magic) != XFS_DINODE_MAGIC) {
> > - xfs_trans_brelse(tp, bp);
> > - return EINVAL;
> > - }
> > -
> > - /*
> > - * If the on-disk inode is already linked to a directory
> > - * entry, copy all of the inode into the in-core inode.
> > - * xfs_iformat() handles copying in the inode format
> > - * specific information.
> > - * Otherwise, just get the truly permanent information.
> > - */
> > - if (dip->di_core.di_mode) {
> > - xfs_dinode_from_disk(&ip->i_d, &dip->di_core);
> > - error = xfs_iformat(ip, dip);
> > - if (error) {
> > - xfs_trans_brelse(tp, bp);
> > - return error;
> > - }
> > - } else {
> > - ip->i_d.di_magic = be16_to_cpu(dip->di_core.di_magic);
> > - ip->i_d.di_version = dip->di_core.di_version;
> > - ip->i_d.di_gen = be32_to_cpu(dip->di_core.di_gen);
> > - ip->i_d.di_flushiter = be16_to_cpu(dip->di_core.di_flushiter);
> > - /*
> > - * Make sure to pull in the mode here as well in
> > - * case the inode is released without being used.
> > - * This ensures that xfs_inactive() will see that
> > - * the inode is already free and not try to mess
> > - * with the uninitialized part of it.
> > - */
> > - ip->i_d.di_mode = 0;
> > - /*
> > - * Initialize the per-fork minima and maxima for a new
> > - * inode here. xfs_iformat will do it for old inodes.
> > - */
> > - ip->i_df.if_ext_max =
> > - XFS_IFORK_DSIZE(ip) / (uint)sizeof(xfs_bmbt_rec_t);
> > - }
> > -
> > - /*
> > - * The inode format changed when we moved the link count and
> > - * made it 32 bits long. If this is an old format inode,
> > - * convert it in memory to look like a new one. If it gets
> > - * flushed to disk we will convert back before flushing or
> > - * logging it. We zero out the new projid field and the old link
> > - * count field. We'll handle clearing the pad field (the remains
> > - * of the old uuid field) when we actually convert the inode to
> > - * the new format. We don't change the version number so that we
> > - * can distinguish this from a real new format inode.
> > - */
> > - if (ip->i_d.di_version == XFS_DINODE_VERSION_1) {
> > - ip->i_d.di_nlink = ip->i_d.di_onlink;
> > - ip->i_d.di_onlink = 0;
> > - ip->i_d.di_projid = 0;
> > - }
> > -
> > - ip->i_delayed_blks = 0;
> > - ip->i_size = ip->i_d.di_size;
> > -
> > - /*
> > - * Use xfs_trans_brelse() to release the buffer containing the
> > - * on-disk inode, because it was acquired with xfs_trans_read_buf()
> > - * in xfs_itobp() above. If tp is NULL, this is just a normal
> > - * brelse(). If we're within a transaction, then xfs_trans_brelse()
> > - * will only release the buffer if it is not dirty within the
> > - * transaction. It will be OK to release the buffer in this case,
> > - * because inodes on disk are never destroyed and we will be
> > - * locking the new in-core inode before putting it in the hash
> > - * table where other processes can find it. Thus we don't have
> > - * to worry about the inode being changed just because we released
> > - * the buffer.
> > - */
> > - xfs_trans_brelse(tp, bp);
> > - return 0;
> > -}
> > -
> > -/*
> > * Allocate an inode on disk and return a copy of it's in-core version.
> > * Set mode, nlink, and rdev appropriately within the inode.
> > * The uid and gid for the inode are set according to the contents of
> > @@ -229,8 +109,8 @@
> > * here rather than here and in the flush/logging code.
> > */
> > if (xfs_sb_version_hasnlink(&tp->t_mountp->m_sb) &&
> > - ip->i_d.di_version == XFS_DINODE_VERSION_1) {
> > - ip->i_d.di_version = XFS_DINODE_VERSION_2;
> > + ip->i_d.di_version == 1) {
> > + ip->i_d.di_version = 2;
> > /* old link count, projid field, pad field already zeroed */
> > }
> >
> > @@ -395,7 +275,7 @@
> > mp = ip->i_mount;
> >
> > /* set *dip = inode's place in the buffer */
> > - dip = (xfs_dinode_t *)xfs_buf_offset(bp, ip->i_boffset);
> > + dip = (xfs_dinode_t *)xfs_buf_offset(bp, ip->i_imap.im_boffset);
> >
> > ASSERT(ip->i_d.di_magic == XFS_DINODE_MAGIC);
> > if ((ip->i_d.di_mode & S_IFMT) == S_IFREG) {
> > @@ -416,7 +296,7 @@
> > * because if the inode is dirty at all the core must
> > * be.
> > */
> > - xfs_dinode_to_disk(&dip->di_core, &ip->i_d);
> > + xfs_dinode_to_disk(dip, &ip->i_d);
> >
> > /*
> > * If this is really an old format inode and the superblock version
> > @@ -424,28 +304,26 @@
> > * convert back to the old inode format. If the superblock version
> > * has been updated, then make the conversion permanent.
> > */
> > - ASSERT(ip->i_d.di_version == XFS_DINODE_VERSION_1 ||
> > - xfs_sb_version_hasnlink(&mp->m_sb));
> > - if (ip->i_d.di_version == XFS_DINODE_VERSION_1) {
> > + ASSERT(ip->i_d.di_version == 1 || xfs_sb_version_hasnlink(&mp->m_sb));
> > + if (ip->i_d.di_version == 1) {
> > if (!xfs_sb_version_hasnlink(&mp->m_sb)) {
> > /*
> > * Convert it back.
> > */
> > ASSERT(ip->i_d.di_nlink <= XFS_MAXLINK_1);
> > - dip->di_core.di_onlink = cpu_to_be16(ip->i_d.di_nlink);
> > + dip->di_onlink = cpu_to_be16(ip->i_d.di_nlink);
> > } else {
> > /*
> > * The superblock version has already been bumped,
> > * so just make the conversion to the new inode
> > * format permanent.
> > */
> > - ip->i_d.di_version = XFS_DINODE_VERSION_2;
> > - dip->di_core.di_version = XFS_DINODE_VERSION_2;
> > + ip->i_d.di_version = 2;
> > + dip->di_version = 2;
> > ip->i_d.di_onlink = 0;
> > - dip->di_core.di_onlink = 0;
> > - memset(&(ip->i_d.di_pad[0]), 0, sizeof(ip->i_d.di_pad));
> > - memset(&(dip->di_core.di_pad[0]), 0,
> > - sizeof(dip->di_core.di_pad));
> > + dip->di_onlink = 0;
> > + memset(&ip->i_d.di_pad[0], 0, sizeof(ip->i_d.di_pad));
> > + memset(&dip->di_pad[0], 0, sizeof(dip->di_pad));
> > ASSERT(ip->i_d.di_projid == 0);
> > }
> > }
> > Index: xfs-cmds/xfsprogs/libxfs/xfs_alloc.c
> > ===================================================================
> > --- xfs-cmds.orig/xfsprogs/libxfs/xfs_alloc.c 2008-12-06 20:05:46.000000000 +0100
> > +++ xfs-cmds/xfsprogs/libxfs/xfs_alloc.c 2008-12-06 20:05:49.000000000 +0100
> > @@ -2064,44 +2064,41 @@
> > * Read in the allocation group header (free/alloc section).
> > */
> > int /* error */
> > -xfs_alloc_read_agf(
> > - xfs_mount_t *mp, /* mount point structure */
> > - xfs_trans_t *tp, /* transaction pointer */
> > - xfs_agnumber_t agno, /* allocation group number */
> > - int flags, /* XFS_ALLOC_FLAG_... */
> > - xfs_buf_t **bpp) /* buffer for the ag freelist header */
> > +xfs_read_agf(
> > + struct xfs_mount *mp, /* mount point structure */
> > + struct xfs_trans *tp, /* transaction pointer */
> > + xfs_agnumber_t agno, /* allocation group number */
> > + int flags, /* XFS_BUF_ */
> > + struct xfs_buf **bpp) /* buffer for the ag freelist header */
> > {
> > - xfs_agf_t *agf; /* ag freelist header */
> > + struct xfs_agf *agf; /* ag freelist header */
> > int agf_ok; /* set if agf is consistent */
> > - xfs_buf_t *bp; /* return value */
> > - xfs_perag_t *pag; /* per allocation group data */
> > int error;
> >
> > ASSERT(agno != NULLAGNUMBER);
> > error = xfs_trans_read_buf(
> > mp, tp, mp->m_ddev_targp,
> > XFS_AG_DADDR(mp, agno, XFS_AGF_DADDR(mp)),
> > - XFS_FSS_TO_BB(mp, 1),
> > - (flags & XFS_ALLOC_FLAG_TRYLOCK) ? XFS_BUF_TRYLOCK : 0U,
> > - &bp);
> > + XFS_FSS_TO_BB(mp, 1), flags, bpp);
> > if (error)
> > return error;
> > - ASSERT(!bp || !XFS_BUF_GETERROR(bp));
> > - if (!bp) {
> > - *bpp = NULL;
> > + if (!*bpp)
> > return 0;
> > - }
> > +
> > + ASSERT(!XFS_BUF_GETERROR(*bpp));
> > + agf = XFS_BUF_TO_AGF(*bpp);
> > +
> > /*
> > * Validate the magic number of the agf block.
> > */
> > - agf = XFS_BUF_TO_AGF(bp);
> > agf_ok =
> > be32_to_cpu(agf->agf_magicnum) == XFS_AGF_MAGIC &&
> > XFS_AGF_GOOD_VERSION(be32_to_cpu(agf->agf_versionnum)) &&
> > be32_to_cpu(agf->agf_freeblks) <= be32_to_cpu(agf->agf_length) &&
> > be32_to_cpu(agf->agf_flfirst) < XFS_AGFL_SIZE(mp) &&
> > be32_to_cpu(agf->agf_fllast) < XFS_AGFL_SIZE(mp) &&
> > - be32_to_cpu(agf->agf_flcount) <= XFS_AGFL_SIZE(mp);
> > + be32_to_cpu(agf->agf_flcount) <= XFS_AGFL_SIZE(mp) &&
> > + be32_to_cpu(agf->agf_seqno) == agno;
> > if (xfs_sb_version_haslazysbcount(&mp->m_sb))
> > agf_ok = agf_ok && be32_to_cpu(agf->agf_btreeblks) <=
> > be32_to_cpu(agf->agf_length);
> > @@ -2109,9 +2106,41 @@
> > XFS_RANDOM_ALLOC_READ_AGF))) {
> > XFS_CORRUPTION_ERROR("xfs_alloc_read_agf",
> > XFS_ERRLEVEL_LOW, mp, agf);
> > - xfs_trans_brelse(tp, bp);
> > + xfs_trans_brelse(tp, *bpp);
> > return XFS_ERROR(EFSCORRUPTED);
> > }
> > +
> > + XFS_BUF_SET_VTYPE_REF(*bpp, B_FS_AGF, XFS_AGF_REF);
> > + return 0;
> > +}
> > +
> > +/*
> > + * Read in the allocation group header (free/alloc section).
> > + */
> > +int /* error */
> > +xfs_alloc_read_agf(
> > + struct xfs_mount *mp, /* mount point structure */
> > + struct xfs_trans *tp, /* transaction pointer */
> > + xfs_agnumber_t agno, /* allocation group number */
> > + int flags, /* XFS_ALLOC_FLAG_... */
> > + struct xfs_buf **bpp) /* buffer for the ag freelist header */
> > +{
> > + struct xfs_agf *agf; /* ag freelist header */
> > + struct xfs_perag *pag; /* per allocation group data */
> > + int error;
> > +
> > + ASSERT(agno != NULLAGNUMBER);
> > +
> > + error = xfs_read_agf(mp, tp, agno,
> > + (flags & XFS_ALLOC_FLAG_TRYLOCK) ? XFS_BUF_TRYLOCK : 0,
> > + bpp);
> > + if (error)
> > + return error;
> > + if (!*bpp)
> > + return 0;
> > + ASSERT(!XFS_BUF_GETERROR(*bpp));
> > +
> > + agf = XFS_BUF_TO_AGF(*bpp);
> > pag = &mp->m_perag[agno];
> > if (!pag->pagf_init) {
> > pag->pagf_freeblks = be32_to_cpu(agf->agf_freeblks);
> > @@ -2139,8 +2168,6 @@
> > be32_to_cpu(agf->agf_levels[XFS_BTNUM_CNTi]));
> > }
> > #endif
> > - XFS_BUF_SET_VTYPE_REF(bp, B_FS_AGF, XFS_AGF_REF);
> > - *bpp = bp;
> > return 0;
> > }
> >
> > Index: xfs-cmds/xfsprogs/libxfs/xfs_ialloc.c
> > ===================================================================
> > --- xfs-cmds.orig/xfsprogs/libxfs/xfs_ialloc.c 2008-12-06 20:05:45.000000000 +0100
> > +++ xfs-cmds/xfsprogs/libxfs/xfs_ialloc.c 2008-12-06 20:05:49.000000000 +0100
> > @@ -22,68 +22,6 @@
> > * Internal functions.
> > */
> >
> > -/*
> > - * Log specified fields for the inode given by bp and off.
> > - */
> > -STATIC void
> > -xfs_ialloc_log_di(
> > - xfs_trans_t *tp, /* transaction pointer */
> > - xfs_buf_t *bp, /* inode buffer */
> > - int off, /* index of inode in buffer */
> > - int fields) /* bitmask of fields to log */
> > -{
> > - int first; /* first byte number */
> > - int ioffset; /* off in bytes */
> > - int last; /* last byte number */
> > - xfs_mount_t *mp; /* mount point structure */
> > - static const short offsets[] = { /* field offsets */
> > - /* keep in sync with bits */
> > - offsetof(xfs_dinode_core_t, di_magic),
> > - offsetof(xfs_dinode_core_t, di_mode),
> > - offsetof(xfs_dinode_core_t, di_version),
> > - offsetof(xfs_dinode_core_t, di_format),
> > - offsetof(xfs_dinode_core_t, di_onlink),
> > - offsetof(xfs_dinode_core_t, di_uid),
> > - offsetof(xfs_dinode_core_t, di_gid),
> > - offsetof(xfs_dinode_core_t, di_nlink),
> > - offsetof(xfs_dinode_core_t, di_projid),
> > - offsetof(xfs_dinode_core_t, di_pad),
> > - offsetof(xfs_dinode_core_t, di_atime),
> > - offsetof(xfs_dinode_core_t, di_mtime),
> > - offsetof(xfs_dinode_core_t, di_ctime),
> > - offsetof(xfs_dinode_core_t, di_size),
> > - offsetof(xfs_dinode_core_t, di_nblocks),
> > - offsetof(xfs_dinode_core_t, di_extsize),
> > - offsetof(xfs_dinode_core_t, di_nextents),
> > - offsetof(xfs_dinode_core_t, di_anextents),
> > - offsetof(xfs_dinode_core_t, di_forkoff),
> > - offsetof(xfs_dinode_core_t, di_aformat),
> > - offsetof(xfs_dinode_core_t, di_dmevmask),
> > - offsetof(xfs_dinode_core_t, di_dmstate),
> > - offsetof(xfs_dinode_core_t, di_flags),
> > - offsetof(xfs_dinode_core_t, di_gen),
> > - offsetof(xfs_dinode_t, di_next_unlinked),
> > - offsetof(xfs_dinode_t, di_u),
> > - offsetof(xfs_dinode_t, di_a),
> > - sizeof(xfs_dinode_t)
> > - };
> > -
> > -
> > - ASSERT(offsetof(xfs_dinode_t, di_core) == 0);
> > - ASSERT((fields & (XFS_DI_U|XFS_DI_A)) == 0);
> > - mp = tp->t_mountp;
> > - /*
> > - * Get the inode-relative first and last bytes for these fields
> > - */
> > - xfs_btree_offsets(fields, offsets, XFS_DI_NUM_BITS, &first, &last);
> > - /*
> > - * Convert to buffer offsets and log it.
> > - */
> > - ioffset = off << mp->m_sb.sb_inodelog;
> > - first += ioffset;
> > - last += ioffset;
> > - xfs_trans_log_buf(tp, bp, first, last);
> > -}
> >
> > /*
> > * Allocation group level functions.
> > @@ -364,9 +302,9 @@
> > * able to use the file system.
> > */
> > if (xfs_sb_version_hasnlink(&args.mp->m_sb))
> > - version = XFS_DINODE_VERSION_2;
> > + version = 2;
> > else
> > - version = XFS_DINODE_VERSION_1;
> > + version = 1;
> >
> > /*
> > * Seed the new inode cluster with a random generation number. This
> > @@ -387,18 +325,25 @@
> > XFS_BUF_LOCK);
> > ASSERT(fbuf);
> > ASSERT(!XFS_BUF_GETERROR(fbuf));
> > +
> > /*
> > - * Set initial values for the inodes in this buffer.
> > + * Initialize all inodes in this buffer and then log them.
> > + *
> > + * XXX: It would be much better if we had just one transaction to
> > + * log a whole cluster of inodes instead of all the indivdual
> > + * transactions causing a lot of log traffic.
> > */
> > xfs_biozero(fbuf, 0, ninodes << args.mp->m_sb.sb_inodelog);
> > for (i = 0; i < ninodes; i++) {
> > + int ioffset = i << args.mp->m_sb.sb_inodelog;
> > + uint isize = sizeof(struct xfs_dinode);
> > +
> > free = XFS_MAKE_IPTR(args.mp, fbuf, i);
> > - free->di_core.di_magic = cpu_to_be16(XFS_DINODE_MAGIC);
> > - free->di_core.di_version = version;
> > - free->di_core.di_gen = cpu_to_be32(gen);
> > + free->di_magic = cpu_to_be16(XFS_DINODE_MAGIC);
> > + free->di_version = version;
> > + free->di_gen = cpu_to_be32(gen);
> > free->di_next_unlinked = cpu_to_be32(NULLAGINO);
> > - xfs_ialloc_log_di(tp, fbuf, i,
> > - XFS_DI_CORE_BITS | XFS_DI_NEXT_UNLINKED);
> > + xfs_trans_log_buf(tp, fbuf, ioffset, ioffset + isize - 1);
> > }
> > xfs_trans_inode_alloc_buf(tp, fbuf);
> > }
> > @@ -1019,38 +964,29 @@
> > return error;
> > }
> >
> > -
> > /*
> > - * Return the location of the inode in bno/off, for mapping it into a buffer.
> > + * Return the location of the inode in imap, for mapping it into a buffer.
> > */
> > -/*ARGSUSED*/
> > int
> > -xfs_dilocate(
> > - xfs_mount_t *mp, /* file system mount structure */
> > - xfs_trans_t *tp, /* transaction pointer */
> > +xfs_imap(
> > + xfs_mount_t *mp, /* file system mount structure */
> > + xfs_trans_t *tp, /* transaction pointer */
> > xfs_ino_t ino, /* inode to locate */
> > - xfs_fsblock_t *bno, /* output: block containing inode */
> > - int *len, /* output: num blocks in inode cluster */
> > - int *off, /* output: index in block of inode */
> > - uint flags) /* flags concerning inode lookup */
> > + struct xfs_imap *imap, /* location map structure */
> > + uint flags) /* flags for inode btree lookup */
> > {
> > xfs_agblock_t agbno; /* block number of inode in the alloc group */
> > - xfs_buf_t *agbp; /* agi buffer */
> > xfs_agino_t agino; /* inode number within alloc group */
> > xfs_agnumber_t agno; /* allocation group number */
> > int blks_per_cluster; /* num blocks per inode cluster */
> > xfs_agblock_t chunk_agbno; /* first block in inode chunk */
> > - xfs_agino_t chunk_agino; /* first agino in inode chunk */
> > - __int32_t chunk_cnt; /* count of free inodes in chunk */
> > - xfs_inofree_t chunk_free; /* mask of free inodes in chunk */
> > xfs_agblock_t cluster_agbno; /* first block in inode cluster */
> > - xfs_btree_cur_t *cur; /* inode btree cursor */
> > int error; /* error code */
> > - int i; /* temp state */
> > int offset; /* index of inode in its buffer */
> > int offset_agbno; /* blks from chunk start to inode */
> >
> > ASSERT(ino != NULLFSINO);
> > +
> > /*
> > * Split up the inode number into its parts.
> > */
> > @@ -1061,24 +997,24 @@
> > ino != XFS_AGINO_TO_INO(mp, agno, agino)) {
> > #ifdef DEBUG
> > /* no diagnostics for bulkstat, ino comes from userspace */
> > - if (flags & XFS_IMAP_BULKSTAT)
> > + if (flags & XFS_IGET_BULKSTAT)
> > return XFS_ERROR(EINVAL);
> > if (agno >= mp->m_sb.sb_agcount) {
> > xfs_fs_cmn_err(CE_ALERT, mp,
> > - "xfs_dilocate: agno (%d) >= "
> > + "xfs_imap: agno (%d) >= "
> > "mp->m_sb.sb_agcount (%d)",
> > agno, mp->m_sb.sb_agcount);
> > }
> > if (agbno >= mp->m_sb.sb_agblocks) {
> > xfs_fs_cmn_err(CE_ALERT, mp,
> > - "xfs_dilocate: agbno (0x%llx) >= "
> > + "xfs_imap: agbno (0x%llx) >= "
> > "mp->m_sb.sb_agblocks (0x%lx)",
> > (unsigned long long) agbno,
> > (unsigned long) mp->m_sb.sb_agblocks);
> > }
> > if (ino != XFS_AGINO_TO_INO(mp, agno, agino)) {
> > xfs_fs_cmn_err(CE_ALERT, mp,
> > - "xfs_dilocate: ino (0x%llx) != "
> > + "xfs_imap: ino (0x%llx) != "
> > "XFS_AGINO_TO_INO(mp, agno, agino) "
> > "(0x%llx)",
> > ino, XFS_AGINO_TO_INO(mp, agno, agino));
> > @@ -1087,64 +1023,89 @@
> > #endif /* DEBUG */
> > return XFS_ERROR(EINVAL);
> > }
> > - if ((mp->m_sb.sb_blocksize >= XFS_INODE_CLUSTER_SIZE(mp)) ||
> > - !(flags & XFS_IMAP_LOOKUP)) {
> > +
> > + /*
> > + * If the inode cluster size is the same as the blocksize or
> > + * smaller we get to the buffer by simple arithmetics.
> > + */
> > + if (XFS_INODE_CLUSTER_SIZE(mp) <= mp->m_sb.sb_blocksize) {
> > offset = XFS_INO_TO_OFFSET(mp, ino);
> > ASSERT(offset < mp->m_sb.sb_inopblock);
> > - *bno = XFS_AGB_TO_FSB(mp, agno, agbno);
> > - *off = offset;
> > - *len = 1;
> > +
> > + imap->im_blkno = XFS_AGB_TO_DADDR(mp, agno, agbno);
> > + imap->im_len = XFS_FSB_TO_BB(mp, 1);
> > + imap->im_boffset = (ushort)(offset << mp->m_sb.sb_inodelog);
> > return 0;
> > }
> > +
> > blks_per_cluster = XFS_INODE_CLUSTER_SIZE(mp) >> mp->m_sb.sb_blocklog;
> > - if (*bno != NULLFSBLOCK) {
> > +
> > + /*
> > + * If we get a block number passed from bulkstat we can use it to
> > + * find the buffer easily.
> > + */
> > + if (imap->im_blkno) {
> > offset = XFS_INO_TO_OFFSET(mp, ino);
> > ASSERT(offset < mp->m_sb.sb_inopblock);
> > - cluster_agbno = XFS_FSB_TO_AGBNO(mp, *bno);
> > - *off = ((agbno - cluster_agbno) * mp->m_sb.sb_inopblock) +
> > - offset;
> > - *len = blks_per_cluster;
> > +
> > + cluster_agbno = XFS_DADDR_TO_AGBNO(mp, imap->im_blkno);
> > + offset += (agbno - cluster_agbno) * mp->m_sb.sb_inopblock;
> > +
> > + imap->im_len = XFS_FSB_TO_BB(mp, blks_per_cluster);
> > + imap->im_boffset = (ushort)(offset << mp->m_sb.sb_inodelog);
> > return 0;
> > }
> > +
> > + /*
> > + * If the inode chunks are aligned then use simple maths to
> > + * find the location. Otherwise we have to do a btree
> > + * lookup to find the location.
> > + */
> > if (mp->m_inoalign_mask) {
> > offset_agbno = agbno & mp->m_inoalign_mask;
> > chunk_agbno = agbno - offset_agbno;
> > } else {
> > + xfs_btree_cur_t *cur; /* inode btree cursor */
> > + xfs_agino_t chunk_agino; /* first agino in inode chunk */
> > + __int32_t chunk_cnt; /* count of free inodes in chunk */
> > + xfs_inofree_t chunk_free; /* mask of free inodes in chunk */
> > + xfs_buf_t *agbp; /* agi buffer */
> > + int i; /* temp state */
> > +
> > down_read(&mp->m_peraglock);
> > error = xfs_ialloc_read_agi(mp, tp, agno, &agbp);
> > up_read(&mp->m_peraglock);
> > if (error) {
> > -#ifdef DEBUG
> > - xfs_fs_cmn_err(CE_ALERT, mp, "xfs_dilocate: "
> > + xfs_fs_cmn_err(CE_ALERT, mp, "xfs_imap: "
> > "xfs_ialloc_read_agi() returned "
> > "error %d, agno %d",
> > error, agno);
> > -#endif /* DEBUG */
> > return error;
> > }
> > +
> > cur = xfs_inobt_init_cursor(mp, tp, agbp, agno);
> > - if ((error = xfs_inobt_lookup_le(cur, agino, 0, 0, &i))) {
> > -#ifdef DEBUG
> > - xfs_fs_cmn_err(CE_ALERT, mp, "xfs_dilocate: "
> > + error = xfs_inobt_lookup_le(cur, agino, 0, 0, &i);
> > + if (error) {
> > + xfs_fs_cmn_err(CE_ALERT, mp, "xfs_imap: "
> > "xfs_inobt_lookup_le() failed");
> > -#endif /* DEBUG */
> > goto error0;
> > }
> > - if ((error = xfs_inobt_get_rec(cur, &chunk_agino, &chunk_cnt,
> > - &chunk_free, &i))) {
> > -#ifdef DEBUG
> > - xfs_fs_cmn_err(CE_ALERT, mp, "xfs_dilocate: "
> > +
> > + error = xfs_inobt_get_rec(cur, &chunk_agino, &chunk_cnt,
> > + &chunk_free, &i);
> > + if (error) {
> > + xfs_fs_cmn_err(CE_ALERT, mp, "xfs_imap: "
> > "xfs_inobt_get_rec() failed");
> > -#endif /* DEBUG */
> > goto error0;
> > }
> > if (i == 0) {
> > #ifdef DEBUG
> > - xfs_fs_cmn_err(CE_ALERT, mp, "xfs_dilocate: "
> > + xfs_fs_cmn_err(CE_ALERT, mp, "xfs_imap: "
> > "xfs_inobt_get_rec() failed");
> > #endif /* DEBUG */
> > error = XFS_ERROR(EINVAL);
> > }
> > + error0:
> > xfs_trans_brelse(tp, agbp);
> > xfs_btree_del_cursor(cur, XFS_BTREE_NOERROR);
> > if (error)
> > @@ -1152,19 +1113,35 @@
> > chunk_agbno = XFS_AGINO_TO_AGBNO(mp, chunk_agino);
> > offset_agbno = agbno - chunk_agbno;
> > }
> > +
> > ASSERT(agbno >= chunk_agbno);
> > cluster_agbno = chunk_agbno +
> > ((offset_agbno / blks_per_cluster) * blks_per_cluster);
> > offset = ((agbno - cluster_agbno) * mp->m_sb.sb_inopblock) +
> > XFS_INO_TO_OFFSET(mp, ino);
> > - *bno = XFS_AGB_TO_FSB(mp, agno, cluster_agbno);
> > - *off = offset;
> > - *len = blks_per_cluster;
> > +
> > + imap->im_blkno = XFS_AGB_TO_DADDR(mp, agno, cluster_agbno);
> > + imap->im_len = XFS_FSB_TO_BB(mp, blks_per_cluster);
> > + imap->im_boffset = (ushort)(offset << mp->m_sb.sb_inodelog);
> > +
> > + /*
> > + * If the inode number maps to a block outside the bounds
> > + * of the file system then return NULL rather than calling
> > + * read_buf and panicing when we get an error from the
> > + * driver.
> > + */
> > + if ((imap->im_blkno + imap->im_len) >
> > + XFS_FSB_TO_BB(mp, mp->m_sb.sb_dblocks)) {
> > + xfs_fs_cmn_err(CE_ALERT, mp, "xfs_imap: "
> > + "(imap->im_blkno (0x%llx) + imap->im_len (0x%llx)) > "
> > + " XFS_FSB_TO_BB(mp, mp->m_sb.sb_dblocks) (0x%llx)",
> > + (unsigned long long) imap->im_blkno,
> > + (unsigned long long) imap->im_len,
> > + XFS_FSB_TO_BB(mp, mp->m_sb.sb_dblocks));
> > + return XFS_ERROR(EINVAL);
> > + }
> > +
> > return 0;
> > -error0:
> > - xfs_trans_brelse(tp, agbp);
> > - xfs_btree_del_cursor(cur, XFS_BTREE_ERROR);
> > - return error;
> > }
> >
> > /*
> > @@ -1232,70 +1209,95 @@
> > xfs_trans_log_buf(tp, bp, first, last);
> > }
> >
> > +#ifdef DEBUG
> > +STATIC void
> > +xfs_check_agi_unlinked(
> > + struct xfs_agi *agi)
> > +{
> > + int i;
> > +
> > + for (i = 0; i < XFS_AGI_UNLINKED_BUCKETS; i++)
> > + ASSERT(agi->agi_unlinked[i]);
> > +}
> > +#else
> > +#define xfs_check_agi_unlinked(agi)
> > +#endif
> > +
> > /*
> > * Read in the allocation group header (inode allocation section)
> > */
> > int
> > -xfs_ialloc_read_agi(
> > - xfs_mount_t *mp, /* file system mount structure */
> > - xfs_trans_t *tp, /* transaction pointer */
> > - xfs_agnumber_t agno, /* allocation group number */
> > - xfs_buf_t **bpp) /* allocation group hdr buf */
> > +xfs_read_agi(
> > + struct xfs_mount *mp, /* file system mount structure */
> > + struct xfs_trans *tp, /* transaction pointer */
> > + xfs_agnumber_t agno, /* allocation group number */
> > + struct xfs_buf **bpp) /* allocation group hdr buf */
> > {
> > - xfs_agi_t *agi; /* allocation group header */
> > - int agi_ok; /* agi is consistent */
> > - xfs_buf_t *bp; /* allocation group hdr buf */
> > - xfs_perag_t *pag; /* per allocation group data */
> > - int error;
> > + struct xfs_agi *agi; /* allocation group header */
> > + int agi_ok; /* agi is consistent */
> > + int error;
> >
> > ASSERT(agno != NULLAGNUMBER);
> > - error = xfs_trans_read_buf(
> > - mp, tp, mp->m_ddev_targp,
> > +
> > + error = xfs_trans_read_buf(mp, tp, mp->m_ddev_targp,
> > XFS_AG_DADDR(mp, agno, XFS_AGI_DADDR(mp)),
> > - XFS_FSS_TO_BB(mp, 1), 0, &bp);
> > + XFS_FSS_TO_BB(mp, 1), 0, bpp);
> > if (error)
> > return error;
> > - ASSERT(bp && !XFS_BUF_GETERROR(bp));
> > +
> > + ASSERT(*bpp && !XFS_BUF_GETERROR(*bpp));
> > + agi = XFS_BUF_TO_AGI(*bpp);
> >
> > /*
> > * Validate the magic number of the agi block.
> > */
> > - agi = XFS_BUF_TO_AGI(bp);
> > - agi_ok =
> > - be32_to_cpu(agi->agi_magicnum) == XFS_AGI_MAGIC &&
> > - XFS_AGI_GOOD_VERSION(be32_to_cpu(agi->agi_versionnum));
> > + agi_ok = be32_to_cpu(agi->agi_magicnum) == XFS_AGI_MAGIC &&
> > + XFS_AGI_GOOD_VERSION(be32_to_cpu(agi->agi_versionnum)) &&
> > + be32_to_cpu(agi->agi_seqno) == agno;
> > if (unlikely(XFS_TEST_ERROR(!agi_ok, mp, XFS_ERRTAG_IALLOC_READ_AGI,
> > XFS_RANDOM_IALLOC_READ_AGI))) {
> > - XFS_CORRUPTION_ERROR("xfs_ialloc_read_agi", XFS_ERRLEVEL_LOW,
> > + XFS_CORRUPTION_ERROR("xfs_read_agi", XFS_ERRLEVEL_LOW,
> > mp, agi);
> > - xfs_trans_brelse(tp, bp);
> > + xfs_trans_brelse(tp, *bpp);
> > return XFS_ERROR(EFSCORRUPTED);
> > }
> > +
> > + XFS_BUF_SET_VTYPE_REF(*bpp, B_FS_AGI, XFS_AGI_REF);
> > +
> > + xfs_check_agi_unlinked(agi);
> > + return 0;
> > +}
> > +
> > +int
> > +xfs_ialloc_read_agi(
> > + struct xfs_mount *mp, /* file system mount structure */
> > + struct xfs_trans *tp, /* transaction pointer */
> > + xfs_agnumber_t agno, /* allocation group number */
> > + struct xfs_buf **bpp) /* allocation group hdr buf */
> > +{
> > + struct xfs_agi *agi; /* allocation group header */
> > + struct xfs_perag *pag; /* per allocation group data */
> > + int error;
> > +
> > + error = xfs_read_agi(mp, tp, agno, bpp);
> > + if (error)
> > + return error;
> > +
> > + agi = XFS_BUF_TO_AGI(*bpp);
> > pag = &mp->m_perag[agno];
> > +
> > if (!pag->pagi_init) {
> > pag->pagi_freecount = be32_to_cpu(agi->agi_freecount);
> > pag->pagi_count = be32_to_cpu(agi->agi_count);
> > pag->pagi_init = 1;
> > - } else {
> > - /*
> > - * It's possible for these to be out of sync if
> > - * we are in the middle of a forced shutdown.
> > - */
> > - ASSERT(pag->pagi_freecount == be32_to_cpu(agi->agi_freecount) ||
> > - XFS_FORCED_SHUTDOWN(mp));
> > - }
> > -
> > -#ifdef DEBUG
> > - {
> > - int i;
> > -
> > - for (i = 0; i < XFS_AGI_UNLINKED_BUCKETS; i++)
> > - ASSERT(agi->agi_unlinked[i]);
> > }
> > -#endif
> >
> > - XFS_BUF_SET_VTYPE_REF(bp, B_FS_AGI, XFS_AGI_REF);
> > - *bpp = bp;
> > + /*
> > + * It's possible for these to be out of sync if
> > + * we are in the middle of a forced shutdown.
> > + */
> > + ASSERT(pag->pagi_freecount == be32_to_cpu(agi->agi_freecount) ||
> > + XFS_FORCED_SHUTDOWN(mp));
> > return 0;
> > }
> >
> > Index: xfs-cmds/xfsprogs/libxfs/xfs_inode.c
> > ===================================================================
> > --- xfs-cmds.orig/xfsprogs/libxfs/xfs_inode.c 2008-12-06 20:05:45.000000000 +0100
> > +++ xfs-cmds/xfsprogs/libxfs/xfs_inode.c 2008-12-06 20:05:49.000000000 +0100
> > @@ -91,10 +91,10 @@
> > xfs_imap_to_bp(
> > xfs_mount_t *mp,
> > xfs_trans_t *tp,
> > - xfs_imap_t *imap,
> > + struct xfs_imap *imap,
> > xfs_buf_t **bpp,
> > uint buf_flags,
> > - uint imap_flags)
> > + uint iget_flags)
> > {
> > int error;
> > int i;
> > @@ -131,12 +131,12 @@
> >
> > dip = (xfs_dinode_t *)xfs_buf_offset(bp,
> > (i << mp->m_sb.sb_inodelog));
> > - di_ok = be16_to_cpu(dip->di_core.di_magic) == XFS_DINODE_MAGIC &&
> > - XFS_DINODE_GOOD_VERSION(dip->di_core.di_version);
> > + di_ok = be16_to_cpu(dip->di_magic) == XFS_DINODE_MAGIC &&
> > + XFS_DINODE_GOOD_VERSION(dip->di_version);
> > if (unlikely(XFS_TEST_ERROR(!di_ok, mp,
> > XFS_ERRTAG_ITOBP_INOTOBP,
> > XFS_RANDOM_ITOBP_INOTOBP))) {
> > - if (imap_flags & XFS_IMAP_BULKSTAT) {
> > + if (iget_flags & XFS_IGET_BULKSTAT) {
> > xfs_trans_brelse(tp, bp);
> > return XFS_ERROR(EINVAL);
> > }
> > @@ -148,7 +148,7 @@
> > "daddr %lld #%d (magic=%x)",
> > XFS_BUFTARG_NAME(mp->m_ddev_targp),
> > (unsigned long long)imap->im_blkno, i,
> > - be16_to_cpu(dip->di_core.di_magic));
> > + be16_to_cpu(dip->di_magic));
> > #endif
> > xfs_trans_brelse(tp, bp);
> > return XFS_ERROR(EFSCORRUPTED);
> > @@ -167,6 +167,49 @@
> > }
> >
> > /*
> > + * This routine is called to map an inode number within a file
> > + * system to the buffer containing the on-disk version of the
> > + * inode. It returns a pointer to the buffer containing the
> > + * on-disk inode in the bpp parameter, and in the dip parameter
> > + * it returns a pointer to the on-disk inode within that buffer.
> > + *
> > + * If a non-zero error is returned, then the contents of bpp and
> > + * dipp are undefined.
> > + *
> > + * Use xfs_imap() to determine the size and location of the
> > + * buffer to read from disk.
> > + */
> > +int
> > +xfs_inotobp(
> > + xfs_mount_t *mp,
> > + xfs_trans_t *tp,
> > + xfs_ino_t ino,
> > + xfs_dinode_t **dipp,
> > + xfs_buf_t **bpp,
> > + int *offset,
> > + uint imap_flags)
> > +{
> > + struct xfs_imap imap;
> > + xfs_buf_t *bp;
> > + int error;
> > +
> > + imap.im_blkno = 0;
> > + error = xfs_imap(mp, tp, ino, &imap, imap_flags);
> > + if (error)
> > + return error;
> > +
> > + error = xfs_imap_to_bp(mp, tp, &imap, &bp, XFS_BUF_LOCK, imap_flags);
> > + if (error)
> > + return error;
> > +
> > + *dipp = (xfs_dinode_t *)xfs_buf_offset(bp, imap.im_boffset);
> > + *bpp = bp;
> > + *offset = imap.im_boffset;
> > + return 0;
> > +}
> > +
> > +
> > +/*
> > * This routine is called to map an inode to the buffer containing
> > * the on-disk version of the inode. It returns a pointer to the
> > * buffer containing the on-disk inode in the bpp parameter, and in
> > @@ -176,15 +219,11 @@
> > * If a non-zero error is returned, then the contents of bpp and
> > * dipp are undefined.
> > *
> > - * If the inode is new and has not yet been initialized, use xfs_imap()
> > - * to determine the size and location of the buffer to read from disk.
> > - * If the inode has already been mapped to its buffer and read in once,
> > - * then use the mapping information stored in the inode rather than
> > - * calling xfs_imap(). This allows us to avoid the overhead of looking
> > - * at the inode btree for small block file systems (see xfs_dilocate()).
> > - * We can tell whether the inode has been mapped in before by comparing
> > - * its disk block address to 0. Only uninitialized inodes will have
> > - * 0 for the disk block address.
> > + * The inode is expected to already been mapped to its buffer and read
> > + * in once, thus we can use the mapping information stored in the inode
> > + * rather than calling xfs_imap(). This allows us to avoid the overhead
> > + * of looking at the inode btree for small block file systems
> > + * (see xfs_imap()).
> > */
> > int
> > xfs_itobp(
> > @@ -193,40 +232,14 @@
> > xfs_inode_t *ip,
> > xfs_dinode_t **dipp,
> > xfs_buf_t **bpp,
> > - xfs_daddr_t bno,
> > - uint imap_flags,
> > uint buf_flags)
> > {
> > - xfs_imap_t imap;
> > xfs_buf_t *bp;
> > int error;
> >
> > - if (ip->i_blkno == (xfs_daddr_t)0) {
> > - imap.im_blkno = bno;
> > - error = xfs_imap(mp, tp, ip->i_ino, &imap,
> > - XFS_IMAP_LOOKUP | imap_flags);
> > - if (error)
> > - return error;
> > -
> > - /*
> > - * Fill in the fields in the inode that will be used to
> > - * map the inode to its buffer from now on.
> > - */
> > - ip->i_blkno = imap.im_blkno;
> > - ip->i_len = imap.im_len;
> > - ip->i_boffset = imap.im_boffset;
> > - } else {
> > - /*
> > - * We've already mapped the inode once, so just use the
> > - * mapping that we saved the first time.
> > - */
> > - imap.im_blkno = ip->i_blkno;
> > - imap.im_len = ip->i_len;
> > - imap.im_boffset = ip->i_boffset;
> > - }
> > - ASSERT(bno == 0 || bno == imap.im_blkno);
> > + ASSERT(ip->i_imap.im_blkno != 0);
> >
> > - error = xfs_imap_to_bp(mp, tp, &imap, &bp, buf_flags, imap_flags);
> > + error = xfs_imap_to_bp(mp, tp, &ip->i_imap, &bp, buf_flags, 0);
> > if (error)
> > return error;
> >
> > @@ -237,7 +250,7 @@
> > return EAGAIN;
> > }
> >
> > - *dipp = (xfs_dinode_t *)xfs_buf_offset(bp, imap.im_boffset);
> > + *dipp = (xfs_dinode_t *)xfs_buf_offset(bp, ip->i_imap.im_boffset);
> > *bpp = bp;
> > return 0;
> > }
> > @@ -250,10 +263,8 @@
> > * pointers. For a file in B-tree format, only the root is immediately
> > * brought in-core. The rest will be in-lined in if_extents when it
> > * is first referenced (see xfs_iread_extents()).
> > - *
> > - * Note: this requires user-space public scope for libxfs_iread
> > */
> > -int
> > +STATIC int
> > xfs_iformat(
> > xfs_inode_t *ip,
> > xfs_dinode_t *dip)
> > @@ -266,26 +277,26 @@
> > XFS_IFORK_DSIZE(ip) / (uint)sizeof(xfs_bmbt_rec_t);
> > error = 0;
> >
> > - if (unlikely(be32_to_cpu(dip->di_core.di_nextents) +
> > - be16_to_cpu(dip->di_core.di_anextents) >
> > - be64_to_cpu(dip->di_core.di_nblocks))) {
> > + if (unlikely(be32_to_cpu(dip->di_nextents) +
> > + be16_to_cpu(dip->di_anextents) >
> > + be64_to_cpu(dip->di_nblocks))) {
> > xfs_fs_repair_cmn_err(CE_WARN, ip->i_mount,
> > "corrupt dinode %Lu, extent total = %d, nblocks = %Lu.",
> > (unsigned long long)ip->i_ino,
> > - (int)(be32_to_cpu(dip->di_core.di_nextents) +
> > - be16_to_cpu(dip->di_core.di_anextents)),
> > + (int)(be32_to_cpu(dip->di_nextents) +
> > + be16_to_cpu(dip->di_anextents)),
> > (unsigned long long)
> > - be64_to_cpu(dip->di_core.di_nblocks));
> > + be64_to_cpu(dip->di_nblocks));
> > XFS_CORRUPTION_ERROR("xfs_iformat(1)", XFS_ERRLEVEL_LOW,
> > ip->i_mount, dip);
> > return XFS_ERROR(EFSCORRUPTED);
> > }
> >
> > - if (unlikely(dip->di_core.di_forkoff > ip->i_mount->m_sb.sb_inodesize)) {
> > + if (unlikely(dip->di_forkoff > ip->i_mount->m_sb.sb_inodesize)) {
> > xfs_fs_repair_cmn_err(CE_WARN, ip->i_mount,
> > "corrupt dinode %Lu, forkoff = 0x%x.",
> > (unsigned long long)ip->i_ino,
> > - dip->di_core.di_forkoff);
> > + dip->di_forkoff);
> > XFS_CORRUPTION_ERROR("xfs_iformat(2)", XFS_ERRLEVEL_LOW,
> > ip->i_mount, dip);
> > return XFS_ERROR(EFSCORRUPTED);
> > @@ -296,25 +307,25 @@
> > case S_IFCHR:
> > case S_IFBLK:
> > case S_IFSOCK:
> > - if (unlikely(dip->di_core.di_format != XFS_DINODE_FMT_DEV)) {
> > + if (unlikely(dip->di_format != XFS_DINODE_FMT_DEV)) {
> > XFS_CORRUPTION_ERROR("xfs_iformat(3)", XFS_ERRLEVEL_LOW,
> > ip->i_mount, dip);
> > return XFS_ERROR(EFSCORRUPTED);
> > }
> > ip->i_d.di_size = 0;
> > ip->i_size = 0;
> > - ip->i_df.if_u2.if_rdev = be32_to_cpu(dip->di_u.di_dev);
> > + ip->i_df.if_u2.if_rdev = xfs_dinode_get_rdev(dip);
> > break;
> >
> > case S_IFREG:
> > case S_IFLNK:
> > case S_IFDIR:
> > - switch (dip->di_core.di_format) {
> > + switch (dip->di_format) {
> > case XFS_DINODE_FMT_LOCAL:
> > /*
> > * no local regular files yet
> > */
> > - if (unlikely((be16_to_cpu(dip->di_core.di_mode) & S_IFMT) == S_IFREG)) {
> > + if (unlikely((be16_to_cpu(dip->di_mode) & S_IFMT) == S_IFREG)) {
> > xfs_fs_repair_cmn_err(CE_WARN, ip->i_mount,
> > "corrupt inode %Lu "
> > "(local format for regular file).",
> > @@ -325,7 +336,7 @@
> > return XFS_ERROR(EFSCORRUPTED);
> > }
> >
> > - di_size = be64_to_cpu(dip->di_core.di_size);
> > + di_size = be64_to_cpu(dip->di_size);
> > if (unlikely(di_size > XFS_DFORK_DSIZE(dip, ip->i_mount))) {
> > xfs_fs_repair_cmn_err(CE_WARN, ip->i_mount,
> > "corrupt inode %Lu "
> > @@ -367,7 +378,7 @@
> > ip->i_afp = kmem_zone_zalloc(xfs_ifork_zone, KM_SLEEP);
> > ip->i_afp->if_ext_max =
> > XFS_IFORK_ASIZE(ip) / (uint)sizeof(xfs_bmbt_rec_t);
> > - switch (dip->di_core.di_aformat) {
> > + switch (dip->di_aformat) {
> > case XFS_DINODE_FMT_LOCAL:
> > atp = (xfs_attr_shortform_t *)XFS_DFORK_APTR(dip);
> > size = be16_to_cpu(atp->hdr.totsize);
> > @@ -579,7 +590,7 @@
> > void
> > xfs_dinode_from_disk(
> > xfs_icdinode_t *to,
> > - xfs_dinode_core_t *from)
> > + xfs_dinode_t *from)
> > {
> > to->di_magic = be16_to_cpu(from->di_magic);
> > to->di_mode = be16_to_cpu(from->di_mode);
> > @@ -613,7 +624,7 @@
> >
> > void
> > xfs_dinode_to_disk(
> > - xfs_dinode_core_t *to,
> > + xfs_dinode_t *to,
> > xfs_icdinode_t *from)
> > {
> > to->di_magic = cpu_to_be16(from->di_magic);
> > @@ -647,6 +658,139 @@
> > }
> >
> > /*
> > + * Read the disk inode attributes into the in-core inode structure.
> > + */
> > +int
> > +xfs_iread(
> > + xfs_mount_t *mp,
> > + xfs_trans_t *tp,
> > + xfs_inode_t *ip,
> > + xfs_daddr_t bno,
> > + uint iget_flags)
> > +{
> > + xfs_buf_t *bp;
> > + xfs_dinode_t *dip;
> > + int error;
> > +
> > + /*
> > + * Fill in the location information in the in-core inode.
> > + */
> > + ip->i_imap.im_blkno = bno;
> > + error = xfs_imap(mp, tp, ip->i_ino, &ip->i_imap, iget_flags);
> > + if (error)
> > + return error;
> > + ASSERT(bno == 0 || bno == ip->i_imap.im_blkno);
> > +
> > + /*
> > + * Get pointers to the on-disk inode and the buffer containing it.
> > + */
> > + error = xfs_imap_to_bp(mp, tp, &ip->i_imap, &bp,
> > + XFS_BUF_LOCK, iget_flags);
> > + if (error)
> > + return error;
> > + dip = (xfs_dinode_t *)xfs_buf_offset(bp, ip->i_imap.im_boffset);
> > +
> > + /*
> > + * If we got something that isn't an inode it means someone
> > + * (nfs or dmi) has a stale handle.
> > + */
> > + if (be16_to_cpu(dip->di_magic) != XFS_DINODE_MAGIC) {
> > +#ifdef DEBUG
> > + xfs_fs_cmn_err(CE_ALERT, mp, "xfs_iread: "
> > + "dip->di_magic (0x%x) != "
> > + "XFS_DINODE_MAGIC (0x%x)",
> > + be16_to_cpu(dip->di_magic),
> > + XFS_DINODE_MAGIC);
> > +#endif /* DEBUG */
> > + error = XFS_ERROR(EINVAL);
> > + goto out_brelse;
> > + }
> > +
> > + /*
> > + * If the on-disk inode is already linked to a directory
> > + * entry, copy all of the inode into the in-core inode.
> > + * xfs_iformat() handles copying in the inode format
> > + * specific information.
> > + * Otherwise, just get the truly permanent information.
> > + */
> > + if (dip->di_mode) {
> > + xfs_dinode_from_disk(&ip->i_d, dip);
> > + error = xfs_iformat(ip, dip);
> > + if (error) {
> > +#ifdef DEBUG
> > + xfs_fs_cmn_err(CE_ALERT, mp, "xfs_iread: "
> > + "xfs_iformat() returned error %d",
> > + error);
> > +#endif /* DEBUG */
> > + goto out_brelse;
> > + }
> > + } else {
> > + ip->i_d.di_magic = be16_to_cpu(dip->di_magic);
> > + ip->i_d.di_version = dip->di_version;
> > + ip->i_d.di_gen = be32_to_cpu(dip->di_gen);
> > + ip->i_d.di_flushiter = be16_to_cpu(dip->di_flushiter);
> > + /*
> > + * Make sure to pull in the mode here as well in
> > + * case the inode is released without being used.
> > + * This ensures that xfs_inactive() will see that
> > + * the inode is already free and not try to mess
> > + * with the uninitialized part of it.
> > + */
> > + ip->i_d.di_mode = 0;
> > + /*
> > + * Initialize the per-fork minima and maxima for a new
> > + * inode here. xfs_iformat will do it for old inodes.
> > + */
> > + ip->i_df.if_ext_max =
> > + XFS_IFORK_DSIZE(ip) / (uint)sizeof(xfs_bmbt_rec_t);
> > + }
> > +
> > + /*
> > + * The inode format changed when we moved the link count and
> > + * made it 32 bits long. If this is an old format inode,
> > + * convert it in memory to look like a new one. If it gets
> > + * flushed to disk we will convert back before flushing or
> > + * logging it. We zero out the new projid field and the old link
> > + * count field. We'll handle clearing the pad field (the remains
> > + * of the old uuid field) when we actually convert the inode to
> > + * the new format. We don't change the version number so that we
> > + * can distinguish this from a real new format inode.
> > + */
> > + if (ip->i_d.di_version == 1) {
> > + ip->i_d.di_nlink = ip->i_d.di_onlink;
> > + ip->i_d.di_onlink = 0;
> > + ip->i_d.di_projid = 0;
> > + }
> > +
> > + ip->i_delayed_blks = 0;
> > + ip->i_size = ip->i_d.di_size;
> > +
> > + /*
> > + * Mark the buffer containing the inode as something to keep
> > + * around for a while. This helps to keep recently accessed
> > + * meta-data in-core longer.
> > + */
> > + XFS_BUF_SET_REF(bp, XFS_INO_REF);
> > +
> > + /*
> > + * Use xfs_trans_brelse() to release the buffer containing the
> > + * on-disk inode, because it was acquired with xfs_trans_read_buf()
> > + * in xfs_itobp() above. If tp is NULL, this is just a normal
> > + * brelse(). If we're within a transaction, then xfs_trans_brelse()
> > + * will only release the buffer if it is not dirty within the
> > + * transaction. It will be OK to release the buffer in this case,
> > + * because inodes on disk are never destroyed and we will be
> > + * locking the new in-core inode before putting it in the hash
> > + * table where other processes can find it. Thus we don't have
> > + * to worry about the inode being changed just because we released
> > + * the buffer.
> > + */
> > + out_brelse:
> > + xfs_trans_brelse(tp, bp);
> > + return error;
> > +}
> > +
> > +/*
> > * Read in extents from a btree-format inode.
> > * Allocate and fill in if_extents. Real work is done in xfs_bmap.c.
> > */
> > @@ -906,64 +1050,6 @@
> > ASSERT(ifp->if_bytes <= XFS_IFORK_SIZE(ip, whichfork));
> > }
> >
> > -
> > -
> > -
> > -/*
> > - * Map inode to disk block and offset.
> > - *
> > - * mp -- the mount point structure for the current file system
> > - * tp -- the current transaction
> > - * ino -- the inode number of the inode to be located
> > - * imap -- this structure is filled in with the information necessary
> > - * to retrieve the given inode from disk
> > - * flags -- flags to pass to xfs_dilocate indicating whether or not
> > - * lookups in the inode btree were OK or not
> > - */
> > -int
> > -xfs_imap(
> > - xfs_mount_t *mp,
> > - xfs_trans_t *tp,
> > - xfs_ino_t ino,
> > - xfs_imap_t *imap,
> > - uint flags)
> > -{
> > - xfs_fsblock_t fsbno;
> > - int len;
> > - int off;
> > - int error;
> > -
> > - fsbno = imap->im_blkno ?
> > - XFS_DADDR_TO_FSB(mp, imap->im_blkno) : NULLFSBLOCK;
> > - error = xfs_dilocate(mp, tp, ino, &fsbno, &len, &off, flags);
> > - if (error)
> > - return error;
> > -
> > - imap->im_blkno = XFS_FSB_TO_DADDR(mp, fsbno);
> > - imap->im_len = XFS_FSB_TO_BB(mp, len);
> > - imap->im_agblkno = XFS_FSB_TO_AGBNO(mp, fsbno);
> > - imap->im_ioffset = (ushort)off;
> > - imap->im_boffset = (ushort)(off << mp->m_sb.sb_inodelog);
> > -
> > - /*
> > - * If the inode number maps to a block outside the bounds
> > - * of the file system then return NULL rather than calling
> > - * read_buf and panicing when we get an error from the
> > - * driver.
> > - */
> > - if ((imap->im_blkno + imap->im_len) >
> > - XFS_FSB_TO_BB(mp, mp->m_sb.sb_dblocks)) {
> > - xfs_fs_cmn_err(CE_ALERT, mp, "xfs_imap: "
> > - "(imap->im_blkno (0x%llx) + imap->im_len (0x%llx)) > "
> > - " XFS_FSB_TO_BB(mp, mp->m_sb.sb_dblocks) (0x%llx)",
> > - (unsigned long long) imap->im_blkno,
> > - (unsigned long long) imap->im_len,
> > - XFS_FSB_TO_BB(mp, mp->m_sb.sb_dblocks));
> > - return EINVAL;
> > - }
> > - return 0;
> > -}
> > -
> > void
> > xfs_idestroy_fork(
> > xfs_inode_t *ip,
> > @@ -1077,7 +1163,7 @@
> > * In these cases, the format always takes precedence, because the
> > * format indicates the current state of the fork.
> > *
> > - * Note: this requires user-space public scope for libxfs_iread
> > + * Note: this requires user-space public scope for libxfs_iflush_int
> > */
> > /*ARGSUSED*/
> > void
> > @@ -1155,15 +1241,16 @@
> > case XFS_DINODE_FMT_DEV:
> > if (iip->ili_format.ilf_fields & XFS_ILOG_DEV) {
> > ASSERT(whichfork == XFS_DATA_FORK);
> > - dip->di_u.di_dev = cpu_to_be32(ip->i_df.if_u2.if_rdev);
> > + xfs_dinode_put_rdev(dip, ip->i_df.if_u2.if_rdev);
> > }
> > break;
> >
> > case XFS_DINODE_FMT_UUID:
> > if (iip->ili_format.ilf_fields & XFS_ILOG_UUID) {
> > ASSERT(whichfork == XFS_DATA_FORK);
> > - memcpy(&dip->di_u.di_muuid, &ip->i_df.if_u2.if_uuid,
> > - sizeof(uuid_t));
> > + memcpy(XFS_DFORK_DPTR(dip),
> > + &ip->i_df.if_u2.if_uuid,
> > + sizeof(uuid_t));
> > }
> > break;
> >
> > Index: xfs-cmds/xfsprogs/libxfs/xfs_mount.c
> > ===================================================================
> > --- xfs-cmds.orig/xfsprogs/libxfs/xfs_mount.c 2008-12-06 20:05:46.000000000 +0100
> > +++ xfs-cmds/xfsprogs/libxfs/xfs_mount.c 2008-12-06 20:05:49.000000000 +0100
> > @@ -265,8 +265,7 @@
> > mp->m_sectbb_log = sbp->sb_sectlog - BBSHIFT;
> > mp->m_agno_log = xfs_highbit32(sbp->sb_agcount - 1) + 1;
> > mp->m_agino_log = sbp->sb_inopblog + sbp->sb_agblklog;
> > - mp->m_litino = sbp->sb_inodesize -
> > - ((uint)sizeof(xfs_dinode_core_t) + (uint)sizeof(xfs_agino_t));
> > + mp->m_litino = sbp->sb_inodesize - sizeof(struct xfs_dinode);
> > mp->m_blockmask = sbp->sb_blocksize - 1;
> > mp->m_blockwsize = sbp->sb_blocksize >> XFS_WORDLOG;
> > mp->m_blockwmask = mp->m_blockwsize - 1;
> > Index: xfs-cmds/xfsprogs/libxlog/xfs_log_recover.c
> > ===================================================================
> > --- xfs-cmds.orig/xfsprogs/libxlog/xfs_log_recover.c 2008-12-06 20:05:45.000000000 +0100
> > +++ xfs-cmds/xfsprogs/libxlog/xfs_log_recover.c 2008-12-06 20:05:49.000000000 +0100
> > @@ -1238,7 +1238,6 @@
> > xlog_t *log)
> > {
> > int i, j, k;
> > - xlog_in_core_2_t *xhdr;
> >
> > for (i = 0; i < BTOBB(be32_to_cpu(rhead->h_len)) &&
> > i < (XLOG_HEADER_CYCLE_SIZE / BBSIZE); i++) {
> > @@ -1247,7 +1246,7 @@
> > }
> >
> > if (xfs_sb_version_haslogv2(&log->l_mp->m_sb)) {
> > - xhdr = (xlog_in_core_2_t *)rhead;
> > + xlog_in_core_2_t *xhdr = (xlog_in_core_2_t *)rhead;
> > for ( ; i < BTOBB(be32_to_cpu(rhead->h_len)); i++) {
> > j = i / (XLOG_HEADER_CYCLE_SIZE / BBSIZE);
> > k = i % (XLOG_HEADER_CYCLE_SIZE / BBSIZE);
> > Index: xfs-cmds/xfsprogs/logprint/log_misc.c
> > ===================================================================
> > --- xfs-cmds.orig/xfsprogs/logprint/log_misc.c 2008-12-06 20:05:45.000000000 +0100
> > +++ xfs-cmds/xfsprogs/logprint/log_misc.c 2008-12-06 20:05:49.000000000 +0100
> > @@ -642,7 +642,7 @@
> > mode = dino.di_mode & S_IFMT;
> > size = (int)dino.di_size;
> > xlog_print_trans_inode_core(&dino);
> > - *ptr += sizeof(xfs_dinode_core_t);
> > + *ptr += sizeof(xfs_icdinode_t);
> >
> > if (*i == num_ops-1 && f->ilf_size == 3) {
> > return 1;
> > Index: xfs-cmds/xfsprogs/repair/attr_repair.c
> > ===================================================================
> > --- xfs-cmds.orig/xfsprogs/repair/attr_repair.c 2008-12-06 20:05:45.000000000 +0100
> > +++ xfs-cmds/xfsprogs/repair/attr_repair.c 2008-12-06 20:05:49.000000000 +0100
> > @@ -840,8 +840,8 @@
> > bno = blkmap_get(blkmap, 0);
> >
> > if ( bno == NULLDFSBNO ) {
> > - if (dip->di_core.di_aformat == XFS_DINODE_FMT_EXTENTS &&
> > - be16_to_cpu(dip->di_core.di_anextents) == 0)
> > + if (dip->di_aformat == XFS_DINODE_FMT_EXTENTS &&
> > + be16_to_cpu(dip->di_anextents) == 0)
> > return(0); /* the kernel can handle this state */
> > do_warn(_("block 0 of inode %llu attribute fork is missing\n"),
> > ino);
> > @@ -958,7 +958,7 @@
> > int *repair) /* returned if we did repair */
> > {
> > int err;
> > - __u8 aformat = dip->di_core.di_aformat;
> > + __u8 aformat = dip->di_aformat;
> > xfs_attr_shortform_t *asf;
> >
> > asf = (xfs_attr_shortform_t *) XFS_DFORK_APTR(dip);
> > Index: xfs-cmds/xfsprogs/repair/dino_chunks.c
> > ===================================================================
> > --- xfs-cmds.orig/xfsprogs/repair/dino_chunks.c 2008-12-06 20:05:45.000000000 +0100
> > +++ xfs-cmds/xfsprogs/repair/dino_chunks.c 2008-12-06 20:05:49.000000000 +0100
> > @@ -810,9 +810,9 @@
> > * store on-disk nlink count for comparing in phase 7
> > */
> > set_inode_disk_nlinks(ino_rec, irec_offset,
> > - dino->di_core.di_version > XFS_DINODE_VERSION_1
> > - ? be32_to_cpu(dino->di_core.di_nlink)
> > - : be16_to_cpu(dino->di_core.di_onlink));
> > + dino->di_version > 1
> > + ? be32_to_cpu(dino->di_nlink)
> > + : be16_to_cpu(dino->di_onlink));
> >
> > } else {
> > set_inode_free(ino_rec, irec_offset);
> > Index: xfs-cmds/xfsprogs/repair/dinode.c
> > ===================================================================
> > --- xfs-cmds.orig/xfsprogs/repair/dinode.c 2008-12-06 20:05:45.000000000 +0100
> > +++ xfs-cmds/xfsprogs/repair/dinode.c 2008-12-06 20:05:49.000000000 +0100
> > @@ -41,29 +41,29 @@
> > */
> > /* ARGSUSED */
> > int
> > -calc_attr_offset(xfs_mount_t *mp, xfs_dinode_t *dino)
> > +calc_attr_offset(xfs_mount_t *mp, xfs_dinode_t *dip)
> > {
> > - xfs_dinode_core_t *dinoc = &dino->di_core;
> > - int offset = ((__psint_t) &dino->di_u)
> > - - (__psint_t)dino;
> > + char *dfork = XFS_DFORK_DPTR(dip);
> > + xfs_bmdr_block_t *bmdr = (xfs_bmdr_block_t *)dfork;
> > + int offset = ((__psint_t)dfork) - (__psint_t)dip;
> >
> > /*
> > * don't worry about alignment when calculating offset
> > * because the data fork is already 8-byte aligned
> > */
> > - switch (dinoc->di_format) {
> > + switch (dip->di_format) {
> > case XFS_DINODE_FMT_DEV:
> > offset += sizeof(xfs_dev_t);
> > break;
> > case XFS_DINODE_FMT_LOCAL:
> > - offset += be64_to_cpu(dinoc->di_size);
> > + offset += be64_to_cpu(dip->di_size);
> > break;
> > case XFS_DINODE_FMT_EXTENTS:
> > - offset += be32_to_cpu(dinoc->di_nextents) *
> > + offset += be32_to_cpu(dip->di_nextents) *
> > sizeof(xfs_bmbt_rec_t);
> > break;
> > case XFS_DINODE_FMT_BTREE:
> > - offset += be16_to_cpu(dino->di_u.di_bmbt.bb_numrecs) *
> > + offset += be16_to_cpu(bmdr->bb_numrecs) *
> > sizeof(xfs_bmbt_rec_t);
> > break;
> > default:
> > @@ -77,11 +77,9 @@
> >
> > /* ARGSUSED */
> > int
> > -clear_dinode_attr(xfs_mount_t *mp, xfs_dinode_t *dino, xfs_ino_t ino_num)
> > +clear_dinode_attr(xfs_mount_t *mp, xfs_dinode_t *dip, xfs_ino_t ino_num)
> > {
> > - xfs_dinode_core_t *dinoc = &dino->di_core;
> > -
> > - ASSERT(dinoc->di_forkoff != 0);
> > + ASSERT(dip->di_forkoff != 0);
> >
> > if (!no_modify)
> > fprintf(stderr, _("clearing inode %llu attributes\n"),
> > @@ -90,16 +88,16 @@
> > fprintf(stderr, _("would have cleared inode %llu attributes\n"),
> > (unsigned long long)ino_num);
> >
> > - if (be16_to_cpu(dinoc->di_anextents) != 0) {
> > + if (dip->di_anextents) {
> > if (no_modify)
> > - return(1);
> > - dinoc->di_anextents = cpu_to_be16(0);
> > + return 1;
> > + dip->di_anextents = 0;
> > }
> >
> > - if (dinoc->di_aformat != XFS_DINODE_FMT_EXTENTS) {
> > + if (dip->di_aformat != XFS_DINODE_FMT_EXTENTS) {
> > if (no_modify)
> > - return(1);
> > - dinoc->di_aformat = XFS_DINODE_FMT_EXTENTS;
> > + return 1;
> > + dip->di_aformat = XFS_DINODE_FMT_EXTENTS;
> > }
> >
> > /* get rid of the fork by clearing forkoff */
> > @@ -115,168 +113,138 @@
> >
> > if (!no_modify) {
> > xfs_attr_shortform_t *asf = (xfs_attr_shortform_t *)
> > - XFS_DFORK_APTR(dino);
> > + XFS_DFORK_APTR(dip);
> > asf->hdr.totsize = cpu_to_be16(sizeof(xfs_attr_sf_hdr_t));
> > asf->hdr.count = 0;
> > - dinoc->di_forkoff = 0; /* got to do this after asf is set */
> > + dip->di_forkoff = 0; /* got to do this after asf is set */
> > }
> >
> > /*
> > * always returns 1 since the fork gets zapped
> > */
> > - return(1);
> > + return 1;
> > }
> >
> > /* ARGSUSED */
> > int
> > -clear_dinode_core(xfs_dinode_core_t *dinoc, xfs_ino_t ino_num)
> > +clear_dinode_core(xfs_dinode_t *dip, xfs_ino_t ino_num)
> > {
> > int dirty = 0;
> >
> > - if (be16_to_cpu(dinoc->di_magic) != XFS_DINODE_MAGIC) {
> > + if (be16_to_cpu(dip->di_magic) != XFS_DINODE_MAGIC) {
> > dirty = 1;
> > -
> > if (no_modify)
> > - return(1);
> > -
> > - dinoc->di_magic = cpu_to_be16(XFS_DINODE_MAGIC);
> > + return 1;
> > + dip->di_magic = cpu_to_be16(XFS_DINODE_MAGIC);
> > }
> >
> > - if (!XFS_DINODE_GOOD_VERSION(dinoc->di_version) ||
> > - (!fs_inode_nlink && dinoc->di_version > XFS_DINODE_VERSION_1)) {
> > + if (!XFS_DINODE_GOOD_VERSION(dip->di_version) ||
> > + (!fs_inode_nlink && dip->di_version > 1)) {
> > dirty = 1;
> > -
> > if (no_modify)
> > - return(1);
> > -
> > - dinoc->di_version = (fs_inode_nlink) ? XFS_DINODE_VERSION_2
> > - : XFS_DINODE_VERSION_1;
> > + return 1;
> > + dip->di_version = (fs_inode_nlink) ? 2 : 1;
> > }
> >
> > - if (be16_to_cpu(dinoc->di_mode) != 0) {
> > + if (dip->di_mode) {
> > dirty = 1;
> > -
> > if (no_modify)
> > - return(1);
> > -
> > - dinoc->di_mode = 0;
> > + return 1;
> > + dip->di_mode = 0;
> > }
> >
> > - if (be16_to_cpu(dinoc->di_flags) != 0) {
> > + if (dip->di_flags) {
> > dirty = 1;
> > -
> > if (no_modify)
> > - return(1);
> > -
> > - dinoc->di_flags = 0;
> > + return 1;
> > + dip->di_flags = 0;
> > }
> >
> > - if (be32_to_cpu(dinoc->di_dmevmask) != 0) {
> > + if (dip->di_dmevmask) {
> > dirty = 1;
> > -
> > if (no_modify)
> > - return(1);
> > -
> > - dinoc->di_dmevmask = 0;
> > + return 1;
> > + dip->di_dmevmask = 0;
> > }
> >
> > - if (dinoc->di_forkoff != 0) {
> > + if (dip->di_forkoff) {
> > dirty = 1;
> > -
> > if (no_modify)
> > - return(1);
> > -
> > - dinoc->di_forkoff = 0;
> > + return 1;
> > + dip->di_forkoff = 0;
> > }
> >
> > - if (dinoc->di_format != XFS_DINODE_FMT_EXTENTS) {
> > + if (dip->di_format != XFS_DINODE_FMT_EXTENTS) {
> > dirty = 1;
> > -
> > if (no_modify)
> > - return(1);
> > -
> > - dinoc->di_format = XFS_DINODE_FMT_EXTENTS;
> > + return 1;
> > + dip->di_format = XFS_DINODE_FMT_EXTENTS;
> > }
> >
> > - if (dinoc->di_aformat != XFS_DINODE_FMT_EXTENTS) {
> > + if (dip->di_aformat != XFS_DINODE_FMT_EXTENTS) {
> > dirty = 1;
> > -
> > if (no_modify)
> > - return(1);
> > -
> > - dinoc->di_aformat = XFS_DINODE_FMT_EXTENTS;
> > + return 1;
> > + dip->di_aformat = XFS_DINODE_FMT_EXTENTS;
> > }
> >
> > - if (be64_to_cpu(dinoc->di_size) != 0) {
> > + if (dip->di_size) {
> > dirty = 1;
> > -
> > if (no_modify)
> > - return(1);
> > -
> > - dinoc->di_size = 0;
> > + return 1;
> > + dip->di_size = 0;
> > }
> >
> > - if (be64_to_cpu(dinoc->di_nblocks) != 0) {
> > + if (dip->di_nblocks) {
> > dirty = 1;
> > -
> > if (no_modify)
> > - return(1);
> > -
> > - dinoc->di_nblocks = 0;
> > + return 1;
> > + dip->di_nblocks = 0;
> > }
> >
> > - if (be16_to_cpu(dinoc->di_onlink) != 0) {
> > + if (dip->di_onlink) {
> > dirty = 1;
> > -
> > if (no_modify)
> > - return(1);
> > -
> > - dinoc->di_onlink = 0;
> > + return 1;
> > + dip->di_onlink = 0;
> > }
> >
> > - if (be32_to_cpu(dinoc->di_nextents) != 0) {
> > + if (dip->di_nextents) {
> > dirty = 1;
> > -
> > if (no_modify)
> > - return(1);
> > -
> > - dinoc->di_nextents = 0;
> > + return 1;
> > + dip->di_nextents = 0;
> > }
> >
> > - if (be16_to_cpu(dinoc->di_anextents) != 0) {
> > + if (dip->di_anextents) {
> > dirty = 1;
> > -
> > if (no_modify)
> > - return(1);
> > -
> > - dinoc->di_anextents = 0;
> > + return 1;
> > + dip->di_anextents = 0;
> > }
> >
> > - if (dinoc->di_version > XFS_DINODE_VERSION_1 &&
> > - be32_to_cpu(dinoc->di_nlink) != 0) {
> > + if (dip->di_version > 1 && dip->di_nlink) {
> > dirty = 1;
> > -
> > if (no_modify)
> > - return(1);
> > -
> > - dinoc->di_nlink = 0;
> > + return 1;
> > + dip->di_nlink = 0;
> > }
> >
> > - return(dirty);
> > + return dirty;
> > }
> >
> > /* ARGSUSED */
> > int
> > -clear_dinode_unlinked(xfs_mount_t *mp, xfs_dinode_t *dino)
> > +clear_dinode_unlinked(xfs_mount_t *mp, xfs_dinode_t *dip)
> > {
> >
> > - if (be32_to_cpu(dino->di_next_unlinked) != NULLAGINO) {
> > + if (be32_to_cpu(dip->di_next_unlinked) != NULLAGINO) {
> > if (!no_modify)
> > - dino->di_next_unlinked = cpu_to_be32(NULLAGINO);
> > - return(1);
> > + dip->di_next_unlinked = cpu_to_be32(NULLAGINO);
> > + return 1;
> > }
> >
> > - return(0);
> > + return 0;
> > }
> >
> > /*
> > @@ -285,17 +253,17 @@
> > * returns > zero if the inode has been altered while being cleared
> > */
> > int
> > -clear_dinode(xfs_mount_t *mp, xfs_dinode_t *dino, xfs_ino_t ino_num)
> > +clear_dinode(xfs_mount_t *mp, xfs_dinode_t *dip, xfs_ino_t ino_num)
> > {
> > int dirty;
> >
> > - dirty = clear_dinode_core(&dino->di_core, ino_num);
> > - dirty += clear_dinode_unlinked(mp, dino);
> > + dirty = clear_dinode_core(dip, ino_num);
> > + dirty += clear_dinode_unlinked(mp, dip);
> >
> > /* and clear the forks */
> >
> > if (dirty && !no_modify)
> > - memset(&dino->di_u, 0, XFS_LITINO(mp));
> > + memset(XFS_DFORK_DPTR(dip), 0, XFS_LITINO(mp));
> >
> > return(dirty);
> > }
> > @@ -1354,11 +1322,11 @@
> > xfs_ino_t lino;
> >
> > lino = XFS_AGINO_TO_INO(mp, agno, ino);
> > - if (whichfork == XFS_DATA_FORK && be64_to_cpu(dip->di_core.di_size) >
> > - XFS_DFORK_DSIZE(dip, mp)) {
> > + if (whichfork == XFS_DATA_FORK &&
> > + be64_to_cpu(dip->di_size) > XFS_DFORK_DSIZE(dip, mp)) {
> > do_warn(
> > _("local inode %llu data fork is too large (size = %lld, max = %d)\n"),
> > - lino, be64_to_cpu(dip->di_core.di_size),
> > + lino, be64_to_cpu(dip->di_size),
> > XFS_DFORK_DSIZE(dip, mp));
> > return(1);
> > } else if (whichfork == XFS_ATTR_FORK) {
> > @@ -1383,7 +1351,7 @@
> > }
> >
> > int
> > -process_symlink_extlist(xfs_mount_t *mp, xfs_ino_t lino, xfs_dinode_t *dino)
> > +process_symlink_extlist(xfs_mount_t *mp, xfs_ino_t lino, xfs_dinode_t *dip)
> > {
> > xfs_dfiloff_t expected_offset;
> > xfs_bmbt_rec_t *rp;
> > @@ -1392,23 +1360,23 @@
> > int i;
> > int max_blocks;
> >
> > - if (be64_to_cpu(dino->di_core.di_size) <= XFS_DFORK_DSIZE(dino, mp)) {
> > - if (dino->di_core.di_format == XFS_DINODE_FMT_LOCAL)
> > + if (be64_to_cpu(dip->di_size) <= XFS_DFORK_DSIZE(dip, mp)) {
> > + if (dip->di_format == XFS_DINODE_FMT_LOCAL)
> > return 0;
> > do_warn(_("mismatch between format (%d) and size (%lld) in "
> > - "symlink ino %llu\n"), dino->di_core.di_format,
> > - be64_to_cpu(dino->di_core.di_size), lino);
> > + "symlink ino %llu\n"), dip->di_format,
> > + be64_to_cpu(dip->di_size), lino);
> > return 1;
> > }
> > - if (dino->di_core.di_format == XFS_DINODE_FMT_LOCAL) {
> > + if (dip->di_format == XFS_DINODE_FMT_LOCAL) {
> > do_warn(_("mismatch between format (%d) and size (%lld) in "
> > - "symlink inode %llu\n"), dino->di_core.di_format,
> > - be64_to_cpu(dino->di_core.di_size), lino);
> > + "symlink inode %llu\n"), dip->di_format,
> > + be64_to_cpu(dip->di_size), lino);
> > return 1;
> > }
> >
> > - rp = (xfs_bmbt_rec_t *)XFS_DFORK_DPTR(dino);
> > - numrecs = be32_to_cpu(dino->di_core.di_nextents);
> > + rp = (xfs_bmbt_rec_t *)XFS_DFORK_DPTR(dip);
> > + numrecs = be32_to_cpu(dip->di_nextents);
> >
> > /*
> > * the max # of extents in a symlink inode is equal to the
> > @@ -1474,11 +1442,10 @@
> > process_symlink(
> > xfs_mount_t *mp,
> > xfs_ino_t lino,
> > - xfs_dinode_t *dino,
> > + xfs_dinode_t *dip,
> > blkmap_t *blkmap)
> > {
> > xfs_dfsbno_t fsbno;
> > - xfs_dinode_core_t *dinoc = &dino->di_core;
> > xfs_buf_t *bp = NULL;
> > char *symlink, *cptr, *buf_data;
> > int i, size, amountdone;
> > @@ -1490,9 +1457,9 @@
> > * the inode is structurally ok so we don't have to check
> > * for that
> > */
> > - if (be64_to_cpu(dinoc->di_size) >= MAXPATHLEN) {
> > + if (be64_to_cpu(dip->di_size) >= MAXPATHLEN) {
> > do_warn(_("symlink in inode %llu too long (%lld chars)\n"),
> > - lino, be64_to_cpu(dinoc->di_size));
> > + lino, be64_to_cpu(dip->di_size));
> > return(1);
> > }
> >
> > @@ -1501,13 +1468,13 @@
> > * get symlink contents into data area
> > */
> > symlink = &data[0];
> > - if (be64_to_cpu(dinoc->di_size) <= XFS_DFORK_DSIZE(dino, mp)) {
> > + if (be64_to_cpu(dip->di_size) <= XFS_DFORK_DSIZE(dip, mp)) {
> > /*
> > * local symlink, just copy the symlink out of the
> > * inode into the data area
> > */
> > - memmove(symlink, XFS_DFORK_DPTR(dino),
> > - be64_to_cpu(dinoc->di_size));
> > + memmove(symlink, XFS_DFORK_DPTR(dip),
> > + be64_to_cpu(dip->di_size));
> > } else {
> > /*
> > * stored in a meta-data file, have to bmap one block
> > @@ -1516,7 +1483,7 @@
> > i = size = amountdone = 0;
> > cptr = symlink;
> >
> > - while (amountdone < be64_to_cpu(dinoc->di_size)) {
> > + while (amountdone < be64_to_cpu(dip->di_size)) {
> > fsbno = blkmap_get(blkmap, i);
> > if (fsbno != NULLDFSBNO)
> > bp = libxfs_readbuf(mp->m_dev,
> > @@ -1530,7 +1497,7 @@
> > }
> >
> > buf_data = (char *)XFS_BUF_PTR(bp);
> > - size = MIN(be64_to_cpu(dinoc->di_size) - amountdone,
> > + size = MIN(be64_to_cpu(dip->di_size) - amountdone,
> > XFS_FSB_TO_BB(mp, 1) * BBSIZE);
> > memmove(cptr, buf_data, size);
> > cptr += size;
> > @@ -1539,12 +1506,12 @@
> > libxfs_putbuf(bp);
> > }
> > }
> > - data[be64_to_cpu(dinoc->di_size)] = '\0';
> > + data[be64_to_cpu(dip->di_size)] = '\0';
> >
> > /*
> > * check for nulls
> > */
> > - if (null_check(symlink, be64_to_cpu(dinoc->di_size))) {
> > + if (null_check(symlink, be64_to_cpu(dip->di_size))) {
> > do_warn(
> > _("found illegal null character in symlink inode %llu\n"),
> > lino);
> > @@ -1554,7 +1521,7 @@
> > /*
> > * check for any component being too long
> > */
> > - if (be64_to_cpu(dinoc->di_size) >= MAXNAMELEN) {
> > + if (be64_to_cpu(dip->di_size) >= MAXNAMELEN) {
> > cptr = strchr(symlink, '/');
> >
> > while (cptr != NULL) {
> > @@ -1585,7 +1552,7 @@
> > */
> > static int
> > process_misc_ino_types(xfs_mount_t *mp,
> > - xfs_dinode_t *dino,
> > + xfs_dinode_t *dip,
> > xfs_ino_t lino,
> > int type)
> > {
> > @@ -1602,27 +1569,27 @@
> > /*
> > * must also have a zero size
> > */
> > - if (be64_to_cpu(dino->di_core.di_size) != 0) {
> > + if (be64_to_cpu(dip->di_size) != 0) {
> > switch (type) {
> > case XR_INO_CHRDEV:
> > do_warn(_("size of character device inode %llu != 0 "
> > "(%lld bytes)\n"), lino,
> > - be64_to_cpu(dino->di_core.di_size));
> > + be64_to_cpu(dip->di_size));
> > break;
> > case XR_INO_BLKDEV:
> > do_warn(_("size of block device inode %llu != 0 "
> > "(%lld bytes)\n"), lino,
> > - be64_to_cpu(dino->di_core.di_size));
> > + be64_to_cpu(dip->di_size));
> > break;
> > case XR_INO_SOCK:
> > do_warn(_("size of socket inode %llu != 0 "
> > "(%lld bytes)\n"), lino,
> > - be64_to_cpu(dino->di_core.di_size));
> > + be64_to_cpu(dip->di_size));
> > break;
> > case XR_INO_FIFO:
> > do_warn(_("size of fifo inode %llu != 0 "
> > "(%lld bytes)\n"), lino,
> > - be64_to_cpu(dino->di_core.di_size));
> > + be64_to_cpu(dip->di_size));
> > break;
> > default:
> > do_warn(_("Internal error - process_misc_ino_types, "
> > @@ -1641,7 +1608,7 @@
> > {
> > /*
> > * you can not enforce all misc types have zero data fork blocks
> > - * by checking dino->di_core.di_nblocks because atotblocks (attribute
> > + * by checking dip->di_nblocks because atotblocks (attribute
> > * blocks) are part of nblocks. We must check this later when atotblocks
> > * has been calculated or by doing a simple check that anExtents == 0.
> > * We must also guarantee that totblocks is 0. Thus nblocks checking
> > @@ -1680,50 +1647,50 @@
> >
> > static inline int
> > dinode_fmt(
> > - xfs_dinode_core_t *dinoc)
> > + xfs_dinode_t *dip)
> > {
> > - return be16_to_cpu(dinoc->di_mode) & S_IFMT;
> > + return be16_to_cpu(dip->di_mode) & S_IFMT;
> > }
> >
> > static inline void
> > change_dinode_fmt(
> > - xfs_dinode_core_t *dinoc,
> > + xfs_dinode_t *dip,
> > int new_fmt)
> > {
> > - int mode = be16_to_cpu(dinoc->di_mode);
> > + int mode = be16_to_cpu(dip->di_mode);
> >
> > ASSERT((new_fmt & ~S_IFMT) == 0);
> >
> > mode &= ~S_IFMT;
> > mode |= new_fmt;
> > - dinoc->di_mode = cpu_to_be16(mode);
> > + dip->di_mode = cpu_to_be16(mode);
> > }
> >
> > static int
> > check_dinode_mode_format(
> > - xfs_dinode_core_t *dinoc)
> > + xfs_dinode_t *dip)
> > {
> > - if (dinoc->di_format >= XFS_DINODE_FMT_UUID)
> > + if (dip->di_format >= XFS_DINODE_FMT_UUID)
> > return -1; /* FMT_UUID is not used */
> >
> > - switch (dinode_fmt(dinoc)) {
> > + switch (dinode_fmt(dip)) {
> > case S_IFIFO:
> > case S_IFCHR:
> > case S_IFBLK:
> > case S_IFSOCK:
> > - return (dinoc->di_format != XFS_DINODE_FMT_DEV) ? -1 : 0;
> > + return (dip->di_format != XFS_DINODE_FMT_DEV) ? -1 : 0;
> >
> > case S_IFDIR:
> > - return (dinoc->di_format < XFS_DINODE_FMT_LOCAL ||
> > - dinoc->di_format > XFS_DINODE_FMT_BTREE) ? -1 : 0;
> > + return (dip->di_format < XFS_DINODE_FMT_LOCAL ||
> > + dip->di_format > XFS_DINODE_FMT_BTREE) ? -1 : 0;
> >
> > case S_IFREG:
> > - return (dinoc->di_format < XFS_DINODE_FMT_EXTENTS ||
> > - dinoc->di_format > XFS_DINODE_FMT_BTREE) ? -1 : 0;
> > + return (dip->di_format < XFS_DINODE_FMT_EXTENTS ||
> > + dip->di_format > XFS_DINODE_FMT_BTREE) ? -1 : 0;
> >
> > case S_IFLNK:
> > - return (dinoc->di_format < XFS_DINODE_FMT_LOCAL ||
> > - dinoc->di_format > XFS_DINODE_FMT_EXTENTS) ? -1 : 0;
> > + return (dip->di_format < XFS_DINODE_FMT_LOCAL ||
> > + dip->di_format > XFS_DINODE_FMT_EXTENTS) ? -1 : 0;
> >
> > default: ;
> > }
> > @@ -1738,7 +1705,7 @@
> > static int
> > process_check_sb_inodes(
> > xfs_mount_t *mp,
> > - xfs_dinode_core_t *dinoc,
> > + xfs_dinode_t *dip,
> > xfs_ino_t lino,
> > int *type,
> > int *dirty)
> > @@ -1746,11 +1713,11 @@
> > if (lino == mp->m_sb.sb_rootino) {
> > if (*type != XR_INO_DIR) {
> > do_warn(_("root inode %llu has bad type 0x%x\n"),
> > - lino, dinode_fmt(dinoc));
> > + lino, dinode_fmt(dip));
> > *type = XR_INO_DIR;
> > if (!no_modify) {
> > do_warn(_("resetting to directory\n"));
> > - change_dinode_fmt(dinoc, S_IFDIR);
> > + change_dinode_fmt(dip, S_IFDIR);
> > *dirty = 1;
> > } else
> > do_warn(_("would reset to directory\n"));
> > @@ -1760,7 +1727,7 @@
> > if (lino == mp->m_sb.sb_uquotino) {
> > if (*type != XR_INO_DATA) {
> > do_warn(_("user quota inode %llu has bad type 0x%x\n"),
> > - lino, dinode_fmt(dinoc));
> > + lino, dinode_fmt(dip));
> > mp->m_sb.sb_uquotino = NULLFSINO;
> > return 1;
> > }
> > @@ -1769,7 +1736,7 @@
> > if (lino == mp->m_sb.sb_gquotino) {
> > if (*type != XR_INO_DATA) {
> > do_warn(_("group quota inode %llu has bad type 0x%x\n"),
> > - lino, dinode_fmt(dinoc));
> > + lino, dinode_fmt(dip));
> > mp->m_sb.sb_gquotino = NULLFSINO;
> > return 1;
> > }
> > @@ -1778,18 +1745,18 @@
> > if (lino == mp->m_sb.sb_rsumino) {
> > if (*type != XR_INO_RTSUM) {
> > do_warn(_("realtime summary inode %llu has bad type 0x%x, "),
> > - lino, dinode_fmt(dinoc));
> > + lino, dinode_fmt(dip));
> > if (!no_modify) {
> > do_warn(_("resetting to regular file\n"));
> > - change_dinode_fmt(dinoc, S_IFREG);
> > + change_dinode_fmt(dip, S_IFREG);
> > *dirty = 1;
> > } else {
> > do_warn(_("would reset to regular file\n"));
> > }
> > }
> > - if (mp->m_sb.sb_rblocks == 0 && dinoc->di_nextents != 0) {
> > + if (mp->m_sb.sb_rblocks == 0 && dip->di_nextents != 0) {
> > do_warn(_("bad # of extents (%u) for realtime summary inode %llu\n"),
> > - be32_to_cpu(dinoc->di_nextents), lino);
> > + be32_to_cpu(dip->di_nextents), lino);
> > return 1;
> > }
> > return 0;
> > @@ -1797,18 +1764,18 @@
> > if (lino == mp->m_sb.sb_rbmino) {
> > if (*type != XR_INO_RTBITMAP) {
> > do_warn(_("realtime bitmap inode %llu has bad type 0x%x, "),
> > - lino, dinode_fmt(dinoc));
> > + lino, dinode_fmt(dip));
> > if (!no_modify) {
> > do_warn(_("resetting to regular file\n"));
> > - change_dinode_fmt(dinoc, S_IFREG);
> > + change_dinode_fmt(dip, S_IFREG);
> > *dirty = 1;
> > } else {
> > do_warn(_("would reset to regular file\n"));
> > }
> > }
> > - if (mp->m_sb.sb_rblocks == 0 && dinoc->di_nextents != 0) {
> > + if (mp->m_sb.sb_rblocks == 0 && dip->di_nextents != 0) {
> > do_warn(_("bad # of extents (%u) for realtime bitmap inode %llu\n"),
> > - be32_to_cpu(dinoc->di_nextents), lino);
> > + be32_to_cpu(dip->di_nextents), lino);
> > return 1;
> > }
> > return 0;
> > @@ -1830,21 +1797,20 @@
> > static int
> > process_check_inode_sizes(
> > xfs_mount_t *mp,
> > - xfs_dinode_t *dino,
> > + xfs_dinode_t *dip,
> > xfs_ino_t lino,
> > int type)
> > {
> > - xfs_dinode_core_t *dinoc = &dino->di_core;
> > - xfs_fsize_t size = be64_to_cpu(dinoc->di_size);
> > + xfs_fsize_t size = be64_to_cpu(dip->di_size);
> >
> > switch (type) {
> >
> > case XR_INO_DIR:
> > - if (size <= XFS_DFORK_DSIZE(dino, mp) &&
> > - dinoc->di_format != XFS_DINODE_FMT_LOCAL) {
> > + if (size <= XFS_DFORK_DSIZE(dip, mp) &&
> > + dip->di_format != XFS_DINODE_FMT_LOCAL) {
> > do_warn(_("mismatch between format (%d) and size "
> > "(%lld) in directory ino %llu\n"),
> > - dinoc->di_format, size, lino);
> > + dip->di_format, size, lino);
> > return 1;
> > }
> > if (size > XFS_DIR2_LEAF_OFFSET) {
> > @@ -1855,7 +1821,7 @@
> > break;
> >
> > case XR_INO_SYMLINK:
> > - if (process_symlink_extlist(mp, lino, dino)) {
> > + if (process_symlink_extlist(mp, lino, dip)) {
> > do_warn(_("bad data fork in symlink %llu\n"), lino);
> > return 1;
> > }
> > @@ -1866,7 +1832,7 @@
> > case XR_INO_SOCK: /* fall through to FIFO case ... */
> > case XR_INO_MOUNTPOINT: /* fall through to FIFO case ... */
> > case XR_INO_FIFO:
> > - if (process_misc_ino_types(mp, dino, lino, type))
> > + if (process_misc_ino_types(mp, dip, lino, type))
> > return 1;
> > break;
> >
> > @@ -1914,17 +1880,17 @@
> > static int
> > process_check_inode_forkoff(
> > xfs_mount_t *mp,
> > - xfs_dinode_core_t *dinoc,
> > + xfs_dinode_t *dip,
> > xfs_ino_t lino)
> > {
> > - if (dinoc->di_forkoff == 0)
> > + if (dip->di_forkoff == 0)
> > return 0;
> >
> > - switch (dinoc->di_format) {
> > + switch (dip->di_format) {
> > case XFS_DINODE_FMT_DEV:
> > - if (dinoc->di_forkoff != (roundup(sizeof(xfs_dev_t), 8) >> 3)) {
> > + if (dip->di_forkoff != (roundup(sizeof(xfs_dev_t), 8) >> 3)) {
> > do_warn(_("bad attr fork offset %d in dev inode %llu, "
> > - "should be %d\n"), dinoc->di_forkoff, lino,
> > + "should be %d\n"), dip->di_forkoff, lino,
> > (int)(roundup(sizeof(xfs_dev_t), 8) >> 3));
> > return 1;
> > }
> > @@ -1932,15 +1898,15 @@
> > case XFS_DINODE_FMT_LOCAL: /* fall through ... */
> > case XFS_DINODE_FMT_EXTENTS: /* fall through ... */
> > case XFS_DINODE_FMT_BTREE:
> > - if (dinoc->di_forkoff >= (XFS_LITINO(mp) >> 3)) {
> > + if (dip->di_forkoff >= (XFS_LITINO(mp) >> 3)) {
> > do_warn(_("bad attr fork offset %d in inode %llu, "
> > - "max=%d\n"), dinoc->di_forkoff, lino,
> > + "max=%d\n"), dip->di_forkoff, lino,
> > XFS_LITINO(mp) >> 3);
> > return 1;
> > }
> > break;
> > default:
> > - do_error(_("unexpected inode format %d\n"), dinoc->di_format);
> > + do_error(_("unexpected inode format %d\n"), dip->di_format);
> > break;
> > }
> > return 0;
> > @@ -1951,24 +1917,24 @@
> > */
> > static int
> > process_inode_blocks_and_extents(
> > - xfs_dinode_core_t *dinoc,
> > + xfs_dinode_t *dip,
> > xfs_drfsbno_t nblocks,
> > __uint64_t nextents,
> > __uint64_t anextents,
> > xfs_ino_t lino,
> > int *dirty)
> > {
> > - if (nblocks != be64_to_cpu(dinoc->di_nblocks)) {
> > + if (nblocks != be64_to_cpu(dip->di_nblocks)) {
> > if (!no_modify) {
> > do_warn(_("correcting nblocks for inode %llu, "
> > "was %llu - counted %llu\n"), lino,
> > - be64_to_cpu(dinoc->di_nblocks), nblocks);
> > - dinoc->di_nblocks = cpu_to_be64(nblocks);
> > + be64_to_cpu(dip->di_nblocks), nblocks);
> > + dip->di_nblocks = cpu_to_be64(nblocks);
> > *dirty = 1;
> > } else {
> > do_warn(_("bad nblocks %llu for inode %llu, "
> > "would reset to %llu\n"),
> > - be64_to_cpu(dinoc->di_nblocks), lino, nblocks);
> > + be64_to_cpu(dip->di_nblocks), lino, nblocks);
> > }
> > }
> >
> > @@ -1977,16 +1943,16 @@
> > nextents, lino);
> > return 1;
> > }
> > - if (nextents != be32_to_cpu(dinoc->di_nextents)) {
> > + if (nextents != be32_to_cpu(dip->di_nextents)) {
> > if (!no_modify) {
> > do_warn(_("correcting nextents for inode %llu, "
> > "was %d - counted %llu\n"), lino,
> > - be32_to_cpu(dinoc->di_nextents), nextents);
> > - dinoc->di_nextents = cpu_to_be32(nextents);
> > + be32_to_cpu(dip->di_nextents), nextents);
> > + dip->di_nextents = cpu_to_be32(nextents);
> > *dirty = 1;
> > } else {
> > do_warn(_("bad nextents %d for inode %llu, would reset "
> > - "to %llu\n"), be32_to_cpu(dinoc->di_nextents),
> > + "to %llu\n"), be32_to_cpu(dip->di_nextents),
> > lino, nextents);
> > }
> > }
> > @@ -1996,16 +1962,16 @@
> > anextents, lino);
> > return 1;
> > }
> > - if (anextents != be16_to_cpu(dinoc->di_anextents)) {
> > + if (anextents != be16_to_cpu(dip->di_anextents)) {
> > if (!no_modify) {
> > do_warn(_("correcting anextents for inode %llu, "
> > "was %d - counted %llu\n"), lino,
> > - be16_to_cpu(dinoc->di_anextents), anextents);
> > - dinoc->di_anextents = cpu_to_be16(anextents);
> > + be16_to_cpu(dip->di_anextents), anextents);
> > + dip->di_anextents = cpu_to_be16(anextents);
> > *dirty = 1;
> > } else {
> > do_warn(_("bad anextents %d for inode %llu, would reset"
> > - " to %llu\n"), be16_to_cpu(dinoc->di_anextents),
> > + " to %llu\n"), be16_to_cpu(dip->di_anextents),
> > lino, anextents);
> > }
> > }
> > @@ -2020,7 +1986,7 @@
> > xfs_mount_t *mp,
> > xfs_agnumber_t agno,
> > xfs_agino_t ino,
> > - xfs_dinode_t *dino,
> > + xfs_dinode_t *dip,
> > int type,
> > int *dirty,
> > xfs_drfsbno_t *totblocks,
> > @@ -2028,30 +1994,29 @@
> > blkmap_t **dblkmap,
> > int check_dups)
> > {
> > - xfs_dinode_core_t *dinoc = &dino->di_core;
> > xfs_ino_t lino = XFS_AGINO_TO_INO(mp, agno, ino);
> > int err = 0;
> >
> > - *nextents = be32_to_cpu(dinoc->di_nextents);
> > - if (*nextents > be64_to_cpu(dinoc->di_nblocks))
> > + *nextents = be32_to_cpu(dip->di_nextents);
> > + if (*nextents > be64_to_cpu(dip->di_nblocks))
> > *nextents = 1;
> >
> > - if (dinoc->di_format != XFS_DINODE_FMT_LOCAL && type != XR_INO_RTDATA)
> > + if (dip->di_format != XFS_DINODE_FMT_LOCAL && type != XR_INO_RTDATA)
> > *dblkmap = blkmap_alloc(*nextents);
> > *nextents = 0;
> >
> > - switch (dinoc->di_format) {
> > + switch (dip->di_format) {
> > case XFS_DINODE_FMT_LOCAL:
> > - err = process_lclinode(mp, agno, ino, dino, XFS_DATA_FORK);
> > + err = process_lclinode(mp, agno, ino, dip, XFS_DATA_FORK);
> > *totblocks = 0;
> > break;
> > case XFS_DINODE_FMT_EXTENTS:
> > - err = process_exinode(mp, agno, ino, dino, type, dirty,
> > + err = process_exinode(mp, agno, ino, dip, type, dirty,
> > totblocks, nextents, dblkmap, XFS_DATA_FORK,
> > check_dups);
> > break;
> > case XFS_DINODE_FMT_BTREE:
> > - err = process_btinode(mp, agno, ino, dino, type, dirty,
> > + err = process_btinode(mp, agno, ino, dip, type, dirty,
> > totblocks, nextents, dblkmap, XFS_DATA_FORK,
> > check_dups);
> > break;
> > @@ -2060,13 +2025,13 @@
> > break;
> > default:
> > do_error(_("unknown format %d, ino %llu (mode = %d)\n"),
> > - dinoc->di_format, lino, be16_to_cpu(dinoc->di_mode));
> > + dip->di_format, lino, be16_to_cpu(dip->di_mode));
> > }
> >
> > if (err) {
> > do_warn(_("bad data fork in inode %llu\n"), lino);
> > if (!no_modify) {
> > - *dirty += clear_dinode(mp, dino, lino);
> > + *dirty += clear_dinode(mp, dip, lino);
> > ASSERT(*dirty > 0);
> > }
> > return 1;
> > @@ -2078,18 +2043,18 @@
> > * re-process data fork to set bitmap since the
> > * bitmap wasn't set the first time through
> > */
> > - switch (dinoc->di_format) {
> > + switch (dip->di_format) {
> > case XFS_DINODE_FMT_LOCAL:
> > - err = process_lclinode(mp, agno, ino, dino,
> > + err = process_lclinode(mp, agno, ino, dip,
> > XFS_DATA_FORK);
> > break;
> > case XFS_DINODE_FMT_EXTENTS:
> > - err = process_exinode(mp, agno, ino, dino, type,
> > + err = process_exinode(mp, agno, ino, dip, type,
> > dirty, totblocks, nextents, dblkmap,
> > XFS_DATA_FORK, 0);
> > break;
> > case XFS_DINODE_FMT_BTREE:
> > - err = process_btinode(mp, agno, ino, dino, type,
> > + err = process_btinode(mp, agno, ino, dip, type,
> > dirty, totblocks, nextents, dblkmap,
> > XFS_DATA_FORK, 0);
> > break;
> > @@ -2098,8 +2063,8 @@
> > break;
> > default:
> > do_error(_("unknown format %d, ino %llu (mode = %d)\n"),
> > - dinoc->di_format, lino,
> > - be16_to_cpu(dinoc->di_mode));
> > + dip->di_format, lino,
> > + be16_to_cpu(dip->di_mode));
> > }
> >
> > if (no_modify && err != 0)
> > @@ -2118,7 +2083,7 @@
> > xfs_mount_t *mp,
> > xfs_agnumber_t agno,
> > xfs_agino_t ino,
> > - xfs_dinode_t *dino,
> > + xfs_dinode_t *dip,
> > int type,
> > int *dirty,
> > xfs_drfsbno_t *atotblocks,
> > @@ -2127,20 +2092,19 @@
> > int extra_attr_check,
> > int *retval)
> > {
> > - xfs_dinode_core_t *dinoc = &dino->di_core;
> > xfs_ino_t lino = XFS_AGINO_TO_INO(mp, agno, ino);
> > blkmap_t *ablkmap = NULL;
> > int repair = 0;
> > int err;
> >
> > - if (!XFS_DFORK_Q(dino)) {
> > + if (!XFS_DFORK_Q(dip)) {
> > *anextents = 0;
> > - if (dinoc->di_aformat != XFS_DINODE_FMT_EXTENTS) {
> > + if (dip->di_aformat != XFS_DINODE_FMT_EXTENTS) {
> > do_warn(_("bad attribute format %d in inode %llu, "),
> > - dinoc->di_aformat, lino);
> > + dip->di_aformat, lino);
> > if (!no_modify) {
> > do_warn(_("resetting value\n"));
> > - dinoc->di_aformat = XFS_DINODE_FMT_EXTENTS;
> > + dip->di_aformat = XFS_DINODE_FMT_EXTENTS;
> > *dirty = 1;
> > } else
> > do_warn(_("would reset value\n"));
> > @@ -2148,33 +2112,33 @@
> > return 0;
> > }
> >
> > - *anextents = be16_to_cpu(dinoc->di_anextents);
> > - if (*anextents > be64_to_cpu(dinoc->di_nblocks))
> > + *anextents = be16_to_cpu(dip->di_anextents);
> > + if (*anextents > be64_to_cpu(dip->di_nblocks))
> > *anextents = 1;
> >
> > - switch (dinoc->di_aformat) {
> > + switch (dip->di_aformat) {
> > case XFS_DINODE_FMT_LOCAL:
> > *anextents = 0;
> > *atotblocks = 0;
> > - err = process_lclinode(mp, agno, ino, dino, XFS_ATTR_FORK);
> > + err = process_lclinode(mp, agno, ino, dip, XFS_ATTR_FORK);
> > break;
> > case XFS_DINODE_FMT_EXTENTS:
> > ablkmap = blkmap_alloc(*anextents);
> > *anextents = 0;
> > - err = process_exinode(mp, agno, ino, dino, type, dirty,
> > + err = process_exinode(mp, agno, ino, dip, type, dirty,
> > atotblocks, anextents, &ablkmap,
> > XFS_ATTR_FORK, check_dups);
> > break;
> > case XFS_DINODE_FMT_BTREE:
> > ablkmap = blkmap_alloc(*anextents);
> > *anextents = 0;
> > - err = process_btinode(mp, agno, ino, dino, type, dirty,
> > + err = process_btinode(mp, agno, ino, dip, type, dirty,
> > atotblocks, anextents, &ablkmap,
> > XFS_ATTR_FORK, check_dups);
> > break;
> > default:
> > do_warn(_("illegal attribute format %d, ino %llu\n"),
> > - dinoc->di_aformat, lino);
> > + dip->di_aformat, lino);
> > err = 1;
> > break;
> > }
> > @@ -2193,11 +2157,11 @@
> > if (!no_modify) {
> > if (delete_attr_ok) {
> > do_warn(_(", clearing attr fork\n"));
> > - *dirty += clear_dinode_attr(mp, dino, lino);
> > - dinoc->di_aformat = XFS_DINODE_FMT_LOCAL;
> > + *dirty += clear_dinode_attr(mp, dip, lino);
> > + dip->di_aformat = XFS_DINODE_FMT_LOCAL;
> > } else {
> > do_warn("\n");
> > - *dirty += clear_dinode(mp, dino, lino);
> > + *dirty += clear_dinode(mp, dip, lino);
> > }
> > ASSERT(*dirty > 0);
> > } else {
> > @@ -2213,24 +2177,24 @@
> > }
> >
> > if (check_dups) {
> > - switch (dinoc->di_aformat) {
> > + switch (dip->di_aformat) {
> > case XFS_DINODE_FMT_LOCAL:
> > - err = process_lclinode(mp, agno, ino, dino,
> > + err = process_lclinode(mp, agno, ino, dip,
> > XFS_ATTR_FORK);
> > break;
> > case XFS_DINODE_FMT_EXTENTS:
> > - err = process_exinode(mp, agno, ino, dino,
> > + err = process_exinode(mp, agno, ino, dip,
> > type, dirty, atotblocks, anextents,
> > &ablkmap, XFS_ATTR_FORK, 0);
> > break;
> > case XFS_DINODE_FMT_BTREE:
> > - err = process_btinode(mp, agno, ino, dino,
> > + err = process_btinode(mp, agno, ino, dip,
> > type, dirty, atotblocks, anextents,
> > &ablkmap, XFS_ATTR_FORK, 0);
> > break;
> > default:
> > do_error(_("illegal attribute fmt %d, ino %llu\n"),
> > - dinoc->di_aformat, lino);
> > + dip->di_aformat, lino);
> > }
> >
> > if (no_modify && err != 0) {
> > @@ -2247,14 +2211,14 @@
> >
> > /* get this only in phase 3, not in both phase 3 and 4 */
> > if (extra_attr_check &&
> > - process_attributes(mp, lino, dino, ablkmap, &repair)) {
> > + process_attributes(mp, lino, dip, ablkmap, &repair)) {
> > do_warn(_("problem with attribute contents in inode %llu\n"),
> > lino);
> > if (!repair) {
> > /* clear attributes if not done already */
> > if (!no_modify) {
> > - *dirty += clear_dinode_attr(mp, dino, lino);
> > - dinoc->di_aformat = XFS_DINODE_FMT_LOCAL;
> > + *dirty += clear_dinode_attr(mp, dip, lino);
> > + dip->di_aformat = XFS_DINODE_FMT_LOCAL;
> > } else {
> > do_warn(_("would clear attr fork\n"));
> > }
> > @@ -2277,18 +2241,18 @@
> >
> > static int
> > process_check_inode_nlink_version(
> > - xfs_dinode_core_t *dinoc,
> > + xfs_dinode_t *dip,
> > xfs_ino_t lino)
> > {
> > int dirty = 0;
> >
> > - if (dinoc->di_version > XFS_DINODE_VERSION_1 && !fs_inode_nlink) {
> > + if (dip->di_version > 1 && !fs_inode_nlink) {
> > /*
> > * do we have a fs/inode version mismatch with a valid
> > * version 2 inode here that has to stay version 2 or
> > * lose links?
> > */
> > - if (be32_to_cpu(dinoc->di_nlink) > XFS_MAXLINK_1) {
> > + if (be32_to_cpu(dip->di_nlink) > XFS_MAXLINK_1) {
> > /*
> > * yes. are nlink inodes allowed?
> > */
> > @@ -2318,17 +2282,17 @@
> > if (!no_modify) {
> > do_warn(_("converting back to version 1,\n"
> > "this may destroy %d links\n"),
> > - be32_to_cpu(dinoc->di_nlink) -
> > + be32_to_cpu(dip->di_nlink) -
> > XFS_MAXLINK_1);
> >
> > - dinoc->di_version = XFS_DINODE_VERSION_1;
> > - dinoc->di_nlink = cpu_to_be32(XFS_MAXLINK_1);
> > - dinoc->di_onlink = cpu_to_be16(XFS_MAXLINK_1);
> > + dip->di_version = 1;
> > + dip->di_nlink = cpu_to_be32(XFS_MAXLINK_1);
> > + dip->di_onlink = cpu_to_be16(XFS_MAXLINK_1);
> > dirty = 1;
> > } else {
> > do_warn(_("would convert back to version 1,\n"
> > "\tthis might destroy %d links\n"),
> > - be32_to_cpu(dinoc->di_nlink) -
> > + be32_to_cpu(dip->di_nlink) -
> > XFS_MAXLINK_1);
> > }
> > }
> > @@ -2344,9 +2308,9 @@
> > do_warn(_("found version 2 inode %llu, "), lino);
> > if (!no_modify) {
> > do_warn(_("converting back to version 1\n"));
> > - dinoc->di_version = XFS_DINODE_VERSION_1;
> > - dinoc->di_onlink = cpu_to_be16(
> > - be32_to_cpu(dinoc->di_nlink));
> > + dip->di_version = 1;
> > + dip->di_onlink = cpu_to_be16(
> > + be32_to_cpu(dip->di_nlink));
> > dirty = 1;
> > } else {
> > do_warn(_("would convert back to version 1\n"));
> > @@ -2359,18 +2323,17 @@
> > * to stay a version 2 inode. it should have a zero
> > * onlink field, so clear it.
> > */
> > - if (dinoc->di_version > XFS_DINODE_VERSION_1 &&
> > - dinoc->di_onlink != 0 && fs_inode_nlink > 0) {
> > + if (dip->di_version > 1 && dip->di_onlink != 0 && fs_inode_nlink > 0) {
> > if (!no_modify) {
> > do_warn(_("clearing obsolete nlink field in "
> > "version 2 inode %llu, was %d, now 0\n"),
> > - lino, be16_to_cpu(dinoc->di_onlink));
> > - dinoc->di_onlink = 0;
> > + lino, be16_to_cpu(dip->di_onlink));
> > + dip->di_onlink = 0;
> > dirty = 1;
> > } else {
> > do_warn(_("would clear obsolete nlink field in "
> > "version 2 inode %llu, currently %d\n"),
> > - lino, be16_to_cpu(dinoc->di_onlink));
> > + lino, be16_to_cpu(dip->di_onlink));
> > }
> > }
> > return dirty;
> > @@ -2388,7 +2351,7 @@
> > /* ARGSUSED */
> > int
> > process_dinode_int(xfs_mount_t *mp,
> > - xfs_dinode_t *dino,
> > + xfs_dinode_t *dip,
> > xfs_agnumber_t agno,
> > xfs_agino_t ino,
> > int was_free, /* 1 if inode is currently free */
> > @@ -2405,7 +2368,6 @@
> > {
> > xfs_drfsbno_t totblocks = 0;
> > xfs_drfsbno_t atotblocks = 0;
> > - xfs_dinode_core_t *dinoc;
> > int di_mode;
> > int type;
> > int retval = 0;
> > @@ -2420,9 +2382,8 @@
> > *used = is_used;
> > type = XR_INO_UNKNOWN;
> >
> > - dinoc = &dino->di_core;
> > lino = XFS_AGINO_TO_INO(mp, agno, ino);
> > - di_mode = be16_to_cpu(dinoc->di_mode);
> > + di_mode = be16_to_cpu(dip->di_mode);
> >
> > /*
> > * if in verify mode, don't modify the inode.
> > @@ -2438,35 +2399,33 @@
> > */
> > ASSERT(uncertain == 0 || verify_mode != 0);
> >
> > - if (be16_to_cpu(dinoc->di_magic) != XFS_DINODE_MAGIC) {
> > + if (be16_to_cpu(dip->di_magic) != XFS_DINODE_MAGIC) {
> > retval = 1;
> > if (!uncertain)
> > do_warn(_("bad magic number 0x%x on inode %llu%c"),
> > - be16_to_cpu(dinoc->di_magic), lino,
> > + be16_to_cpu(dip->di_magic), lino,
> > verify_mode ? '\n' : ',');
> > if (!verify_mode) {
> > if (!no_modify) {
> > do_warn(_(" resetting magic number\n"));
> > - dinoc->di_magic = cpu_to_be16(XFS_DINODE_MAGIC);
> > + dip->di_magic = cpu_to_be16(XFS_DINODE_MAGIC);
> > *dirty = 1;
> > } else
> > do_warn(_(" would reset magic number\n"));
> > }
> > }
> >
> > - if (!XFS_DINODE_GOOD_VERSION(dinoc->di_version) ||
> > - (!fs_inode_nlink && dinoc->di_version > XFS_DINODE_VERSION_1)) {
> > + if (!XFS_DINODE_GOOD_VERSION(dip->di_version) ||
> > + (!fs_inode_nlink && dip->di_version > 1)) {
> > retval = 1;
> > if (!uncertain)
> > do_warn(_("bad version number 0x%x on inode %llu%c"),
> > - (__s8)dinoc->di_version, lino,
> > + (__s8)dip->di_version, lino,
> > verify_mode ? '\n' : ',');
> > if (!verify_mode) {
> > if (!no_modify) {
> > do_warn(_(" resetting version number\n"));
> > - dinoc->di_version = (fs_inode_nlink) ?
> > - XFS_DINODE_VERSION_2 :
> > - XFS_DINODE_VERSION_1;
> > + dip->di_version = (fs_inode_nlink) ? 2 : 1;
> > *dirty = 1;
> > } else
> > do_warn(_(" would reset version number\n"));
> > @@ -2476,10 +2435,10 @@
> > /*
> > * blow out of here if the inode size is < 0
> > */
> > - if ((xfs_fsize_t)be64_to_cpu(dinoc->di_size) < 0) {
> > + if ((xfs_fsize_t)be64_to_cpu(dip->di_size) < 0) {
> > if (!uncertain)
> > do_warn(_("bad (negative) size %lld on inode %llu\n"),
> > - be64_to_cpu(dinoc->di_size), lino);
> > + be64_to_cpu(dip->di_size), lino);
> > if (verify_mode)
> > return 1;
> > goto clear_bad_out;
> > @@ -2500,7 +2459,7 @@
> > * set correctly
> > */
> > if (!no_modify)
> > - *dirty += clear_dinode(mp, dino, lino);
> > + *dirty += clear_dinode(mp, dip, lino);
> > *used = is_free;
> > return 0;
> > }
> > @@ -2512,7 +2471,7 @@
> > do_warn(_("imap claims a free inode %llu is in use, "), lino);
> > if (!no_modify) {
> > do_warn(_("correcting imap and clearing inode\n"));
> > - *dirty += clear_dinode(mp, dino, lino);
> > + *dirty += clear_dinode(mp, dip, lino);
> > retval = 1;
> > } else
> > do_warn(_("would correct imap and clear inode\n"));
> > @@ -2529,7 +2488,7 @@
> > * free inodes since technically any format is legal
> > * as we reset the inode when we re-use it.
> > */
> > - if (di_mode != 0 && check_dinode_mode_format(dinoc) != 0) {
> > + if (di_mode != 0 && check_dinode_mode_format(dip) != 0) {
> > if (!uncertain)
> > do_warn(_("bad inode format in inode %llu\n"), lino);
> > if (verify_mode)
> > @@ -2549,7 +2508,7 @@
> > * phase 4. Ugly.
> > */
> > if (check_dups && !no_modify)
> > - *dirty += clear_dinode_unlinked(mp, dino);
> > + *dirty += clear_dinode_unlinked(mp, dip);
> >
> > /* set type and map type info */
> >
> > @@ -2559,7 +2518,7 @@
> > *isa_dir = 1;
> > break;
> > case S_IFREG:
> > - if (be16_to_cpu(dinoc->di_flags) & XFS_DIFLAG_REALTIME)
> > + if (be16_to_cpu(dip->di_flags) & XFS_DIFLAG_REALTIME)
> > type = XR_INO_RTDATA;
> > else if (lino == mp->m_sb.sb_rbmino)
> > type = XR_INO_RTBITMAP;
> > @@ -2592,27 +2551,27 @@
> > /*
> > * type checks for superblock inodes
> > */
> > - if (process_check_sb_inodes(mp, dinoc, lino, &type, dirty) != 0)
> > + if (process_check_sb_inodes(mp, dip, lino, &type, dirty) != 0)
> > goto clear_bad_out;
> >
> > /*
> > * only regular files with REALTIME or EXTSIZE flags set can have
> > * extsize set, or directories with EXTSZINHERIT.
> > */
> > - if (be32_to_cpu(dinoc->di_extsize) != 0) {
> > + if (be32_to_cpu(dip->di_extsize) != 0) {
> > if ((type == XR_INO_RTDATA) ||
> > - (type == XR_INO_DIR && (be16_to_cpu(dinoc->di_flags) &
> > + (type == XR_INO_DIR && (be16_to_cpu(dip->di_flags) &
> > XFS_DIFLAG_EXTSZINHERIT)) ||
> > - (type == XR_INO_DATA && (be16_to_cpu(dinoc->di_flags) &
> > + (type == XR_INO_DATA && (be16_to_cpu(dip->di_flags) &
> > XFS_DIFLAG_EXTSIZE))) {
> > /* s'okay */ ;
> > } else {
> > do_warn(_("bad non-zero extent size %u for "
> > "non-realtime/extsize inode %llu, "),
> > - be32_to_cpu(dinoc->di_extsize), lino);
> > + be32_to_cpu(dip->di_extsize), lino);
> > if (!no_modify) {
> > do_warn(_("resetting to zero\n"));
> > - dinoc->di_extsize = 0;
> > + dip->di_extsize = 0;
> > *dirty = 1;
> > } else
> > do_warn(_("would reset to zero\n"));
> > @@ -2622,19 +2581,19 @@
> > /*
> > * general size/consistency checks:
> > */
> > - if (process_check_inode_sizes(mp, dino, lino, type) != 0)
> > + if (process_check_inode_sizes(mp, dip, lino, type) != 0)
> > goto clear_bad_out;
> >
> > /*
> > * check for illegal values of forkoff
> > */
> > - if (process_check_inode_forkoff(mp, dinoc, lino) != 0)
> > + if (process_check_inode_forkoff(mp, dip, lino) != 0)
> > goto clear_bad_out;
> >
> > /*
> > * check data fork -- if it's bad, clear the inode
> > */
> > - if (process_inode_data_fork(mp, agno, ino, dino, type, dirty,
> > + if (process_inode_data_fork(mp, agno, ino, dip, type, dirty,
> > &totblocks, &nextents, &dblkmap, check_dups) != 0)
> > goto bad_out;
> >
> > @@ -2642,7 +2601,7 @@
> > * check attribute fork if necessary. attributes are
> > * always stored in the regular filesystem.
> > */
> > - if (process_inode_attr_fork(mp, agno, ino, dino, type, dirty,
> > + if (process_inode_attr_fork(mp, agno, ino, dip, type, dirty,
> > &atotblocks, &anextents, check_dups, extra_attr_check,
> > &retval))
> > goto bad_out;
> > @@ -2656,7 +2615,7 @@
> > /*
> > * correct space counters if required
> > */
> > - if (process_inode_blocks_and_extents(dinoc, totblocks + atotblocks,
> > + if (process_inode_blocks_and_extents(dip, totblocks + atotblocks,
> > nextents, anextents, lino, dirty) != 0)
> > goto clear_bad_out;
> >
> > @@ -2666,9 +2625,9 @@
> > switch (type) {
> > case XR_INO_DIR:
> > if (xfs_sb_version_hasdirv2(&mp->m_sb) ?
> > - process_dir2(mp, lino, dino, ino_discovery,
> > + process_dir2(mp, lino, dip, ino_discovery,
> > dirty, "", parent, dblkmap) :
> > - process_dir(mp, lino, dino, ino_discovery,
> > + process_dir(mp, lino, dip, ino_discovery,
> > dirty, "", parent, dblkmap)) {
> > do_warn(_("problem with directory contents in "
> > "inode %llu\n"), lino);
> > @@ -2676,7 +2635,7 @@
> > }
> > break;
> > case XR_INO_SYMLINK:
> > - if (process_symlink(mp, lino, dino, dblkmap) != 0) {
> > + if (process_symlink(mp, lino, dip, dblkmap) != 0) {
> > do_warn(_("problem with symbolic link in inode %llu\n"),
> > lino);
> > goto clear_bad_out;
> > @@ -2694,13 +2653,13 @@
> > * just leave nlinks alone. even if it's set wrong,
> > * it'll be reset when read in.
> > */
> > - *dirty += process_check_inode_nlink_version(dinoc, lino);
> > + *dirty += process_check_inode_nlink_version(dip, lino);
> >
> > return retval;
> >
> > clear_bad_out:
> > if (!no_modify) {
> > - *dirty += clear_dinode(mp, dino, lino);
> > + *dirty += clear_dinode(mp, dip, lino);
> > ASSERT(*dirty > 0);
> > }
> > bad_out:
> > Index: xfs-cmds/xfsprogs/repair/dir.c
> > ===================================================================
> > --- xfs-cmds.orig/xfsprogs/repair/dir.c 2008-12-06 20:05:45.000000000 +0100
> > +++ xfs-cmds/xfsprogs/repair/dir.c 2008-12-06 20:05:49.000000000 +0100
> > @@ -107,7 +107,7 @@
> > sf = (xfs_dir_shortform_t *)XFS_DFORK_DPTR(dip);
> > max_size = XFS_DFORK_DSIZE(dip, mp);
> > num_entries = sf->hdr.count;
> > - ino_dir_size = be64_to_cpu(dip->di_core.di_size);
> > + ino_dir_size = be64_to_cpu(dip->di_size);
> > *repair = 0;
> >
> > ASSERT(ino_dir_size <= max_size);
> > @@ -338,7 +338,7 @@
> >
> > if (!no_modify) {
> > tmp_elen = xfs_dir_sf_entsize_byentry(sf_entry);
> > - be64_add_cpu(&dip->di_core.di_size, -tmp_elen);
> > + be64_add_cpu(&dip->di_size, -tmp_elen);
> > ino_dir_size -= tmp_elen;
> >
> > tmp_sfe = (xfs_dir_sf_entry_t *)
> > @@ -425,7 +425,7 @@
> > ino, (__int64_t) ino_dir_size,
> > (__int64_t)((__psint_t) next_sfe - (__psint_t) sf));
> >
> > - dip->di_core.di_size = cpu_to_be64((__psint_t)next_sfe
> > + dip->di_size = cpu_to_be64((__psint_t)next_sfe
> > - (__psint_t)sf);
> > *dino_dirty = 1;
> > *repair = 1;
> > @@ -954,7 +954,7 @@
> > return(fsbno);
> > }
> >
> > - if (be64_to_cpu(dino->di_core.di_size) <= XFS_LBSIZE(mp))
> > + if (be64_to_cpu(dino->di_size) <= XFS_LBSIZE(mp))
> > return(fsbno);
> >
> > do {
> > @@ -2551,7 +2551,7 @@
> > /*
> > * sanity check inode size
> > */
> > - if (be64_to_cpu(dip->di_core.di_size) <
> > + if (be64_to_cpu(dip->di_size) <
> > (da_cursor.greatest_bno + 1) * mp->m_sb.sb_blocksize) {
> > if ((xfs_fsize_t) da_cursor.greatest_bno
> > * mp->m_sb.sb_blocksize > UINT_MAX) {
> > @@ -2565,9 +2565,9 @@
> > _("setting directory inode (%llu) size to %llu bytes, was %lld bytes\n"),
> > ino, (xfs_dfiloff_t) (da_cursor.greatest_bno + 1)
> > * mp->m_sb.sb_blocksize,
> > - be64_to_cpu(dip->di_core.di_size));
> > + be64_to_cpu(dip->di_size));
> >
> > - dip->di_core.di_size = cpu_to_be64((da_cursor.greatest_bno + 1)
> > + dip->di_size = cpu_to_be64((da_cursor.greatest_bno + 1)
> > * mp->m_sb.sb_blocksize);
> > }
> > return(0);
> > @@ -2709,13 +2709,13 @@
> > * is only called ONCE so all the subordinate routines will
> > * fix '.' and junk '..' if they're bogus.
> > */
> > - if (be64_to_cpu(dip->di_core.di_size) <= XFS_DFORK_DSIZE(dip, mp)) {
> > + if (be64_to_cpu(dip->di_size) <= XFS_DFORK_DSIZE(dip, mp)) {
> > dot = 1;
> > dotdot = 1;
> > if (process_shortform_dir(mp, ino, dip, ino_discovery,
> > dino_dirty, parent, dirname, &repair))
> > res = 1;
> > - } else if (be64_to_cpu(dip->di_core.di_size) <= XFS_LBSIZE(mp)) {
> > + } else if (be64_to_cpu(dip->di_size) <= XFS_LBSIZE(mp)) {
> > if (process_leaf_dir(mp, ino, dip, ino_discovery,
> > dino_dirty, blkmap, &dot, &dotdot,
> > parent, dirname, &repair))
> > Index: xfs-cmds/xfsprogs/repair/dir2.c
> > ===================================================================
> > --- xfs-cmds.orig/xfsprogs/repair/dir2.c 2008-12-06 20:05:45.000000000 +0100
> > +++ xfs-cmds/xfsprogs/repair/dir2.c 2008-12-06 20:05:49.000000000 +0100
> > @@ -806,7 +806,7 @@
> > xfs_dir2_sf_entry_t *sfep;
> > xfs_dir2_sf_t *sfp;
> >
> > - sfp = &dip->di_u.di_dir2sf;
> > + sfp = (xfs_dir2_sf_t *)XFS_DFORK_DPTR(dip);
> > sfep = xfs_dir2_sf_firstentry(sfp);
> > offset = XFS_DIR2_DATA_FIRST_OFFSET;
> >
> > @@ -858,10 +858,10 @@
> > xfs_dir2_sf_entry_t *tmp_sfep;
> > xfs_ino_t zero = 0;
> >
> > - sfp = &dip->di_u.di_dir2sf;
> > + sfp = (xfs_dir2_sf_t *)XFS_DFORK_DPTR(dip);
> > max_size = XFS_DFORK_DSIZE(dip, mp);
> > num_entries = sfp->hdr.count;
> > - ino_dir_size = be64_to_cpu(dip->di_core.di_size);
> > + ino_dir_size = be64_to_cpu(dip->di_size);
> > offset = XFS_DIR2_DATA_FIRST_OFFSET;
> > bad_offset = *repair = 0;
> >
> > @@ -1097,7 +1097,7 @@
> > if (!no_modify) {
> > tmp_elen =
> > xfs_dir2_sf_entsize_byentry(sfp, sfep);
> > - be64_add_cpu(&dip->di_core.di_size, -tmp_elen);
> > + be64_add_cpu(&dip->di_size, -tmp_elen);
> > ino_dir_size -= tmp_elen;
> >
> > tmp_sfep = (xfs_dir2_sf_entry_t *)
> > @@ -1205,7 +1205,7 @@
> > (__int64_t)((__psint_t)next_sfep -
> > (__psint_t)sfp));
> >
> > - dip->di_core.di_size = cpu_to_be64(
> > + dip->di_size = cpu_to_be64(
> > (__psint_t)next_sfep - (__psint_t)sfp);
> > *dino_dirty = 1;
> > *repair = 1;
> > @@ -2069,20 +2069,20 @@
> > */
> > if (blkmap)
> > last = blkmap_last_off(blkmap);
> > - if (be64_to_cpu(dip->di_core.di_size) <= XFS_DFORK_DSIZE(dip, mp) &&
> > - dip->di_core.di_format == XFS_DINODE_FMT_LOCAL) {
> > + if (be64_to_cpu(dip->di_size) <= XFS_DFORK_DSIZE(dip, mp) &&
> > + dip->di_format == XFS_DINODE_FMT_LOCAL) {
> > dot = dotdot = 1;
> > res = process_sf_dir2(mp, ino, dip, ino_discovery, dino_dirty,
> > dirname, parent, &repair);
> > } else if (last == mp->m_dirblkfsbs &&
> > - (dip->di_core.di_format == XFS_DINODE_FMT_EXTENTS ||
> > - dip->di_core.di_format == XFS_DINODE_FMT_BTREE)) {
> > + (dip->di_format == XFS_DINODE_FMT_EXTENTS ||
> > + dip->di_format == XFS_DINODE_FMT_BTREE)) {
> > res = process_block_dir2(mp, ino, dip, ino_discovery,
> > dino_dirty, dirname, parent, blkmap, &dot, &dotdot,
> > &repair);
> > } else if (last >= mp->m_dirleafblk + mp->m_dirblkfsbs &&
> > - (dip->di_core.di_format == XFS_DINODE_FMT_EXTENTS ||
> > - dip->di_core.di_format == XFS_DINODE_FMT_BTREE)) {
> > + (dip->di_format == XFS_DINODE_FMT_EXTENTS ||
> > + dip->di_format == XFS_DINODE_FMT_BTREE)) {
> > res = process_leaf_node_dir2(mp, ino, dip, ino_discovery,
> > dirname, parent, blkmap, &dot, &dotdot, &repair,
> > last > mp->m_dirleafblk + mp->m_dirblkfsbs);
> > Index: xfs-cmds/xfsprogs/repair/phase6.c
> > ===================================================================
> > --- xfs-cmds.orig/xfsprogs/repair/phase6.c 2008-12-06 20:05:45.000000000 +0100
> > +++ xfs-cmds/xfsprogs/repair/phase6.c 2008-12-06 20:05:49.000000000 +0100
> > @@ -444,11 +444,11 @@
> > error);
> > }
> >
> > - memset(&ip->i_d, 0, sizeof(xfs_dinode_core_t));
> > + memset(&ip->i_d, 0, sizeof(xfs_icdinode_t));
> >
> > ip->i_d.di_magic = XFS_DINODE_MAGIC;
> > ip->i_d.di_mode = S_IFREG;
> > - ip->i_d.di_version = XFS_DINODE_VERSION_1;
> > + ip->i_d.di_version = 1;
> > ip->i_d.di_format = XFS_DINODE_FMT_EXTENTS;
> > ip->i_d.di_aformat = XFS_DINODE_FMT_EXTENTS;
> >
> > @@ -677,11 +677,11 @@
> > error);
> > }
> >
> > - memset(&ip->i_d, 0, sizeof(xfs_dinode_core_t));
> > + memset(&ip->i_d, 0, sizeof(xfs_icdinode_t));
> >
> > ip->i_d.di_magic = XFS_DINODE_MAGIC;
> > ip->i_d.di_mode = S_IFREG;
> > - ip->i_d.di_version = XFS_DINODE_VERSION_1;
> > + ip->i_d.di_version = 1;
> > ip->i_d.di_format = XFS_DINODE_FMT_EXTENTS;
> > ip->i_d.di_aformat = XFS_DINODE_FMT_EXTENTS;
> >
> > @@ -778,11 +778,11 @@
> > /*
> > * take care of the core -- initialization from xfs_ialloc()
> > */
> > - memset(&ip->i_d, 0, sizeof(xfs_dinode_core_t));
> > + memset(&ip->i_d, 0, sizeof(xfs_icdinode_t));
> >
> > ip->i_d.di_magic = XFS_DINODE_MAGIC;
> > ip->i_d.di_mode = (__uint16_t) mode|S_IFDIR;
> > - ip->i_d.di_version = XFS_DINODE_VERSION_1;
> > + ip->i_d.di_version = 1;
> > ip->i_d.di_format = XFS_DINODE_FMT_EXTENTS;
> > ip->i_d.di_aformat = XFS_DINODE_FMT_EXTENTS;
> >
> > Index: xfs-cmds/xfsprogs/repair/prefetch.c
> > ===================================================================
> > --- xfs-cmds.orig/xfsprogs/repair/prefetch.c 2008-12-06 20:05:45.000000000 +0100
> > +++ xfs-cmds/xfsprogs/repair/prefetch.c 2008-12-06 20:05:49.000000000 +0100
> > @@ -330,7 +330,7 @@
> > xfs_dinode_t *dino)
> > {
> > pf_read_bmbt_reclist(args, (xfs_bmbt_rec_t *)XFS_DFORK_DPTR(dino),
> > - be32_to_cpu(dino->di_core.di_nextents));
> > + be32_to_cpu(dino->di_nextents));
> > }
> >
> > static void
> > @@ -338,27 +338,25 @@
> > prefetch_args_t *args,
> > xfs_buf_t *bp)
> > {
> > - xfs_dinode_t *dino;
> > int icnt = 0;
> > int hasdir = 0;
> > int isadir;
> > - xfs_dinode_core_t *dinoc;
> > + xfs_dinode_t *dip;
> >
> > for (icnt = 0; icnt < (XFS_BUF_COUNT(bp) >> mp->m_sb.sb_inodelog); icnt++) {
> > - dino = XFS_MAKE_IPTR(mp, bp, icnt);
> > - dinoc = &dino->di_core;
> > + dip = XFS_MAKE_IPTR(mp, bp, icnt);
> >
> > /*
> > * We are only prefetching directory contents in extents
> > * and btree nodes for other inodes
> > */
> > - isadir = (be16_to_cpu(dinoc->di_mode) & S_IFMT) == S_IFDIR;
> > + isadir = (be16_to_cpu(dip->di_mode) & S_IFMT) == S_IFDIR;
> > hasdir |= isadir;
> >
> > - if (dinoc->di_format <= XFS_DINODE_FMT_LOCAL)
> > + if (dip->di_format <= XFS_DINODE_FMT_LOCAL)
> > continue;
> >
> > - if (!isadir && (dinoc->di_format == XFS_DINODE_FMT_EXTENTS ||
> > + if (!isadir && (dip->di_format == XFS_DINODE_FMT_EXTENTS ||
> > args->dirs_only))
> > continue;
> >
> > @@ -367,30 +365,29 @@
> > * its directory data. It's a cut down version of
> > * process_dinode_int() in dinode.c.
> > */
> > - if (dinoc->di_format > XFS_DINODE_FMT_BTREE)
> > + if (dip->di_format > XFS_DINODE_FMT_BTREE)
> > continue;
> >
> > - if (be16_to_cpu(dinoc->di_magic) != XFS_DINODE_MAGIC)
> > + if (be16_to_cpu(dip->di_magic) != XFS_DINODE_MAGIC)
> > continue;
> >
> > - if (!XFS_DINODE_GOOD_VERSION(dinoc->di_version) ||
> > - (!fs_inode_nlink && dinoc->di_version >
> > - XFS_DINODE_VERSION_1))
> > + if (!XFS_DINODE_GOOD_VERSION(dip->di_version) ||
> > + (!fs_inode_nlink && dip->di_version > 1))
> > continue;
> >
> > - if (be64_to_cpu(dinoc->di_size) <= XFS_DFORK_DSIZE(dino, mp))
> > + if (be64_to_cpu(dip->di_size) <= XFS_DFORK_DSIZE(dip, mp))
> > continue;
> >
> > - if ((dinoc->di_forkoff != 0) &&
> > - (dinoc->di_forkoff >= (XFS_LITINO(mp) >> 3)))
> > + if (dip->di_forkoff &&
> > + (dip->di_forkoff >= (XFS_LITINO(mp) >> 3)))
> > continue;
> >
> > - switch (dinoc->di_format) {
> > + switch (dip->di_format) {
> > case XFS_DINODE_FMT_EXTENTS:
> > - pf_read_exinode(args, dino);
> > + pf_read_exinode(args, dip);
> > break;
> > case XFS_DINODE_FMT_BTREE:
> > - pf_read_btinode(args, dino, isadir);
> > + pf_read_btinode(args, dip, isadir);
> > break;
> > }
> > }
> > Index: xfs-cmds/xfsprogs/include/libxfs.h
> > ===================================================================
> > --- xfs-cmds.orig/xfsprogs/include/libxfs.h 2008-12-06 20:05:46.000000000 +0100
> > +++ xfs-cmds/xfsprogs/include/libxfs.h 2008-12-06 20:05:49.000000000 +0100
> > @@ -389,10 +389,8 @@
> > struct cache_node i_node;
> > xfs_mount_t *i_mount; /* fs mount struct ptr */
> > xfs_ino_t i_ino; /* inode number (agno/agino) */
> > - xfs_daddr_t i_blkno; /* blkno of inode buffer */
> > + struct xfs_imap i_imap; /* location for xfs_imap() */
> > dev_t i_dev; /* dev for this inode */
> > - ushort i_len; /* len of inode buffer */
> > - ushort i_boffset; /* off of inode in buffer */
> > xfs_ifork_t *i_afp; /* attribute fork pointer */
> > xfs_ifork_t i_df; /* data fork */
> > xfs_trans_t *i_transp; /* ptr to owning transaction */
> > @@ -419,8 +417,6 @@
> >
> > extern void libxfs_ichgtime (xfs_inode_t *, int);
> > extern int libxfs_iflush_int (xfs_inode_t *, xfs_buf_t *);
> > -extern int libxfs_iread (xfs_mount_t *, xfs_trans_t *, xfs_ino_t,
> > - xfs_inode_t *, xfs_daddr_t);
> >
> > /* Inode Cache Interfaces */
> > extern struct cache *libxfs_icache;
> > @@ -465,7 +461,6 @@
> > #include <xfs/xfs_attr_leaf.h>
> > #include <xfs/xfs_quota.h>
> > #include <xfs/xfs_trans_space.h>
> > -#include <xfs/xfs_imap.h>
> > #include <xfs/xfs_log.h>
> > #include <xfs/xfs_log_priv.h>
> >
> > Index: xfs-cmds/xfsprogs/libxfs/logitem.c
> > ===================================================================
> > --- xfs-cmds.orig/xfsprogs/libxfs/logitem.c 2008-12-06 20:05:45.000000000 +0100
> > +++ xfs-cmds/xfsprogs/libxfs/logitem.c 2008-12-06 20:05:49.000000000 +0100
> > @@ -493,7 +493,7 @@
> > iip->ili_inode = ip;
> > iip->ili_format.ilf_type = XFS_LI_INODE;
> > iip->ili_format.ilf_ino = ip->i_ino;
> > - iip->ili_format.ilf_blkno = ip->i_blkno;
> > - iip->ili_format.ilf_len = ip->i_len;
> > - iip->ili_format.ilf_boffset = ip->i_boffset;
> > + iip->ili_format.ilf_blkno = ip->i_imap.im_blkno;
> > + iip->ili_format.ilf_len = ip->i_imap.im_len;
> > + iip->ili_format.ilf_boffset = ip->i_imap.im_boffset;
> > }
> > Index: xfs-cmds/xfsprogs/libxfs/rdwr.c
> > ===================================================================
> > --- xfs-cmds.orig/xfsprogs/libxfs/rdwr.c 2008-12-06 20:05:46.000000000 +0100
> > +++ xfs-cmds/xfsprogs/libxfs/rdwr.c 2008-12-06 20:05:49.000000000 +0100
> > @@ -677,7 +677,10 @@
> > fprintf(stderr, "%s: allocated inode, ino=%llu(%llu), %p\n",
> > __FUNCTION__, (unsigned long long)ino, bno, ip);
> > #endif
> > - if ((error = libxfs_iread(mp, tp, ino, ip, bno))) {
> > + ip->i_ino = ino;
> > + ip->i_mount = mp;
> > + error = xfs_iread(mp, tp, ip, bno, 0);
> > + if (error) {
> > cache_node_purge(libxfs_icache, &ino,
> > (struct cache_node *)ip);
> > ip = NULL;
> > Index: xfs-cmds/xfsprogs/libxfs/trans.c
> > ===================================================================
> > --- xfs-cmds.orig/xfsprogs/libxfs/trans.c 2008-12-06 20:05:46.000000000 +0100
> > +++ xfs-cmds/xfsprogs/libxfs/trans.c 2008-12-06 20:05:49.000000000 +0100
> > @@ -592,7 +592,7 @@
> > /*
> > * Get the buffer containing the on-disk inode.
> > */
> > - error = xfs_itobp(mp, NULL, ip, &dip, &bp, 0, 0, 0);
> > + error = xfs_itobp(mp, NULL, ip, &dip, &bp, 0);
> > if (error) {
> > fprintf(stderr, _("%s: warning - itobp failed (%d)\n"),
> > progname, error);
> > Index: xfs-cmds/xfsprogs/libxfs/xfs.h
> > ===================================================================
> > --- xfs-cmds.orig/xfsprogs/libxfs/xfs.h 2008-12-06 20:05:45.000000000 +0100
> > +++ xfs-cmds/xfsprogs/libxfs/xfs.h 2008-12-06 20:05:49.000000000 +0100
> > @@ -181,6 +181,7 @@
> > #define XFS_BUF_UNDELAYWRITE(bp) ((bp)->b_flags &= ~LIBXFS_B_DIRTY)
> > #define XFS_BUF_SET_VTYPE(a,b) ((void) 0)
> > #define XFS_BUF_SET_VTYPE_REF(a,b,c) ((void) 0)
> > +#define XFS_BUF_SET_REF(a,b) ((void) 0)
> > #define XFS_BUF_SET_BDSTRAT_FUNC(a,b) ((void) 0)
> >
> > #define xfs_incore(bt,blkno,len,lockit) 0
> > @@ -300,7 +301,6 @@
> > /* xfs_inode.c */
> > void xfs_iflush_fork(xfs_inode_t *, xfs_dinode_t *, xfs_inode_log_item_t *,
> > int, xfs_buf_t *);
> > -int xfs_iformat(xfs_inode_t *, xfs_dinode_t *);
> >
> > /* xfs_mount.c */
> > int xfs_initialize_perag_data(xfs_mount_t *, xfs_agnumber_t);
> > Index: xfs-cmds/xfsprogs/libxfs/xfs_da_btree.c
> > ===================================================================
> > --- xfs-cmds.orig/xfsprogs/libxfs/xfs_da_btree.c 2008-12-06 20:05:46.000000000 +0100
> > +++ xfs-cmds/xfsprogs/libxfs/xfs_da_btree.c 2008-12-06 20:05:49.000000000 +0100
> > @@ -1539,11 +1539,14 @@
> > int nmap, error, w, count, c, got, i, mapi;
> > xfs_trans_t *tp;
> > xfs_mount_t *mp;
> > + xfs_drfsbno_t nblks;
> >
> > dp = args->dp;
> > mp = dp->i_mount;
> > w = args->whichfork;
> > tp = args->trans;
> > + nblks = dp->i_d.di_nblocks;
> > +
> > /*
> > * For new directories adjust the file offset and block count.
> > */
> > @@ -1620,6 +1623,8 @@
> > }
> > if (mapp != &map)
> > kmem_free(mapp);
> > + /* account for newly allocated blocks in reserved blocks total */
> > + args->total -= dp->i_d.di_nblocks - nblks;
> > *new_blkno = (xfs_dablk_t)bno;
> > return 0;
> > }
> > Index: xfs-cmds/xfsprogs/libxfs/xfs_bmap.c
> > ===================================================================
> > --- xfs-cmds.orig/xfsprogs/libxfs/xfs_bmap.c 2008-12-06 20:05:46.000000000 +0100
> > +++ xfs-cmds/xfsprogs/libxfs/xfs_bmap.c 2008-12-06 20:05:49.000000000 +0100
> > @@ -169,7 +169,7 @@
> > * Remove the entry "free" from the free item list. Prev points to the
> > * previous entry, unless "free" is the head of the list.
> > *
> > - * Note: this requires user-space public scope for libxfs_iread
> > + * Note: this requires user-space public scope for libxfs_bmap_finish
> > */
> > void
> > xfs_bmap_del_free(
> > @@ -3250,7 +3250,7 @@
> > * Remove the entry "free" from the free item list. Prev points to the
> > * previous entry, unless "free" is the head of the list.
> > *
> > - * Note: this requires user-space public scope for libxfs_iread
> > + * Note: this requires user-space public scope for libxfs_bmap_finish
> > */
> > void
> > xfs_bmap_del_free(
> > Index: xfs-cmds/xfstests/186
> > ===================================================================
> > --- xfs-cmds.orig/xfstests/186 2008-12-06 20:04:34.000000000 +0100
> > +++ xfs-cmds/xfstests/186 2008-12-06 20:05:59.000000000 +0100
> > @@ -66,7 +66,7 @@
> >
> > _filter_inode()
> > {
> > - tee -a $seq.full | egrep '^u.sfdir2|^a.sfattr|core.forkoff' |\
> > + tee -a $seq.full | egrep '^u.sfdir2|^a.sfattr|forkoff' |\
> > egrep -v 'inumber|parent'
> > }
> >
> > Index: xfs-cmds/xfstests/186.out
> > ===================================================================
> > --- xfs-cmds.orig/xfstests/186.out 2008-12-06 20:05:57.000000000 +0100
> > +++ xfs-cmds/xfstests/186.out 2008-12-06 20:05:59.000000000 +0100
> > @@ -2,7 +2,7 @@
> >
> > =================================
> > ATTR2
> > -core.forkoff = 0
> > +forkoff = 0
> > u.sfdir2.hdr.count = 0
> > u.sfdir2.hdr.i8count = 0
> > =================================
> > @@ -12,7 +12,7 @@
> >
> > =================================
> > ATTR2
> > -core.forkoff = 0
> > +forkoff = 0
> > u.sfdir2.hdr.count = 25
> > u.sfdir2.hdr.i8count = 0
> > u.sfdir2.list[0].namelen = 6
> > @@ -98,7 +98,7 @@
> > =================================
> > ATTR
> > ATTR2
> > -core.forkoff = 47
> > +forkoff = 47
> > u.sfdir2.hdr.count = 25
> > u.sfdir2.hdr.i8count = 0
> > u.sfdir2.list[0].namelen = 6
> > @@ -195,7 +195,7 @@
> >
> > =================================
> > ATTR
> > -core.forkoff = 47
> > +forkoff = 47
> > u.sfdir2.hdr.count = 25
> > u.sfdir2.hdr.i8count = 0
> > u.sfdir2.list[0].namelen = 6
> >
> > --
> >
> > _______________________________________________
> > xfs mailing list
> > xfs@oss.sgi.com
> > http://oss.sgi.com/mailman/listinfo/xfs
> ---end quoted text---
>
> _______________________________________________
> xfs mailing list
> xfs@oss.sgi.com
> http://oss.sgi.com/mailman/listinfo/xfs
---end quoted text---
_______________________________________________
xfs mailing list
xfs@oss.sgi.com
http://oss.sgi.com/mailman/listinfo/xfs
next prev parent reply other threads:[~2009-01-22 20:16 UTC|newest]
Thread overview: 30+ messages / expand[flat|nested] mbox.gz Atom feed top
2008-12-22 16:38 [PATCH 00/20] xfs-cmds staging tree Christoph Hellwig
2008-12-22 16:38 ` [PATCH 01/20] fix up xfs-cmds build after the parallel-fest Christoph Hellwig
2008-12-22 16:38 ` [PATCH 02/20] update Debian packaging Christoph Hellwig
2008-12-22 16:38 ` [PATCH 03/20] Fix build when gettext is enabled Christoph Hellwig
2008-12-22 16:38 ` [PATCH 04/20] Apply gettext translation to strings kept in format->{fmt, msg, type} Christoph Hellwig
2008-12-22 16:38 ` [PATCH 05/20] xfsprogs Polish translation update Christoph Hellwig
2008-12-22 16:38 ` [PATCH 06/20] build system: Make --enable-gettext actually enable gettext Christoph Hellwig
2008-12-22 16:38 ` [PATCH 07/20] return error status from the xfs_quota tool Christoph Hellwig
2008-12-22 16:38 ` [PATCH 08/20] xfs_quota: Add missing options to --help Christoph Hellwig
2008-12-22 16:38 ` [PATCH 09/20] xfs_quota: Fix range for -U Christoph Hellwig
2008-12-22 16:38 ` [PATCH 10/20] xfs_quota: Warn if specified non-zero quota will be round down to zero Christoph Hellwig
2008-12-22 16:38 ` [PATCH 11/20] xfs_quota: Dont ignore every error when asking for quota Christoph Hellwig
2008-12-22 16:38 ` [PATCH 12/20] EXCLUDED_FILE_TYPES: Fix macro for negation case Christoph Hellwig
2008-12-22 16:38 ` [PATCH 13/20] xfstests: test 194, test tricky mapping/conversion around holes Christoph Hellwig
2008-12-22 16:38 ` [PATCH 14/20] xfstests: add a unified diff option Christoph Hellwig
2008-12-22 16:38 ` [PATCH 15/20] fix xfsqa 189 for log and rt devices Christoph Hellwig
2008-12-22 16:38 ` [PATCH 16/20] xfstests: fix dbtest build Christoph Hellwig
2008-12-22 16:38 ` [PATCH 17/20] xfstests: add more tests to the auto group Christoph Hellwig
2008-12-22 16:38 ` [PATCH 18/20] 080 seems to run fine on linux, un-comment the quiet var to make the output match. Added to auto group as well Christoph Hellwig
2008-12-22 16:38 ` [PATCH 19/20] xfsdump: add support for building with sparse Christoph Hellwig
2008-12-22 16:38 ` [PATCH 20/20] xfsprogs: resync libxfs with the kernel code Christoph Hellwig
2008-12-30 17:39 ` Christoph Hellwig
2009-01-22 20:15 ` Christoph Hellwig [this message]
2008-12-22 20:33 ` [PATCH 00/20] xfs-cmds staging tree Mark Goodwin
2008-12-22 20:49 ` Christoph Hellwig
2008-12-22 22:11 ` Mark Goodwin
2008-12-22 22:16 ` Christoph Hellwig
2008-12-22 23:02 ` Nathan Scott
2008-12-29 5:26 ` Mark Goodwin
2008-12-29 8:41 ` Christoph Hellwig
Reply instructions:
You may reply publicly to this message via plain-text email
using any one of the following methods:
* Save the following mbox file, import it into your mail client,
and reply-to-all from there: mbox
Avoid top-posting and favor interleaved quoting:
https://en.wikipedia.org/wiki/Posting_style#Interleaved_style
* Reply using the --to, --cc, and --in-reply-to
switches of git-send-email(1):
git send-email \
--in-reply-to=20090122201524.GA4447@infradead.org \
--to=hch@infradead.org \
--cc=xfs@oss.sgi.com \
/path/to/YOUR_REPLY
https://kernel.org/pub/software/scm/git/docs/git-send-email.html
* If your mail client supports setting the In-Reply-To header
via mailto: links, try the mailto: link
Be sure your reply has a Subject: header at the top and a blank line
before the message body.
This is an external index of several public inboxes,
see mirroring instructions on how to clone and mirror
all data and code used by this external index.