Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 347d1c01 authored by Christoph Hellwig's avatar Christoph Hellwig Committed by Tim Shimmin
Browse files

[XFS] dinode endianess annotations 



Biggest bit is duplicating the dinode structure so we have one annotated for
native endianess and one for disk endianess. The other significant change
is that xfs_xlate_dinode_core is split into one helper per direction to
allow for proper annotations, everything else is trivial.

As a sidenode splitting out the incore dinode means we can move it into
xfs_inode.h in a later patch and severely improving on the include hell in
xfs.

SGI-PV: 968563
SGI-Modid: xfs-linux-melb:xfs-kern:29476a

Signed-off-by: default avatarChristoph Hellwig <hch@infradead.org>
Signed-off-by: default avatarDavid Chinner <dgc@sgi.com>
Signed-off-by: default avatarTim Shimmin <tes@sgi.com>
parent ddc6d3b3

fs/xfs/xfs_dinode.h

+32 −33
Original line number Diff line number Diff line
@@ -34,41 +34,41 @@ struct xfs_mount; 
 * because we only need the core part in the in-core inode.

 */

typedef struct xfs_timestamp {

	__int32_t	t_sec;		/* timestamp seconds */

	__int32_t	t_nsec;		/* timestamp nanoseconds */

	__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 and the offsets table in xfs_ialloc_log_di().

 * below, the offsets table in xfs_ialloc_log_di() and struct xfs_icdinode

 * in xfs_inode.h.

 */

typedef struct xfs_dinode_core

{

	__uint16_t	di_magic;	/* inode magic # = XFS_DINODE_MAGIC */

	__uint16_t	di_mode;	/* mode and type of file */

	__int8_t	di_version;	/* inode version */

	__int8_t	di_format;	/* format of di_c data */

	__uint16_t	di_onlink;	/* old number of links to file */

	__uint32_t	di_uid;		/* owner's user id */

	__uint32_t	di_gid;		/* owner's group id */

	__uint32_t	di_nlink;	/* number of links to file */

	__uint16_t	di_projid;	/* owner's project id */

	__uint8_t	di_pad[8];	/* unused, zeroed space */

	__uint16_t	di_flushiter;	/* incremented on flush */

typedef struct xfs_dinode_core {

	__be16		di_magic;	/* inode magic # = XFS_DINODE_MAGIC */

	__be16		di_mode;	/* mode and type of file */

	__u8		di_version;	/* inode version */

	__u8		di_format;	/* format of di_c data */

	__be16		di_onlink;	/* old number of links to file */

	__be32		di_uid;		/* owner's user id */

	__be32		di_gid;		/* owner's group id */

	__be32		di_nlink;	/* number of links to file */

	__be16		di_projid;	/* owner's project id */

	__u8		di_pad[8];	/* unused, zeroed space */

	__be16		di_flushiter;	/* incremented on flush */

	xfs_timestamp_t	di_atime;	/* time last accessed */

	xfs_timestamp_t	di_mtime;	/* time last modified */

	xfs_timestamp_t	di_ctime;	/* time created/inode modified */

	xfs_fsize_t	di_size;	/* number of bytes in file */

	xfs_drfsbno_t	di_nblocks;	/* # of direct & btree blocks used */

	xfs_extlen_t	di_extsize;	/* basic/minimum extent size for file */

	xfs_extnum_t	di_nextents;	/* number of extents in data fork */

	xfs_aextnum_t	di_anextents;	/* number of extents in attribute fork*/

	__uint8_t	di_forkoff;	/* attr fork offs, <<3 for 64b align */

	__int8_t	di_aformat;	/* format of attr fork's data */

	__uint32_t	di_dmevmask;	/* DMIG event mask */

	__uint16_t	di_dmstate;	/* DMIG state info */

	__uint16_t	di_flags;	/* random flags, XFS_DIFLAG_... */

	__uint32_t	di_gen;		/* generation number */

	__be64		di_size;	/* number of bytes in file */

	__be64		di_nblocks;	/* # of direct & btree blocks used */

	__be32		di_extsize;	/* basic/minimum extent size for file */

	__be32		di_nextents;	/* number of extents in data fork */

	__be16		di_anextents;	/* number of extents in attribute fork*/

	__u8		di_forkoff;	/* attr fork offs, <<3 for 64b align */

	__s8		di_aformat;	/* format of attr fork's data */

	__be32		di_dmevmask;	/* DMIG event mask */

	__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
@@ -81,13 +81,13 @@ typedef struct xfs_dinode 
	 * sure to update the macros like XFS_LITINO below and

	 * XFS_BMAP_RBLOCK_DSIZE in xfs_bmap_btree.h.

	 */

	xfs_agino_t		di_next_unlinked;/* agi unlinked list ptr */

	__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 */

		xfs_dev_t	di_dev;		/* device for S_IFCHR/S_IFBLK */

		__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;
@@ -175,8 +175,7 @@ typedef enum xfs_dinode_fmt 
#define	XFS_CFORK_Q_DISK(dcp)		    ((dcp)->di_forkoff != 0)



#define XFS_CFORK_BOFF(dcp)                 ((int)((dcp)->di_forkoff << 3))

#define	XFS_CFORK_BOFF_DISK(dcp) \

	((int)(INT_GET((dcp)->di_forkoff, ARCH_CONVERT) << 3))

#define	XFS_CFORK_BOFF_DISK(dcp)	    ((int)((dcp)->di_forkoff << 3))



#define	XFS_CFORK_DSIZE_DISK(dcp,mp) \

	(XFS_CFORK_Q_DISK(dcp) ? XFS_CFORK_BOFF_DISK(dcp) : XFS_LITINO(mp))
@@ -225,8 +224,8 @@ typedef enum xfs_dinode_fmt 


#define	XFS_CFORK_NEXTENTS_DISK(dcp,w) \

	((w) == XFS_DATA_FORK ? \

	 	INT_GET((dcp)->di_nextents, ARCH_CONVERT) : \

	 	INT_GET((dcp)->di_anextents, ARCH_CONVERT))

	 	be32_to_cpu((dcp)->di_nextents) : \

	 	be16_to_cpu((dcp)->di_anextents))

#define XFS_CFORK_NEXTENTS(dcp,w) \

	((w) == XFS_DATA_FORK ? (dcp)->di_nextents : (dcp)->di_anextents)

#define	XFS_DFORK_NEXTENTS(dip,w) XFS_CFORK_NEXTENTS_DISK(&(dip)->di_core, w)

fs/xfs/xfs_ialloc.c

+3 −3
Original line number Diff line number Diff line
@@ -293,9 +293,9 @@ xfs_ialloc_ag_alloc( 
		xfs_biozero(fbuf, 0, ninodes << args.mp->m_sb.sb_inodelog);

		for (i = 0; i < ninodes; i++) {

			free = XFS_MAKE_IPTR(args.mp, fbuf, i);

			INT_SET(free->di_core.di_magic, ARCH_CONVERT, XFS_DINODE_MAGIC);

			INT_SET(free->di_core.di_version, ARCH_CONVERT, version);

			INT_SET(free->di_next_unlinked, ARCH_CONVERT, NULLAGINO);

			free->di_core.di_magic = cpu_to_be16(XFS_DINODE_MAGIC);

			free->di_core.di_version = version;

			free->di_next_unlinked = cpu_to_be32(NULLAGINO);

			xfs_ialloc_log_di(tp, fbuf, i,

				XFS_DI_CORE_BITS | XFS_DI_NEXT_UNLINKED);

		}

fs/xfs/xfs_inode.c

+107 −106
Original line number Diff line number Diff line
@@ -193,8 +193,8 @@ xfs_inotobp( 
	}

	dip = (xfs_dinode_t *)xfs_buf_offset(bp, 0);

	di_ok =

		INT_GET(dip->di_core.di_magic, ARCH_CONVERT) == XFS_DINODE_MAGIC &&

		XFS_DINODE_GOOD_VERSION(INT_GET(dip->di_core.di_version, ARCH_CONVERT));

		be16_to_cpu(dip->di_core.di_magic) == XFS_DINODE_MAGIC &&

		XFS_DINODE_GOOD_VERSION(dip->di_core.di_version);

	if (unlikely(XFS_TEST_ERROR(!di_ok, mp, XFS_ERRTAG_ITOBP_INOTOBP,

			XFS_RANDOM_ITOBP_INOTOBP))) {

		XFS_CORRUPTION_ERROR("xfs_inotobp", XFS_ERRLEVEL_LOW, mp, dip);
@@ -338,8 +338,8 @@ xfs_itobp( 


		dip = (xfs_dinode_t *)xfs_buf_offset(bp,

					(i << mp->m_sb.sb_inodelog));

		di_ok = INT_GET(dip->di_core.di_magic, ARCH_CONVERT) == XFS_DINODE_MAGIC &&

			    XFS_DINODE_GOOD_VERSION(INT_GET(dip->di_core.di_version, ARCH_CONVERT));

		di_ok = be16_to_cpu(dip->di_core.di_magic) == XFS_DINODE_MAGIC &&

			    XFS_DINODE_GOOD_VERSION(dip->di_core.di_version);

		if (unlikely(XFS_TEST_ERROR(!di_ok, mp,

						XFS_ERRTAG_ITOBP_INOTOBP,

						XFS_RANDOM_ITOBP_INOTOBP))) {
@@ -353,7 +353,7 @@ xfs_itobp( 
					"daddr %lld #%d (magic=%x)",

				XFS_BUFTARG_NAME(mp->m_ddev_targp),

				(unsigned long long)imap.im_blkno, i,

				INT_GET(dip->di_core.di_magic, ARCH_CONVERT));

				be16_to_cpu(dip->di_core.di_magic));

#endif

			XFS_CORRUPTION_ERROR("xfs_itobp", XFS_ERRLEVEL_HIGH,

					     mp, dip);
@@ -399,27 +399,26 @@ xfs_iformat( 
		XFS_IFORK_DSIZE(ip) / (uint)sizeof(xfs_bmbt_rec_t);

	error = 0;



	if (unlikely(

	    INT_GET(dip->di_core.di_nextents, ARCH_CONVERT) +

		INT_GET(dip->di_core.di_anextents, ARCH_CONVERT) >

	    INT_GET(dip->di_core.di_nblocks, ARCH_CONVERT))) {

	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))) {

		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)(INT_GET(dip->di_core.di_nextents, ARCH_CONVERT)

			    + INT_GET(dip->di_core.di_anextents, ARCH_CONVERT)),

			(int)(be32_to_cpu(dip->di_core.di_nextents) +

			      be16_to_cpu(dip->di_core.di_anextents)),

			(unsigned long long)

			INT_GET(dip->di_core.di_nblocks, ARCH_CONVERT));

				be64_to_cpu(dip->di_core.di_nblocks));

		XFS_CORRUPTION_ERROR("xfs_iformat(1)", XFS_ERRLEVEL_LOW,

				     ip->i_mount, dip);

		return XFS_ERROR(EFSCORRUPTED);

	}



	if (unlikely(INT_GET(dip->di_core.di_forkoff, ARCH_CONVERT) > ip->i_mount->m_sb.sb_inodesize)) {

	if (unlikely(dip->di_core.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,

			(int)(INT_GET(dip->di_core.di_forkoff, ARCH_CONVERT)));

			dip->di_core.di_forkoff);

		XFS_CORRUPTION_ERROR("xfs_iformat(2)", XFS_ERRLEVEL_LOW,

				     ip->i_mount, dip);

		return XFS_ERROR(EFSCORRUPTED);
@@ -430,25 +429,25 @@ xfs_iformat( 
	case S_IFCHR:

	case S_IFBLK:

	case S_IFSOCK:

		if (unlikely(INT_GET(dip->di_core.di_format, ARCH_CONVERT) != XFS_DINODE_FMT_DEV)) {

		if (unlikely(dip->di_core.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 = INT_GET(dip->di_u.di_dev, ARCH_CONVERT);

		ip->i_df.if_u2.if_rdev = be32_to_cpu(dip->di_u.di_dev);

		break;



	case S_IFREG:

	case S_IFLNK:

	case S_IFDIR:

		switch (INT_GET(dip->di_core.di_format, ARCH_CONVERT)) {

		switch (dip->di_core.di_format) {

		case XFS_DINODE_FMT_LOCAL:

			/*

			 * no local regular files yet

			 */

			if (unlikely((INT_GET(dip->di_core.di_mode, ARCH_CONVERT) & S_IFMT) == S_IFREG)) {

			if (unlikely((be16_to_cpu(dip->di_core.di_mode) & S_IFMT) == S_IFREG)) {

				xfs_fs_repair_cmn_err(CE_WARN, ip->i_mount,

					"corrupt inode %Lu "

					"(local format for regular file).",
@@ -459,7 +458,7 @@ xfs_iformat( 
				return XFS_ERROR(EFSCORRUPTED);

			}



			di_size = INT_GET(dip->di_core.di_size, ARCH_CONVERT);

			di_size = be64_to_cpu(dip->di_core.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 "
@@ -501,7 +500,7 @@ xfs_iformat( 
	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 (INT_GET(dip->di_core.di_aformat, ARCH_CONVERT)) {

	switch (dip->di_core.di_aformat) {

	case XFS_DINODE_FMT_LOCAL:

		atp = (xfs_attr_shortform_t *)XFS_DFORK_APTR(dip);

		size = be16_to_cpu(atp->hdr.totsize);
@@ -709,70 +708,74 @@ xfs_iformat_btree( 
	return 0;

}



/*

 * xfs_xlate_dinode_core - translate an xfs_inode_core_t between ondisk

 * and native format

 *

 * buf  = on-disk representation

 * dip  = native representation

 * dir  = direction - +ve -> disk to native

 *                    -ve -> native to disk

 */

void

xfs_xlate_dinode_core(

	xfs_caddr_t		buf,

	xfs_dinode_core_t	*dip,

	int			dir)

xfs_dinode_from_disk(

	xfs_icdinode_t		*to,

	xfs_dinode_core_t	*from)

{

	xfs_dinode_core_t	*buf_core = (xfs_dinode_core_t *)buf;

	xfs_dinode_core_t	*mem_core = (xfs_dinode_core_t *)dip;

	xfs_arch_t		arch = ARCH_CONVERT;



	ASSERT(dir);



	INT_XLATE(buf_core->di_magic, mem_core->di_magic, dir, arch);

	INT_XLATE(buf_core->di_mode, mem_core->di_mode, dir, arch);

	INT_XLATE(buf_core->di_version,	mem_core->di_version, dir, arch);

	INT_XLATE(buf_core->di_format, mem_core->di_format, dir, arch);

	INT_XLATE(buf_core->di_onlink, mem_core->di_onlink, dir, arch);

	INT_XLATE(buf_core->di_uid, mem_core->di_uid, dir, arch);

	INT_XLATE(buf_core->di_gid, mem_core->di_gid, dir, arch);

	INT_XLATE(buf_core->di_nlink, mem_core->di_nlink, dir, arch);

	INT_XLATE(buf_core->di_projid, mem_core->di_projid, dir, arch);



	if (dir > 0) {

		memcpy(mem_core->di_pad, buf_core->di_pad,

			sizeof(buf_core->di_pad));

	} else {

		memcpy(buf_core->di_pad, mem_core->di_pad,

			sizeof(buf_core->di_pad));

	}



	INT_XLATE(buf_core->di_flushiter, mem_core->di_flushiter, dir, arch);



	INT_XLATE(buf_core->di_atime.t_sec, mem_core->di_atime.t_sec,

			dir, arch);

	INT_XLATE(buf_core->di_atime.t_nsec, mem_core->di_atime.t_nsec,

			dir, arch);

	INT_XLATE(buf_core->di_mtime.t_sec, mem_core->di_mtime.t_sec,

			dir, arch);

	INT_XLATE(buf_core->di_mtime.t_nsec, mem_core->di_mtime.t_nsec,

			dir, arch);

	INT_XLATE(buf_core->di_ctime.t_sec, mem_core->di_ctime.t_sec,

			dir, arch);

	INT_XLATE(buf_core->di_ctime.t_nsec, mem_core->di_ctime.t_nsec,

			dir, arch);

	INT_XLATE(buf_core->di_size, mem_core->di_size, dir, arch);

	INT_XLATE(buf_core->di_nblocks, mem_core->di_nblocks, dir, arch);

	INT_XLATE(buf_core->di_extsize, mem_core->di_extsize, dir, arch);

	INT_XLATE(buf_core->di_nextents, mem_core->di_nextents, dir, arch);

	INT_XLATE(buf_core->di_anextents, mem_core->di_anextents, dir, arch);

	INT_XLATE(buf_core->di_forkoff, mem_core->di_forkoff, dir, arch);

	INT_XLATE(buf_core->di_aformat, mem_core->di_aformat, dir, arch);

	INT_XLATE(buf_core->di_dmevmask, mem_core->di_dmevmask, dir, arch);

	INT_XLATE(buf_core->di_dmstate, mem_core->di_dmstate, dir, arch);

	INT_XLATE(buf_core->di_flags, mem_core->di_flags, dir, arch);

	INT_XLATE(buf_core->di_gen, mem_core->di_gen, dir, arch);

	to->di_magic = be16_to_cpu(from->di_magic);

	to->di_mode = be16_to_cpu(from->di_mode);

	to->di_version = from ->di_version;

	to->di_format = from->di_format;

	to->di_onlink = be16_to_cpu(from->di_onlink);

	to->di_uid = be32_to_cpu(from->di_uid);

	to->di_gid = be32_to_cpu(from->di_gid);

	to->di_nlink = be32_to_cpu(from->di_nlink);

	to->di_projid = be16_to_cpu(from->di_projid);

	memcpy(to->di_pad, from->di_pad, sizeof(to->di_pad));

	to->di_flushiter = be16_to_cpu(from->di_flushiter);

	to->di_atime.t_sec = be32_to_cpu(from->di_atime.t_sec);

	to->di_atime.t_nsec = be32_to_cpu(from->di_atime.t_nsec);

	to->di_mtime.t_sec = be32_to_cpu(from->di_mtime.t_sec);

	to->di_mtime.t_nsec = be32_to_cpu(from->di_mtime.t_nsec);

	to->di_ctime.t_sec = be32_to_cpu(from->di_ctime.t_sec);

	to->di_ctime.t_nsec = be32_to_cpu(from->di_ctime.t_nsec);

	to->di_size = be64_to_cpu(from->di_size);

	to->di_nblocks = be64_to_cpu(from->di_nblocks);

	to->di_extsize = be32_to_cpu(from->di_extsize);

	to->di_nextents = be32_to_cpu(from->di_nextents);

	to->di_anextents = be16_to_cpu(from->di_anextents);

	to->di_forkoff = from->di_forkoff;

	to->di_aformat	= from->di_aformat;

	to->di_dmevmask	= be32_to_cpu(from->di_dmevmask);

	to->di_dmstate	= be16_to_cpu(from->di_dmstate);

	to->di_flags	= be16_to_cpu(from->di_flags);

	to->di_gen	= be32_to_cpu(from->di_gen);

}



void

xfs_dinode_to_disk(

	xfs_dinode_core_t	*to,

	xfs_icdinode_t		*from)

{

	to->di_magic = cpu_to_be16(from->di_magic);

	to->di_mode = cpu_to_be16(from->di_mode);

	to->di_version = from ->di_version;

	to->di_format = from->di_format;

	to->di_onlink = cpu_to_be16(from->di_onlink);

	to->di_uid = cpu_to_be32(from->di_uid);

	to->di_gid = cpu_to_be32(from->di_gid);

	to->di_nlink = cpu_to_be32(from->di_nlink);

	to->di_projid = cpu_to_be16(from->di_projid);

	memcpy(to->di_pad, from->di_pad, sizeof(to->di_pad));

	to->di_flushiter = cpu_to_be16(from->di_flushiter);

	to->di_atime.t_sec = cpu_to_be32(from->di_atime.t_sec);

	to->di_atime.t_nsec = cpu_to_be32(from->di_atime.t_nsec);

	to->di_mtime.t_sec = cpu_to_be32(from->di_mtime.t_sec);

	to->di_mtime.t_nsec = cpu_to_be32(from->di_mtime.t_nsec);

	to->di_ctime.t_sec = cpu_to_be32(from->di_ctime.t_sec);

	to->di_ctime.t_nsec = cpu_to_be32(from->di_ctime.t_nsec);

	to->di_size = cpu_to_be64(from->di_size);

	to->di_nblocks = cpu_to_be64(from->di_nblocks);

	to->di_extsize = cpu_to_be32(from->di_extsize);

	to->di_nextents = cpu_to_be32(from->di_nextents);

	to->di_anextents = cpu_to_be16(from->di_anextents);

	to->di_forkoff = from->di_forkoff;

	to->di_aformat = from->di_aformat;

	to->di_dmevmask = cpu_to_be32(from->di_dmevmask);

	to->di_dmstate = cpu_to_be16(from->di_dmstate);

	to->di_flags = cpu_to_be16(from->di_flags);

	to->di_gen = cpu_to_be32(from->di_gen);

}



STATIC uint
@@ -819,7 +822,7 @@ uint 
xfs_ip2xflags(

	xfs_inode_t		*ip)

{

	xfs_dinode_core_t	*dic = &ip->i_d;

	xfs_icdinode_t		*dic = &ip->i_d;



	return _xfs_dic2xflags(dic->di_flags) |

				(XFS_CFORK_Q(dic) ? XFS_XFLAG_HASATTR : 0);
@@ -829,7 +832,7 @@ uint 
xfs_dic2xflags(

	xfs_dinode_core_t	*dic)

{

	return _xfs_dic2xflags(INT_GET(dic->di_flags, ARCH_CONVERT)) |

	return _xfs_dic2xflags(be16_to_cpu(dic->di_flags)) |

				(XFS_CFORK_Q_DISK(dic) ? XFS_XFLAG_HASATTR : 0);

}
@@ -899,14 +902,14 @@ xfs_iread( 
	 * If we got something that isn't an inode it means someone

	 * (nfs or dmi) has a stale handle.

	 */

	if (INT_GET(dip->di_core.di_magic, ARCH_CONVERT) != XFS_DINODE_MAGIC) {

	if (be16_to_cpu(dip->di_core.di_magic) != XFS_DINODE_MAGIC) {

		kmem_zone_free(xfs_inode_zone, ip);

		xfs_trans_brelse(tp, bp);

#ifdef DEBUG

		xfs_fs_cmn_err(CE_ALERT, mp, "xfs_iread: "

				"dip->di_core.di_magic (0x%x) != "

				"XFS_DINODE_MAGIC (0x%x)",

				INT_GET(dip->di_core.di_magic, ARCH_CONVERT),

				be16_to_cpu(dip->di_core.di_magic),

				XFS_DINODE_MAGIC);

#endif /* DEBUG */

		return XFS_ERROR(EINVAL);
@@ -920,8 +923,7 @@ xfs_iread( 
	 * Otherwise, just get the truly permanent information.

	 */

	if (dip->di_core.di_mode) {

		xfs_xlate_dinode_core((xfs_caddr_t)&dip->di_core,

		     &(ip->i_d), 1);

		xfs_dinode_from_disk(&ip->i_d, &dip->di_core);

		error = xfs_iformat(ip, dip);

		if (error)  {

			kmem_zone_free(xfs_inode_zone, ip);
@@ -934,10 +936,10 @@ xfs_iread( 
			return error;

		}

	} else {

		ip->i_d.di_magic = INT_GET(dip->di_core.di_magic, ARCH_CONVERT);

		ip->i_d.di_version = INT_GET(dip->di_core.di_version, ARCH_CONVERT);

		ip->i_d.di_gen = INT_GET(dip->di_core.di_gen, ARCH_CONVERT);

		ip->i_d.di_flushiter = INT_GET(dip->di_core.di_flushiter, ARCH_CONVERT);

		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.
@@ -1959,8 +1961,7 @@ xfs_iunlink( 
		if (error) {

			return error;

		}

		ASSERT(INT_GET(dip->di_next_unlinked, ARCH_CONVERT) == NULLAGINO);

		ASSERT(dip->di_next_unlinked);

		ASSERT(be32_to_cpu(dip->di_next_unlinked) == NULLAGINO);

		/* both on-disk, don't endian flip twice */

		dip->di_next_unlinked = agi->agi_unlinked[bucket_index];

		offset = ip->i_boffset +
@@ -2071,10 +2072,10 @@ xfs_iunlink_remove( 
				error, mp->m_fsname);

			return error;

		}

		next_agino = INT_GET(dip->di_next_unlinked, ARCH_CONVERT);

		next_agino = be32_to_cpu(dip->di_next_unlinked);

		ASSERT(next_agino != 0);

		if (next_agino != NULLAGINO) {

			INT_SET(dip->di_next_unlinked, ARCH_CONVERT, NULLAGINO);

			dip->di_next_unlinked = cpu_to_be32(NULLAGINO);

			offset = ip->i_boffset +

				offsetof(xfs_dinode_t, di_next_unlinked);

			xfs_trans_inode_buf(tp, ibp);
@@ -2118,7 +2119,7 @@ xfs_iunlink_remove( 
					error, mp->m_fsname);

				return error;

			}

			next_agino = INT_GET(last_dip->di_next_unlinked, ARCH_CONVERT);

			next_agino = be32_to_cpu(last_dip->di_next_unlinked);

			ASSERT(next_agino != NULLAGINO);

			ASSERT(next_agino != 0);

		}
@@ -2133,11 +2134,11 @@ xfs_iunlink_remove( 
				error, mp->m_fsname);

			return error;

		}

		next_agino = INT_GET(dip->di_next_unlinked, ARCH_CONVERT);

		next_agino = be32_to_cpu(dip->di_next_unlinked);

		ASSERT(next_agino != 0);

		ASSERT(next_agino != agino);

		if (next_agino != NULLAGINO) {

			INT_SET(dip->di_next_unlinked, ARCH_CONVERT, NULLAGINO);

			dip->di_next_unlinked = cpu_to_be32(NULLAGINO);

			offset = ip->i_boffset +

				offsetof(xfs_dinode_t, di_next_unlinked);

			xfs_trans_inode_buf(tp, ibp);
@@ -2150,7 +2151,7 @@ xfs_iunlink_remove( 
		/*

		 * Point the previous inode on the list to the next inode.

		 */

		INT_SET(last_dip->di_next_unlinked, ARCH_CONVERT, next_agino);

		last_dip->di_next_unlinked = cpu_to_be32(next_agino);

		ASSERT(next_agino != 0);

		offset = last_offset + offsetof(xfs_dinode_t, di_next_unlinked);

		xfs_trans_inode_buf(tp, last_ibp);
@@ -3009,7 +3010,7 @@ xfs_iflush_fork( 
	case XFS_DINODE_FMT_DEV:

		if (iip->ili_format.ilf_fields & XFS_ILOG_DEV) {

			ASSERT(whichfork == XFS_DATA_FORK);

			INT_SET(dip->di_u.di_dev, ARCH_CONVERT, ip->i_df.if_u2.if_rdev);

			dip->di_u.di_dev = cpu_to_be32(ip->i_df.if_u2.if_rdev);

		}

		break;
@@ -3358,11 +3359,11 @@ xfs_iflush_int( 
	 */

	xfs_synchronize_atime(ip);



	if (XFS_TEST_ERROR(INT_GET(dip->di_core.di_magic,ARCH_CONVERT) != XFS_DINODE_MAGIC,

	if (XFS_TEST_ERROR(be16_to_cpu(dip->di_core.di_magic) != XFS_DINODE_MAGIC,

			       mp, XFS_ERRTAG_IFLUSH_1, XFS_RANDOM_IFLUSH_1)) {

		xfs_cmn_err(XFS_PTAG_IFLUSH, CE_ALERT, mp,

		    "xfs_iflush: Bad inode %Lu magic number 0x%x, ptr 0x%p",

			ip->i_ino, (int) INT_GET(dip->di_core.di_magic, ARCH_CONVERT), dip);

			ip->i_ino, be16_to_cpu(dip->di_core.di_magic), dip);

		goto corrupt_out;

	}

	if (XFS_TEST_ERROR(ip->i_d.di_magic != XFS_DINODE_MAGIC,
@@ -3425,7 +3426,7 @@ xfs_iflush_int( 
	 * because if the inode is dirty at all the core must

	 * be.

	 */

	xfs_xlate_dinode_core((xfs_caddr_t)&(dip->di_core), &(ip->i_d), -1);

	xfs_dinode_to_disk(&dip->di_core, &ip->i_d);



	/* Wrap, we never let the log put out DI_MAX_FLUSH */

	if (ip->i_d.di_flushiter == DI_MAX_FLUSH)
@@ -3445,7 +3446,7 @@ xfs_iflush_int( 
			 * Convert it back.

			 */

			ASSERT(ip->i_d.di_nlink <= XFS_MAXLINK_1);

			INT_SET(dip->di_core.di_onlink, ARCH_CONVERT, ip->i_d.di_nlink);

			dip->di_core.di_onlink = cpu_to_be16(ip->i_d.di_nlink);

		} else {

			/*

			 * The superblock version has already been bumped,
@@ -3453,7 +3454,7 @@ xfs_iflush_int( 
			 * format permanent.

			 */

			ip->i_d.di_version = XFS_DINODE_VERSION_2;

			INT_SET(dip->di_core.di_version, ARCH_CONVERT, XFS_DINODE_VERSION_2);

			dip->di_core.di_version =  XFS_DINODE_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));

fs/xfs/xfs_inode.h

+48 −4
Original line number Diff line number Diff line
@@ -18,6 +18,10 @@ 
#ifndef	__XFS_INODE_H__

#define	__XFS_INODE_H__



struct xfs_dinode;

struct xfs_dinode_core;





/*

 * Fork identifiers.

 */
@@ -227,6 +231,43 @@ typedef struct xfs_chash { 
 * chain off the mount structure by xfs_sync calls.

 */



typedef struct xfs_ictimestamp {

	__int32_t	t_sec;		/* timestamp seconds */

	__int32_t	t_nsec;		/* timestamp nanoseconds */

} xfs_ictimestamp_t;



/*

 * NOTE:  This structure must be kept identical to struct xfs_dinode_core

 * 	  in xfs_dinode.h except for the endianess annotations.

 */

typedef struct xfs_icdinode {

	__uint16_t	di_magic;	/* inode magic # = XFS_DINODE_MAGIC */

	__uint16_t	di_mode;	/* mode and type of file */

	__int8_t	di_version;	/* inode version */

	__int8_t	di_format;	/* format of di_c data */

	__uint16_t	di_onlink;	/* old number of links to file */

	__uint32_t	di_uid;		/* owner's user id */

	__uint32_t	di_gid;		/* owner's group id */

	__uint32_t	di_nlink;	/* number of links to file */

	__uint16_t	di_projid;	/* owner's project id */

	__uint8_t	di_pad[8];	/* unused, zeroed space */

	__uint16_t	di_flushiter;	/* incremented on flush */

	xfs_ictimestamp_t di_atime;	/* time last accessed */

	xfs_ictimestamp_t di_mtime;	/* time last modified */

	xfs_ictimestamp_t di_ctime;	/* time created/inode modified */

	xfs_fsize_t	di_size;	/* number of bytes in file */

	xfs_drfsbno_t	di_nblocks;	/* # of direct & btree blocks used */

	xfs_extlen_t	di_extsize;	/* basic/minimum extent size for file */

	xfs_extnum_t	di_nextents;	/* number of extents in data fork */

	xfs_aextnum_t	di_anextents;	/* number of extents in attribute fork*/

	__uint8_t	di_forkoff;	/* attr fork offs, <<3 for 64b align */

	__int8_t	di_aformat;	/* format of attr fork's data */

	__uint32_t	di_dmevmask;	/* DMIG event mask */

	__uint16_t	di_dmstate;	/* DMIG state info */

	__uint16_t	di_flags;	/* random flags, XFS_DIFLAG_... */

	__uint32_t	di_gen;		/* generation number */

} xfs_icdinode_t;



typedef struct {

	struct xfs_ihash	*ip_hash;	/* pointer to hash header */

	struct xfs_inode	*ip_next;	/* inode hash link forw */
@@ -282,7 +323,7 @@ typedef struct xfs_inode { 
	unsigned int		i_gen;		/* generation count */

	unsigned int		i_delayed_blks;	/* count of delay alloc blks */



	xfs_dinode_core_t	i_d;		/* most of ondisk inode */

	xfs_icdinode_t		i_d;		/* most of ondisk inode */

	xfs_chashlist_t		*i_chash;	/* cluster hash list header */

	struct xfs_inode	*i_cnext;	/* cluster hash link forward */

	struct xfs_inode	*i_cprev;	/* cluster hash link backward */
@@ -506,7 +547,7 @@ int xfs_finish_reclaim_all(struct xfs_mount *, int); 
 * xfs_inode.c prototypes.

 */

int		xfs_itobp(struct xfs_mount *, struct xfs_trans *,

			  xfs_inode_t *, xfs_dinode_t **, struct xfs_buf **,

			  xfs_inode_t *, struct xfs_dinode **, struct xfs_buf **,

			  xfs_daddr_t, uint);

int		xfs_iread(struct xfs_mount *, struct xfs_trans *, xfs_ino_t,

			  xfs_inode_t **, xfs_daddr_t, uint);
@@ -514,8 +555,11 @@ int xfs_iread_extents(struct xfs_trans *, xfs_inode_t *, int); 
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 **);

void		xfs_xlate_dinode_core(xfs_caddr_t, struct xfs_dinode_core *,

					int);

void		xfs_dinode_from_disk(struct xfs_icdinode *,

				     struct xfs_dinode_core *);

void		xfs_dinode_to_disk(struct xfs_dinode_core *,

				   struct xfs_icdinode *);



uint		xfs_ip2xflags(struct xfs_inode *);

uint		xfs_dic2xflags(struct xfs_dinode_core *);

int		xfs_ifree(struct xfs_trans *, xfs_inode_t *,

fs/xfs/xfs_itable.c

+27 −28

File changed.

Preview size limit exceeded, changes collapsed.