xfsprogs: resync libxfs with the kernel code 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