Merge branch 'xfs-feature-bit-cleanup' into for-next (b70f14e1) · Commits · e / devices / android_kernel_samsung_universal8890

fs/xfs/xfs_dir2.c

+1 −1

Original line number	Original line	Diff line number	Diff line
	@@ -92,7 +92,7 @@ xfs_dir_mount(
	int nodehdr_size;		int nodehdr_size;


	ASSERT(xfs_sb_version_hasdirv2(&mp->m_sb));		ASSERT(mp->m_sb.sb_versionnum & XFS_SB_VERSION_DIRV2BIT);
	ASSERT((1 << (mp->m_sb.sb_blocklog + mp->m_sb.sb_dirblklog)) <=		ASSERT((1 << (mp->m_sb.sb_blocklog + mp->m_sb.sb_dirblklog)) <=
	XFS_MAX_BLOCKSIZE);		XFS_MAX_BLOCKSIZE);

fs/xfs/xfs_fsops.c

+2 −7

Original line number	Original line	Diff line number	Diff line
	@@ -74,23 +74,18 @@ xfs_fs_geometry(
	}		}
	if (new_version >= 3) {		if (new_version >= 3) {
	geo->version = XFS_FSOP_GEOM_VERSION;		geo->version = XFS_FSOP_GEOM_VERSION;
	geo->flags =		geo->flags = XFS_FSOP_GEOM_FLAGS_NLINK \|
			XFS_FSOP_GEOM_FLAGS_DIRV2 \|
	(xfs_sb_version_hasattr(&mp->m_sb) ?		(xfs_sb_version_hasattr(&mp->m_sb) ?
	XFS_FSOP_GEOM_FLAGS_ATTR : 0) \|		XFS_FSOP_GEOM_FLAGS_ATTR : 0) \|
	(xfs_sb_version_hasnlink(&mp->m_sb) ?
	XFS_FSOP_GEOM_FLAGS_NLINK : 0) \|
	(xfs_sb_version_hasquota(&mp->m_sb) ?		(xfs_sb_version_hasquota(&mp->m_sb) ?
	XFS_FSOP_GEOM_FLAGS_QUOTA : 0) \|		XFS_FSOP_GEOM_FLAGS_QUOTA : 0) \|
	(xfs_sb_version_hasalign(&mp->m_sb) ?		(xfs_sb_version_hasalign(&mp->m_sb) ?
	XFS_FSOP_GEOM_FLAGS_IALIGN : 0) \|		XFS_FSOP_GEOM_FLAGS_IALIGN : 0) \|
	(xfs_sb_version_hasdalign(&mp->m_sb) ?		(xfs_sb_version_hasdalign(&mp->m_sb) ?
	XFS_FSOP_GEOM_FLAGS_DALIGN : 0) \|		XFS_FSOP_GEOM_FLAGS_DALIGN : 0) \|
	(xfs_sb_version_hasshared(&mp->m_sb) ?
	XFS_FSOP_GEOM_FLAGS_SHARED : 0) \|
	(xfs_sb_version_hasextflgbit(&mp->m_sb) ?		(xfs_sb_version_hasextflgbit(&mp->m_sb) ?
	XFS_FSOP_GEOM_FLAGS_EXTFLG : 0) \|		XFS_FSOP_GEOM_FLAGS_EXTFLG : 0) \|
	(xfs_sb_version_hasdirv2(&mp->m_sb) ?
	XFS_FSOP_GEOM_FLAGS_DIRV2 : 0) \|
	(xfs_sb_version_hassector(&mp->m_sb) ?		(xfs_sb_version_hassector(&mp->m_sb) ?
	XFS_FSOP_GEOM_FLAGS_SECTOR : 0) \|		XFS_FSOP_GEOM_FLAGS_SECTOR : 0) \|
	(xfs_sb_version_hasasciici(&mp->m_sb) ?		(xfs_sb_version_hasasciici(&mp->m_sb) ?

fs/xfs/xfs_ialloc.c

+1 −3

Original line number	Original line	Diff line number	Diff line
	@@ -280,10 +280,8 @@ xfs_ialloc_inode_init(
	if (tp)		if (tp)
	xfs_icreate_log(tp, agno, agbno, mp->m_ialloc_inos,		xfs_icreate_log(tp, agno, agbno, mp->m_ialloc_inos,
	mp->m_sb.sb_inodesize, length, gen);		mp->m_sb.sb_inodesize, length, gen);
	} else if (xfs_sb_version_hasnlink(&mp->m_sb))		} else
	version = 2;		version = 2;
	else
	version = 1;

	for (j = 0; j < nbufs; j++) {		for (j = 0; j < nbufs; j++) {
	/*		/*

fs/xfs/xfs_inode.c

+11 −100

Original line number	Original line	Diff line number	Diff line
	@@ -681,6 +681,14 @@ xfs_ialloc(
	return error;		return error;
	ASSERT(ip != NULL);		ASSERT(ip != NULL);

			/*
			* We always convert v1 inodes to v2 now - we only support filesystems
			* with >= v2 inode capability, so there is no reason for ever leaving
			* an inode in v1 format.
			*/
			if (ip->i_d.di_version == 1)
			ip->i_d.di_version = 2;

	ip->i_d.di_mode = mode;		ip->i_d.di_mode = mode;
	ip->i_d.di_onlink = 0;		ip->i_d.di_onlink = 0;
	ip->i_d.di_nlink = nlink;		ip->i_d.di_nlink = nlink;
	@@ -690,27 +698,6 @@ xfs_ialloc(
	xfs_set_projid(ip, prid);		xfs_set_projid(ip, prid);
	memset(&(ip->i_d.di_pad[0]), 0, sizeof(ip->i_d.di_pad));		memset(&(ip->i_d.di_pad[0]), 0, sizeof(ip->i_d.di_pad));

	/*
	* If the superblock version is up to where we support new format
	* inodes and this is currently an old format inode, then change
	* the inode version number now. This way we only do the conversion
	* here rather than here and in the flush/logging code.
	*/
	if (xfs_sb_version_hasnlink(&mp->m_sb) &&
	ip->i_d.di_version == 1) {
	ip->i_d.di_version = 2;
	/*
	* We've already zeroed the old link count, the projid field,
	* and the pad field.
	*/
	}

	/*
	* Project ids won't be stored on disk if we are using a version 1 inode.
	*/
	if ((prid != 0) && (ip->i_d.di_version == 1))
	xfs_bump_ino_vers2(tp, ip);

	if (pip && XFS_INHERIT_GID(pip)) {		if (pip && XFS_INHERIT_GID(pip)) {
	ip->i_d.di_gid = pip->i_d.di_gid;		ip->i_d.di_gid = pip->i_d.di_gid;
	if ((pip->i_d.di_mode & S_ISGID) && S_ISDIR(mode)) {		if ((pip->i_d.di_mode & S_ISGID) && S_ISDIR(mode)) {
	@@ -1055,40 +1042,6 @@ xfs_droplink(
	return error;		return error;
	}		}

	/*
	* This gets called when the inode's version needs to be changed from 1 to 2.
	* Currently this happens when the nlink field overflows the old 16-bit value
	* or when chproj is called to change the project for the first time.
	* As a side effect the superblock version will also get rev'd
	* to contain the NLINK bit.
	*/
	void
	xfs_bump_ino_vers2(
	xfs_trans_t *tp,
	xfs_inode_t *ip)
	{
	xfs_mount_t *mp;

	ASSERT(xfs_isilocked(ip, XFS_ILOCK_EXCL));
	ASSERT(ip->i_d.di_version == 1);

	ip->i_d.di_version = 2;
	ip->i_d.di_onlink = 0;
	memset(&(ip->i_d.di_pad[0]), 0, sizeof(ip->i_d.di_pad));
	mp = tp->t_mountp;
	if (!xfs_sb_version_hasnlink(&mp->m_sb)) {
	spin_lock(&mp->m_sb_lock);
	if (!xfs_sb_version_hasnlink(&mp->m_sb)) {
	xfs_sb_version_addnlink(&mp->m_sb);
	spin_unlock(&mp->m_sb_lock);
	xfs_mod_sb(tp, XFS_SB_VERSIONNUM);
	} else {
	spin_unlock(&mp->m_sb_lock);
	}
	}
	/* Caller must log the inode */
	}

	/*		/*
	* Increment the link count on an inode & log the change.		* Increment the link count on an inode & log the change.
	*/		*/
	@@ -1099,22 +1052,10 @@ xfs_bumplink(
	{		{
	xfs_trans_ichgtime(tp, ip, XFS_ICHGTIME_CHG);		xfs_trans_ichgtime(tp, ip, XFS_ICHGTIME_CHG);

			ASSERT(ip->i_d.di_version > 1);
	ASSERT(ip->i_d.di_nlink > 0 \|\| (VFS_I(ip)->i_state & I_LINKABLE));		ASSERT(ip->i_d.di_nlink > 0 \|\| (VFS_I(ip)->i_state & I_LINKABLE));
	ip->i_d.di_nlink++;		ip->i_d.di_nlink++;
	inc_nlink(VFS_I(ip));		inc_nlink(VFS_I(ip));
	if ((ip->i_d.di_version == 1) &&
	(ip->i_d.di_nlink > XFS_MAXLINK_1)) {
	/*
	* The inode has increased its number of links beyond
	* what can fit in an old format inode. It now needs
	* to be converted to a version 2 inode with a 32 bit
	* link count. If this is the first inode in the file
	* system to do this, then we need to bump the superblock
	* version number as well.
	*/
	xfs_bump_ino_vers2(tp, ip);
	}

	xfs_trans_log_inode(tp, ip, XFS_ILOG_CORE);		xfs_trans_log_inode(tp, ip, XFS_ILOG_CORE);
	return 0;		return 0;
	}		}
	@@ -3249,6 +3190,7 @@ xfs_iflush_int(
	ASSERT(ip->i_d.di_format != XFS_DINODE_FMT_BTREE \|\|		ASSERT(ip->i_d.di_format != XFS_DINODE_FMT_BTREE \|\|
	ip->i_d.di_nextents > XFS_IFORK_MAXEXT(ip, XFS_DATA_FORK));		ip->i_d.di_nextents > XFS_IFORK_MAXEXT(ip, XFS_DATA_FORK));
	ASSERT(iip != NULL && iip->ili_fields != 0);		ASSERT(iip != NULL && iip->ili_fields != 0);
			ASSERT(ip->i_d.di_version > 1);

	/* set dip = inode's place in the buffer /		/* set dip = inode's place in the buffer /
	dip = (xfs_dinode_t *)xfs_buf_offset(bp, ip->i_imap.im_boffset);		dip = (xfs_dinode_t *)xfs_buf_offset(bp, ip->i_imap.im_boffset);
	@@ -3309,7 +3251,7 @@ xfs_iflush_int(
	}		}

	/*		/*
	* Inode item log recovery for v1/v2 inodes are dependent on the		* Inode item log recovery for v2 inodes are dependent on the
	* di_flushiter count for correct sequencing. We bump the flush		* di_flushiter count for correct sequencing. We bump the flush
	* iteration count so we can detect flushes which postdate a log record		* iteration count so we can detect flushes which postdate a log record
	* during recovery. This is redundant as we now log every change and		* during recovery. This is redundant as we now log every change and
	@@ -3332,37 +3274,6 @@ xfs_iflush_int(
	if (ip->i_d.di_flushiter == DI_MAX_FLUSH)		if (ip->i_d.di_flushiter == DI_MAX_FLUSH)
	ip->i_d.di_flushiter = 0;		ip->i_d.di_flushiter = 0;

	/*
	* If this is really an old format inode and the superblock version
	* has not been updated to support only new format inodes, then
	* 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 == 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_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 = 2;
	dip->di_version = 2;
	ip->i_d.di_onlink = 0;
	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(xfs_get_projid(ip) == 0);
	}
	}

	xfs_iflush_fork(ip, dip, iip, XFS_DATA_FORK);		xfs_iflush_fork(ip, dip, iip, XFS_DATA_FORK);
	if (XFS_IFORK_Q(ip))		if (XFS_IFORK_Q(ip))
	xfs_iflush_fork(ip, dip, iip, XFS_ATTR_FORK);		xfs_iflush_fork(ip, dip, iip, XFS_ATTR_FORK);

fs/xfs/xfs_inode.h

+0 −1

Original line number	Original line	Diff line number	Diff line
	@@ -377,7 +377,6 @@ int xfs_dir_ialloc(struct xfs_trans *, struct xfs_inode , umode_t,
	struct xfs_inode *, int );		struct xfs_inode *, int );
	int xfs_droplink(struct xfs_trans , struct xfs_inode );		int xfs_droplink(struct xfs_trans , struct xfs_inode );
	int xfs_bumplink(struct xfs_trans , struct xfs_inode );		int xfs_bumplink(struct xfs_trans , struct xfs_inode );
	void xfs_bump_ino_vers2(struct xfs_trans , struct xfs_inode );

	/* from xfs_file.c */		/* from xfs_file.c */
	int xfs_zero_eof(struct xfs_inode *, xfs_off_t, xfs_fsize_t);		int xfs_zero_eof(struct xfs_inode *, xfs_off_t, xfs_fsize_t);