Merge branch 'upstream-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/mfasheh/ocfs2 (b7a818e4) · Commits · 戴 / test

fs/namei.c

+3 −3

Original line number	Diff line number	Diff line
		@@ -2370,6 +2370,7 @@ static int vfs_rename_dir(struct inode old_dir, struct dentry old_dentry,
		dput(new_dentry);
		}
		if (!error)
		if (!(old_dir->i_sb->s_type->fs_flags & FS_RENAME_DOES_D_MOVE))
		d_move(old_dentry,new_dentry);
		return error;
		}
		@@ -2393,8 +2394,7 @@ static int vfs_rename_other(struct inode old_dir, struct dentry old_dentry,
		else
		error = old_dir->i_op->rename(old_dir, old_dentry, new_dir, new_dentry);
		if (!error) {
		/* The following d_move() should become unconditional */
		if (!(old_dir->i_sb->s_type->fs_flags & FS_ODD_RENAME))
		if (!(old_dir->i_sb->s_type->fs_flags & FS_RENAME_DOES_D_MOVE))
		d_move(old_dentry, new_dentry);
		}
		if (target)

fs/nfs/dir.c

+1 −2

Original line number	Diff line number	Diff line
		@@ -1669,7 +1669,6 @@ out:
		if (rehash)
		d_rehash(rehash);
		if (!error) {
		if (!S_ISDIR(old_inode->i_mode))
		d_move(old_dentry, new_dentry);
		nfs_renew_times(new_dentry);
		nfs_set_verifier(new_dentry, nfs_save_change_attribute(new_dir));

fs/nfs/super.c

+5 −5

Original line number	Diff line number	Diff line
		@@ -71,7 +71,7 @@ static struct file_system_type nfs_fs_type = {
		.name = "nfs",
		.get_sb = nfs_get_sb,
		.kill_sb = nfs_kill_super,
		.fs_flags = FS_ODD_RENAME\|FS_REVAL_DOT\|FS_BINARY_MOUNTDATA,
		.fs_flags = FS_RENAME_DOES_D_MOVE\|FS_REVAL_DOT\|FS_BINARY_MOUNTDATA,
		};

		struct file_system_type nfs_xdev_fs_type = {
		@@ -79,7 +79,7 @@ struct file_system_type nfs_xdev_fs_type = {
		.name = "nfs",
		.get_sb = nfs_xdev_get_sb,
		.kill_sb = nfs_kill_super,
		.fs_flags = FS_ODD_RENAME\|FS_REVAL_DOT\|FS_BINARY_MOUNTDATA,
		.fs_flags = FS_RENAME_DOES_D_MOVE\|FS_REVAL_DOT\|FS_BINARY_MOUNTDATA,
		};

		static struct super_operations nfs_sops = {
		@@ -107,7 +107,7 @@ static struct file_system_type nfs4_fs_type = {
		.name = "nfs4",
		.get_sb = nfs4_get_sb,
		.kill_sb = nfs4_kill_super,
		.fs_flags = FS_ODD_RENAME\|FS_REVAL_DOT\|FS_BINARY_MOUNTDATA,
		.fs_flags = FS_RENAME_DOES_D_MOVE\|FS_REVAL_DOT\|FS_BINARY_MOUNTDATA,
		};

		struct file_system_type nfs4_xdev_fs_type = {
		@@ -115,7 +115,7 @@ struct file_system_type nfs4_xdev_fs_type = {
		.name = "nfs4",
		.get_sb = nfs4_xdev_get_sb,
		.kill_sb = nfs4_kill_super,
		.fs_flags = FS_ODD_RENAME\|FS_REVAL_DOT\|FS_BINARY_MOUNTDATA,
		.fs_flags = FS_RENAME_DOES_D_MOVE\|FS_REVAL_DOT\|FS_BINARY_MOUNTDATA,
		};

		struct file_system_type nfs4_referral_fs_type = {
		@@ -123,7 +123,7 @@ struct file_system_type nfs4_referral_fs_type = {
		.name = "nfs4",
		.get_sb = nfs4_referral_get_sb,
		.kill_sb = nfs4_kill_super,
		.fs_flags = FS_ODD_RENAME\|FS_REVAL_DOT\|FS_BINARY_MOUNTDATA,
		.fs_flags = FS_RENAME_DOES_D_MOVE\|FS_REVAL_DOT\|FS_BINARY_MOUNTDATA,
		};

		static struct super_operations nfs4_sops = {

fs/ocfs2/cluster/tcp_internal.h

+7 −1

Original line number	Diff line number	Diff line
		@@ -44,11 +44,17 @@
		* locking semantics of the file system using the protocol. It should
		* be somewhere else, I'm sure, but right now it isn't.
		*
		* New in version 4:
		* - Remove i_generation from lock names for better stat performance.
		*
		* New in version 3:
		* - Replace dentry votes with a cluster lock
		*
		* New in version 2:
		* - full 64 bit i_size in the metadata lock lvbs
		* - introduction of "rw" lock and pushing meta/data locking down
		*/
		#define O2NET_PROTOCOL_VERSION 2ULL
		#define O2NET_PROTOCOL_VERSION 4ULL
		struct o2net_handshake {
		__be64 protocol_version;
		__be64 connector_id;

fs/ocfs2/dcache.c

+340 −19

Original line number	Diff line number	Diff line
		@@ -35,15 +35,17 @@

		#include "alloc.h"
		#include "dcache.h"
		#include "dlmglue.h"
		#include "file.h"
		#include "inode.h"


		static int ocfs2_dentry_revalidate(struct dentry *dentry,
		struct nameidata *nd)
		{
		struct inode *inode = dentry->d_inode;
		int ret = 0; /* if all else fails, just return false */
		struct ocfs2_super *osb;
		struct ocfs2_super *osb = OCFS2_SB(dentry->d_sb);

		mlog_entry("(0x%p, '%.*s')\n", dentry,
		dentry->d_name.len, dentry->d_name.name);
		@@ -55,11 +57,11 @@ static int ocfs2_dentry_revalidate(struct dentry *dentry,
		goto bail;
		}

		osb = OCFS2_SB(inode->i_sb);

		BUG_ON(!osb);

		if (inode != osb->root_inode) {
		if (inode == osb->root_inode \|\| is_bad_inode(inode))
		goto bail;

		spin_lock(&OCFS2_I(inode)->ip_lock);
		/* did we or someone else delete this inode? */
		if (OCFS2_I(inode)->ip_flags & OCFS2_INODE_DELETED) {
		@@ -70,14 +72,17 @@ static int ocfs2_dentry_revalidate(struct dentry *dentry,
		}
		spin_unlock(&OCFS2_I(inode)->ip_lock);

		if (!inode->i_nlink) {
		/*
		* We don't need a cluster lock to test this because once an
		* inode nlink hits zero, it never goes back.
		*/
		if (inode->i_nlink == 0) {
		mlog(0, "Inode %llu orphaned, returning false "
		"dir = %d\n",
		(unsigned long long)OCFS2_I(inode)->ip_blkno,
		S_ISDIR(inode->i_mode));
		goto bail;
		}
		}

		ret = 1;

		@@ -87,6 +92,322 @@ bail:
		return ret;
		}

		static int ocfs2_match_dentry(struct dentry *dentry,
		u64 parent_blkno,
		int skip_unhashed)
		{
		struct inode *parent;

		/*
		* ocfs2_lookup() does a d_splice_alias() _before_ attaching
		* to the lock data, so we skip those here, otherwise
		* ocfs2_dentry_attach_lock() will get its original dentry
		* back.
		*/
		if (!dentry->d_fsdata)
		return 0;

		if (!dentry->d_parent)
		return 0;

		if (skip_unhashed && d_unhashed(dentry))
		return 0;

		parent = dentry->d_parent->d_inode;
		/* Negative parent dentry? */
		if (!parent)
		return 0;

		/* Name is in a different directory. */
		if (OCFS2_I(parent)->ip_blkno != parent_blkno)
		return 0;

		return 1;
		}

		/*
		* Walk the inode alias list, and find a dentry which has a given
		* parent. ocfs2_dentry_attach_lock() wants to find _any_ alias as it
		* is looking for a dentry_lock reference. The vote thread is looking
		* to unhash aliases, so we allow it to skip any that already have
		* that property.
		*/
		struct dentry ocfs2_find_local_alias(struct inode inode,
		u64 parent_blkno,
		int skip_unhashed)
		{
		struct list_head *p;
		struct dentry *dentry = NULL;

		spin_lock(&dcache_lock);

		list_for_each(p, &inode->i_dentry) {
		dentry = list_entry(p, struct dentry, d_alias);

		if (ocfs2_match_dentry(dentry, parent_blkno, skip_unhashed)) {
		mlog(0, "dentry found: %.*s\n",
		dentry->d_name.len, dentry->d_name.name);

		dget_locked(dentry);
		break;
		}

		dentry = NULL;
		}

		spin_unlock(&dcache_lock);

		return dentry;
		}

		DEFINE_SPINLOCK(dentry_attach_lock);

		/*
		* Attach this dentry to a cluster lock.
		*
		* Dentry locks cover all links in a given directory to a particular
		* inode. We do this so that ocfs2 can build a lock name which all
		* nodes in the cluster can agree on at all times. Shoving full names
		* in the cluster lock won't work due to size restrictions. Covering
		* links inside of a directory is a good compromise because it still
		* allows us to use the parent directory lock to synchronize
		* operations.
		*
		* Call this function with the parent dir semaphore and the parent dir
		* cluster lock held.
		*
		* The dir semaphore will protect us from having to worry about
		* concurrent processes on our node trying to attach a lock at the
		* same time.
		*
		* The dir cluster lock (held at either PR or EX mode) protects us
		* from unlink and rename on other nodes.
		*
		* A dput() can happen asynchronously due to pruning, so we cover
		* attaching and detaching the dentry lock with a
		* dentry_attach_lock.
		*
		* A node which has done lookup on a name retains a protected read
		* lock until final dput. If the user requests and unlink or rename,
		* the protected read is upgraded to an exclusive lock. Other nodes
		* who have seen the dentry will then be informed that they need to
		* downgrade their lock, which will involve d_delete on the
		* dentry. This happens in ocfs2_dentry_convert_worker().
		*/
		int ocfs2_dentry_attach_lock(struct dentry *dentry,
		struct inode *inode,
		u64 parent_blkno)
		{
		int ret;
		struct dentry *alias;
		struct ocfs2_dentry_lock *dl = dentry->d_fsdata;

		mlog(0, "Attach \"%.*s\", parent %llu, fsdata: %p\n",
		dentry->d_name.len, dentry->d_name.name,
		(unsigned long long)parent_blkno, dl);

		/*
		* Negative dentry. We ignore these for now.
		*
		* XXX: Could we can improve ocfs2_dentry_revalidate() by
		* tracking these?
		*/
		if (!inode)
		return 0;

		if (dl) {
		mlog_bug_on_msg(dl->dl_parent_blkno != parent_blkno,
		" \"%.*s\": old parent: %llu, new: %llu\n",
		dentry->d_name.len, dentry->d_name.name,
		(unsigned long long)parent_blkno,
		(unsigned long long)dl->dl_parent_blkno);
		return 0;
		}

		alias = ocfs2_find_local_alias(inode, parent_blkno, 0);
		if (alias) {
		/*
		* Great, an alias exists, which means we must have a
		* dentry lock already. We can just grab the lock off
		* the alias and add it to the list.
		*
		* We're depending here on the fact that this dentry
		* was found and exists in the dcache and so must have
		* a reference to the dentry_lock because we can't
		* race creates. Final dput() cannot happen on it
		* since we have it pinned, so our reference is safe.
		*/
		dl = alias->d_fsdata;
		mlog_bug_on_msg(!dl, "parent %llu, ino %llu\n",
		(unsigned long long)parent_blkno,
		(unsigned long long)OCFS2_I(inode)->ip_blkno);

		mlog_bug_on_msg(dl->dl_parent_blkno != parent_blkno,
		" \"%.*s\": old parent: %llu, new: %llu\n",
		dentry->d_name.len, dentry->d_name.name,
		(unsigned long long)parent_blkno,
		(unsigned long long)dl->dl_parent_blkno);

		mlog(0, "Found: %s\n", dl->dl_lockres.l_name);

		goto out_attach;
		}

		/*
		* There are no other aliases
		*/
		dl = kmalloc(sizeof(*dl), GFP_NOFS);
		if (!dl) {
		ret = -ENOMEM;
		mlog_errno(ret);
		return ret;
		}

		dl->dl_count = 0;
		/*
		* Does this have to happen below, for all attaches, in case
		* the struct inode gets blown away by votes?
		*/
		dl->dl_inode = igrab(inode);
		dl->dl_parent_blkno = parent_blkno;
		ocfs2_dentry_lock_res_init(dl, parent_blkno, inode);

		out_attach:
		spin_lock(&dentry_attach_lock);
		dentry->d_fsdata = dl;
		dl->dl_count++;
		spin_unlock(&dentry_attach_lock);

		/*
		* This actually gets us our PRMODE level lock. From now on,
		* we'll have a notification if one of these names is
		* destroyed on another node.
		*/
		ret = ocfs2_dentry_lock(dentry, 0);
		if (!ret)
		ocfs2_dentry_unlock(dentry, 0);
		else
		mlog_errno(ret);

		dput(alias);

		return ret;
		}

		/*
		* ocfs2_dentry_iput() and friends.
		*
		* At this point, our particular dentry is detached from the inodes
		* alias list, so there's no way that the locking code can find it.
		*
		* The interesting stuff happens when we determine that our lock needs
		* to go away because this is the last subdir alias in the
		* system. This function needs to handle a couple things:
		*
		* 1) Synchronizing lock shutdown with the downconvert threads. This
		* is already handled for us via the lockres release drop function
		* called in ocfs2_release_dentry_lock()
		*
		* 2) A race may occur when we're doing our lock shutdown and
		* another process wants to create a new dentry lock. Right now we
		* let them race, which means that for a very short while, this
		* node might have two locks on a lock resource. This should be a
		* problem though because one of them is in the process of being
		* thrown out.
		*/
		static void ocfs2_drop_dentry_lock(struct ocfs2_super *osb,
		struct ocfs2_dentry_lock *dl)
		{
		ocfs2_simple_drop_lockres(osb, &dl->dl_lockres);
		ocfs2_lock_res_free(&dl->dl_lockres);
		iput(dl->dl_inode);
		kfree(dl);
		}

		void ocfs2_dentry_lock_put(struct ocfs2_super *osb,
		struct ocfs2_dentry_lock *dl)
		{
		int unlock = 0;

		BUG_ON(dl->dl_count == 0);

		spin_lock(&dentry_attach_lock);
		dl->dl_count--;
		unlock = !dl->dl_count;
		spin_unlock(&dentry_attach_lock);

		if (unlock)
		ocfs2_drop_dentry_lock(osb, dl);
		}

		static void ocfs2_dentry_iput(struct dentry dentry, struct inode inode)
		{
		struct ocfs2_dentry_lock *dl = dentry->d_fsdata;

		mlog_bug_on_msg(!dl && !(dentry->d_flags & DCACHE_DISCONNECTED),
		"dentry: %.*s\n", dentry->d_name.len,
		dentry->d_name.name);

		if (!dl)
		goto out;

		mlog_bug_on_msg(dl->dl_count == 0, "dentry: %.*s, count: %u\n",
		dentry->d_name.len, dentry->d_name.name,
		dl->dl_count);

		ocfs2_dentry_lock_put(OCFS2_SB(dentry->d_sb), dl);

		out:
		iput(inode);
		}

		/*
		* d_move(), but keep the locks in sync.
		*
		* When we are done, "dentry" will have the parent dir and name of
		* "target", which will be thrown away.
		*
		* We manually update the lock of "dentry" if need be.
		*
		* "target" doesn't have it's dentry lock touched - we allow the later
		* dput() to handle this for us.
		*
		* This is called during ocfs2_rename(), while holding parent
		* directory locks. The dentries have already been deleted on other
		* nodes via ocfs2_remote_dentry_delete().
		*
		* Normally, the VFS handles the d_move() for the file sytem, after
		* the ->rename() callback. OCFS2 wants to handle this internally, so
		* the new lock can be created atomically with respect to the cluster.
		*/
		void ocfs2_dentry_move(struct dentry dentry, struct dentry target,
		struct inode old_dir, struct inode new_dir)
		{
		int ret;
		struct ocfs2_super *osb = OCFS2_SB(old_dir->i_sb);
		struct inode *inode = dentry->d_inode;

		/*
		* Move within the same directory, so the actual lock info won't
		* change.
		*
		* XXX: Is there any advantage to dropping the lock here?
		*/
		if (old_dir == new_dir)
		goto out_move;

		ocfs2_dentry_lock_put(osb, dentry->d_fsdata);

		dentry->d_fsdata = NULL;
		ret = ocfs2_dentry_attach_lock(dentry, inode, OCFS2_I(new_dir)->ip_blkno);
		if (ret)
		mlog_errno(ret);

		out_move:
		d_move(dentry, target);
		}

		struct dentry_operations ocfs2_dentry_ops = {
		.d_revalidate = ocfs2_dentry_revalidate,
		.d_iput = ocfs2_dentry_iput,
		};

Admin message