xfs: turn NLINK feature on by default (263997a6) · Commits · 戴 / test

fs/xfs/xfs_fsops.c

+1 −3

Original line number	Diff line number	Diff line
		@@ -74,11 +74,9 @@ xfs_fs_geometry(
		}
		if (new_version >= 3) {
		geo->version = XFS_FSOP_GEOM_VERSION;
		geo->flags =
		geo->flags = XFS_FSOP_GEOM_FLAGS_NLINK \|
		(xfs_sb_version_hasattr(&mp->m_sb) ?
		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_FSOP_GEOM_FLAGS_QUOTA : 0) \|
		(xfs_sb_version_hasalign(&mp->m_sb) ?

fs/xfs/xfs_ialloc.c

+1 −3

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

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

fs/xfs/xfs_inode.c

+11 −100

Original line number	Diff line number	Diff line
		@@ -682,6 +682,14 @@ xfs_ialloc(
		return error;
		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_onlink = 0;
		ip->i_d.di_nlink = nlink;
		@@ -691,27 +699,6 @@ xfs_ialloc(
		xfs_set_projid(ip, prid);
		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)) {
		ip->i_d.di_gid = pip->i_d.di_gid;
		if ((pip->i_d.di_mode & S_ISGID) && S_ISDIR(mode)) {
		@@ -1072,40 +1059,6 @@ xfs_droplink(
		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.
		*/
		@@ -1116,22 +1069,10 @@ xfs_bumplink(
		{
		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));
		ip->i_d.di_nlink++;
		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);
		return 0;
		}
		@@ -3258,6 +3199,7 @@ xfs_iflush_int(
		ASSERT(ip->i_d.di_format != XFS_DINODE_FMT_BTREE \|\|
		ip->i_d.di_nextents > XFS_IFORK_MAXEXT(ip, XFS_DATA_FORK));
		ASSERT(iip != NULL && iip->ili_fields != 0);
		ASSERT(ip->i_d.di_version > 1);

		/* set dip = inode's place in the buffer /
		dip = (xfs_dinode_t *)xfs_buf_offset(bp, ip->i_imap.im_boffset);
		@@ -3318,7 +3260,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
		* iteration count so we can detect flushes which postdate a log record
		* during recovery. This is redundant as we now log every change and
		@@ -3341,37 +3283,6 @@ xfs_iflush_int(
		if (ip->i_d.di_flushiter == DI_MAX_FLUSH)
		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, bp);
		if (XFS_IFORK_Q(ip))
		xfs_iflush_fork(ip, dip, iip, XFS_ATTR_FORK, bp);

fs/xfs/xfs_inode.h

+0 −1

Original line number	Diff line number	Diff line
		@@ -379,7 +379,6 @@ int xfs_dir_ialloc(struct xfs_trans *, struct xfs_inode , umode_t,
		struct xfs_inode *, int );
		int xfs_droplink(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 */
		int xfs_zero_eof(struct xfs_inode *, xfs_off_t, xfs_fsize_t);

fs/xfs/xfs_inode_buf.c

+8 −9

Original line number	Diff line number	Diff line
		@@ -437,17 +437,16 @@ xfs_iread(
		}

		/*
		* 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.
		* 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);

Admin message