dentry_stat.nr_dentry--;        /* For d_free, below */
        /*drops the locks, at that point nobody can reach this dentry */
        dentry_iput(dentry);
-       parent = dentry->d_parent;
+       if (IS_ROOT(dentry))
+               parent = NULL;
+       else
+               parent = dentry->d_parent;
        d_free(dentry);
-       return dentry == parent ? NULL : parent;
+       return parent;
 }
 
 /* 
                                BUG();
                        }
 
-                       parent = dentry->d_parent;
-                       if (parent == dentry)
+                       if (IS_ROOT(dentry))
                                parent = NULL;
-                       else
+                       else {
+                               parent = dentry->d_parent;
                                atomic_dec(&parent->d_count);
+                       }
 
                        list_del(&dentry->d_u.d_child);
                        detached++;
 {
        struct dentry *p;
 
-       for (p = p2; p->d_parent != p; p = p->d_parent) {
+       for (p = p2; !IS_ROOT(p); p = p->d_parent) {
                if (p->d_parent == p1)
                        return 1;
        }
                seq = read_seqbegin(&rename_lock);
                for (;;) {
                        if (new_dentry != old_dentry) {
-                               struct dentry * parent = new_dentry->d_parent;
-                               if (parent == new_dentry)
+                               if (IS_ROOT(new_dentry))
                                        break;
-                               new_dentry = parent;
+                               new_dentry = new_dentry->d_parent;
                                continue;
                        }
                        result = 1;
 
 
        mutex_lock(&p1->d_inode->i_sb->s_vfs_rename_mutex);
 
-       for (p = p1; p->d_parent != p; p = p->d_parent) {
+       for (p = p1; !IS_ROOT(p); p = p->d_parent) {
                if (p->d_parent == p2) {
                        mutex_lock_nested(&p2->d_inode->i_mutex, I_MUTEX_PARENT);
                        mutex_lock_nested(&p1->d_inode->i_mutex, I_MUTEX_CHILD);
                }
        }
 
-       for (p = p2; p->d_parent != p; p = p->d_parent) {
+       for (p = p2; !IS_ROOT(p); p = p->d_parent) {
                if (p->d_parent == p1) {
                        mutex_lock_nested(&p1->d_inode->i_mutex, I_MUTEX_PARENT);
                        mutex_lock_nested(&p2->d_inode->i_mutex, I_MUTEX_CHILD);