Piteball
/
android_kernel_google_msm
mirror of https://github.com/followmsi/android_kernel_google_msm.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity

move d_rcu from overlapping d_child to overlapping d_alias 

commit 946e51f2bf37f1656916eb75bd0742ba33983c28 upstream.

Change-Id: I85366e6ce0423ec9620bcc9cd3e7695e81aa1171
Signed-off-by: Al Viro <viro@zeniv.linux.org.uk>
[bwh: Backported to 3.2:
 - Apply name changes in all the different places we use d_alias and d_child
 - Move the WARN_ON() in __d_free() to d_free() as we don't have dentry_free()]
Signed-off-by: Ben Hutchings <ben@decadent.org.uk>
[lizf: Backported to 3.4:
 - adjust context
 - need one more name change in debugfs]
This commit is contained in:
Al Viro 2014-10-26 19:19:16 -04:00 committed by Artem Borisov
parent f787204b2f
commit be084ce9f1
23 changed files with 91 additions and 91 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
arch/powerpc/platforms/cell/spufs/inode.c
View File

@ -163,7 +163,7 @@ static void spufs_prune_dir(struct dentry *dir)
struct dentry *dentry, *tmp; struct dentry *dentry, *tmp;
mutex_lock(&dir->d_inode->i_mutex); mutex_lock(&dir->d_inode->i_mutex);
list_for_each_entry_safe(dentry, tmp, &dir->d_subdirs, d_u.d_child) { list_for_each_entry_safe(dentry, tmp, &dir->d_subdirs, d_child) {
spin_lock(&dentry->d_lock); spin_lock(&dentry->d_lock);
if (!(d_unhashed(dentry)) && dentry->d_inode) { if (!(d_unhashed(dentry)) && dentry->d_inode) {
dget_dlock(dentry); dget_dlock(dentry);
@ -221,7 +221,7 @@ out:
* - free child's inode if possible * - free child's inode if possible
* - free child * - free child
*/ */
list_for_each_entry_safe(dentry, tmp, &dir->d_subdirs, d_u.d_child) { list_for_each_entry_safe(dentry, tmp, &dir->d_subdirs, d_child) {
dput(dentry); dput(dentry);
} }

6
drivers/usb/core/inode.c
View File

@ -211,7 +211,7 @@ static void update_bus(struct dentry *bus)
mutex_lock(&bus->d_inode->i_mutex); mutex_lock(&bus->d_inode->i_mutex);
list_for_each_entry(dev, &bus->d_subdirs, d_u.d_child) list_for_each_entry(dev, &bus->d_subdirs, d_child)
if (dev->d_inode) if (dev->d_inode)
update_dev(dev); update_dev(dev);
@ -228,7 +228,7 @@ static void update_sb(struct super_block *sb)
mutex_lock_nested(&root->d_inode->i_mutex, I_MUTEX_PARENT); mutex_lock_nested(&root->d_inode->i_mutex, I_MUTEX_PARENT);
list_for_each_entry(bus, &root->d_subdirs, d_u.d_child) { list_for_each_entry(bus, &root->d_subdirs, d_child) {
if (bus->d_inode) { if (bus->d_inode) {
switch (S_IFMT & bus->d_inode->i_mode) { switch (S_IFMT & bus->d_inode->i_mode) {
case S_IFDIR: case S_IFDIR:
@ -342,7 +342,7 @@ static int usbfs_empty (struct dentry *dentry)
spin_lock(&dentry->d_lock); spin_lock(&dentry->d_lock);
list_for_each(list, &dentry->d_subdirs) { list_for_each(list, &dentry->d_subdirs) {
struct dentry *de = list_entry(list, struct dentry, d_u.d_child); struct dentry *de = list_entry(list, struct dentry, d_child);
spin_lock_nested(&de->d_lock, DENTRY_D_LOCK_NESTED); spin_lock_nested(&de->d_lock, DENTRY_D_LOCK_NESTED);
if (usbfs_positive(de)) { if (usbfs_positive(de)) {

2
fs/9p/vfs_inode_dotl.c
View File

@ -81,7 +81,7 @@ static struct dentry *v9fs_dentry_from_dir_inode(struct inode *inode)
spin_lock(&inode->i_lock); spin_lock(&inode->i_lock);
/* Directory should have only one entry. */ /* Directory should have only one entry. */
BUG_ON(S_ISDIR(inode->i_mode) && !list_is_singular(&inode->i_dentry)); BUG_ON(S_ISDIR(inode->i_mode) && !list_is_singular(&inode->i_dentry));
dentry = list_entry(inode->i_dentry.next, struct dentry, d_alias); dentry = list_entry(inode->i_dentry.next, struct dentry, d_u.d_alias);
spin_unlock(&inode->i_lock); spin_unlock(&inode->i_lock);
return dentry; return dentry;
} }

2
fs/affs/amigaffs.c
View File

@ -132,7 +132,7 @@ affs_fix_dcache(struct dentry *dentry, u32 entry_ino)
head = &inode->i_dentry; head = &inode->i_dentry;
next = head->next; next = head->next;
while (next != head) { while (next != head) {
dentry = list_entry(next, struct dentry, d_alias); dentry = list_entry(next, struct dentry, d_u.d_alias);
if (entry_ino == (u32)(long)dentry->d_fsdata) { if (entry_ino == (u32)(long)dentry->d_fsdata) {
dentry->d_fsdata = data; dentry->d_fsdata = data;
break; break;

10
fs/autofs4/expire.c
View File

@ -109,7 +109,7 @@ static struct dentry *get_next_positive_subdir(struct dentry *prev,
p = prev; p = prev;
spin_lock(&p->d_lock); spin_lock(&p->d_lock);
again: again:
next = p->d_u.d_child.next; next = p->d_child.next;
start: start:
if (next == &root->d_subdirs) { if (next == &root->d_subdirs) {
spin_unlock(&p->d_lock); spin_unlock(&p->d_lock);
@ -118,7 +118,7 @@ start:
return NULL; return NULL;
} }
q = list_entry(next, struct dentry, d_u.d_child); q = list_entry(next, struct dentry, d_child);
spin_lock_nested(&q->d_lock, DENTRY_D_LOCK_NESTED); spin_lock_nested(&q->d_lock, DENTRY_D_LOCK_NESTED);
/* Negative dentry - try next */ /* Negative dentry - try next */
@ -175,13 +175,13 @@ again:
goto relock; goto relock;
} }
spin_unlock(&p->d_lock); spin_unlock(&p->d_lock);
next = p->d_u.d_child.next; next = p->d_child.next;
p = parent; p = parent;
if (next != &parent->d_subdirs) if (next != &parent->d_subdirs)
break; break;
} }
} }
ret = list_entry(next, struct dentry, d_u.d_child); ret = list_entry(next, struct dentry, d_child);
spin_lock_nested(&ret->d_lock, DENTRY_D_LOCK_NESTED); spin_lock_nested(&ret->d_lock, DENTRY_D_LOCK_NESTED);
/* Negative dentry - try next */ /* Negative dentry - try next */
@ -466,7 +466,7 @@ found:
spin_lock(&sbi->lookup_lock); spin_lock(&sbi->lookup_lock);
spin_lock(&expired->d_parent->d_lock); spin_lock(&expired->d_parent->d_lock);
spin_lock_nested(&expired->d_lock, DENTRY_D_LOCK_NESTED); spin_lock_nested(&expired->d_lock, DENTRY_D_LOCK_NESTED);
list_move(&expired->d_parent->d_subdirs, &expired->d_u.d_child); list_move(&expired->d_parent->d_subdirs, &expired->d_child);
spin_unlock(&expired->d_lock); spin_unlock(&expired->d_lock);
spin_unlock(&expired->d_parent->d_lock); spin_unlock(&expired->d_parent->d_lock);
spin_unlock(&sbi->lookup_lock); spin_unlock(&sbi->lookup_lock);

2
fs/autofs4/root.c
View File

@ -649,7 +649,7 @@ static void autofs_clear_leaf_automount_flags(struct dentry *dentry)
/* only consider parents below dentrys in the root */ /* only consider parents below dentrys in the root */
if (IS_ROOT(parent->d_parent)) if (IS_ROOT(parent->d_parent))
return; return;
d_child = &dentry->d_u.d_child; d_child = &dentry->d_child;
/* Set parent managed if it's becoming empty */ /* Set parent managed if it's becoming empty */
if (d_child->next == &parent->d_subdirs && if (d_child->next == &parent->d_subdirs &&
d_child->prev == &parent->d_subdirs) d_child->prev == &parent->d_subdirs)

8
fs/ceph/dir.c
View File

@ -104,7 +104,7 @@ static unsigned fpos_off(loff_t p)
/* /*
* When possible, we try to satisfy a readdir by peeking at the * When possible, we try to satisfy a readdir by peeking at the
* dcache. We make this work by carefully ordering dentries on * dcache. We make this work by carefully ordering dentries on
* d_u.d_child when we initially get results back from the MDS, and * d_child when we initially get results back from the MDS, and
* falling back to a "normal" sync readdir if any dentries in the dir * falling back to a "normal" sync readdir if any dentries in the dir
* are dropped. * are dropped.
* *
@ -140,11 +140,11 @@ static int __dcache_readdir(struct file *filp,
p = parent->d_subdirs.prev; p = parent->d_subdirs.prev;
dout(" initial p %p/%p\n", p->prev, p->next); dout(" initial p %p/%p\n", p->prev, p->next);
} else { } else {
p = last->d_u.d_child.prev; p = last->d_child.prev;
} }
more: more:
dentry = list_entry(p, struct dentry, d_u.d_child); dentry = list_entry(p, struct dentry, d_child);
di = ceph_dentry(dentry); di = ceph_dentry(dentry);
while (1) { while (1) {
dout(" p %p/%p %s d_subdirs %p/%p\n", p->prev, p->next, dout(" p %p/%p %s d_subdirs %p/%p\n", p->prev, p->next,
@ -166,7 +166,7 @@ more:
!dentry->d_inode ? " null" : ""); !dentry->d_inode ? " null" : "");
spin_unlock(&dentry->d_lock); spin_unlock(&dentry->d_lock);
p = p->prev; p = p->prev;
dentry = list_entry(p, struct dentry, d_u.d_child); dentry = list_entry(p, struct dentry, d_child);
di = ceph_dentry(dentry); di = ceph_dentry(dentry);
} }

6
fs/ceph/inode.c
View File

@ -869,9 +869,9 @@ static void ceph_set_dentry_offset(struct dentry *dn)
spin_lock(&dir->d_lock); spin_lock(&dir->d_lock);
spin_lock_nested(&dn->d_lock, DENTRY_D_LOCK_NESTED); spin_lock_nested(&dn->d_lock, DENTRY_D_LOCK_NESTED);
list_move(&dn->d_u.d_child, &dir->d_subdirs); list_move(&dn->d_child, &dir->d_subdirs);
dout("set_dentry_offset %p %lld (%p %p)\n", dn, di->offset, dout("set_dentry_offset %p %lld (%p %p)\n", dn, di->offset,
dn->d_u.d_child.prev, dn->d_u.d_child.next); dn->d_child.prev, dn->d_child.next);
spin_unlock(&dn->d_lock); spin_unlock(&dn->d_lock);
spin_unlock(&dir->d_lock); spin_unlock(&dir->d_lock);
} }
@ -1257,7 +1257,7 @@ retry_lookup:
/* reorder parent's d_subdirs */ /* reorder parent's d_subdirs */
spin_lock(&parent->d_lock); spin_lock(&parent->d_lock);
spin_lock_nested(&dn->d_lock, DENTRY_D_LOCK_NESTED); spin_lock_nested(&dn->d_lock, DENTRY_D_LOCK_NESTED);
list_move(&dn->d_u.d_child, &parent->d_subdirs); list_move(&dn->d_child, &parent->d_subdirs);
spin_unlock(&dn->d_lock); spin_unlock(&dn->d_lock);
spin_unlock(&parent->d_lock); spin_unlock(&parent->d_lock);
} }

2
fs/cifs/inode.c
View File

@ -827,7 +827,7 @@ inode_has_hashed_dentries(struct inode *inode)
struct dentry *dentry; struct dentry *dentry;
spin_lock(&inode->i_lock); spin_lock(&inode->i_lock);
list_for_each_entry(dentry, &inode->i_dentry, d_alias) { list_for_each_entry(dentry, &inode->i_dentry, d_u.d_alias) {
if (!d_unhashed(dentry) || IS_ROOT(dentry)) { if (!d_unhashed(dentry) || IS_ROOT(dentry)) {
spin_unlock(&inode->i_lock); spin_unlock(&inode->i_lock);
return true; return true;

2
fs/coda/cache.c
View File

@ -95,7 +95,7 @@ static void coda_flag_children(struct dentry *parent, int flag)
spin_lock(&parent->d_lock); spin_lock(&parent->d_lock);
list_for_each(child, &parent->d_subdirs) list_for_each(child, &parent->d_subdirs)
{ {
de = list_entry(child, struct dentry, d_u.d_child); de = list_entry(child, struct dentry, d_child);
/* don't know what to do with negative dentries */ /* don't know what to do with negative dentries */
if ( ! de->d_inode ) if ( ! de->d_inode )
continue; continue;

80
fs/dcache.c
View File

@ -43,7 +43,7 @@
/* /*
* Usage: * Usage:
* dcache->d_inode->i_lock protects: * dcache->d_inode->i_lock protects:
* - i_dentry, d_alias, d_inode of aliases * - i_dentry, d_u.d_alias, d_inode of aliases
* dcache_hash_bucket lock protects: * dcache_hash_bucket lock protects:
* - the dcache hash table * - the dcache hash table
* s_anon bl list spinlock protects: * s_anon bl list spinlock protects:
@ -58,7 +58,7 @@
* - d_unhashed() * - d_unhashed()
* - d_parent and d_subdirs * - d_parent and d_subdirs
* - childrens' d_child and d_parent * - childrens' d_child and d_parent
* - d_alias, d_inode * - d_u.d_alias, d_inode
* *
* Ordering: * Ordering:
* dentry->d_inode->i_lock * dentry->d_inode->i_lock
@ -202,7 +202,6 @@ static void __d_free(struct rcu_head *head)
{ {
struct dentry *dentry = container_of(head, struct dentry, d_u.d_rcu); struct dentry *dentry = container_of(head, struct dentry, d_u.d_rcu);
WARN_ON(!list_empty(&dentry->d_alias));
if (dname_external(dentry)) if (dname_external(dentry))
kfree(dentry->d_name.name); kfree(dentry->d_name.name);
kmem_cache_free(dentry_cache, dentry); kmem_cache_free(dentry_cache, dentry);
@ -213,6 +212,7 @@ static void __d_free(struct rcu_head *head)
*/ */
static void d_free(struct dentry *dentry) static void d_free(struct dentry *dentry)
{ {
WARN_ON(!list_empty(&dentry->d_u.d_alias));
BUG_ON(dentry->d_count); BUG_ON(dentry->d_count);
this_cpu_dec(nr_dentry); this_cpu_dec(nr_dentry);
if (dentry->d_op && dentry->d_op->d_release) if (dentry->d_op && dentry->d_op->d_release)
@ -251,7 +251,7 @@ static void dentry_iput(struct dentry * dentry)
struct inode *inode = dentry->d_inode; struct inode *inode = dentry->d_inode;
if (inode) { if (inode) {
dentry->d_inode = NULL; dentry->d_inode = NULL;
list_del_init(&dentry->d_alias); list_del_init(&dentry->d_u.d_alias);
spin_unlock(&dentry->d_lock); spin_unlock(&dentry->d_lock);
spin_unlock(&inode->i_lock); spin_unlock(&inode->i_lock);
if (!inode->i_nlink) if (!inode->i_nlink)
@ -275,7 +275,7 @@ static void dentry_unlink_inode(struct dentry * dentry)
{ {
struct inode *inode = dentry->d_inode; struct inode *inode = dentry->d_inode;
dentry->d_inode = NULL; dentry->d_inode = NULL;
list_del_init(&dentry->d_alias); list_del_init(&dentry->d_u.d_alias);
dentry_rcuwalk_barrier(dentry); dentry_rcuwalk_barrier(dentry);
spin_unlock(&dentry->d_lock); spin_unlock(&dentry->d_lock);
spin_unlock(&inode->i_lock); spin_unlock(&inode->i_lock);
@ -368,7 +368,7 @@ static struct dentry *d_kill(struct dentry *dentry, struct dentry *parent)
__releases(parent->d_lock) __releases(parent->d_lock)
__releases(dentry->d_inode->i_lock) __releases(dentry->d_inode->i_lock)
{ {
list_del(&dentry->d_u.d_child); list_del(&dentry->d_child);
/* /*
* Inform try_to_ascend() that we are no longer attached to the * Inform try_to_ascend() that we are no longer attached to the
* dentry tree * dentry tree
@ -686,7 +686,7 @@ static struct dentry *__d_find_alias(struct inode *inode, int want_discon)
again: again:
discon_alias = NULL; discon_alias = NULL;
list_for_each_entry(alias, &inode->i_dentry, d_alias) { list_for_each_entry(alias, &inode->i_dentry, d_u.d_alias) {
spin_lock(&alias->d_lock); spin_lock(&alias->d_lock);
if (S_ISDIR(inode->i_mode) || !d_unhashed(alias)) { if (S_ISDIR(inode->i_mode) || !d_unhashed(alias)) {
if (IS_ROOT(alias) && if (IS_ROOT(alias) &&
@ -739,7 +739,7 @@ void d_prune_aliases(struct inode *inode)
struct dentry *dentry; struct dentry *dentry;
restart: restart:
spin_lock(&inode->i_lock); spin_lock(&inode->i_lock);
list_for_each_entry(dentry, &inode->i_dentry, d_alias) { list_for_each_entry(dentry, &inode->i_dentry, d_u.d_alias) {
spin_lock(&dentry->d_lock); spin_lock(&dentry->d_lock);
if (!dentry->d_count) { if (!dentry->d_count) {
__dget_dlock(dentry); __dget_dlock(dentry);
@ -919,7 +919,7 @@ static void shrink_dcache_for_umount_subtree(struct dentry *dentry)
/* descend to the first leaf in the current subtree */ /* descend to the first leaf in the current subtree */
while (!list_empty(&dentry->d_subdirs)) while (!list_empty(&dentry->d_subdirs))
dentry = list_entry(dentry->d_subdirs.next, dentry = list_entry(dentry->d_subdirs.next,
struct dentry, d_u.d_child); struct dentry, d_child);
/* consume the dentries from this leaf up through its parents /* consume the dentries from this leaf up through its parents
* until we find one with children or run out altogether */ * until we find one with children or run out altogether */
@ -951,17 +951,17 @@ static void shrink_dcache_for_umount_subtree(struct dentry *dentry)
if (IS_ROOT(dentry)) { if (IS_ROOT(dentry)) {
parent = NULL; parent = NULL;
list_del(&dentry->d_u.d_child); list_del(&dentry->d_child);
} else { } else {
parent = dentry->d_parent; parent = dentry->d_parent;
parent->d_count--; parent->d_count--;
list_del(&dentry->d_u.d_child); list_del(&dentry->d_child);
} }
inode = dentry->d_inode; inode = dentry->d_inode;
if (inode) { if (inode) {
dentry->d_inode = NULL; dentry->d_inode = NULL;
list_del_init(&dentry->d_alias); list_del_init(&dentry->d_u.d_alias);
if (dentry->d_op && dentry->d_op->d_iput) if (dentry->d_op && dentry->d_op->d_iput)
dentry->d_op->d_iput(dentry, inode); dentry->d_op->d_iput(dentry, inode);
else else
@ -979,7 +979,7 @@ static void shrink_dcache_for_umount_subtree(struct dentry *dentry)
} while (list_empty(&dentry->d_subdirs)); } while (list_empty(&dentry->d_subdirs));
dentry = list_entry(dentry->d_subdirs.next, dentry = list_entry(dentry->d_subdirs.next,
struct dentry, d_u.d_child); struct dentry, d_child);
} }
} }
@ -1072,7 +1072,7 @@ repeat:
resume: resume:
while (next != &this_parent->d_subdirs) { while (next != &this_parent->d_subdirs) {
struct list_head *tmp = next; struct list_head *tmp = next;
struct dentry *dentry = list_entry(tmp, struct dentry, d_u.d_child); struct dentry *dentry = list_entry(tmp, struct dentry, d_child);
next = tmp->next; next = tmp->next;
spin_lock_nested(&dentry->d_lock, DENTRY_D_LOCK_NESTED); spin_lock_nested(&dentry->d_lock, DENTRY_D_LOCK_NESTED);
@ -1099,7 +1099,7 @@ resume:
this_parent = try_to_ascend(this_parent, locked, seq); this_parent = try_to_ascend(this_parent, locked, seq);
if (!this_parent) if (!this_parent)
goto rename_retry; goto rename_retry;
next = child->d_u.d_child.next; next = child->d_child.next;
goto resume; goto resume;
} }
spin_unlock(&this_parent->d_lock); spin_unlock(&this_parent->d_lock);
@ -1155,7 +1155,7 @@ repeat:
resume: resume:
while (next != &this_parent->d_subdirs) { while (next != &this_parent->d_subdirs) {
struct list_head *tmp = next; struct list_head *tmp = next;
struct dentry *dentry = list_entry(tmp, struct dentry, d_u.d_child); struct dentry *dentry = list_entry(tmp, struct dentry, d_child);
next = tmp->next; next = tmp->next;
spin_lock_nested(&dentry->d_lock, DENTRY_D_LOCK_NESTED); spin_lock_nested(&dentry->d_lock, DENTRY_D_LOCK_NESTED);
@ -1206,7 +1206,7 @@ resume:
this_parent = try_to_ascend(this_parent, locked, seq); this_parent = try_to_ascend(this_parent, locked, seq);
if (!this_parent) if (!this_parent)
goto rename_retry; goto rename_retry;
next = child->d_u.d_child.next; next = child->d_child.next;
goto resume; goto resume;
} }
out: out:
@ -1290,8 +1290,8 @@ struct dentry *__d_alloc(struct super_block *sb, const struct qstr *name)
INIT_HLIST_BL_NODE(&dentry->d_hash); INIT_HLIST_BL_NODE(&dentry->d_hash);
INIT_LIST_HEAD(&dentry->d_lru); INIT_LIST_HEAD(&dentry->d_lru);
INIT_LIST_HEAD(&dentry->d_subdirs); INIT_LIST_HEAD(&dentry->d_subdirs);
INIT_LIST_HEAD(&dentry->d_alias); INIT_LIST_HEAD(&dentry->d_u.d_alias);
INIT_LIST_HEAD(&dentry->d_u.d_child); INIT_LIST_HEAD(&dentry->d_child);
d_set_d_op(dentry, dentry->d_sb->s_d_op); d_set_d_op(dentry, dentry->d_sb->s_d_op);
this_cpu_inc(nr_dentry); this_cpu_inc(nr_dentry);
@ -1321,7 +1321,7 @@ struct dentry *d_alloc(struct dentry * parent, const struct qstr *name)
*/ */
__dget_dlock(parent); __dget_dlock(parent);
dentry->d_parent = parent; dentry->d_parent = parent;
list_add(&dentry->d_u.d_child, &parent->d_subdirs); list_add(&dentry->d_child, &parent->d_subdirs);
spin_unlock(&parent->d_lock); spin_unlock(&parent->d_lock);
return dentry; return dentry;
@ -1378,7 +1378,7 @@ static void __d_instantiate(struct dentry *dentry, struct inode *inode)
if (inode) { if (inode) {
if (unlikely(IS_AUTOMOUNT(inode))) if (unlikely(IS_AUTOMOUNT(inode)))
dentry->d_flags |= DCACHE_NEED_AUTOMOUNT; dentry->d_flags |= DCACHE_NEED_AUTOMOUNT;
list_add(&dentry->d_alias, &inode->i_dentry); list_add(&dentry->d_u.d_alias, &inode->i_dentry);
} }
dentry->d_inode = inode; dentry->d_inode = inode;
dentry_rcuwalk_barrier(dentry); dentry_rcuwalk_barrier(dentry);
@ -1403,7 +1403,7 @@ static void __d_instantiate(struct dentry *dentry, struct inode *inode)
void d_instantiate(struct dentry *entry, struct inode * inode) void d_instantiate(struct dentry *entry, struct inode * inode)
{ {
BUG_ON(!list_empty(&entry->d_alias)); BUG_ON(!list_empty(&entry->d_u.d_alias));
if (inode) if (inode)
spin_lock(&inode->i_lock); spin_lock(&inode->i_lock);
__d_instantiate(entry, inode); __d_instantiate(entry, inode);
@ -1442,7 +1442,7 @@ static struct dentry *__d_instantiate_unique(struct dentry *entry,
return NULL; return NULL;
} }
list_for_each_entry(alias, &inode->i_dentry, d_alias) { list_for_each_entry(alias, &inode->i_dentry, d_u.d_alias) {
struct qstr *qstr = &alias->d_name; struct qstr *qstr = &alias->d_name;
/* /*
@ -1468,7 +1468,7 @@ struct dentry *d_instantiate_unique(struct dentry *entry, struct inode *inode)
{ {
struct dentry *result; struct dentry *result;
BUG_ON(!list_empty(&entry->d_alias)); BUG_ON(!list_empty(&entry->d_u.d_alias));
if (inode) if (inode)
spin_lock(&inode->i_lock); spin_lock(&inode->i_lock);
@ -1511,7 +1511,7 @@ static struct dentry * __d_find_any_alias(struct inode *inode)
if (list_empty(&inode->i_dentry)) if (list_empty(&inode->i_dentry))
return NULL; return NULL;
alias = list_first_entry(&inode->i_dentry, struct dentry, d_alias); alias = list_first_entry(&inode->i_dentry, struct dentry, d_u.d_alias);
__dget(alias); __dget(alias);
return alias; return alias;
} }
@ -1585,7 +1585,7 @@ struct dentry *d_obtain_alias(struct inode *inode)
spin_lock(&tmp->d_lock); spin_lock(&tmp->d_lock);
tmp->d_inode = inode; tmp->d_inode = inode;
tmp->d_flags |= DCACHE_DISCONNECTED; tmp->d_flags |= DCACHE_DISCONNECTED;
list_add(&tmp->d_alias, &inode->i_dentry); list_add(&tmp->d_u.d_alias, &inode->i_dentry);
hlist_bl_lock(&tmp->d_sb->s_anon); hlist_bl_lock(&tmp->d_sb->s_anon);
hlist_bl_add_head(&tmp->d_hash, &tmp->d_sb->s_anon); hlist_bl_add_head(&tmp->d_hash, &tmp->d_sb->s_anon);
hlist_bl_unlock(&tmp->d_sb->s_anon); hlist_bl_unlock(&tmp->d_sb->s_anon);
@ -1994,7 +1994,7 @@ int d_validate(struct dentry *dentry, struct dentry *dparent)
struct dentry *child; struct dentry *child;
spin_lock(&dparent->d_lock); spin_lock(&dparent->d_lock);
list_for_each_entry(child, &dparent->d_subdirs, d_u.d_child) { list_for_each_entry(child, &dparent->d_subdirs, d_child) {
if (dentry == child) { if (dentry == child) {
spin_lock_nested(&dentry->d_lock, DENTRY_D_LOCK_NESTED); spin_lock_nested(&dentry->d_lock, DENTRY_D_LOCK_NESTED);
__dget_dlock(dentry); __dget_dlock(dentry);
@ -2241,8 +2241,8 @@ static void __d_move(struct dentry * dentry, struct dentry * target)
/* Unhash the target: dput() will then get rid of it */ /* Unhash the target: dput() will then get rid of it */
__d_drop(target); __d_drop(target);
list_del(&dentry->d_u.d_child); list_del(&dentry->d_child);
list_del(&target->d_u.d_child); list_del(&target->d_child);
/* Switch the names.. */ /* Switch the names.. */
switch_names(dentry, target); switch_names(dentry, target);
@ -2252,15 +2252,15 @@ static void __d_move(struct dentry * dentry, struct dentry * target)
if (IS_ROOT(dentry)) { if (IS_ROOT(dentry)) {
dentry->d_parent = target->d_parent; dentry->d_parent = target->d_parent;
target->d_parent = target; target->d_parent = target;
INIT_LIST_HEAD(&target->d_u.d_child); INIT_LIST_HEAD(&target->d_child);
} else { } else {
swap(dentry->d_parent, target->d_parent); swap(dentry->d_parent, target->d_parent);
/* And add them back to the (new) parent lists */ /* And add them back to the (new) parent lists */
list_add(&target->d_u.d_child, &target->d_parent->d_subdirs); list_add(&target->d_child, &target->d_parent->d_subdirs);
} }
list_add(&dentry->d_u.d_child, &dentry->d_parent->d_subdirs); list_add(&dentry->d_child, &dentry->d_parent->d_subdirs);
write_seqcount_end(&target->d_seq); write_seqcount_end(&target->d_seq);
write_seqcount_end(&dentry->d_seq); write_seqcount_end(&dentry->d_seq);
@ -2367,18 +2367,18 @@ static void __d_materialise_dentry(struct dentry *dentry, struct dentry *anon)
swap(dentry->d_name.hash, anon->d_name.hash); swap(dentry->d_name.hash, anon->d_name.hash);
dentry->d_parent = (aparent == anon) ? dentry : aparent; dentry->d_parent = (aparent == anon) ? dentry : aparent;
list_del(&dentry->d_u.d_child); list_del(&dentry->d_child);
if (!IS_ROOT(dentry)) if (!IS_ROOT(dentry))
list_add(&dentry->d_u.d_child, &dentry->d_parent->d_subdirs); list_add(&dentry->d_child, &dentry->d_parent->d_subdirs);
else else
INIT_LIST_HEAD(&dentry->d_u.d_child); INIT_LIST_HEAD(&dentry->d_child);
anon->d_parent = (dparent == dentry) ? anon : dparent; anon->d_parent = (dparent == dentry) ? anon : dparent;
list_del(&anon->d_u.d_child); list_del(&anon->d_child);
if (!IS_ROOT(anon)) if (!IS_ROOT(anon))
list_add(&anon->d_u.d_child, &anon->d_parent->d_subdirs); list_add(&anon->d_child, &anon->d_parent->d_subdirs);
else else
INIT_LIST_HEAD(&anon->d_u.d_child); INIT_LIST_HEAD(&anon->d_child);
write_seqcount_end(&dentry->d_seq); write_seqcount_end(&dentry->d_seq);
write_seqcount_end(&anon->d_seq); write_seqcount_end(&anon->d_seq);
@ -2926,7 +2926,7 @@ repeat:
resume: resume:
while (next != &this_parent->d_subdirs) { while (next != &this_parent->d_subdirs) {
struct list_head *tmp = next; struct list_head *tmp = next;
struct dentry *dentry = list_entry(tmp, struct dentry, d_u.d_child); struct dentry *dentry = list_entry(tmp, struct dentry, d_child);
next = tmp->next; next = tmp->next;
spin_lock_nested(&dentry->d_lock, DENTRY_D_LOCK_NESTED); spin_lock_nested(&dentry->d_lock, DENTRY_D_LOCK_NESTED);
@ -2956,7 +2956,7 @@ resume:
this_parent = try_to_ascend(this_parent, locked, seq); this_parent = try_to_ascend(this_parent, locked, seq);
if (!this_parent) if (!this_parent)
goto rename_retry; goto rename_retry;
next = child->d_u.d_child.next; next = child->d_child.next;
goto resume; goto resume;
} }
spin_unlock(&this_parent->d_lock); spin_unlock(&this_parent->d_lock);

10
fs/debugfs/inode.c
View File

@ -553,7 +553,7 @@ void debugfs_remove_recursive(struct dentry *dentry)
mutex_lock(&parent->d_inode->i_mutex); mutex_lock(&parent->d_inode->i_mutex);
} }
child = list_entry(parent->d_subdirs.next, struct dentry, child = list_entry(parent->d_subdirs.next, struct dentry,
d_u.d_child); d_child);
next_sibling: next_sibling:
/* /*
@ -567,14 +567,14 @@ void debugfs_remove_recursive(struct dentry *dentry)
continue; continue;
} }
__debugfs_remove(child, parent); __debugfs_remove(child, parent);
if (parent->d_subdirs.next == &child->d_u.d_child) { if (parent->d_subdirs.next == &child->d_child) {
/* /*
* Try the next sibling. * Try the next sibling.
*/ */
if (child->d_u.d_child.next != &parent->d_subdirs) { if (child->d_child.next != &parent->d_subdirs) {
child = list_entry(child->d_u.d_child.next, child = list_entry(child->d_child.next,
struct dentry, struct dentry,
d_u.d_child); d_child);
goto next_sibling; goto next_sibling;
} }

2
fs/exportfs/expfs.c
View File

@ -50,7 +50,7 @@ find_acceptable_alias(struct dentry *result,
inode = result->d_inode; inode = result->d_inode;
spin_lock(&inode->i_lock); spin_lock(&inode->i_lock);
list_for_each_entry(dentry, &inode->i_dentry, d_alias) { list_for_each_entry(dentry, &inode->i_dentry, d_u.d_alias) {
dget(dentry); dget(dentry);
spin_unlock(&inode->i_lock); spin_unlock(&inode->i_lock);
if (toput) if (toput)

2
fs/ext4/fsync.c
View File

@ -139,7 +139,7 @@ static int ext4_sync_parent(struct inode *inode)
spin_lock(&inode->i_lock); spin_lock(&inode->i_lock);
if (!list_empty(&inode->i_dentry)) { if (!list_empty(&inode->i_dentry)) {
dentry = list_first_entry(&inode->i_dentry, dentry = list_first_entry(&inode->i_dentry,
struct dentry, d_alias); struct dentry, d_u.d_alias);
dget(dentry); dget(dentry);
} }
spin_unlock(&inode->i_lock); spin_unlock(&inode->i_lock);

12
fs/libfs.c
View File

@ -104,18 +104,18 @@ loff_t dcache_dir_lseek(struct file *file, loff_t offset, int origin)
spin_lock(&dentry->d_lock); spin_lock(&dentry->d_lock);
/* d_lock not required for cursor */ /* d_lock not required for cursor */
list_del(&cursor->d_u.d_child); list_del(&cursor->d_child);
p = dentry->d_subdirs.next; p = dentry->d_subdirs.next;
while (n && p != &dentry->d_subdirs) { while (n && p != &dentry->d_subdirs) {
struct dentry *next; struct dentry *next;
next = list_entry(p, struct dentry, d_u.d_child); next = list_entry(p, struct dentry, d_child);
spin_lock_nested(&next->d_lock, DENTRY_D_LOCK_NESTED); spin_lock_nested(&next->d_lock, DENTRY_D_LOCK_NESTED);
if (simple_positive(next)) if (simple_positive(next))
n--; n--;
spin_unlock(&next->d_lock); spin_unlock(&next->d_lock);
p = p->next; p = p->next;
} }
list_add_tail(&cursor->d_u.d_child, p); list_add_tail(&cursor->d_child, p);
spin_unlock(&dentry->d_lock); spin_unlock(&dentry->d_lock);
} }
} }
@ -139,7 +139,7 @@ int dcache_readdir(struct file * filp, void * dirent, filldir_t filldir)
{ {
struct dentry *dentry = filp->f_path.dentry; struct dentry *dentry = filp->f_path.dentry;
struct dentry *cursor = filp->private_data; struct dentry *cursor = filp->private_data;
struct list_head *p, *q = &cursor->d_u.d_child; struct list_head *p, *q = &cursor->d_child;
ino_t ino; ino_t ino;
int i = filp->f_pos; int i = filp->f_pos;
@ -165,7 +165,7 @@ int dcache_readdir(struct file * filp, void * dirent, filldir_t filldir)
for (p=q->next; p != &dentry->d_subdirs; p=p->next) { for (p=q->next; p != &dentry->d_subdirs; p=p->next) {
struct dentry *next; struct dentry *next;
next = list_entry(p, struct dentry, d_u.d_child); next = list_entry(p, struct dentry, d_child);
spin_lock_nested(&next->d_lock, DENTRY_D_LOCK_NESTED); spin_lock_nested(&next->d_lock, DENTRY_D_LOCK_NESTED);
if (!simple_positive(next)) { if (!simple_positive(next)) {
spin_unlock(&next->d_lock); spin_unlock(&next->d_lock);
@ -289,7 +289,7 @@ int simple_empty(struct dentry *dentry)
int ret = 0; int ret = 0;
spin_lock(&dentry->d_lock); spin_lock(&dentry->d_lock);
list_for_each_entry(child, &dentry->d_subdirs, d_u.d_child) { list_for_each_entry(child, &dentry->d_subdirs, d_child) {
spin_lock_nested(&child->d_lock, DENTRY_D_LOCK_NESTED); spin_lock_nested(&child->d_lock, DENTRY_D_LOCK_NESTED);
if (simple_positive(child)) { if (simple_positive(child)) {
spin_unlock(&child->d_lock); spin_unlock(&child->d_lock);

2
fs/ncpfs/dir.c
View File

@ -391,7 +391,7 @@ ncp_dget_fpos(struct dentry *dentry, struct dentry *parent, unsigned long fpos)
spin_lock(&parent->d_lock); spin_lock(&parent->d_lock);
next = parent->d_subdirs.next; next = parent->d_subdirs.next;
while (next != &parent->d_subdirs) { while (next != &parent->d_subdirs) {
dent = list_entry(next, struct dentry, d_u.d_child); dent = list_entry(next, struct dentry, d_child);
if ((unsigned long)dent->d_fsdata == fpos) { if ((unsigned long)dent->d_fsdata == fpos) {
if (dent->d_inode) if (dent->d_inode)
dget(dent); dget(dent);

4
fs/ncpfs/ncplib_kernel.h
View File

@ -194,7 +194,7 @@ ncp_renew_dentries(struct dentry *parent)
spin_lock(&parent->d_lock); spin_lock(&parent->d_lock);
next = parent->d_subdirs.next; next = parent->d_subdirs.next;
while (next != &parent->d_subdirs) { while (next != &parent->d_subdirs) {
dentry = list_entry(next, struct dentry, d_u.d_child); dentry = list_entry(next, struct dentry, d_child);
if (dentry->d_fsdata == NULL) if (dentry->d_fsdata == NULL)
ncp_age_dentry(server, dentry); ncp_age_dentry(server, dentry);
@ -216,7 +216,7 @@ ncp_invalidate_dircache_entries(struct dentry *parent)
spin_lock(&parent->d_lock); spin_lock(&parent->d_lock);
next = parent->d_subdirs.next; next = parent->d_subdirs.next;
while (next != &parent->d_subdirs) { while (next != &parent->d_subdirs) {
dentry = list_entry(next, struct dentry, d_u.d_child); dentry = list_entry(next, struct dentry, d_child);
dentry->d_fsdata = NULL; dentry->d_fsdata = NULL;
ncp_age_dentry(server, dentry); ncp_age_dentry(server, dentry);
next = next->next; next = next->next;

2
fs/nfs/getroot.c
View File

@ -62,7 +62,7 @@ static int nfs_superblock_set_dummy_root(struct super_block *sb, struct inode *i
*/ */
spin_lock(&sb->s_root->d_inode->i_lock); spin_lock(&sb->s_root->d_inode->i_lock);
spin_lock(&sb->s_root->d_lock); spin_lock(&sb->s_root->d_lock);
list_del_init(&sb->s_root->d_alias); list_del_init(&sb->s_root->d_u.d_alias);
spin_unlock(&sb->s_root->d_lock); spin_unlock(&sb->s_root->d_lock);
spin_unlock(&sb->s_root->d_inode->i_lock); spin_unlock(&sb->s_root->d_inode->i_lock);
} }

4
fs/notify/fsnotify.c
View File

@ -63,14 +63,14 @@ void __fsnotify_update_child_dentry_flags(struct inode *inode)
spin_lock(&inode->i_lock); spin_lock(&inode->i_lock);
/* run all of the dentries associated with this inode. Since this is a /* run all of the dentries associated with this inode. Since this is a
* directory, there damn well better only be one item on this list */ * directory, there damn well better only be one item on this list */
list_for_each_entry(alias, &inode->i_dentry, d_alias) { list_for_each_entry(alias, &inode->i_dentry, d_u.d_alias) {
struct dentry *child; struct dentry *child;
/* run all of the children of the original inode and fix their /* run all of the children of the original inode and fix their
* d_flags to indicate parental interest (their parent is the * d_flags to indicate parental interest (their parent is the
* original inode) */ * original inode) */
spin_lock(&alias->d_lock); spin_lock(&alias->d_lock);
list_for_each_entry(child, &alias->d_subdirs, d_u.d_child) { list_for_each_entry(child, &alias->d_subdirs, d_child) {
if (!child->d_inode) if (!child->d_inode)
continue; continue;

2
fs/ocfs2/dcache.c
View File

@ -175,7 +175,7 @@ struct dentry *ocfs2_find_local_alias(struct inode *inode,
spin_lock(&inode->i_lock); spin_lock(&inode->i_lock);
list_for_each(p, &inode->i_dentry) { list_for_each(p, &inode->i_dentry) {
dentry = list_entry(p, struct dentry, d_alias); dentry = list_entry(p, struct dentry, d_u.d_alias);
spin_lock(&dentry->d_lock); spin_lock(&dentry->d_lock);
if (ocfs2_match_dentry(dentry, parent_blkno, skip_unhashed)) { if (ocfs2_match_dentry(dentry, parent_blkno, skip_unhashed)) {

8
include/linux/dcache.h
View File

@ -105,15 +105,15 @@ struct dentry {
void *d_fsdata; /* fs-specific data */ void *d_fsdata; /* fs-specific data */
struct list_head d_lru; /* LRU list */ struct list_head d_lru; /* LRU list */
struct list_head d_child; /* child of parent list */
struct list_head d_subdirs; /* our children */
/* /*
* d_child and d_rcu can share memory * d_alias and d_rcu can share memory
*/ */
union { union {
struct list_head d_child; /* child of parent list */ struct list_head d_alias; /* inode alias list */
struct rcu_head d_rcu; struct rcu_head d_rcu;
} d_u; } d_u;
struct list_head d_subdirs; /* our children */
struct list_head d_alias; /* inode alias list */
}; };
/* /*

4
kernel/cgroup.c
View File

@ -920,7 +920,7 @@ static void cgroup_clear_directory(struct dentry *dentry)
spin_lock(&dentry->d_lock); spin_lock(&dentry->d_lock);
node = dentry->d_subdirs.next; node = dentry->d_subdirs.next;
while (node != &dentry->d_subdirs) { while (node != &dentry->d_subdirs) {
struct dentry *d = list_entry(node, struct dentry, d_u.d_child); struct dentry *d = list_entry(node, struct dentry, d_child);
spin_lock_nested(&d->d_lock, DENTRY_D_LOCK_NESTED); spin_lock_nested(&d->d_lock, DENTRY_D_LOCK_NESTED);
list_del_init(node); list_del_init(node);
@ -954,7 +954,7 @@ static void cgroup_d_remove_dir(struct dentry *dentry)
parent = dentry->d_parent; parent = dentry->d_parent;
spin_lock(&parent->d_lock); spin_lock(&parent->d_lock);
spin_lock_nested(&dentry->d_lock, DENTRY_D_LOCK_NESTED); spin_lock_nested(&dentry->d_lock, DENTRY_D_LOCK_NESTED);
list_del_init(&dentry->d_u.d_child); list_del_init(&dentry->d_child);
spin_unlock(&dentry->d_lock); spin_unlock(&dentry->d_lock);
spin_unlock(&parent->d_lock); spin_unlock(&parent->d_lock);
remove_dir(dentry); remove_dir(dentry);

6
security/selinux/selinuxfs.c
View File

@ -1191,7 +1191,7 @@ static void sel_remove_entries(struct dentry *de)
spin_lock(&de->d_lock); spin_lock(&de->d_lock);
node = de->d_subdirs.next; node = de->d_subdirs.next;
while (node != &de->d_subdirs) { while (node != &de->d_subdirs) {
struct dentry *d = list_entry(node, struct dentry, d_u.d_child); struct dentry *d = list_entry(node, struct dentry, d_child);
spin_lock_nested(&d->d_lock, DENTRY_D_LOCK_NESTED); spin_lock_nested(&d->d_lock, DENTRY_D_LOCK_NESTED);
list_del_init(node); list_del_init(node);
@ -1693,12 +1693,12 @@ static void sel_remove_classes(void)
list_for_each(class_node, &class_dir->d_subdirs) { list_for_each(class_node, &class_dir->d_subdirs) {
struct dentry *class_subdir = list_entry(class_node, struct dentry *class_subdir = list_entry(class_node,
struct dentry, d_u.d_child); struct dentry, d_child);
struct list_head *class_subdir_node; struct list_head *class_subdir_node;
list_for_each(class_subdir_node, &class_subdir->d_subdirs) { list_for_each(class_subdir_node, &class_subdir->d_subdirs) {
struct dentry *d = list_entry(class_subdir_node, struct dentry *d = list_entry(class_subdir_node,
struct dentry, d_u.d_child); struct dentry, d_child);
if (d->d_inode) if (d->d_inode)
if (d->d_inode->i_mode & S_IFDIR) if (d->d_inode->i_mode & S_IFDIR)