Gitweb:     
http://git.kernel.org/git/?p=linux/kernel/git/torvalds/linux-2.6.git;a=commit;h=e0712bbfd9cb617fc3a822781c2466fb6b7ede50
Commit:     e0712bbfd9cb617fc3a822781c2466fb6b7ede50
Parent:     932ea2e374dd1ca26676297a5eccd1cdab86f7cd
Author:     Tejun Heo <[EMAIL PROTECTED]>
AuthorDate: Mon Aug 20 21:36:30 2007 +0900
Committer:  Greg Kroah-Hartman <[EMAIL PROTECTED]>
CommitDate: Fri Oct 12 14:51:08 2007 -0700

    sysfs: simply sysfs_get_dentry
    
    Now that we know the sysfs tree structure cannot change under us and
    sysfs shadow support is dropped, sysfs_get_dentry() can be simplified
    greatly.  It can just look up from the root and there's no need to
    retry on failure.
    
    Signed-off-by: Tejun Heo <[EMAIL PROTECTED]>
    Cc: Eric W. Biederman <[EMAIL PROTECTED]>
    Cc: Cornelia Huck <[EMAIL PROTECTED]>
    Signed-off-by: Greg Kroah-Hartman <[EMAIL PROTECTED]>
---
 fs/sysfs/dir.c |   91 ++++++++++----------------------------------------------
 1 files changed, 16 insertions(+), 75 deletions(-)

diff --git a/fs/sysfs/dir.c b/fs/sysfs/dir.c
index 9fe83d2..1c3dc5d 100644
--- a/fs/sysfs/dir.c
+++ b/fs/sysfs/dir.c
@@ -78,9 +78,8 @@ static void sysfs_unlink_sibling(struct sysfs_dirent *sd)
  *     @sd: sysfs_dirent of interest
  *
  *     Get dentry for @sd.  Dentry is looked up if currently not
- *     present.  This function climbs sysfs_dirent tree till it
- *     reaches a sysfs_dirent with valid dentry attached and descends
- *     down from there looking up dentry for each step.
+ *     present.  This function descends from the root looking up
+ *     dentry for each step.
  *
  *     LOCKING:
  *     mutex_lock(sysfs_rename_mutex)
@@ -90,86 +89,28 @@ static void sysfs_unlink_sibling(struct sysfs_dirent *sd)
  */
 struct dentry *sysfs_get_dentry(struct sysfs_dirent *sd)
 {
-       struct sysfs_dirent *cur;
-       struct dentry *parent_dentry, *dentry;
-       int i, depth;
+       struct dentry *dentry = dget(sysfs_sb->s_root);
 
-       /* Find the first parent which has valid s_dentry and get the
-        * dentry.
-        */
-       mutex_lock(&sysfs_mutex);
- restart0:
-       spin_lock(&sysfs_assoc_lock);
- restart1:
-       spin_lock(&dcache_lock);
-
-       dentry = NULL;
-       depth = 0;
-       cur = sd;
-       while (!cur->s_dentry || !cur->s_dentry->d_inode) {
-               if (cur->s_flags & SYSFS_FLAG_REMOVED) {
-                       dentry = ERR_PTR(-ENOENT);
-                       depth = 0;
-                       break;
-               }
-               cur = cur->s_parent;
-               depth++;
-       }
-       if (!IS_ERR(dentry))
-               dentry = dget_locked(cur->s_dentry);
+       while (dentry->d_fsdata != sd) {
+               struct sysfs_dirent *cur;
+               struct dentry *parent;
 
-       spin_unlock(&dcache_lock);
-       spin_unlock(&sysfs_assoc_lock);
-
-       /* from the found dentry, look up depth times */
-       while (depth--) {
-               /* find and get depth'th ancestor */
-               for (cur = sd, i = 0; cur && i < depth; i++)
+               /* find the first ancestor which hasn't been looked up */
+               cur = sd;
+               while (cur->s_parent != dentry->d_fsdata)
                        cur = cur->s_parent;
 
-               /* This can happen if tree structure was modified due
-                * to move/rename.  Restart.
-                */
-               if (i != depth) {
-                       dput(dentry);
-                       goto restart0;
-               }
-
-               sysfs_get(cur);
-
-               mutex_unlock(&sysfs_mutex);
-
                /* look it up */
-               parent_dentry = dentry;
-               mutex_lock(&parent_dentry->d_inode->i_mutex);
-               dentry = lookup_one_len_kern(cur->s_name, parent_dentry,
+               parent = dentry;
+               mutex_lock(&parent->d_inode->i_mutex);
+               dentry = lookup_one_len_kern(cur->s_name, parent,
                                             strlen(cur->s_name));
-               mutex_unlock(&parent_dentry->d_inode->i_mutex);
-               dput(parent_dentry);
-
-               if (IS_ERR(dentry)) {
-                       sysfs_put(cur);
-                       return dentry;
-               }
+               mutex_unlock(&parent->d_inode->i_mutex);
+               dput(parent);
 
-               mutex_lock(&sysfs_mutex);
-               spin_lock(&sysfs_assoc_lock);
-
-               /* This, again, can happen if tree structure has
-                * changed and we looked up the wrong thing.  Restart.
-                */
-               if (cur->s_dentry != dentry) {
-                       dput(dentry);
-                       sysfs_put(cur);
-                       goto restart1;
-               }
-
-               spin_unlock(&sysfs_assoc_lock);
-
-               sysfs_put(cur);
+               if (IS_ERR(dentry))
+                       break;
        }
-
-       mutex_unlock(&sysfs_mutex);
        return dentry;
 }
 
-
To unsubscribe from this list: send the line "unsubscribe git-commits-head" in
the body of a message to [EMAIL PROTECTED]
More majordomo info at  http://vger.kernel.org/majordomo-info.html

Reply via email to