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

Commit b5898cd0 authored by Linus Torvalds's avatar Linus Torvalds
Browse files

Merge branch 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/viro/vfs 

Pull vfs bits and pieces from Al Viro:
 "Assorted bits that got missed in the first pull request + fixes for a
  couple of coredump regressions"

* 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/viro/vfs:
  fold try_to_ascend() into the sole remaining caller
  dcache.c: get rid of pointless macros
  take read_seqbegin_or_lock() and friends to seqlock.h
  consolidate simple ->d_delete() instances
  gfs2: endianness misannotations
  dump_emit(): use __kernel_write(), not vfs_write()
  dump_align(): fix the dumb braino
parents 2a46eed5 31dec132

arch/ia64/kernel/perfmon.c

+1 −7
Original line number Diff line number Diff line
@@ -2166,12 +2166,6 @@ static const struct file_operations pfm_file_ops = { 
	.flush		= pfm_flush

};



static int

pfmfs_delete_dentry(const struct dentry *dentry)

{

	return 1;

}



static char *pfmfs_dname(struct dentry *dentry, char *buffer, int buflen)

{

	return dynamic_dname(dentry, buffer, buflen, "pfm:[%lu]",
@@ -2179,7 +2173,7 @@ static char *pfmfs_dname(struct dentry *dentry, char *buffer, int buflen) 
}



static const struct dentry_operations pfmfs_dentry_operations = {

	.d_delete = pfmfs_delete_dentry,

	.d_delete = always_delete_dentry,

	.d_dname = pfmfs_dname,

};

fs/9p/vfs_dentry.c

+1 −18
Original line number Diff line number Diff line
@@ -42,23 +42,6 @@ 
#include "v9fs_vfs.h"

#include "fid.h"



/**

 * v9fs_dentry_delete - called when dentry refcount equals 0

 * @dentry:  dentry in question

 *

 * By returning 1 here we should remove cacheing of unused

 * dentry components.

 *

 */



static int v9fs_dentry_delete(const struct dentry *dentry)

{

	p9_debug(P9_DEBUG_VFS, " dentry: %s (%p)\n",

		 dentry->d_name.name, dentry);



	return 1;

}



/**

 * v9fs_cached_dentry_delete - called when dentry refcount equals 0

 * @dentry:  dentry in question
@@ -134,6 +117,6 @@ const struct dentry_operations v9fs_cached_dentry_operations = { 
};



const struct dentry_operations v9fs_dentry_operations = {

	.d_delete = v9fs_dentry_delete,

	.d_delete = always_delete_dentry,

	.d_release = v9fs_dentry_release,

};

fs/configfs/dir.c

+1 −11
Original line number Diff line number Diff line
@@ -66,19 +66,9 @@ static void configfs_d_iput(struct dentry * dentry, 
	iput(inode);

}



/*

 * We _must_ delete our dentries on last dput, as the chain-to-parent

 * behavior is required to clear the parents of default_groups.

 */

static int configfs_d_delete(const struct dentry *dentry)

{

	return 1;

}



const struct dentry_operations configfs_dentry_ops = {

	.d_iput		= configfs_d_iput,

	/* simple_delete_dentry() isn't exported */

	.d_delete	= configfs_d_delete,

	.d_delete	= always_delete_dentry,

};



#ifdef CONFIG_LOCKDEP

fs/coredump.c

+3 −3
Original line number Diff line number Diff line
@@ -695,7 +695,7 @@ int dump_emit(struct coredump_params *cprm, const void *addr, int nr) 
	while (nr) {

		if (dump_interrupted())

			return 0;

		n = vfs_write(file, addr, nr, &pos);

		n = __kernel_write(file, addr, nr, &pos);

		if (n <= 0)

			return 0;

		file->f_pos = pos;
@@ -733,7 +733,7 @@ int dump_align(struct coredump_params *cprm, int align) 
{

	unsigned mod = cprm->written & (align - 1);

	if (align & (align - 1))

		return -EINVAL;

	return mod ? dump_skip(cprm, align - mod) : 0;

		return 0;

	return mod ? dump_skip(cprm, align - mod) : 1;

}

EXPORT_SYMBOL(dump_align);

fs/dcache.c

+20 −64
Original line number Diff line number Diff line
@@ -88,35 +88,6 @@ EXPORT_SYMBOL(rename_lock); 


static struct kmem_cache *dentry_cache __read_mostly;



/**

 * read_seqbegin_or_lock - begin a sequence number check or locking block

 * @lock: sequence lock

 * @seq : sequence number to be checked

 *

 * First try it once optimistically without taking the lock. If that fails,

 * take the lock. The sequence number is also used as a marker for deciding

 * whether to be a reader (even) or writer (odd).

 * N.B. seq must be initialized to an even number to begin with.

 */

static inline void read_seqbegin_or_lock(seqlock_t *lock, int *seq)

{

	if (!(*seq & 1))	/* Even */

		*seq = read_seqbegin(lock);

	else			/* Odd */

		read_seqlock_excl(lock);

}



static inline int need_seqretry(seqlock_t *lock, int seq)

{

	return !(seq & 1) && read_seqretry(lock, seq);

}



static inline void done_seqretry(seqlock_t *lock, int seq)

{

	if (seq & 1)

		read_sequnlock_excl(lock);

}



/*

 * This is the single most critical data structure when it comes

 * to the dcache: the hashtable for lookups. Somebody should try
@@ -125,8 +96,6 @@ static inline void done_seqretry(seqlock_t *lock, int seq) 
 * This hash-function tries to avoid losing too many bits of hash

 * information, yet avoid using a prime hash-size or similar.

 */

#define D_HASHBITS     d_hash_shift

#define D_HASHMASK     d_hash_mask



static unsigned int d_hash_mask __read_mostly;

static unsigned int d_hash_shift __read_mostly;
@@ -137,8 +106,8 @@ static inline struct hlist_bl_head *d_hash(const struct dentry *parent, 
					unsigned int hash)

{

	hash += (unsigned long) parent / L1_CACHE_BYTES;

	hash = hash + (hash >> D_HASHBITS);

	return dentry_hashtable + (hash & D_HASHMASK);

	hash = hash + (hash >> d_hash_shift);

	return dentry_hashtable + (hash & d_hash_mask);

}



/* Statistics gathering. */
@@ -469,7 +438,7 @@ static struct dentry *d_kill(struct dentry *dentry, struct dentry *parent) 
{

	list_del(&dentry->d_u.d_child);

	/*

	 * Inform try_to_ascend() that we are no longer attached to the

	 * Inform d_walk() that we are no longer attached to the

	 * dentry tree

	 */

	dentry->d_flags |= DCACHE_DENTRY_KILLED;
@@ -1069,34 +1038,6 @@ void shrink_dcache_sb(struct super_block *sb) 
}

EXPORT_SYMBOL(shrink_dcache_sb);



/*

 * This tries to ascend one level of parenthood, but

 * we can race with renaming, so we need to re-check

 * the parenthood after dropping the lock and check

 * that the sequence number still matches.

 */

static struct dentry *try_to_ascend(struct dentry *old, unsigned seq)

{

	struct dentry *new = old->d_parent;



	rcu_read_lock();

	spin_unlock(&old->d_lock);

	spin_lock(&new->d_lock);



	/*

	 * might go back up the wrong parent if we have had a rename

	 * or deletion

	 */

	if (new != old->d_parent ||

		 (old->d_flags & DCACHE_DENTRY_KILLED) ||

		 need_seqretry(&rename_lock, seq)) {

		spin_unlock(&new->d_lock);

		new = NULL;

	}

	rcu_read_unlock();

	return new;

}



/**

 * enum d_walk_ret - action to talke during tree walk

 * @D_WALK_CONTINUE:	contrinue walk
@@ -1185,9 +1126,24 @@ static void d_walk(struct dentry *parent, void *data, 
	 */

	if (this_parent != parent) {

		struct dentry *child = this_parent;

		this_parent = try_to_ascend(this_parent, seq);

		if (!this_parent)

		this_parent = child->d_parent;



		rcu_read_lock();

		spin_unlock(&child->d_lock);

		spin_lock(&this_parent->d_lock);



		/*

		 * might go back up the wrong parent if we have had a rename

		 * or deletion

		 */

		if (this_parent != child->d_parent ||

			 (child->d_flags & DCACHE_DENTRY_KILLED) ||

			 need_seqretry(&rename_lock, seq)) {

			spin_unlock(&this_parent->d_lock);

			rcu_read_unlock();

			goto rename_retry;

		}

		rcu_read_unlock();

		next = child->d_u.d_child.next;

		goto resume;

	}