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

Commit a2bbcb60 authored by Dave Chinner's avatar Dave Chinner
Browse files

Merge branch 'xfs-gut-icdinode-4.6' into for-next

parents 6d247d47 c19b3b05

fs/xfs/libxfs/xfs_bmap.c

+3 −3
Original line number Diff line number Diff line
@@ -912,7 +912,7 @@ xfs_bmap_local_to_extents( 
	 * We don't want to deal with the case of keeping inode data inline yet.

	 * So sending the data fork of a regular inode is invalid.

	 */

	ASSERT(!(S_ISREG(ip->i_d.di_mode) && whichfork == XFS_DATA_FORK));

	ASSERT(!(S_ISREG(VFS_I(ip)->i_mode) && whichfork == XFS_DATA_FORK));

	ifp = XFS_IFORK_PTR(ip, whichfork);

	ASSERT(XFS_IFORK_FORMAT(ip, whichfork) == XFS_DINODE_FMT_LOCAL);
@@ -1079,7 +1079,7 @@ xfs_bmap_add_attrfork_local( 
	if (ip->i_df.if_bytes <= XFS_IFORK_DSIZE(ip))

		return 0;



	if (S_ISDIR(ip->i_d.di_mode)) {

	if (S_ISDIR(VFS_I(ip)->i_mode)) {

		memset(&dargs, 0, sizeof(dargs));

		dargs.geo = ip->i_mount->m_dir_geo;

		dargs.dp = ip;
@@ -1091,7 +1091,7 @@ xfs_bmap_add_attrfork_local( 
		return xfs_dir2_sf_to_block(&dargs);

	}



	if (S_ISLNK(ip->i_d.di_mode))

	if (S_ISLNK(VFS_I(ip)->i_mode))

		return xfs_bmap_local_to_extents(tp, ip, firstblock, 1,

						 flags, XFS_DATA_FORK,

						 xfs_symlink_local_to_remote);

fs/xfs/libxfs/xfs_dir2.c

+6 −6
Original line number Diff line number Diff line
@@ -176,7 +176,7 @@ xfs_dir_isempty( 
{

	xfs_dir2_sf_hdr_t	*sfp;



	ASSERT(S_ISDIR(dp->i_d.di_mode));

	ASSERT(S_ISDIR(VFS_I(dp)->i_mode));

	if (dp->i_d.di_size == 0)	/* might happen during shutdown. */

		return 1;

	if (dp->i_d.di_size > XFS_IFORK_DSIZE(dp))
@@ -231,7 +231,7 @@ xfs_dir_init( 
	struct xfs_da_args *args;

	int		error;



	ASSERT(S_ISDIR(dp->i_d.di_mode));

	ASSERT(S_ISDIR(VFS_I(dp)->i_mode));

	error = xfs_dir_ino_validate(tp->t_mountp, pdp->i_ino);

	if (error)

		return error;
@@ -266,7 +266,7 @@ xfs_dir_createname( 
	int			rval;

	int			v;		/* type-checking value */



	ASSERT(S_ISDIR(dp->i_d.di_mode));

	ASSERT(S_ISDIR(VFS_I(dp)->i_mode));

	if (inum) {

		rval = xfs_dir_ino_validate(tp->t_mountp, inum);

		if (rval)
@@ -364,7 +364,7 @@ xfs_dir_lookup( 
	int		v;		/* type-checking value */

	int		lock_mode;



	ASSERT(S_ISDIR(dp->i_d.di_mode));

	ASSERT(S_ISDIR(VFS_I(dp)->i_mode));

	XFS_STATS_INC(dp->i_mount, xs_dir_lookup);



	/*
@@ -443,7 +443,7 @@ xfs_dir_removename( 
	int		rval;

	int		v;		/* type-checking value */



	ASSERT(S_ISDIR(dp->i_d.di_mode));

	ASSERT(S_ISDIR(VFS_I(dp)->i_mode));

	XFS_STATS_INC(dp->i_mount, xs_dir_remove);



	args = kmem_zalloc(sizeof(*args), KM_SLEEP | KM_NOFS);
@@ -505,7 +505,7 @@ xfs_dir_replace( 
	int		rval;

	int		v;		/* type-checking value */



	ASSERT(S_ISDIR(dp->i_d.di_mode));

	ASSERT(S_ISDIR(VFS_I(dp)->i_mode));



	rval = xfs_dir_ino_validate(tp->t_mountp, inum);

	if (rval)

fs/xfs/libxfs/xfs_inode_buf.c

+111 −59
Original line number Diff line number Diff line
@@ -195,28 +195,50 @@ xfs_imap_to_bp( 
}



void

xfs_dinode_from_disk(

	xfs_icdinode_t		*to,

	xfs_dinode_t		*from)

xfs_inode_from_disk(

	struct xfs_inode	*ip,

	struct xfs_dinode	*from)

{

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

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

	struct xfs_icdinode	*to = &ip->i_d;

	struct inode		*inode = VFS_I(ip);





	/*

	 * Convert v1 inodes immediately to v2 inode format as this is the

	 * minimum inode version format we support in the rest of the code.

	 */

	to->di_version = from->di_version;

	if (to->di_version == 1) {

		set_nlink(inode, be16_to_cpu(from->di_onlink));

		to->di_projid_lo = 0;

		to->di_projid_hi = 0;

		to->di_version = 2;

	} else {

		set_nlink(inode, be32_to_cpu(from->di_nlink));

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

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

	}



	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_lo = be16_to_cpu(from->di_projid_lo);

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

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



	/*

	 * Time is signed, so need to convert to signed 32 bit before

	 * storing in inode timestamp which may be 64 bit. Otherwise

	 * a time before epoch is converted to a time long after epoch

	 * on 64 bit systems.

	 */

	inode->i_atime.tv_sec = (int)be32_to_cpu(from->di_atime.t_sec);

	inode->i_atime.tv_nsec = (int)be32_to_cpu(from->di_atime.t_nsec);

	inode->i_mtime.tv_sec = (int)be32_to_cpu(from->di_mtime.t_sec);

	inode->i_mtime.tv_nsec = (int)be32_to_cpu(from->di_mtime.t_nsec);

	inode->i_ctime.tv_sec = (int)be32_to_cpu(from->di_ctime.t_sec);

	inode->i_ctime.tv_nsec = (int)be32_to_cpu(from->di_ctime.t_nsec);

	inode->i_generation = be32_to_cpu(from->di_gen);

	inode->i_mode = be16_to_cpu(from->di_mode);



	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);
@@ -227,42 +249,96 @@ xfs_dinode_from_disk( 
	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);



	if (to->di_version == 3) {

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

		inode->i_version = be64_to_cpu(from->di_changecount);

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

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

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

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

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

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

		uuid_copy(&to->di_uuid, &from->di_uuid);

	}

}



void

xfs_dinode_to_disk(

	xfs_dinode_t		*to,

	xfs_icdinode_t		*from)

xfs_inode_to_disk(

	struct xfs_inode	*ip,

	struct xfs_dinode	*to,

	xfs_lsn_t		lsn)

{

	struct xfs_icdinode	*from = &ip->i_d;

	struct inode		*inode = VFS_I(ip);



	to->di_magic = cpu_to_be16(XFS_DINODE_MAGIC);

	to->di_onlink = 0;



	to->di_version = from->di_version;

	to->di_format = from->di_format;

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

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

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

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



	memset(to->di_pad, 0, sizeof(to->di_pad));

	to->di_atime.t_sec = cpu_to_be32(inode->i_atime.tv_sec);

	to->di_atime.t_nsec = cpu_to_be32(inode->i_atime.tv_nsec);

	to->di_mtime.t_sec = cpu_to_be32(inode->i_mtime.tv_sec);

	to->di_mtime.t_nsec = cpu_to_be32(inode->i_mtime.tv_nsec);

	to->di_ctime.t_sec = cpu_to_be32(inode->i_ctime.tv_sec);

	to->di_ctime.t_nsec = cpu_to_be32(inode->i_ctime.tv_nsec);

	to->di_nlink = cpu_to_be32(inode->i_nlink);

	to->di_gen = cpu_to_be32(inode->i_generation);

	to->di_mode = cpu_to_be16(inode->i_mode);



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



	if (from->di_version == 3) {

		to->di_changecount = cpu_to_be64(inode->i_version);

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

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

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



		to->di_ino = cpu_to_be64(ip->i_ino);

		to->di_lsn = cpu_to_be64(lsn);

		memset(to->di_pad2, 0, sizeof(to->di_pad2));

		uuid_copy(&to->di_uuid, &ip->i_mount->m_sb.sb_meta_uuid);

		to->di_flushiter = 0;

	} else {

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

	}

}



void

xfs_log_dinode_to_disk(

	struct xfs_log_dinode	*from,

	struct xfs_dinode	*to)

{

	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_onlink = 0;

	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_lo = cpu_to_be16(from->di_projid_lo);

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

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



	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);
@@ -367,13 +443,10 @@ xfs_iread( 
	    !(mp->m_flags & XFS_MOUNT_IKEEP)) {

		/* initialise the on-disk inode core */

		memset(&ip->i_d, 0, sizeof(ip->i_d));

		ip->i_d.di_magic = XFS_DINODE_MAGIC;

		ip->i_d.di_gen = prandom_u32();

		if (xfs_sb_version_hascrc(&mp->m_sb)) {

		VFS_I(ip)->i_generation = prandom_u32();

		if (xfs_sb_version_hascrc(&mp->m_sb))

			ip->i_d.di_version = 3;

			ip->i_d.di_ino = ip->i_ino;

			uuid_copy(&ip->i_d.di_uuid, &mp->m_sb.sb_meta_uuid);

		} else

		else

			ip->i_d.di_version = 2;

		return 0;

	}
@@ -403,7 +476,7 @@ xfs_iread( 
	 * Otherwise, just get the truly permanent information.

	 */

	if (dip->di_mode) {

		xfs_dinode_from_disk(&ip->i_d, dip);

		xfs_inode_from_disk(ip, dip);

		error = xfs_iformat_fork(ip, dip);

		if (error)  {

#ifdef DEBUG
@@ -417,16 +490,10 @@ xfs_iread( 
		 * Partial initialisation of the in-core inode. Just the bits

		 * that xfs_ialloc won't overwrite or relies on being correct.

		 */

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

		VFS_I(ip)->i_generation = be32_to_cpu(dip->di_gen);

		ip->i_d.di_flushiter = be16_to_cpu(dip->di_flushiter);



		if (dip->di_version == 3) {

			ip->i_d.di_ino = be64_to_cpu(dip->di_ino);

			uuid_copy(&ip->i_d.di_uuid, &dip->di_uuid);

		}



		/*

		 * Make sure to pull in the mode here as well in

		 * case the inode is released without being used.
@@ -434,25 +501,10 @@ xfs_iread( 
		 * the inode is already free and not try to mess

		 * with the uninitialized part of it.

		 */

		ip->i_d.di_mode = 0;

	}



	/*

	 * Automatically convert version 1 inode formats in memory to version 2

	 * inode format. If the inode is modified, it will get logged and

	 * rewritten as a version 2 inode. We can do this because we set the

	 * superblock feature bit for v2 inodes unconditionally during mount

	 * and it means the reast of the code can assume the inode version is 2

	 * or higher.

	 */

	if (ip->i_d.di_version == 1) {

		ip->i_d.di_version = 2;

		memset(&(ip->i_d.di_pad[0]), 0, sizeof(ip->i_d.di_pad));

		ip->i_d.di_nlink = ip->i_d.di_onlink;

		ip->i_d.di_onlink = 0;

		xfs_set_projid(ip, 0);

		VFS_I(ip)->i_mode = 0;

	}



	ASSERT(ip->i_d.di_version >= 2);

	ip->i_delayed_blks = 0;



	/*

fs/xfs/libxfs/xfs_inode_buf.h

+35 −3
Original line number Diff line number Diff line
@@ -20,7 +20,36 @@ 


struct xfs_inode;

struct xfs_dinode;

struct xfs_icdinode;



/*

 * In memory representation of the XFS inode. This is held in the in-core struct

 * xfs_inode and represents the current on disk values but the structure is not

 * in on-disk format.  That is, this structure is always translated to on-disk

 * format specific structures at the appropriate time.

 */

struct xfs_icdinode {

	__int8_t	di_version;	/* inode version */

	__int8_t	di_format;	/* format of di_c data */

	__uint16_t	di_flushiter;	/* incremented on flush */

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

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

	__uint16_t	di_projid_lo;	/* lower part of owner's project id */

	__uint16_t	di_projid_hi;	/* higher part of owner's project id */

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

	xfs_rfsblock_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_... */



	__uint64_t	di_flags2;	/* more random flags */



	xfs_ictimestamp_t di_crtime;	/* time created */

};



/*

 * Inode location information.  Stored in the inode and passed to
@@ -38,8 +67,11 @@ int xfs_imap_to_bp(struct xfs_mount *, struct xfs_trans *, 
int	xfs_iread(struct xfs_mount *, struct xfs_trans *,

		  struct xfs_inode *, uint);

void	xfs_dinode_calc_crc(struct xfs_mount *, struct xfs_dinode *);

void	xfs_dinode_to_disk(struct xfs_dinode *to, struct xfs_icdinode *from);

void	xfs_dinode_from_disk(struct xfs_icdinode *to, struct xfs_dinode *from);

void	xfs_inode_to_disk(struct xfs_inode *ip, struct xfs_dinode *to,

			  xfs_lsn_t lsn);

void	xfs_inode_from_disk(struct xfs_inode *ip, struct xfs_dinode *from);

void	xfs_log_dinode_to_disk(struct xfs_log_dinode *from,

			       struct xfs_dinode *to);



#if defined(DEBUG)

void	xfs_inobp_check(struct xfs_mount *, struct xfs_buf *);

fs/xfs/libxfs/xfs_inode_fork.c

+1 −1
Original line number Diff line number Diff line
@@ -121,7 +121,7 @@ xfs_iformat_fork( 
		return -EFSCORRUPTED;

	}



	switch (ip->i_d.di_mode & S_IFMT) {

	switch (VFS_I(ip)->i_mode & S_IFMT) {

	case S_IFIFO:

	case S_IFCHR:

	case S_IFBLK: