2005-04-16 16:20:36 -06:00
|
|
|
#ifndef __LINUX_DCACHE_H
|
|
|
|
#define __LINUX_DCACHE_H
|
|
|
|
|
|
|
|
#include <asm/atomic.h>
|
|
|
|
#include <linux/list.h>
|
2008-05-12 13:21:05 -06:00
|
|
|
#include <linux/rculist.h>
|
2011-01-06 23:50:05 -07:00
|
|
|
#include <linux/rculist_bl.h>
|
2005-04-16 16:20:36 -06:00
|
|
|
#include <linux/spinlock.h>
|
fs: rcu-walk for path lookup
Perform common cases of path lookups without any stores or locking in the
ancestor dentry elements. This is called rcu-walk, as opposed to the current
algorithm which is a refcount based walk, or ref-walk.
This results in far fewer atomic operations on every path element,
significantly improving path lookup performance. It also avoids cacheline
bouncing on common dentries, significantly improving scalability.
The overall design is like this:
* LOOKUP_RCU is set in nd->flags, which distinguishes rcu-walk from ref-walk.
* Take the RCU lock for the entire path walk, starting with the acquiring
of the starting path (eg. root/cwd/fd-path). So now dentry refcounts are
not required for dentry persistence.
* synchronize_rcu is called when unregistering a filesystem, so we can
access d_ops and i_ops during rcu-walk.
* Similarly take the vfsmount lock for the entire path walk. So now mnt
refcounts are not required for persistence. Also we are free to perform mount
lookups, and to assume dentry mount points and mount roots are stable up and
down the path.
* Have a per-dentry seqlock to protect the dentry name, parent, and inode,
so we can load this tuple atomically, and also check whether any of its
members have changed.
* Dentry lookups (based on parent, candidate string tuple) recheck the parent
sequence after the child is found in case anything changed in the parent
during the path walk.
* inode is also RCU protected so we can load d_inode and use the inode for
limited things.
* i_mode, i_uid, i_gid can be tested for exec permissions during path walk.
* i_op can be loaded.
When we reach the destination dentry, we lock it, recheck lookup sequence,
and increment its refcount and mountpoint refcount. RCU and vfsmount locks
are dropped. This is termed "dropping rcu-walk". If the dentry refcount does
not match, we can not drop rcu-walk gracefully at the current point in the
lokup, so instead return -ECHILD (for want of a better errno). This signals the
path walking code to re-do the entire lookup with a ref-walk.
Aside from the final dentry, there are other situations that may be encounted
where we cannot continue rcu-walk. In that case, we drop rcu-walk (ie. take
a reference on the last good dentry) and continue with a ref-walk. Again, if
we can drop rcu-walk gracefully, we return -ECHILD and do the whole lookup
using ref-walk. But it is very important that we can continue with ref-walk
for most cases, particularly to avoid the overhead of double lookups, and to
gain the scalability advantages on common path elements (like cwd and root).
The cases where rcu-walk cannot continue are:
* NULL dentry (ie. any uncached path element)
* parent with d_inode->i_op->permission or ACLs
* dentries with d_revalidate
* Following links
In future patches, permission checks and d_revalidate become rcu-walk aware. It
may be possible eventually to make following links rcu-walk aware.
Uncached path elements will always require dropping to ref-walk mode, at the
very least because i_mutex needs to be grabbed, and objects allocated.
Signed-off-by: Nick Piggin <npiggin@kernel.dk>
2011-01-06 23:49:52 -07:00
|
|
|
#include <linux/seqlock.h>
|
2005-04-16 16:20:36 -06:00
|
|
|
#include <linux/cache.h>
|
|
|
|
#include <linux/rcupdate.h>
|
|
|
|
|
|
|
|
struct nameidata;
|
2008-02-14 20:38:44 -07:00
|
|
|
struct path;
|
2005-04-16 16:20:36 -06:00
|
|
|
struct vfsmount;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* linux/include/linux/dcache.h
|
|
|
|
*
|
|
|
|
* Dirent cache data structures
|
|
|
|
*
|
|
|
|
* (C) Copyright 1997 Thomas Schoebel-Theuer,
|
|
|
|
* with heavy changes by Linus Torvalds
|
|
|
|
*/
|
|
|
|
|
|
|
|
#define IS_ROOT(x) ((x) == (x)->d_parent)
|
|
|
|
|
|
|
|
/*
|
|
|
|
* "quick string" -- eases parameter passing, but more importantly
|
|
|
|
* saves "metadata" about the string (ie length and the hash).
|
|
|
|
*
|
|
|
|
* hash comes first so it snuggles against d_parent in the
|
|
|
|
* dentry.
|
|
|
|
*/
|
|
|
|
struct qstr {
|
|
|
|
unsigned int hash;
|
|
|
|
unsigned int len;
|
|
|
|
const unsigned char *name;
|
|
|
|
};
|
|
|
|
|
|
|
|
struct dentry_stat_t {
|
|
|
|
int nr_dentry;
|
|
|
|
int nr_unused;
|
|
|
|
int age_limit; /* age in seconds */
|
|
|
|
int want_pages; /* pages requested by system */
|
|
|
|
int dummy[2];
|
|
|
|
};
|
|
|
|
extern struct dentry_stat_t dentry_stat;
|
|
|
|
|
2011-01-06 23:50:09 -07:00
|
|
|
/*
|
|
|
|
* Compare 2 name strings, return 0 if they match, otherwise non-zero.
|
|
|
|
* The strings are both count bytes long, and count is non-zero.
|
|
|
|
*/
|
|
|
|
static inline int dentry_cmp(const unsigned char *cs, size_t scount,
|
|
|
|
const unsigned char *ct, size_t tcount)
|
|
|
|
{
|
|
|
|
int ret;
|
|
|
|
if (scount != tcount)
|
|
|
|
return 1;
|
|
|
|
do {
|
|
|
|
ret = (*cs != *ct);
|
|
|
|
if (ret)
|
|
|
|
break;
|
|
|
|
cs++;
|
|
|
|
ct++;
|
|
|
|
tcount--;
|
|
|
|
} while (tcount);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
/* Name hashing routines. Initial hash value */
|
|
|
|
/* Hash courtesy of the R5 hash in reiserfs modulo sign bits */
|
|
|
|
#define init_name_hash() 0
|
|
|
|
|
|
|
|
/* partial hash update function. Assume roughly 4 bits per character */
|
|
|
|
static inline unsigned long
|
|
|
|
partial_name_hash(unsigned long c, unsigned long prevhash)
|
|
|
|
{
|
|
|
|
return (prevhash + (c << 4) + (c >> 4)) * 11;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Finally: cut down the number of bits to a int value (and try to avoid
|
|
|
|
* losing bits)
|
|
|
|
*/
|
|
|
|
static inline unsigned long end_name_hash(unsigned long hash)
|
|
|
|
{
|
|
|
|
return (unsigned int) hash;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Compute the hash for a name string. */
|
|
|
|
static inline unsigned int
|
|
|
|
full_name_hash(const unsigned char *name, unsigned int len)
|
|
|
|
{
|
|
|
|
unsigned long hash = init_name_hash();
|
|
|
|
while (len--)
|
|
|
|
hash = partial_name_hash(*name++, hash);
|
|
|
|
return end_name_hash(hash);
|
|
|
|
}
|
|
|
|
|
2008-12-01 01:33:43 -07:00
|
|
|
/*
|
|
|
|
* Try to keep struct dentry aligned on 64 byte cachelines (this will
|
|
|
|
* give reasonable cacheline footprint with larger lines without the
|
|
|
|
* large memory footprint increase).
|
|
|
|
*/
|
|
|
|
#ifdef CONFIG_64BIT
|
2011-01-06 23:49:56 -07:00
|
|
|
# define DNAME_INLINE_LEN 32 /* 192 bytes */
|
2008-12-01 01:33:43 -07:00
|
|
|
#else
|
2011-01-06 23:49:56 -07:00
|
|
|
# ifdef CONFIG_SMP
|
|
|
|
# define DNAME_INLINE_LEN 36 /* 128 bytes */
|
|
|
|
# else
|
|
|
|
# define DNAME_INLINE_LEN 40 /* 128 bytes */
|
|
|
|
# endif
|
2008-12-01 01:33:43 -07:00
|
|
|
#endif
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
struct dentry {
|
2011-01-06 23:49:56 -07:00
|
|
|
/* RCU lookup touched fields */
|
2005-04-16 16:20:36 -06:00
|
|
|
unsigned int d_flags; /* protected by d_lock */
|
fs: rcu-walk for path lookup
Perform common cases of path lookups without any stores or locking in the
ancestor dentry elements. This is called rcu-walk, as opposed to the current
algorithm which is a refcount based walk, or ref-walk.
This results in far fewer atomic operations on every path element,
significantly improving path lookup performance. It also avoids cacheline
bouncing on common dentries, significantly improving scalability.
The overall design is like this:
* LOOKUP_RCU is set in nd->flags, which distinguishes rcu-walk from ref-walk.
* Take the RCU lock for the entire path walk, starting with the acquiring
of the starting path (eg. root/cwd/fd-path). So now dentry refcounts are
not required for dentry persistence.
* synchronize_rcu is called when unregistering a filesystem, so we can
access d_ops and i_ops during rcu-walk.
* Similarly take the vfsmount lock for the entire path walk. So now mnt
refcounts are not required for persistence. Also we are free to perform mount
lookups, and to assume dentry mount points and mount roots are stable up and
down the path.
* Have a per-dentry seqlock to protect the dentry name, parent, and inode,
so we can load this tuple atomically, and also check whether any of its
members have changed.
* Dentry lookups (based on parent, candidate string tuple) recheck the parent
sequence after the child is found in case anything changed in the parent
during the path walk.
* inode is also RCU protected so we can load d_inode and use the inode for
limited things.
* i_mode, i_uid, i_gid can be tested for exec permissions during path walk.
* i_op can be loaded.
When we reach the destination dentry, we lock it, recheck lookup sequence,
and increment its refcount and mountpoint refcount. RCU and vfsmount locks
are dropped. This is termed "dropping rcu-walk". If the dentry refcount does
not match, we can not drop rcu-walk gracefully at the current point in the
lokup, so instead return -ECHILD (for want of a better errno). This signals the
path walking code to re-do the entire lookup with a ref-walk.
Aside from the final dentry, there are other situations that may be encounted
where we cannot continue rcu-walk. In that case, we drop rcu-walk (ie. take
a reference on the last good dentry) and continue with a ref-walk. Again, if
we can drop rcu-walk gracefully, we return -ECHILD and do the whole lookup
using ref-walk. But it is very important that we can continue with ref-walk
for most cases, particularly to avoid the overhead of double lookups, and to
gain the scalability advantages on common path elements (like cwd and root).
The cases where rcu-walk cannot continue are:
* NULL dentry (ie. any uncached path element)
* parent with d_inode->i_op->permission or ACLs
* dentries with d_revalidate
* Following links
In future patches, permission checks and d_revalidate become rcu-walk aware. It
may be possible eventually to make following links rcu-walk aware.
Uncached path elements will always require dropping to ref-walk mode, at the
very least because i_mutex needs to be grabbed, and objects allocated.
Signed-off-by: Nick Piggin <npiggin@kernel.dk>
2011-01-06 23:49:52 -07:00
|
|
|
seqcount_t d_seq; /* per dentry seqlock */
|
2011-01-06 23:50:05 -07:00
|
|
|
struct hlist_bl_node d_hash; /* lookup hash list */
|
2005-04-16 16:20:36 -06:00
|
|
|
struct dentry *d_parent; /* parent directory */
|
|
|
|
struct qstr d_name;
|
2011-01-06 23:49:56 -07:00
|
|
|
struct inode *d_inode; /* Where the name belongs to - NULL is
|
|
|
|
* negative */
|
|
|
|
unsigned char d_iname[DNAME_INLINE_LEN]; /* small names */
|
|
|
|
|
|
|
|
/* Ref lookup also touches following */
|
|
|
|
unsigned int d_count; /* protected by d_lock */
|
|
|
|
spinlock_t d_lock; /* per dentry lock */
|
|
|
|
const struct dentry_operations *d_op;
|
|
|
|
struct super_block *d_sb; /* The root of the dentry tree */
|
|
|
|
unsigned long d_time; /* used by d_revalidate */
|
|
|
|
void *d_fsdata; /* fs-specific data */
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
struct list_head d_lru; /* LRU list */
|
[PATCH] shrink dentry struct
Some long time ago, dentry struct was carefully tuned so that on 32 bits
UP, sizeof(struct dentry) was exactly 128, ie a power of 2, and a multiple
of memory cache lines.
Then RCU was added and dentry struct enlarged by two pointers, with nice
results for SMP, but not so good on UP, because breaking the above tuning
(128 + 8 = 136 bytes)
This patch reverts this unwanted side effect, by using an union (d_u),
where d_rcu and d_child are placed so that these two fields can share their
memory needs.
At the time d_free() is called (and d_rcu is really used), d_child is known
to be empty and not touched by the dentry freeing.
Lockless lookups only access d_name, d_parent, d_lock, d_op, d_flags (so
the previous content of d_child is not needed if said dentry was unhashed
but still accessed by a CPU because of RCU constraints)
As dentry cache easily contains millions of entries, a size reduction is
worth the extra complexity of the ugly C union.
Signed-off-by: Eric Dumazet <dada1@cosmosbay.com>
Cc: Dipankar Sarma <dipankar@in.ibm.com>
Cc: Maneesh Soni <maneesh@in.ibm.com>
Cc: Miklos Szeredi <miklos@szeredi.hu>
Cc: "Paul E. McKenney" <paulmck@us.ibm.com>
Cc: Ian Kent <raven@themaw.net>
Cc: Paul Jackson <pj@sgi.com>
Cc: Al Viro <viro@ftp.linux.org.uk>
Cc: Christoph Hellwig <hch@lst.de>
Cc: Trond Myklebust <trond.myklebust@fys.uio.no>
Cc: Neil Brown <neilb@cse.unsw.edu.au>
Cc: James Morris <jmorris@namei.org>
Cc: Stephen Smalley <sds@epoch.ncsc.mil>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-01-08 02:03:32 -07:00
|
|
|
/*
|
|
|
|
* d_child and d_rcu can share memory
|
|
|
|
*/
|
|
|
|
union {
|
|
|
|
struct list_head d_child; /* child of parent list */
|
|
|
|
struct rcu_head d_rcu;
|
|
|
|
} d_u;
|
2005-04-16 16:20:36 -06:00
|
|
|
struct list_head d_subdirs; /* our children */
|
|
|
|
struct list_head d_alias; /* inode alias list */
|
|
|
|
};
|
|
|
|
|
2006-07-03 01:25:04 -06:00
|
|
|
/*
|
|
|
|
* dentry->d_lock spinlock nesting subclasses:
|
|
|
|
*
|
|
|
|
* 0: normal
|
|
|
|
* 1: nested
|
|
|
|
*/
|
|
|
|
enum dentry_d_lock_class
|
|
|
|
{
|
|
|
|
DENTRY_D_LOCK_NORMAL, /* implicitly used by plain spin_lock() APIs. */
|
|
|
|
DENTRY_D_LOCK_NESTED
|
|
|
|
};
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
struct dentry_operations {
|
|
|
|
int (*d_revalidate)(struct dentry *, struct nameidata *);
|
2011-01-06 23:49:28 -07:00
|
|
|
int (*d_hash)(const struct dentry *, const struct inode *,
|
|
|
|
struct qstr *);
|
2011-01-06 23:49:27 -07:00
|
|
|
int (*d_compare)(const struct dentry *, const struct inode *,
|
|
|
|
const struct dentry *, const struct inode *,
|
|
|
|
unsigned int, const char *, const struct qstr *);
|
2011-01-06 23:49:23 -07:00
|
|
|
int (*d_delete)(const struct dentry *);
|
2005-04-16 16:20:36 -06:00
|
|
|
void (*d_release)(struct dentry *);
|
|
|
|
void (*d_iput)(struct dentry *, struct inode *);
|
2007-05-08 01:26:18 -06:00
|
|
|
char *(*d_dname)(struct dentry *, char *, int);
|
2011-01-06 23:49:56 -07:00
|
|
|
} ____cacheline_aligned;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2011-01-06 23:49:22 -07:00
|
|
|
/*
|
|
|
|
* Locking rules for dentry_operations callbacks are to be found in
|
|
|
|
* Documentation/filesystems/Locking. Keep it updated!
|
|
|
|
*
|
2011-01-06 23:49:27 -07:00
|
|
|
* FUrther descriptions are found in Documentation/filesystems/vfs.txt.
|
|
|
|
* Keep it updated too!
|
2005-04-16 16:20:36 -06:00
|
|
|
*/
|
|
|
|
|
|
|
|
/* d_flags entries */
|
|
|
|
#define DCACHE_AUTOFS_PENDING 0x0001 /* autofs: "under construction" */
|
2011-01-06 23:49:54 -07:00
|
|
|
#define DCACHE_NFSFS_RENAMED 0x0002
|
|
|
|
/* this dentry has been "silly renamed" and has to be deleted on the last
|
|
|
|
* dput() */
|
|
|
|
|
|
|
|
#define DCACHE_DISCONNECTED 0x0004
|
|
|
|
/* This dentry is possibly not currently connected to the dcache tree, in
|
|
|
|
* which case its parent will either be itself, or will have this flag as
|
|
|
|
* well. nfsd will not use a dentry with this bit set, but will first
|
|
|
|
* endeavour to clear the bit either by discovering that it is connected,
|
|
|
|
* or by performing lookup operations. Any filesystem which supports
|
|
|
|
* nfsd_operations MUST have a lookup function which, if it finds a
|
|
|
|
* directory inode with a DCACHE_DISCONNECTED dentry, will d_move that
|
|
|
|
* dentry into place and return that dentry rather than the passed one,
|
|
|
|
* typically using d_splice_alias. */
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
#define DCACHE_REFERENCED 0x0008 /* Recently used, don't discard. */
|
|
|
|
#define DCACHE_UNHASHED 0x0010
|
2011-01-06 23:49:54 -07:00
|
|
|
#define DCACHE_INOTIFY_PARENT_WATCHED 0x0020
|
|
|
|
/* Parent inode is watched by inotify */
|
2006-03-25 04:07:09 -07:00
|
|
|
|
2008-12-01 01:33:43 -07:00
|
|
|
#define DCACHE_COOKIE 0x0040 /* For use by dcookie subsystem */
|
2011-01-06 23:49:54 -07:00
|
|
|
#define DCACHE_FSNOTIFY_PARENT_WATCHED 0x0080
|
|
|
|
/* Parent inode is watched by some fsnotify listener */
|
2009-05-21 15:01:29 -06:00
|
|
|
|
2010-04-30 15:17:09 -06:00
|
|
|
#define DCACHE_CANT_MOUNT 0x0100
|
2011-01-06 23:49:37 -07:00
|
|
|
#define DCACHE_GENOCIDE 0x0200
|
2011-01-06 23:49:54 -07:00
|
|
|
#define DCACHE_MOUNTED 0x0400 /* is a mountpoint */
|
|
|
|
|
2011-01-06 23:49:55 -07:00
|
|
|
#define DCACHE_OP_HASH 0x1000
|
|
|
|
#define DCACHE_OP_COMPARE 0x2000
|
|
|
|
#define DCACHE_OP_REVALIDATE 0x4000
|
|
|
|
#define DCACHE_OP_DELETE 0x8000
|
|
|
|
|
[PATCH] audit: watching subtrees
New kind of audit rule predicates: "object is visible in given subtree".
The part that can be sanely implemented, that is. Limitations:
* if you have hardlink from outside of tree, you'd better watch
it too (or just watch the object itself, obviously)
* if you mount something under a watched tree, tell audit
that new chunk should be added to watched subtrees
* if you umount something in a watched tree and it's still mounted
elsewhere, you will get matches on events happening there. New command
tells audit to recalculate the trees, trimming such sources of false
positives.
Note that it's _not_ about path - if something mounted in several places
(multiple mount, bindings, different namespaces, etc.), the match does
_not_ depend on which one we are using for access.
Signed-off-by: Al Viro <viro@zeniv.linux.org.uk>
2007-07-22 06:04:18 -06:00
|
|
|
extern seqlock_t rename_lock;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
static inline int dname_external(struct dentry *dentry)
|
|
|
|
{
|
|
|
|
return dentry->d_name.name != dentry->d_iname;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* These are the low-level FS interfaces to the dcache..
|
|
|
|
*/
|
|
|
|
extern void d_instantiate(struct dentry *, struct inode *);
|
|
|
|
extern struct dentry * d_instantiate_unique(struct dentry *, struct inode *);
|
2006-08-22 18:06:07 -06:00
|
|
|
extern struct dentry * d_materialise_unique(struct dentry *, struct inode *);
|
2011-01-06 23:49:30 -07:00
|
|
|
extern void __d_drop(struct dentry *dentry);
|
|
|
|
extern void d_drop(struct dentry *dentry);
|
2005-04-16 16:20:36 -06:00
|
|
|
extern void d_delete(struct dentry *);
|
2011-01-06 23:49:55 -07:00
|
|
|
extern void d_set_d_op(struct dentry *dentry, const struct dentry_operations *op);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
/* allocate/de-allocate */
|
|
|
|
extern struct dentry * d_alloc(struct dentry *, const struct qstr *);
|
2011-01-06 23:50:07 -07:00
|
|
|
extern struct dentry * d_alloc_pseudo(struct super_block *, const struct qstr *);
|
2005-04-16 16:20:36 -06:00
|
|
|
extern struct dentry * d_splice_alias(struct inode *, struct dentry *);
|
2008-08-07 15:49:07 -06:00
|
|
|
extern struct dentry * d_add_ci(struct dentry *, struct inode *, struct qstr *);
|
2008-08-11 07:48:57 -06:00
|
|
|
extern struct dentry * d_obtain_alias(struct inode *);
|
2005-04-16 16:20:36 -06:00
|
|
|
extern void shrink_dcache_sb(struct super_block *);
|
|
|
|
extern void shrink_dcache_parent(struct dentry *);
|
2006-10-11 02:22:19 -06:00
|
|
|
extern void shrink_dcache_for_umount(struct super_block *);
|
2005-04-16 16:20:36 -06:00
|
|
|
extern int d_invalidate(struct dentry *);
|
|
|
|
|
|
|
|
/* only used at mount-time */
|
|
|
|
extern struct dentry * d_alloc_root(struct inode *);
|
|
|
|
|
|
|
|
/* <clickety>-<click> the ramfs-type tree */
|
|
|
|
extern void d_genocide(struct dentry *);
|
|
|
|
|
|
|
|
extern struct dentry *d_find_alias(struct inode *);
|
|
|
|
extern void d_prune_aliases(struct inode *);
|
|
|
|
|
|
|
|
/* test whether we have any submounts in a subdir tree */
|
|
|
|
extern int have_submounts(struct dentry *);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* This adds the entry to the hash queues.
|
|
|
|
*/
|
|
|
|
extern void d_rehash(struct dentry *);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* d_add - add dentry to hash queues
|
|
|
|
* @entry: dentry to add
|
|
|
|
* @inode: The inode to attach to this dentry
|
|
|
|
*
|
|
|
|
* This adds the entry to the hash queues and initializes @inode.
|
|
|
|
* The entry was actually filled in earlier during d_alloc().
|
|
|
|
*/
|
|
|
|
|
|
|
|
static inline void d_add(struct dentry *entry, struct inode *inode)
|
|
|
|
{
|
|
|
|
d_instantiate(entry, inode);
|
|
|
|
d_rehash(entry);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* d_add_unique - add dentry to hash queues without aliasing
|
|
|
|
* @entry: dentry to add
|
|
|
|
* @inode: The inode to attach to this dentry
|
|
|
|
*
|
|
|
|
* This adds the entry to the hash queues and initializes @inode.
|
|
|
|
* The entry was actually filled in earlier during d_alloc().
|
|
|
|
*/
|
|
|
|
static inline struct dentry *d_add_unique(struct dentry *entry, struct inode *inode)
|
|
|
|
{
|
|
|
|
struct dentry *res;
|
|
|
|
|
|
|
|
res = d_instantiate_unique(entry, inode);
|
|
|
|
d_rehash(res != NULL ? res : entry);
|
|
|
|
return res;
|
|
|
|
}
|
|
|
|
|
2011-01-06 23:49:26 -07:00
|
|
|
extern void dentry_update_name_case(struct dentry *, struct qstr *);
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
/* used for rename() and baskets */
|
|
|
|
extern void d_move(struct dentry *, struct dentry *);
|
2008-10-15 16:50:28 -06:00
|
|
|
extern struct dentry *d_ancestor(struct dentry *, struct dentry *);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
/* appendix may either be NULL or be used for transname suffixes */
|
fs: rcu-walk for path lookup
Perform common cases of path lookups without any stores or locking in the
ancestor dentry elements. This is called rcu-walk, as opposed to the current
algorithm which is a refcount based walk, or ref-walk.
This results in far fewer atomic operations on every path element,
significantly improving path lookup performance. It also avoids cacheline
bouncing on common dentries, significantly improving scalability.
The overall design is like this:
* LOOKUP_RCU is set in nd->flags, which distinguishes rcu-walk from ref-walk.
* Take the RCU lock for the entire path walk, starting with the acquiring
of the starting path (eg. root/cwd/fd-path). So now dentry refcounts are
not required for dentry persistence.
* synchronize_rcu is called when unregistering a filesystem, so we can
access d_ops and i_ops during rcu-walk.
* Similarly take the vfsmount lock for the entire path walk. So now mnt
refcounts are not required for persistence. Also we are free to perform mount
lookups, and to assume dentry mount points and mount roots are stable up and
down the path.
* Have a per-dentry seqlock to protect the dentry name, parent, and inode,
so we can load this tuple atomically, and also check whether any of its
members have changed.
* Dentry lookups (based on parent, candidate string tuple) recheck the parent
sequence after the child is found in case anything changed in the parent
during the path walk.
* inode is also RCU protected so we can load d_inode and use the inode for
limited things.
* i_mode, i_uid, i_gid can be tested for exec permissions during path walk.
* i_op can be loaded.
When we reach the destination dentry, we lock it, recheck lookup sequence,
and increment its refcount and mountpoint refcount. RCU and vfsmount locks
are dropped. This is termed "dropping rcu-walk". If the dentry refcount does
not match, we can not drop rcu-walk gracefully at the current point in the
lokup, so instead return -ECHILD (for want of a better errno). This signals the
path walking code to re-do the entire lookup with a ref-walk.
Aside from the final dentry, there are other situations that may be encounted
where we cannot continue rcu-walk. In that case, we drop rcu-walk (ie. take
a reference on the last good dentry) and continue with a ref-walk. Again, if
we can drop rcu-walk gracefully, we return -ECHILD and do the whole lookup
using ref-walk. But it is very important that we can continue with ref-walk
for most cases, particularly to avoid the overhead of double lookups, and to
gain the scalability advantages on common path elements (like cwd and root).
The cases where rcu-walk cannot continue are:
* NULL dentry (ie. any uncached path element)
* parent with d_inode->i_op->permission or ACLs
* dentries with d_revalidate
* Following links
In future patches, permission checks and d_revalidate become rcu-walk aware. It
may be possible eventually to make following links rcu-walk aware.
Uncached path elements will always require dropping to ref-walk mode, at the
very least because i_mutex needs to be grabbed, and objects allocated.
Signed-off-by: Nick Piggin <npiggin@kernel.dk>
2011-01-06 23:49:52 -07:00
|
|
|
extern struct dentry *d_lookup(struct dentry *, struct qstr *);
|
|
|
|
extern struct dentry *d_hash_and_lookup(struct dentry *, struct qstr *);
|
|
|
|
extern struct dentry *__d_lookup(struct dentry *, struct qstr *);
|
|
|
|
extern struct dentry *__d_lookup_rcu(struct dentry *parent, struct qstr *name,
|
|
|
|
unsigned *seq, struct inode **inode);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* __d_rcu_to_refcount - take a refcount on dentry if sequence check is ok
|
|
|
|
* @dentry: dentry to take a ref on
|
|
|
|
* @seq: seqcount to verify against
|
2011-01-08 20:37:20 -07:00
|
|
|
* Returns: 0 on failure, else 1.
|
fs: rcu-walk for path lookup
Perform common cases of path lookups without any stores or locking in the
ancestor dentry elements. This is called rcu-walk, as opposed to the current
algorithm which is a refcount based walk, or ref-walk.
This results in far fewer atomic operations on every path element,
significantly improving path lookup performance. It also avoids cacheline
bouncing on common dentries, significantly improving scalability.
The overall design is like this:
* LOOKUP_RCU is set in nd->flags, which distinguishes rcu-walk from ref-walk.
* Take the RCU lock for the entire path walk, starting with the acquiring
of the starting path (eg. root/cwd/fd-path). So now dentry refcounts are
not required for dentry persistence.
* synchronize_rcu is called when unregistering a filesystem, so we can
access d_ops and i_ops during rcu-walk.
* Similarly take the vfsmount lock for the entire path walk. So now mnt
refcounts are not required for persistence. Also we are free to perform mount
lookups, and to assume dentry mount points and mount roots are stable up and
down the path.
* Have a per-dentry seqlock to protect the dentry name, parent, and inode,
so we can load this tuple atomically, and also check whether any of its
members have changed.
* Dentry lookups (based on parent, candidate string tuple) recheck the parent
sequence after the child is found in case anything changed in the parent
during the path walk.
* inode is also RCU protected so we can load d_inode and use the inode for
limited things.
* i_mode, i_uid, i_gid can be tested for exec permissions during path walk.
* i_op can be loaded.
When we reach the destination dentry, we lock it, recheck lookup sequence,
and increment its refcount and mountpoint refcount. RCU and vfsmount locks
are dropped. This is termed "dropping rcu-walk". If the dentry refcount does
not match, we can not drop rcu-walk gracefully at the current point in the
lokup, so instead return -ECHILD (for want of a better errno). This signals the
path walking code to re-do the entire lookup with a ref-walk.
Aside from the final dentry, there are other situations that may be encounted
where we cannot continue rcu-walk. In that case, we drop rcu-walk (ie. take
a reference on the last good dentry) and continue with a ref-walk. Again, if
we can drop rcu-walk gracefully, we return -ECHILD and do the whole lookup
using ref-walk. But it is very important that we can continue with ref-walk
for most cases, particularly to avoid the overhead of double lookups, and to
gain the scalability advantages on common path elements (like cwd and root).
The cases where rcu-walk cannot continue are:
* NULL dentry (ie. any uncached path element)
* parent with d_inode->i_op->permission or ACLs
* dentries with d_revalidate
* Following links
In future patches, permission checks and d_revalidate become rcu-walk aware. It
may be possible eventually to make following links rcu-walk aware.
Uncached path elements will always require dropping to ref-walk mode, at the
very least because i_mutex needs to be grabbed, and objects allocated.
Signed-off-by: Nick Piggin <npiggin@kernel.dk>
2011-01-06 23:49:52 -07:00
|
|
|
*
|
|
|
|
* __d_rcu_to_refcount operates on a dentry,seq pair that was returned
|
|
|
|
* by __d_lookup_rcu, to get a reference on an rcu-walk dentry.
|
|
|
|
*/
|
|
|
|
static inline int __d_rcu_to_refcount(struct dentry *dentry, unsigned seq)
|
|
|
|
{
|
|
|
|
int ret = 0;
|
|
|
|
|
|
|
|
assert_spin_locked(&dentry->d_lock);
|
|
|
|
if (!read_seqcount_retry(&dentry->d_seq, seq)) {
|
|
|
|
ret = 1;
|
|
|
|
dentry->d_count++;
|
|
|
|
}
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
/* validate "insecure" dentry pointer */
|
|
|
|
extern int d_validate(struct dentry *, struct dentry *);
|
|
|
|
|
2007-05-08 01:26:18 -06:00
|
|
|
/*
|
|
|
|
* helper function for dentry_operations.d_dname() members
|
|
|
|
*/
|
|
|
|
extern char *dynamic_dname(struct dentry *, char *, int, const char *, ...);
|
|
|
|
|
2008-03-27 06:06:21 -06:00
|
|
|
extern char *__d_path(const struct path *path, struct path *root, char *, int);
|
2008-06-09 17:40:36 -06:00
|
|
|
extern char *d_path(const struct path *, char *, int);
|
2010-08-10 03:41:41 -06:00
|
|
|
extern char *d_path_with_unreachable(const struct path *, char *, int);
|
2011-01-06 23:49:29 -07:00
|
|
|
extern char *dentry_path_raw(struct dentry *, char *, int);
|
2008-03-27 06:06:20 -06:00
|
|
|
extern char *dentry_path(struct dentry *, char *, int);
|
2008-02-14 20:38:44 -07:00
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
/* Allocation counts.. */
|
|
|
|
|
|
|
|
/**
|
2011-01-06 23:49:43 -07:00
|
|
|
* dget, dget_dlock - get a reference to a dentry
|
2005-04-16 16:20:36 -06:00
|
|
|
* @dentry: dentry to get a reference to
|
|
|
|
*
|
|
|
|
* Given a dentry or %NULL pointer increment the reference count
|
|
|
|
* if appropriate and return the dentry. A dentry will not be
|
2011-01-06 23:49:43 -07:00
|
|
|
* destroyed when it has references.
|
2005-04-16 16:20:36 -06:00
|
|
|
*/
|
2011-01-06 23:49:32 -07:00
|
|
|
static inline struct dentry *dget_dlock(struct dentry *dentry)
|
|
|
|
{
|
2011-01-06 23:49:43 -07:00
|
|
|
if (dentry)
|
2011-01-06 23:49:32 -07:00
|
|
|
dentry->d_count++;
|
|
|
|
return dentry;
|
|
|
|
}
|
2011-01-06 23:49:34 -07:00
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
static inline struct dentry *dget(struct dentry *dentry)
|
|
|
|
{
|
|
|
|
if (dentry) {
|
2011-01-06 23:49:32 -07:00
|
|
|
spin_lock(&dentry->d_lock);
|
|
|
|
dget_dlock(dentry);
|
|
|
|
spin_unlock(&dentry->d_lock);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
return dentry;
|
|
|
|
}
|
|
|
|
|
2011-01-06 23:49:32 -07:00
|
|
|
extern struct dentry *dget_parent(struct dentry *dentry);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
/**
|
|
|
|
* d_unhashed - is dentry hashed
|
|
|
|
* @dentry: entry to check
|
|
|
|
*
|
|
|
|
* Returns true if the dentry passed is not currently hashed.
|
|
|
|
*/
|
|
|
|
|
|
|
|
static inline int d_unhashed(struct dentry *dentry)
|
|
|
|
{
|
|
|
|
return (dentry->d_flags & DCACHE_UNHASHED);
|
|
|
|
}
|
|
|
|
|
2009-05-03 17:32:03 -06:00
|
|
|
static inline int d_unlinked(struct dentry *dentry)
|
|
|
|
{
|
|
|
|
return d_unhashed(dentry) && !IS_ROOT(dentry);
|
|
|
|
}
|
|
|
|
|
2010-04-30 15:17:09 -06:00
|
|
|
static inline int cant_mount(struct dentry *dentry)
|
|
|
|
{
|
|
|
|
return (dentry->d_flags & DCACHE_CANT_MOUNT);
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline void dont_mount(struct dentry *dentry)
|
|
|
|
{
|
|
|
|
spin_lock(&dentry->d_lock);
|
|
|
|
dentry->d_flags |= DCACHE_CANT_MOUNT;
|
|
|
|
spin_unlock(&dentry->d_lock);
|
|
|
|
}
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
extern void dput(struct dentry *);
|
|
|
|
|
|
|
|
static inline int d_mountpoint(struct dentry *dentry)
|
|
|
|
{
|
2011-01-06 23:49:54 -07:00
|
|
|
return dentry->d_flags & DCACHE_MOUNTED;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
2009-04-18 12:06:57 -06:00
|
|
|
extern struct vfsmount *lookup_mnt(struct path *);
|
2005-04-16 16:20:36 -06:00
|
|
|
extern struct dentry *lookup_create(struct nameidata *nd, int is_dir);
|
|
|
|
|
|
|
|
extern int sysctl_vfs_cache_pressure;
|
|
|
|
|
|
|
|
#endif /* __LINUX_DCACHE_H */
|