VFS: Put a small type field into struct dentry::d_flags
authorDavid Howells <dhowells@redhat.com>
Thu, 12 Sep 2013 18:22:53 +0000 (19:22 +0100)
committerAl Viro <viro@zeniv.linux.org.uk>
Sat, 9 Nov 2013 05:16:30 +0000 (00:16 -0500)
Put a type field into struct dentry::d_flags to indicate if the dentry is one
of the following types that relate particularly to pathwalk:

Miss (negative dentry)
Directory
"Automount" directory (defective - no i_op->lookup())
Symlink
Other (regular, socket, fifo, device)

The type field is set to one of the first five types on a dentry by calls to
__d_instantiate() and d_obtain_alias() from information in the inode (if one is
given).

The type is cleared by dentry_unlink_inode() when it reconstitutes an existing
dentry as a negative dentry.

Accessors provided are:

d_set_type(dentry, type)
d_is_directory(dentry)
d_is_autodir(dentry)
d_is_symlink(dentry)
d_is_file(dentry)
d_is_negative(dentry)
d_is_positive(dentry)

A bunch of checks in pathname resolution switched to those.

Signed-off-by: David Howells <dhowells@redhat.com>
Signed-off-by: Al Viro <viro@zeniv.linux.org.uk>
fs/dcache.c
fs/namei.c
include/linux/dcache.h

index fb7bcf3ba5d6d704379b066ad7e50455f0578360..525770e576db0db8085f5c3c2220095008cb2629 100644 (file)
@@ -343,6 +343,7 @@ static void dentry_unlink_inode(struct dentry * dentry)
        __releases(dentry->d_inode->i_lock)
 {
        struct inode *inode = dentry->d_inode;
+       __d_clear_type(dentry);
        dentry->d_inode = NULL;
        hlist_del_init(&dentry->d_alias);
        dentry_rcuwalk_barrier(dentry);
@@ -1648,14 +1649,42 @@ void d_set_d_op(struct dentry *dentry, const struct dentry_operations *op)
 }
 EXPORT_SYMBOL(d_set_d_op);
 
+static unsigned d_flags_for_inode(struct inode *inode)
+{
+       unsigned add_flags = DCACHE_FILE_TYPE;
+
+       if (!inode)
+               return DCACHE_MISS_TYPE;
+
+       if (S_ISDIR(inode->i_mode)) {
+               add_flags = DCACHE_DIRECTORY_TYPE;
+               if (unlikely(!(inode->i_opflags & IOP_LOOKUP))) {
+                       if (unlikely(!inode->i_op->lookup))
+                               add_flags = DCACHE_AUTODIR_TYPE;
+                       else
+                               inode->i_opflags |= IOP_LOOKUP;
+               }
+       } else if (unlikely(!(inode->i_opflags & IOP_NOFOLLOW))) {
+               if (unlikely(inode->i_op->follow_link))
+                       add_flags = DCACHE_SYMLINK_TYPE;
+               else
+                       inode->i_opflags |= IOP_NOFOLLOW;
+       }
+
+       if (unlikely(IS_AUTOMOUNT(inode)))
+               add_flags |= DCACHE_NEED_AUTOMOUNT;
+       return add_flags;
+}
+
 static void __d_instantiate(struct dentry *dentry, struct inode *inode)
 {
+       unsigned add_flags = d_flags_for_inode(inode);
+
        spin_lock(&dentry->d_lock);
-       if (inode) {
-               if (unlikely(IS_AUTOMOUNT(inode)))
-                       dentry->d_flags |= DCACHE_NEED_AUTOMOUNT;
+       dentry->d_flags &= ~DCACHE_ENTRY_TYPE;
+       dentry->d_flags |= add_flags;
+       if (inode)
                hlist_add_head(&dentry->d_alias, &inode->i_dentry);
-       }
        dentry->d_inode = inode;
        dentry_rcuwalk_barrier(dentry);
        spin_unlock(&dentry->d_lock);
@@ -1860,6 +1889,7 @@ struct dentry *d_obtain_alias(struct inode *inode)
        static const struct qstr anonstring = QSTR_INIT("/", 1);
        struct dentry *tmp;
        struct dentry *res;
+       unsigned add_flags;
 
        if (!inode)
                return ERR_PTR(-ESTALE);
@@ -1885,9 +1915,11 @@ struct dentry *d_obtain_alias(struct inode *inode)
        }
 
        /* attach a disconnected dentry */
+       add_flags = d_flags_for_inode(inode) | DCACHE_DISCONNECTED;
+
        spin_lock(&tmp->d_lock);
        tmp->d_inode = inode;
-       tmp->d_flags |= DCACHE_DISCONNECTED;
+       tmp->d_flags |= add_flags;
        hlist_add_head(&tmp->d_alias, &inode->i_dentry);
        hlist_bl_lock(&tmp->d_sb->s_anon);
        hlist_bl_add_head(&tmp->d_hash, &tmp->d_sb->s_anon);
index e5c0118ba9f8ce02e918bc053ede25f316ca21c7..e1fa43346c612e5e65e75c3e83735fddebf7f236 100644 (file)
@@ -1501,18 +1501,9 @@ static void terminate_walk(struct nameidata *nd)
  * so we keep a cache of "no, this doesn't need follow_link"
  * for the common case.
  */
-static inline int should_follow_link(struct inode *inode, int follow)
+static inline int should_follow_link(struct dentry *dentry, int follow)
 {
-       if (unlikely(!(inode->i_opflags & IOP_NOFOLLOW))) {
-               if (likely(inode->i_op->follow_link))
-                       return follow;
-
-               /* This gets set once for the inode lifetime */
-               spin_lock(&inode->i_lock);
-               inode->i_opflags |= IOP_NOFOLLOW;
-               spin_unlock(&inode->i_lock);
-       }
-       return 0;
+       return unlikely(d_is_symlink(dentry)) ? follow : 0;
 }
 
 static inline int walk_component(struct nameidata *nd, struct path *path,
@@ -1542,7 +1533,7 @@ static inline int walk_component(struct nameidata *nd, struct path *path,
        if (!inode)
                goto out_path_put;
 
-       if (should_follow_link(inode, follow)) {
+       if (should_follow_link(path->dentry, follow)) {
                if (nd->flags & LOOKUP_RCU) {
                        if (unlikely(unlazy_walk(nd, path->dentry))) {
                                err = -ECHILD;
@@ -1600,26 +1591,6 @@ static inline int nested_symlink(struct path *path, struct nameidata *nd)
        return res;
 }
 
-/*
- * We really don't want to look at inode->i_op->lookup
- * when we don't have to. So we keep a cache bit in
- * the inode ->i_opflags field that says "yes, we can
- * do lookup on this inode".
- */
-static inline int can_lookup(struct inode *inode)
-{
-       if (likely(inode->i_opflags & IOP_LOOKUP))
-               return 1;
-       if (likely(!inode->i_op->lookup))
-               return 0;
-
-       /* We do this once for the lifetime of the inode */
-       spin_lock(&inode->i_lock);
-       inode->i_opflags |= IOP_LOOKUP;
-       spin_unlock(&inode->i_lock);
-       return 1;
-}
-
 /*
  * We can do the critical dentry name comparison and hashing
  * operations one word at a time, but we are limited to:
@@ -1823,7 +1794,7 @@ static int link_path_walk(const char *name, struct nameidata *nd)
                        if (err)
                                return err;
                }
-               if (!can_lookup(nd->inode)) {
+               if (!d_is_directory(nd->path.dentry)) {
                        err = -ENOTDIR; 
                        break;
                }
@@ -1841,9 +1812,10 @@ static int path_init(int dfd, const char *name, unsigned int flags,
        nd->flags = flags | LOOKUP_JUMPED;
        nd->depth = 0;
        if (flags & LOOKUP_ROOT) {
-               struct inode *inode = nd->root.dentry->d_inode;
+               struct dentry *root = nd->root.dentry;
+               struct inode *inode = root->d_inode;
                if (*name) {
-                       if (!can_lookup(inode))
+                       if (!d_is_directory(root))
                                return -ENOTDIR;
                        retval = inode_permission(inode, MAY_EXEC);
                        if (retval)
@@ -1899,7 +1871,7 @@ static int path_init(int dfd, const char *name, unsigned int flags,
                dentry = f.file->f_path.dentry;
 
                if (*name) {
-                       if (!can_lookup(dentry->d_inode)) {
+                       if (!d_is_directory(dentry)) {
                                fdput(f);
                                return -ENOTDIR;
                        }
@@ -1981,7 +1953,7 @@ static int path_lookupat(int dfd, const char *name,
                err = complete_walk(nd);
 
        if (!err && nd->flags & LOOKUP_DIRECTORY) {
-               if (!can_lookup(nd->inode)) {
+               if (!d_is_directory(nd->path.dentry)) {
                        path_put(&nd->path);
                        err = -ENOTDIR;
                }
@@ -2273,7 +2245,7 @@ done:
        }
        path->dentry = dentry;
        path->mnt = mntget(nd->path.mnt);
-       if (should_follow_link(dentry->d_inode, nd->flags & LOOKUP_FOLLOW))
+       if (should_follow_link(dentry, nd->flags & LOOKUP_FOLLOW))
                return 1;
        follow_mount(path);
        error = 0;
@@ -2417,12 +2389,14 @@ static inline int check_sticky(struct inode *dir, struct inode *inode)
  * 10. We don't allow removal of NFS sillyrenamed files; it's handled by
  *     nfs_async_unlink().
  */
-static int may_delete(struct inode *dir,struct dentry *victim,int isdir)
+static int may_delete(struct inode *dir, struct dentry *victim, bool isdir)
 {
+       struct inode *inode = victim->d_inode;
        int error;
 
-       if (!victim->d_inode)
+       if (d_is_negative(victim))
                return -ENOENT;
+       BUG_ON(!inode);
 
        BUG_ON(victim->d_parent->d_inode != dir);
        audit_inode_child(dir, victim, AUDIT_TYPE_CHILD_DELETE);
@@ -2432,15 +2406,16 @@ static int may_delete(struct inode *dir,struct dentry *victim,int isdir)
                return error;
        if (IS_APPEND(dir))
                return -EPERM;
-       if (check_sticky(dir, victim->d_inode)||IS_APPEND(victim->d_inode)||
-           IS_IMMUTABLE(victim->d_inode) || IS_SWAPFILE(victim->d_inode))
+
+       if (check_sticky(dir, inode) || IS_APPEND(inode) ||
+           IS_IMMUTABLE(inode) || IS_SWAPFILE(inode))
                return -EPERM;
        if (isdir) {
-               if (!S_ISDIR(victim->d_inode->i_mode))
+               if (!d_is_directory(victim) && !d_is_autodir(victim))
                        return -ENOTDIR;
                if (IS_ROOT(victim))
                        return -EBUSY;
-       } else if (S_ISDIR(victim->d_inode->i_mode))
+       } else if (d_is_directory(victim) || d_is_autodir(victim))
                return -EISDIR;
        if (IS_DEADDIR(dir))
                return -ENOENT;
@@ -2974,7 +2949,7 @@ retry_lookup:
        /*
         * create/update audit record if it already exists.
         */
-       if (path->dentry->d_inode)
+       if (d_is_positive(path->dentry))
                audit_inode(name, path->dentry, 0);
 
        /*
@@ -3003,12 +2978,12 @@ retry_lookup:
 finish_lookup:
        /* we _can_ be in RCU mode here */
        error = -ENOENT;
-       if (!inode) {
+       if (d_is_negative(path->dentry)) {
                path_to_nameidata(path, nd);
                goto out;
        }
 
-       if (should_follow_link(inode, !symlink_ok)) {
+       if (should_follow_link(path->dentry, !symlink_ok)) {
                if (nd->flags & LOOKUP_RCU) {
                        if (unlikely(unlazy_walk(nd, path->dentry))) {
                                error = -ECHILD;
@@ -3037,10 +3012,11 @@ finish_open:
        }
        audit_inode(name, nd->path.dentry, 0);
        error = -EISDIR;
-       if ((open_flag & O_CREAT) && S_ISDIR(nd->inode->i_mode))
+       if ((open_flag & O_CREAT) &&
+           (d_is_directory(nd->path.dentry) || d_is_autodir(nd->path.dentry)))
                goto out;
        error = -ENOTDIR;
-       if ((nd->flags & LOOKUP_DIRECTORY) && !can_lookup(nd->inode))
+       if ((nd->flags & LOOKUP_DIRECTORY) && !d_is_directory(nd->path.dentry))
                goto out;
        if (!S_ISREG(nd->inode->i_mode))
                will_truncate = false;
@@ -3266,7 +3242,7 @@ struct file *do_file_open_root(struct dentry *dentry, struct vfsmount *mnt,
        nd.root.mnt = mnt;
        nd.root.dentry = dentry;
 
-       if (dentry->d_inode->i_op->follow_link && op->intent & LOOKUP_OPEN)
+       if (d_is_symlink(dentry) && op->intent & LOOKUP_OPEN)
                return ERR_PTR(-ELOOP);
 
        file = path_openat(-1, &filename, &nd, op, flags | LOOKUP_RCU);
@@ -3316,8 +3292,9 @@ struct dentry *kern_path_create(int dfd, const char *pathname,
                goto unlock;
 
        error = -EEXIST;
-       if (dentry->d_inode)
+       if (d_is_positive(dentry))
                goto fail;
+
        /*
         * Special case - lookup gave negative, but... we had foo/bar/
         * From the vfs_mknod() POV we just have a negative dentry -
@@ -3706,7 +3683,7 @@ retry:
                if (nd.last.name[nd.last.len])
                        goto slashes;
                inode = dentry->d_inode;
-               if (!inode)
+               if (d_is_negative(dentry))
                        goto slashes;
                ihold(inode);
                error = security_path_unlink(&nd.path, dentry);
@@ -3731,8 +3708,12 @@ exit1:
        return error;
 
 slashes:
-       error = !dentry->d_inode ? -ENOENT :
-               S_ISDIR(dentry->d_inode->i_mode) ? -EISDIR : -ENOTDIR;
+       if (d_is_negative(dentry))
+               error = -ENOENT;
+       else if (d_is_directory(dentry) || d_is_autodir(dentry))
+               error = -EISDIR;
+       else
+               error = -ENOTDIR;
        goto exit2;
 }
 
@@ -4046,7 +4027,7 @@ int vfs_rename(struct inode *old_dir, struct dentry *old_dentry,
               struct inode *new_dir, struct dentry *new_dentry)
 {
        int error;
-       int is_dir = S_ISDIR(old_dentry->d_inode->i_mode);
+       int is_dir = d_is_directory(old_dentry) || d_is_autodir(old_dentry);
        const unsigned char *old_name;
 
        if (old_dentry->d_inode == new_dentry->d_inode)
@@ -4134,10 +4115,10 @@ retry:
                goto exit3;
        /* source must exist */
        error = -ENOENT;
-       if (!old_dentry->d_inode)
+       if (d_is_negative(old_dentry))
                goto exit4;
        /* unless the source is a directory trailing slashes give -ENOTDIR */
-       if (!S_ISDIR(old_dentry->d_inode->i_mode)) {
+       if (!d_is_directory(old_dentry) && !d_is_autodir(old_dentry)) {
                error = -ENOTDIR;
                if (oldnd.last.name[oldnd.last.len])
                        goto exit4;
index 716c3760ee3970908577ccdb4ea32fa0275d7e33..57e87e749a484cbf09a2f9f21fac3d3f52574df9 100644 (file)
@@ -169,13 +169,13 @@ struct dentry_operations {
  */
 
 /* d_flags entries */
-#define DCACHE_OP_HASH         0x0001
-#define DCACHE_OP_COMPARE      0x0002
-#define DCACHE_OP_REVALIDATE   0x0004
-#define DCACHE_OP_DELETE       0x0008
-#define DCACHE_OP_PRUNE         0x0010
+#define DCACHE_OP_HASH                 0x00000001
+#define DCACHE_OP_COMPARE              0x00000002
+#define DCACHE_OP_REVALIDATE           0x00000004
+#define DCACHE_OP_DELETE               0x00000008
+#define DCACHE_OP_PRUNE                        0x00000010
 
-#define        DCACHE_DISCONNECTED     0x0020
+#define        DCACHE_DISCONNECTED             0x00000020
      /* 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
@@ -186,30 +186,38 @@ struct dentry_operations {
       * dentry into place and return that dentry rather than the passed one,
       * typically using d_splice_alias. */
 
-#define DCACHE_REFERENCED      0x0040  /* Recently used, don't discard. */
-#define DCACHE_RCUACCESS       0x0080  /* Entry has ever been RCU-visible */
+#define DCACHE_REFERENCED              0x00000040 /* Recently used, don't discard. */
+#define DCACHE_RCUACCESS               0x00000080 /* Entry has ever been RCU-visible */
 
-#define DCACHE_CANT_MOUNT      0x0100
-#define DCACHE_GENOCIDE                0x0200
-#define DCACHE_SHRINK_LIST     0x0400
+#define DCACHE_CANT_MOUNT              0x00000100
+#define DCACHE_GENOCIDE                        0x00000200
+#define DCACHE_SHRINK_LIST             0x00000400
 
-#define DCACHE_OP_WEAK_REVALIDATE      0x0800
+#define DCACHE_OP_WEAK_REVALIDATE      0x00000800
 
-#define DCACHE_NFSFS_RENAMED   0x1000
+#define DCACHE_NFSFS_RENAMED           0x00001000
      /* this dentry has been "silly renamed" and has to be deleted on the last
       * dput() */
-#define DCACHE_COOKIE          0x2000  /* For use by dcookie subsystem */
-#define DCACHE_FSNOTIFY_PARENT_WATCHED 0x4000
+#define DCACHE_COOKIE                  0x00002000 /* For use by dcookie subsystem */
+#define DCACHE_FSNOTIFY_PARENT_WATCHED 0x00004000
      /* Parent inode is watched by some fsnotify listener */
 
-#define DCACHE_MOUNTED         0x10000 /* is a mountpoint */
-#define DCACHE_NEED_AUTOMOUNT  0x20000 /* handle automount on this dir */
-#define DCACHE_MANAGE_TRANSIT  0x40000 /* manage transit from this dirent */
+#define DCACHE_DENTRY_KILLED           0x00008000
+
+#define DCACHE_MOUNTED                 0x00010000 /* is a mountpoint */
+#define DCACHE_NEED_AUTOMOUNT          0x00020000 /* handle automount on this dir */
+#define DCACHE_MANAGE_TRANSIT          0x00040000 /* manage transit from this dirent */
 #define DCACHE_MANAGED_DENTRY \
        (DCACHE_MOUNTED|DCACHE_NEED_AUTOMOUNT|DCACHE_MANAGE_TRANSIT)
 
-#define DCACHE_LRU_LIST                0x80000
-#define DCACHE_DENTRY_KILLED   0x100000
+#define DCACHE_LRU_LIST                        0x00080000
+
+#define DCACHE_ENTRY_TYPE              0x00700000
+#define DCACHE_MISS_TYPE               0x00000000 /* Negative dentry */
+#define DCACHE_DIRECTORY_TYPE          0x00100000 /* Normal directory */
+#define DCACHE_AUTODIR_TYPE            0x00200000 /* Lookupless directory (presumed automount) */
+#define DCACHE_SYMLINK_TYPE            0x00300000 /* Symlink */
+#define DCACHE_FILE_TYPE               0x00400000 /* Other file type */
 
 extern seqlock_t rename_lock;
 
@@ -394,6 +402,61 @@ static inline bool d_mountpoint(const struct dentry *dentry)
        return dentry->d_flags & DCACHE_MOUNTED;
 }
 
+/*
+ * Directory cache entry type accessor functions.
+ */
+static inline void __d_set_type(struct dentry *dentry, unsigned type)
+{
+       dentry->d_flags = (dentry->d_flags & ~DCACHE_ENTRY_TYPE) | type;
+}
+
+static inline void __d_clear_type(struct dentry *dentry)
+{
+       __d_set_type(dentry, DCACHE_MISS_TYPE);
+}
+
+static inline void d_set_type(struct dentry *dentry, unsigned type)
+{
+       spin_lock(&dentry->d_lock);
+       __d_set_type(dentry, type);
+       spin_unlock(&dentry->d_lock);
+}
+
+static inline unsigned __d_entry_type(const struct dentry *dentry)
+{
+       return dentry->d_flags & DCACHE_ENTRY_TYPE;
+}
+
+static inline bool d_is_directory(const struct dentry *dentry)
+{
+       return __d_entry_type(dentry) == DCACHE_DIRECTORY_TYPE;
+}
+
+static inline bool d_is_autodir(const struct dentry *dentry)
+{
+       return __d_entry_type(dentry) == DCACHE_AUTODIR_TYPE;
+}
+
+static inline bool d_is_symlink(const struct dentry *dentry)
+{
+       return __d_entry_type(dentry) == DCACHE_SYMLINK_TYPE;
+}
+
+static inline bool d_is_file(const struct dentry *dentry)
+{
+       return __d_entry_type(dentry) == DCACHE_FILE_TYPE;
+}
+
+static inline bool d_is_negative(const struct dentry *dentry)
+{
+       return __d_entry_type(dentry) == DCACHE_MISS_TYPE;
+}
+
+static inline bool d_is_positive(const struct dentry *dentry)
+{
+       return !d_is_negative(dentry);
+}
+
 extern int sysctl_vfs_cache_pressure;
 
 static inline unsigned long vfs_pressure_ratio(unsigned long val)