[PATCH 20/20] xfsprogs: resync libxfs with the kernel code

Christoph Hellwig
2008-12-22T16:44:48Z

[-- Attachment #1: libxfs-resync --]
[-- Type: text/plain, Size: 174606 bytes --]

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