[XFS] Combine the XFS and Linux inodes (bf904248) · Commits · 戴 / test

fs/xfs/linux-2.6/xfs_iops.c

+13 −4

Original line number	Diff line number	Diff line
		@@ -64,14 +64,14 @@ xfs_synchronize_atime(
		{
		struct inode *inode = VFS_I(ip);

		if (inode) {
		if (!(inode->i_state & I_CLEAR)) {
		ip->i_d.di_atime.t_sec = (__int32_t)inode->i_atime.tv_sec;
		ip->i_d.di_atime.t_nsec = (__int32_t)inode->i_atime.tv_nsec;
		}
		}

		/*
		* If the linux inode exists, mark it dirty.
		* If the linux inode is valid, mark it dirty.
		* Used when commiting a dirty inode into a transaction so that
		* the inode will get written back by the linux code
		*/
		@@ -81,7 +81,7 @@ xfs_mark_inode_dirty_sync(
		{
		struct inode *inode = VFS_I(ip);

		if (inode)
		if (!(inode->i_state & (I_WILL_FREE\|I_FREEING\|I_CLEAR)))
		mark_inode_dirty_sync(inode);
		}

		@@ -766,12 +766,21 @@ xfs_diflags_to_iflags(
		* When reading existing inodes from disk this is called directly
		* from xfs_iget, when creating a new inode it is called from
		* xfs_ialloc after setting up the inode.
		*
		* We are always called with an uninitialised linux inode here.
		* We need to initialise the necessary fields and take a reference
		* on it.
		*/
		void
		xfs_setup_inode(
		struct xfs_inode *ip)
		{
		struct inode *inode = ip->i_vnode;
		struct inode *inode = &ip->i_vnode;

		inode->i_ino = ip->i_ino;
		inode->i_state = I_NEW\|I_LOCK;
		inode_add_to_lists(ip->i_mount->m_super, inode);
		ASSERT(atomic_read(&inode->i_count) == 1);

		inode->i_mode = ip->i_d.di_mode;
		inode->i_nlink = ip->i_d.di_nlink;

fs/xfs/linux-2.6/xfs_super.c

+18 −29

Original line number	Diff line number	Diff line
		@@ -72,7 +72,6 @@

		static struct quotactl_ops xfs_quotactl_operations;
		static struct super_operations xfs_super_operations;
		static kmem_zone_t *xfs_vnode_zone;
		static kmem_zone_t *xfs_ioend_zone;
		mempool_t *xfs_ioend_pool;

		@@ -867,29 +866,24 @@ xfsaild_stop(
		}



		/* Catch misguided souls that try to use this interface on XFS */
		STATIC struct inode *
		xfs_fs_alloc_inode(
		struct super_block *sb)
		{
		return kmem_zone_alloc(xfs_vnode_zone, KM_SLEEP);
		BUG();
		}

		/*
		* we need to provide an empty inode free function to prevent
		* the generic code from trying to free our combined inode.
		*/
		STATIC void
		xfs_fs_destroy_inode(
		struct inode *inode)
		{
		kmem_zone_free(xfs_vnode_zone, inode);
		}

		STATIC void
		xfs_fs_inode_init_once(
		void *vnode)
		{
		inode_init_once((struct inode *)vnode);
		}


		/*
		* Slab object creation initialisation for the XFS inode.
		* This covers only the idempotent fields in the XFS inode;
		@@ -898,13 +892,18 @@ xfs_fs_inode_init_once(
		* fields in the xfs inode that left in the initialise state
		* when freeing the inode.
		*/
		void
		xfs_inode_init_once(
		STATIC void
		xfs_fs_inode_init_once(
		void *inode)
		{
		struct xfs_inode *ip = inode;

		memset(ip, 0, sizeof(struct xfs_inode));

		/* vfs inode */
		inode_init_once(VFS_I(ip));

		/* xfs inode */
		atomic_set(&ip->i_iocount, 0);
		atomic_set(&ip->i_pincount, 0);
		spin_lock_init(&ip->i_flags_lock);
		@@ -975,8 +974,6 @@ xfs_fs_clear_inode(
		if (xfs_reclaim(ip))
		panic("%s: cannot reclaim 0x%p\n", __func__, inode);
		}

		ASSERT(XFS_I(inode) == NULL);
		}

		STATIC void
		@@ -1829,16 +1826,10 @@ xfs_free_trace_bufs(void)
		STATIC int __init
		xfs_init_zones(void)
		{
		xfs_vnode_zone = kmem_zone_init_flags(sizeof(struct inode), "xfs_vnode",
		KM_ZONE_HWALIGN \| KM_ZONE_RECLAIM \|
		KM_ZONE_SPREAD,
		xfs_fs_inode_init_once);
		if (!xfs_vnode_zone)
		goto out;

		xfs_ioend_zone = kmem_zone_init(sizeof(xfs_ioend_t), "xfs_ioend");
		if (!xfs_ioend_zone)
		goto out_destroy_vnode_zone;
		goto out;

		xfs_ioend_pool = mempool_create_slab_pool(4 * MAX_BUF_PER_PAGE,
		xfs_ioend_zone);
		@@ -1854,6 +1845,7 @@ xfs_init_zones(void)
		"xfs_bmap_free_item");
		if (!xfs_bmap_free_item_zone)
		goto out_destroy_log_ticket_zone;

		xfs_btree_cur_zone = kmem_zone_init(sizeof(xfs_btree_cur_t),
		"xfs_btree_cur");
		if (!xfs_btree_cur_zone)
		@@ -1901,8 +1893,8 @@ xfs_init_zones(void)

		xfs_inode_zone =
		kmem_zone_init_flags(sizeof(xfs_inode_t), "xfs_inode",
		KM_ZONE_HWALIGN \| KM_ZONE_RECLAIM \|
		KM_ZONE_SPREAD, xfs_inode_init_once);
		KM_ZONE_HWALIGN \| KM_ZONE_RECLAIM \| KM_ZONE_SPREAD,
		xfs_fs_inode_init_once);
		if (!xfs_inode_zone)
		goto out_destroy_efi_zone;

		@@ -1950,8 +1942,6 @@ xfs_init_zones(void)
		mempool_destroy(xfs_ioend_pool);
		out_destroy_ioend_zone:
		kmem_zone_destroy(xfs_ioend_zone);
		out_destroy_vnode_zone:
		kmem_zone_destroy(xfs_vnode_zone);
		out:
		return -ENOMEM;
		}
		@@ -1976,7 +1966,6 @@ xfs_destroy_zones(void)
		kmem_zone_destroy(xfs_log_ticket_zone);
		mempool_destroy(xfs_ioend_pool);
		kmem_zone_destroy(xfs_ioend_zone);
		kmem_zone_destroy(xfs_vnode_zone);

		}

fs/xfs/linux-2.6/xfs_vnode.c

+1 −14

Original line number	Diff line number	Diff line
		@@ -84,25 +84,12 @@ vn_ioerror(

		#ifdef XFS_INODE_TRACE

		/*
		* Reference count of Linux inode if present, -1 if the xfs_inode
		* has no associated Linux inode.
		*/
		static inline int xfs_icount(struct xfs_inode *ip)
		{
		struct inode *inode = VFS_I(ip);

		if (inode)
		return atomic_read(&inode->i_count);
		return -1;
		}

		#define KTRACE_ENTER(ip, vk, s, line, ra) \
		ktrace_enter( (ip)->i_trace, \
		/* 0 / (void )(__psint_t)(vk), \
		/* 1 / (void )(s), \
		/* 2 / (void )(__psint_t) line, \
		/* 3 / (void )(__psint_t)xfs_icount(ip), \
		/* 3 / (void )(__psint_t)atomic_read(&VFS_I(ip)->i_count), \
		/* 4 / (void )(ra), \
		/* 5 */ NULL, \
		/* 6 / (void )(__psint_t)current_cpu(), \

fs/xfs/xfs_iget.c

+35 −132

Original line number	Diff line number	Diff line
		@@ -44,77 +44,65 @@
		*/
		static int
		xfs_iget_cache_hit(
		struct inode *inode,
		struct xfs_perag *pag,
		struct xfs_inode *ip,
		int flags,
		int lock_flags) __releases(pag->pag_ici_lock)
		{
		struct xfs_mount *mp = ip->i_mount;
		struct inode *old_inode;
		int error = 0;

		/*
		* If INEW is set this inode is being set up
		* If IRECLAIM is set this inode is being torn down
		* Pause and try again.
		*/
		if (xfs_iflags_test(ip, XFS_INEW)) {
		if (xfs_iflags_test(ip, (XFS_INEW\|XFS_IRECLAIM))) {
		error = EAGAIN;
		XFS_STATS_INC(xs_ig_frecycle);
		goto out_error;
		}

		old_inode = ip->i_vnode;
		if (old_inode == NULL) {
		/* If IRECLAIMABLE is set, we've torn down the vfs inode part */
		if (xfs_iflags_test(ip, XFS_IRECLAIMABLE)) {

		/*
		* If IRECLAIM is set this inode is
		* on its way out of the system,
		* we need to pause and try again.
		* If lookup is racing with unlink, then we should return an
		* error immediately so we don't remove it from the reclaim
		* list and potentially leak the inode.
		*/
		if (xfs_iflags_test(ip, XFS_IRECLAIM)) {
		error = EAGAIN;
		XFS_STATS_INC(xs_ig_frecycle);

		if ((ip->i_d.di_mode == 0) && !(flags & XFS_IGET_CREATE)) {
		error = ENOENT;
		goto out_error;
		}
		ASSERT(xfs_iflags_test(ip, XFS_IRECLAIMABLE));

		xfs_itrace_exit_tag(ip, "xfs_iget.alloc");

		/*
		* If lookup is racing with unlink, then we
		* should return an error immediately so we
		* don't remove it from the reclaim list and
		* potentially leak the inode.
		* We need to re-initialise the VFS inode as it has been
		* 'freed' by the VFS. Do this here so we can deal with
		* errors cleanly, then tag it so it can be set up correctly
		* later.
		*/
		if ((ip->i_d.di_mode == 0) &&
		!(flags & XFS_IGET_CREATE)) {
		error = ENOENT;
		if (!inode_init_always(mp->m_super, VFS_I(ip))) {
		error = ENOMEM;
		goto out_error;
		}
		xfs_itrace_exit_tag(ip, "xfs_iget.alloc");

		xfs_iflags_set(ip, XFS_INEW);
		xfs_iflags_clear(ip, XFS_IRECLAIMABLE);
		read_unlock(&pag->pag_ici_lock);

		XFS_MOUNT_ILOCK(mp);
		list_del_init(&ip->i_reclaim);
		XFS_MOUNT_IUNLOCK(mp);

		} else if (inode != old_inode) {
		/* The inode is being torn down, pause and
		* try again.
		*/
		if (old_inode->i_state & (I_FREEING \| I_CLEAR)) {
		} else if (!igrab(VFS_I(ip))) {
		/* If the VFS inode is being torn down, pause and try again. */
		error = EAGAIN;
		XFS_STATS_INC(xs_ig_frecycle);
		goto out_error;
		}
		/* Chances are the other vnode (the one in the inode) is being torn
		* down right now, and we landed on top of it. Question is, what do
		* we do? Unhook the old inode and hook up the new one?
		*/
		cmn_err(CE_PANIC,
		"xfs_iget_core: ambiguous vns: vp/0x%p, invp/0x%p",
		old_inode, inode);
		} else {
		/* we've got a live one */
		read_unlock(&pag->pag_ici_lock);
		}

		@@ -215,11 +203,11 @@ out_destroy:
		/*
		* Look up an inode by number in the given file system.
		* The inode is looked up in the cache held in each AG.
		* If the inode is found in the cache, attach it to the provided
		* vnode.
		* If the inode is found in the cache, initialise the vfs inode
		* if necessary.
		*
		* If it is not in core, read it in from the file system's device,
		* add it to the cache and attach the provided vnode.
		* add it to the cache and initialise the vfs inode.
		*
		* The inode is locked according to the value of the lock_flags parameter.
		* This flag parameter indicates how and if the inode's IO lock and inode lock
		@@ -236,9 +224,8 @@ out_destroy:
		* bno -- the block number starting the buffer containing the inode,
		* if known (as by bulkstat), else 0.
		*/
		STATIC int
		xfs_iget_core(
		struct inode *inode,
		int
		xfs_iget(
		xfs_mount_t *mp,
		xfs_trans_t *tp,
		xfs_ino_t ino,
		@@ -269,7 +256,7 @@ again:
		ip = radix_tree_lookup(&pag->pag_ici_root, agino);

		if (ip) {
		error = xfs_iget_cache_hit(inode, pag, ip, flags, lock_flags);
		error = xfs_iget_cache_hit(pag, ip, flags, lock_flags);
		if (error)
		goto out_error_or_again;
		} else {
		@@ -283,23 +270,16 @@ again:
		}
		xfs_put_perag(mp, pag);

		ASSERT(ip->i_df.if_ext_max ==
		XFS_IFORK_DSIZE(ip) / sizeof(xfs_bmbt_rec_t));

		xfs_iflags_set(ip, XFS_IMODIFIED);
		*ipp = ip;

		/*
		* Set up the Linux with the Linux inode.
		*/
		ip->i_vnode = inode;
		inode->i_private = ip;

		ASSERT(ip->i_df.if_ext_max ==
		XFS_IFORK_DSIZE(ip) / sizeof(xfs_bmbt_rec_t));
		/*
		* If we have a real type for an on-disk inode, we can set ops(&unlock)
		* now. If it's a new inode being created, xfs_ialloc will handle it.
		*/
		if (ip->i_d.di_mode != 0)
		if (xfs_iflags_test(ip, XFS_INEW) && ip->i_d.di_mode != 0)
		xfs_setup_inode(ip);
		return 0;

		@@ -313,75 +293,6 @@ out_error_or_again:
		}


		/*
		* The 'normal' internal xfs_iget, if needed it will
		* 'allocate', or 'get', the vnode.
		*/
		int
		xfs_iget(
		xfs_mount_t *mp,
		xfs_trans_t *tp,
		xfs_ino_t ino,
		uint flags,
		uint lock_flags,
		xfs_inode_t **ipp,
		xfs_daddr_t bno)
		{
		struct inode *inode;
		xfs_inode_t *ip;
		int error;

		XFS_STATS_INC(xs_ig_attempts);

		retry:
		inode = iget_locked(mp->m_super, ino);
		if (!inode)
		/* If we got no inode we are out of memory */
		return ENOMEM;

		if (inode->i_state & I_NEW) {
		XFS_STATS_INC(vn_active);
		XFS_STATS_INC(vn_alloc);

		error = xfs_iget_core(inode, mp, tp, ino, flags,
		lock_flags, ipp, bno);
		if (error) {
		make_bad_inode(inode);
		if (inode->i_state & I_NEW)
		unlock_new_inode(inode);
		iput(inode);
		}
		return error;
		}

		/*
		* If the inode is not fully constructed due to
		* filehandle mismatches wait for the inode to go
		* away and try again.
		*
		* iget_locked will call __wait_on_freeing_inode
		* to wait for the inode to go away.
		*/
		if (is_bad_inode(inode)) {
		iput(inode);
		delay(1);
		goto retry;
		}

		ip = XFS_I(inode);
		if (!ip) {
		iput(inode);
		delay(1);
		goto retry;
		}

		if (lock_flags != 0)
		xfs_ilock(ip, lock_flags);
		XFS_STATS_INC(xs_ig_found);
		*ipp = ip;
		return 0;
		}

		/*
		* Look for the inode corresponding to the given ino in the hash table.
		* If it is there and its i_transp pointer matches tp, return it.
		@@ -481,14 +392,6 @@ xfs_ireclaim(xfs_inode_t *ip)
		*/
		XFS_QM_DQDETACH(ip->i_mount, ip);

		/*
		* Pull our behavior descriptor from the vnode chain.
		*/
		if (ip->i_vnode) {
		ip->i_vnode->i_private = NULL;
		ip->i_vnode = NULL;
		}

		/*
		* Free all memory associated with the inode.
		*/

fs/xfs/xfs_inode.c

+32 −11

Original line number	Diff line number	Diff line
		@@ -813,6 +813,16 @@ xfs_inode_alloc(
		ASSERT(!spin_is_locked(&ip->i_flags_lock));
		ASSERT(list_empty(&ip->i_reclaim));

		/*
		* initialise the VFS inode here to get failures
		* out of the way early.
		*/
		if (!inode_init_always(mp->m_super, VFS_I(ip))) {
		kmem_zone_free(xfs_inode_zone, ip);
		return NULL;
		}

		/* initialise the xfs inode */
		ip->i_ino = ino;
		ip->i_mount = mp;
		ip->i_blkno = 0;
		@@ -1086,6 +1096,7 @@ xfs_ialloc(
		uint flags;
		int error;
		timespec_t tv;
		int filestreams = 0;

		/*
		* Call the space management code to pick
		@@ -1093,9 +1104,8 @@ xfs_ialloc(
		*/
		error = xfs_dialloc(tp, pip ? pip->i_ino : 0, mode, okalloc,
		ialloc_context, call_again, &ino);
		if (error != 0) {
		if (error)
		return error;
		}
		if (*call_again \|\| ino == NULLFSINO) {
		*ipp = NULL;
		return 0;
		@@ -1109,9 +1119,8 @@ xfs_ialloc(
		*/
		error = xfs_trans_iget(tp->t_mountp, tp, ino,
		XFS_IGET_CREATE, XFS_ILOCK_EXCL, &ip);
		if (error != 0) {
		if (error)
		return error;
		}
		ASSERT(ip != NULL);

		ip->i_d.di_mode = (__uint16_t)mode;
		@@ -1192,13 +1201,12 @@ xfs_ialloc(
		flags \|= XFS_ILOG_DEV;
		break;
		case S_IFREG:
		if (pip && xfs_inode_is_filestream(pip)) {
		error = xfs_filestream_associate(pip, ip);
		if (error < 0)
		return -error;
		if (!error)
		xfs_iflags_set(ip, XFS_IFILESTREAM);
		}
		/*
		* we can't set up filestreams until after the VFS inode
		* is set up properly.
		*/
		if (pip && xfs_inode_is_filestream(pip))
		filestreams = 1;
		/* fall through */
		case S_IFDIR:
		if (pip && (pip->i_d.di_flags & XFS_DIFLAG_ANY)) {
		@@ -1264,6 +1272,15 @@ xfs_ialloc(
		/* now that we have an i_mode we can setup inode ops and unlock */
		xfs_setup_inode(ip);

		/* now we have set up the vfs inode we can associate the filestream */
		if (filestreams) {
		error = xfs_filestream_associate(pip, ip);
		if (error < 0)
		return -error;
		if (!error)
		xfs_iflags_set(ip, XFS_IFILESTREAM);
		}

		*ipp = ip;
		return 0;
		}
		@@ -2650,6 +2667,10 @@ xfs_idestroy_fork(
		* It must free the inode itself and any buffers allocated for
		* if_extents/if_data and if_broot. It must also free the lock
		* associated with the inode.
		*
		* Note: because we don't initialise everything on reallocation out
		* of the zone, we must ensure we nullify everything correctly before
		* freeing the structure.
		*/
		void
		xfs_idestroy(

Admin message