autofs4: make autofs type usage explicit
authorIan Kent <raven@themaw.net>
Tue, 6 Jan 2009 22:42:08 +0000 (14:42 -0800)
committerLinus Torvalds <torvalds@linux-foundation.org>
Tue, 6 Jan 2009 23:59:23 +0000 (15:59 -0800)
- the type assigned at mount when no type is given is changed
  from 0 to AUTOFS_TYPE_INDIRECT. This was done because 0 and
  AUTOFS_TYPE_INDIRECT were being treated implicitly as the same
  type.

- previously, an offset mount had it's type set to
  AUTOFS_TYPE_DIRECT|AUTOFS_TYPE_OFFSET but the mount control
  re-implementation needs to be able distinguish all three types.
  So this was changed to make the type setting explicit.

- a type AUTOFS_TYPE_ANY was added for use by the re-implementation
  when checking if a given path is a mountpoint. It's not really a
  type as we use this to ask if a given path is a mountpoint in the
  autofs_dev_ioctl_ismountpoint() function.

- functions to set and test the autofs mount types have been added to
  improve readability and make the type usage explicit.

- the mount type is used from user space for the mount control
  re-implementtion so, for consistency, all the definitions have
  been moved to the user space include file include/linux/auto_fs4.h.

Signed-off-by: Ian Kent <raven@themaw.net>
Signed-off-by: Jeff Moyer <jmoyer@redhat.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
fs/autofs4/autofs_i.h
fs/autofs4/dev-ioctl.c
fs/autofs4/expire.c
fs/autofs4/inode.c
fs/autofs4/waitq.c
include/linux/auto_fs4.h

index e0f16da00e54294912bfd3a36fab3a09d0f1741f..a76803108d06fe58ce8b2a99d24bdae9f3e5004f 100644 (file)
@@ -25,8 +25,6 @@
 #define AUTOFS_DEV_IOCTL_IOC_FIRST     (AUTOFS_DEV_IOCTL_VERSION)
 #define AUTOFS_DEV_IOCTL_IOC_COUNT     (AUTOFS_IOC_COUNT - 11)
 
-#define AUTOFS_TYPE_TRIGGER    (AUTOFS_TYPE_DIRECT|AUTOFS_TYPE_OFFSET)
-
 #include <linux/kernel.h>
 #include <linux/slab.h>
 #include <linux/time.h>
index 0566ff8db4cd711f9b84b151dd95b23e82c19519..aa3f47293bb87cc670b1b106a1358addd9407752 100644 (file)
@@ -532,7 +532,7 @@ static int autofs_dev_ioctl_expire(struct file *fp,
        how = param->expire.how;
        mnt = fp->f_path.mnt;
 
-       if (sbi->type & AUTOFS_TYPE_TRIGGER)
+       if (autofs_type_trigger(sbi->type))
                dentry = autofs4_expire_direct(sbi->sb, mnt, sbi, how);
        else
                dentry = autofs4_expire_indirect(sbi->sb, mnt, sbi, how);
@@ -615,7 +615,7 @@ static int autofs_dev_ioctl_ismountpoint(struct file *fp,
        param->ismountpoint.out.magic = magic = 0;
 
        if (!fp || param->ioctlfd == -1) {
-               if (type == AUTOFS_TYPE_ANY) {
+               if (autofs_type_any(type)) {
                        struct super_block *sb;
 
                        err = path_lookup(path, LOOKUP_FOLLOW, &nd);
index 4b6fb3f628c04be94a2863ad5f7ee05feace9c44..e3bd50776f9e4f9997d21940c11cd99acd855263 100644 (file)
@@ -63,7 +63,7 @@ static int autofs4_mount_busy(struct vfsmount *mnt, struct dentry *dentry)
                struct autofs_sb_info *sbi = autofs4_sbi(dentry->d_sb);
 
                /* This is an autofs submount, we can't expire it */
-               if (sbi->type == AUTOFS_TYPE_INDIRECT)
+               if (autofs_type_indirect(sbi->type))
                        goto done;
 
                /*
@@ -490,7 +490,7 @@ int autofs4_expire_multi(struct super_block *sb, struct vfsmount *mnt,
        if (arg && get_user(do_now, arg))
                return -EFAULT;
 
-       if (sbi->type & AUTOFS_TYPE_TRIGGER)
+       if (autofs_type_trigger(sbi->type))
                dentry = autofs4_expire_direct(sb, mnt, sbi, do_now);
        else
                dentry = autofs4_expire_indirect(sb, mnt, sbi, do_now);
index cfc23e53b6f460fef089881acb04dc2087393453..716e12b627b239d23176551ffec355e0813ad6dc 100644 (file)
@@ -197,9 +197,9 @@ static int autofs4_show_options(struct seq_file *m, struct vfsmount *mnt)
        seq_printf(m, ",minproto=%d", sbi->min_proto);
        seq_printf(m, ",maxproto=%d", sbi->max_proto);
 
-       if (sbi->type & AUTOFS_TYPE_OFFSET)
+       if (autofs_type_offset(sbi->type))
                seq_printf(m, ",offset");
-       else if (sbi->type & AUTOFS_TYPE_DIRECT)
+       else if (autofs_type_direct(sbi->type))
                seq_printf(m, ",direct");
        else
                seq_printf(m, ",indirect");
@@ -284,13 +284,13 @@ static int parse_options(char *options, int *pipefd, uid_t *uid, gid_t *gid,
                        *maxproto = option;
                        break;
                case Opt_indirect:
-                       *type = AUTOFS_TYPE_INDIRECT;
+                       set_autofs_type_indirect(type);
                        break;
                case Opt_direct:
-                       *type = AUTOFS_TYPE_DIRECT;
+                       set_autofs_type_direct(type);
                        break;
                case Opt_offset:
-                       *type = AUTOFS_TYPE_OFFSET;
+                       set_autofs_type_offset(type);
                        break;
                default:
                        return 1;
@@ -338,7 +338,7 @@ int autofs4_fill_super(struct super_block *s, void *data, int silent)
        sbi->sb = s;
        sbi->version = 0;
        sbi->sub_version = 0;
-       sbi->type = AUTOFS_TYPE_INDIRECT;
+       set_autofs_type_indirect(&sbi->type);
        sbi->min_proto = 0;
        sbi->max_proto = 0;
        mutex_init(&sbi->wq_mutex);
@@ -380,7 +380,7 @@ int autofs4_fill_super(struct super_block *s, void *data, int silent)
        }
 
        root_inode->i_fop = &autofs4_root_operations;
-       root_inode->i_op = sbi->type & AUTOFS_TYPE_TRIGGER ?
+       root_inode->i_op = autofs_type_trigger(sbi->type) ?
                        &autofs4_direct_root_inode_operations :
                        &autofs4_indirect_root_inode_operations;
 
index e02cc8ae5eb326a9fcb05f1557a5d8cc64e7c005..eeb2468459096b9d5ca1523233b9fca22ff55a3b 100644 (file)
@@ -337,7 +337,7 @@ int autofs4_wait(struct autofs_sb_info *sbi, struct dentry *dentry,
                 * is very similar for indirect mounts except only dentrys
                 * in the root of the autofs file system may be negative.
                 */
-               if (sbi->type & AUTOFS_TYPE_TRIGGER)
+               if (autofs_type_trigger(sbi->type))
                        return -ENOENT;
                else if (!IS_ROOT(dentry->d_parent))
                        return -ENOENT;
@@ -348,7 +348,7 @@ int autofs4_wait(struct autofs_sb_info *sbi, struct dentry *dentry,
                return -ENOMEM;
 
        /* If this is a direct mount request create a dummy name */
-       if (IS_ROOT(dentry) && sbi->type & AUTOFS_TYPE_TRIGGER)
+       if (IS_ROOT(dentry) && autofs_type_trigger(sbi->type))
                qstr.len = sprintf(name, "%p", dentry);
        else {
                qstr.len = autofs4_getpath(sbi, dentry, &name);
@@ -406,11 +406,11 @@ int autofs4_wait(struct autofs_sb_info *sbi, struct dentry *dentry,
                                type = autofs_ptype_expire_multi;
                } else {
                        if (notify == NFY_MOUNT)
-                               type = (sbi->type & AUTOFS_TYPE_TRIGGER) ?
+                               type = autofs_type_trigger(sbi->type) ?
                                        autofs_ptype_missing_direct :
                                         autofs_ptype_missing_indirect;
                        else
-                               type = (sbi->type & AUTOFS_TYPE_TRIGGER) ?
+                               type = autofs_type_trigger(sbi->type) ?
                                        autofs_ptype_expire_direct :
                                        autofs_ptype_expire_indirect;
                }
index 2253716d4b92227a2d6deb49a20b53b7088ece9d..55fa478bd639127e274ee8564f2779e53dfe2796 100644 (file)
 #define AUTOFS_EXP_IMMEDIATE           1
 #define AUTOFS_EXP_LEAVES              2
 
-#define AUTOFS_TYPE_ANY                        0x0000
-#define AUTOFS_TYPE_INDIRECT           0x0001
-#define AUTOFS_TYPE_DIRECT             0x0002
-#define AUTOFS_TYPE_OFFSET             0x0004
+#define AUTOFS_TYPE_ANY                        0U
+#define AUTOFS_TYPE_INDIRECT           1U
+#define AUTOFS_TYPE_DIRECT             2U
+#define AUTOFS_TYPE_OFFSET             4U
+
+static inline void set_autofs_type_indirect(unsigned int *type)
+{
+       *type = AUTOFS_TYPE_INDIRECT;
+       return;
+}
+
+static inline unsigned int autofs_type_indirect(unsigned int type)
+{
+       return (type == AUTOFS_TYPE_INDIRECT);
+}
+
+static inline void set_autofs_type_direct(unsigned int *type)
+{
+       *type = AUTOFS_TYPE_DIRECT;
+       return;
+}
+
+static inline unsigned int autofs_type_direct(unsigned int type)
+{
+       return (type == AUTOFS_TYPE_DIRECT);
+}
+
+static inline void set_autofs_type_offset(unsigned int *type)
+{
+       *type = AUTOFS_TYPE_OFFSET;
+       return;
+}
+
+static inline unsigned int autofs_type_offset(unsigned int type)
+{
+       return (type == AUTOFS_TYPE_OFFSET);
+}
+
+static inline unsigned int autofs_type_trigger(unsigned int type)
+{
+       return (type == AUTOFS_TYPE_DIRECT || type == AUTOFS_TYPE_OFFSET);
+}
+
+/*
+ * This isn't really a type as we use it to say "no type set" to
+ * indicate we want to search for "any" mount in the
+ * autofs_dev_ioctl_ismountpoint() device ioctl function.
+ */
+static inline void set_autofs_type_any(unsigned int *type)
+{
+       *type = AUTOFS_TYPE_ANY;
+       return;
+}
+
+static inline unsigned int autofs_type_any(unsigned int type)
+{
+       return (type == AUTOFS_TYPE_ANY);
+}
 
 /* Daemon notification packet types */
 enum autofs_notify {