From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from cuda.sgi.com (cuda3.sgi.com [192.48.176.15]) by oss.sgi.com (8.14.3/8.14.3/SuSE Linux 0.8) with ESMTP id n0MKG94S107718 for ; Thu, 22 Jan 2009 14:16:09 -0600 Received: from bombadil.infradead.org (localhost [127.0.0.1]) by cuda.sgi.com (Spam Firewall) with ESMTP id 7273F184F188 for ; Thu, 22 Jan 2009 12:15:25 -0800 (PST) Received: from bombadil.infradead.org (bombadil.infradead.org [18.85.46.34]) by cuda.sgi.com with ESMTP id yzXsjIQasXTpEEOt for ; Thu, 22 Jan 2009 12:15:25 -0800 (PST) Received: from hch by bombadil.infradead.org with local (Exim 4.69 #1 (Red Hat Linux)) id 1LQ5xU-0002Pe-PA for xfs@oss.sgi.com; Thu, 22 Jan 2009 20:15:24 +0000 Date: Thu, 22 Jan 2009 15:15:24 -0500 From: Christoph Hellwig Subject: Re: [PATCH 20/20] xfsprogs: resync libxfs with the kernel code Message-ID: <20090122201524.GA4447@infradead.org> References: <20081222163831.755809000@bombadil.infradead.org> <20081222164412.220377000@bombadil.infradead.org> <20081230173935.GA31861@infradead.org> MIME-Version: 1.0 Content-Disposition: inline In-Reply-To: <20081230173935.GA31861@infradead.org> List-Id: XFS Filesystem from SGI List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Content-Type: text/plain; charset="us-ascii" Content-Transfer-Encoding: 7bit Sender: xfs-bounces@oss.sgi.com Errors-To: xfs-bounces@oss.sgi.com To: xfs@oss.sgi.com ping On Tue, Dec 30, 2008 at 12:39:35PM -0500, Christoph Hellwig wrote: > I know this is a lot of churn, but can I get a review for this please? > > On Mon, Dec 22, 2008 at 11:38:51AM -0500, Christoph Hellwig wrote: > > Also use the kernel xfs_iread now instead of a duplicated version. > > > > > > > > Signed-off-by: Christoph Hellwig > > > > 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 > > #include > > #include > > -#include > > #include > > #include > > > > Index: xfs-cmds/xfsprogs/libxfs/logitem.c > > =================================================================== > > --- xfs-cmds.orig/xfsprogs/libxfs/logitem.c 2008-12-06 20:05:45.000000000 +0100 > > +++ xfs-cmds/xfsprogs/libxfs/logitem.c 2008-12-06 20:05:49.000000000 +0100 > > @@ -493,7 +493,7 @@ > > iip->ili_inode = ip; > > iip->ili_format.ilf_type = XFS_LI_INODE; > > iip->ili_format.ilf_ino = ip->i_ino; > > - iip->ili_format.ilf_blkno = ip->i_blkno; > > - iip->ili_format.ilf_len = ip->i_len; > > - iip->ili_format.ilf_boffset = ip->i_boffset; > > + iip->ili_format.ilf_blkno = ip->i_imap.im_blkno; > > + iip->ili_format.ilf_len = ip->i_imap.im_len; > > + iip->ili_format.ilf_boffset = ip->i_imap.im_boffset; > > } > > Index: xfs-cmds/xfsprogs/libxfs/rdwr.c > > =================================================================== > > --- xfs-cmds.orig/xfsprogs/libxfs/rdwr.c 2008-12-06 20:05:46.000000000 +0100 > > +++ xfs-cmds/xfsprogs/libxfs/rdwr.c 2008-12-06 20:05:49.000000000 +0100 > > @@ -677,7 +677,10 @@ > > fprintf(stderr, "%s: allocated inode, ino=%llu(%llu), %p\n", > > __FUNCTION__, (unsigned long long)ino, bno, ip); > > #endif > > - if ((error = libxfs_iread(mp, tp, ino, ip, bno))) { > > + ip->i_ino = ino; > > + ip->i_mount = mp; > > + error = xfs_iread(mp, tp, ip, bno, 0); > > + if (error) { > > cache_node_purge(libxfs_icache, &ino, > > (struct cache_node *)ip); > > ip = NULL; > > Index: xfs-cmds/xfsprogs/libxfs/trans.c > > =================================================================== > > --- xfs-cmds.orig/xfsprogs/libxfs/trans.c 2008-12-06 20:05:46.000000000 +0100 > > +++ xfs-cmds/xfsprogs/libxfs/trans.c 2008-12-06 20:05:49.000000000 +0100 > > @@ -592,7 +592,7 @@ > > /* > > * Get the buffer containing the on-disk inode. > > */ > > - error = xfs_itobp(mp, NULL, ip, &dip, &bp, 0, 0, 0); > > + error = xfs_itobp(mp, NULL, ip, &dip, &bp, 0); > > if (error) { > > fprintf(stderr, _("%s: warning - itobp failed (%d)\n"), > > progname, error); > > Index: xfs-cmds/xfsprogs/libxfs/xfs.h > > =================================================================== > > --- xfs-cmds.orig/xfsprogs/libxfs/xfs.h 2008-12-06 20:05:45.000000000 +0100 > > +++ xfs-cmds/xfsprogs/libxfs/xfs.h 2008-12-06 20:05:49.000000000 +0100 > > @@ -181,6 +181,7 @@ > > #define XFS_BUF_UNDELAYWRITE(bp) ((bp)->b_flags &= ~LIBXFS_B_DIRTY) > > #define XFS_BUF_SET_VTYPE(a,b) ((void) 0) > > #define XFS_BUF_SET_VTYPE_REF(a,b,c) ((void) 0) > > +#define XFS_BUF_SET_REF(a,b) ((void) 0) > > #define XFS_BUF_SET_BDSTRAT_FUNC(a,b) ((void) 0) > > > > #define xfs_incore(bt,blkno,len,lockit) 0 > > @@ -300,7 +301,6 @@ > > /* xfs_inode.c */ > > void xfs_iflush_fork(xfs_inode_t *, xfs_dinode_t *, xfs_inode_log_item_t *, > > int, xfs_buf_t *); > > -int xfs_iformat(xfs_inode_t *, xfs_dinode_t *); > > > > /* xfs_mount.c */ > > int xfs_initialize_perag_data(xfs_mount_t *, xfs_agnumber_t); > > Index: xfs-cmds/xfsprogs/libxfs/xfs_da_btree.c > > =================================================================== > > --- xfs-cmds.orig/xfsprogs/libxfs/xfs_da_btree.c 2008-12-06 20:05:46.000000000 +0100 > > +++ xfs-cmds/xfsprogs/libxfs/xfs_da_btree.c 2008-12-06 20:05:49.000000000 +0100 > > @@ -1539,11 +1539,14 @@ > > int nmap, error, w, count, c, got, i, mapi; > > xfs_trans_t *tp; > > xfs_mount_t *mp; > > + xfs_drfsbno_t nblks; > > > > dp = args->dp; > > mp = dp->i_mount; > > w = args->whichfork; > > tp = args->trans; > > + nblks = dp->i_d.di_nblocks; > > + > > /* > > * For new directories adjust the file offset and block count. > > */ > > @@ -1620,6 +1623,8 @@ > > } > > if (mapp != &map) > > kmem_free(mapp); > > + /* account for newly allocated blocks in reserved blocks total */ > > + args->total -= dp->i_d.di_nblocks - nblks; > > *new_blkno = (xfs_dablk_t)bno; > > return 0; > > } > > Index: xfs-cmds/xfsprogs/libxfs/xfs_bmap.c > > =================================================================== > > --- xfs-cmds.orig/xfsprogs/libxfs/xfs_bmap.c 2008-12-06 20:05:46.000000000 +0100 > > +++ xfs-cmds/xfsprogs/libxfs/xfs_bmap.c 2008-12-06 20:05:49.000000000 +0100 > > @@ -169,7 +169,7 @@ > > * Remove the entry "free" from the free item list. Prev points to the > > * previous entry, unless "free" is the head of the list. > > * > > - * Note: this requires user-space public scope for libxfs_iread > > + * Note: this requires user-space public scope for libxfs_bmap_finish > > */ > > void > > xfs_bmap_del_free( > > @@ -3250,7 +3250,7 @@ > > * Remove the entry "free" from the free item list. Prev points to the > > * previous entry, unless "free" is the head of the list. > > * > > - * Note: this requires user-space public scope for libxfs_iread > > + * Note: this requires user-space public scope for libxfs_bmap_finish > > */ > > void > > xfs_bmap_del_free( > > Index: xfs-cmds/xfstests/186 > > =================================================================== > > --- xfs-cmds.orig/xfstests/186 2008-12-06 20:04:34.000000000 +0100 > > +++ xfs-cmds/xfstests/186 2008-12-06 20:05:59.000000000 +0100 > > @@ -66,7 +66,7 @@ > > > > _filter_inode() > > { > > - tee -a $seq.full | egrep '^u.sfdir2|^a.sfattr|core.forkoff' |\ > > + tee -a $seq.full | egrep '^u.sfdir2|^a.sfattr|forkoff' |\ > > egrep -v 'inumber|parent' > > } > > > > Index: xfs-cmds/xfstests/186.out > > =================================================================== > > --- xfs-cmds.orig/xfstests/186.out 2008-12-06 20:05:57.000000000 +0100 > > +++ xfs-cmds/xfstests/186.out 2008-12-06 20:05:59.000000000 +0100 > > @@ -2,7 +2,7 @@ > > > > ================================= > > ATTR2 > > -core.forkoff = 0 > > +forkoff = 0 > > u.sfdir2.hdr.count = 0 > > u.sfdir2.hdr.i8count = 0 > > ================================= > > @@ -12,7 +12,7 @@ > > > > ================================= > > ATTR2 > > -core.forkoff = 0 > > +forkoff = 0 > > u.sfdir2.hdr.count = 25 > > u.sfdir2.hdr.i8count = 0 > > u.sfdir2.list[0].namelen = 6 > > @@ -98,7 +98,7 @@ > > ================================= > > ATTR > > ATTR2 > > -core.forkoff = 47 > > +forkoff = 47 > > u.sfdir2.hdr.count = 25 > > u.sfdir2.hdr.i8count = 0 > > u.sfdir2.list[0].namelen = 6 > > @@ -195,7 +195,7 @@ > > > > ================================= > > ATTR > > -core.forkoff = 47 > > +forkoff = 47 > > u.sfdir2.hdr.count = 25 > > u.sfdir2.hdr.i8count = 0 > > u.sfdir2.list[0].namelen = 6 > > > > -- > > > > _______________________________________________ > > xfs mailing list > > xfs@oss.sgi.com > > http://oss.sgi.com/mailman/listinfo/xfs > ---end quoted text--- > > _______________________________________________ > xfs mailing list > xfs@oss.sgi.com > http://oss.sgi.com/mailman/listinfo/xfs ---end quoted text--- _______________________________________________ xfs mailing list xfs@oss.sgi.com http://oss.sgi.com/mailman/listinfo/xfs