Merge branch 'master' of git://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux-2.6 into for-upstream

5 files changed, 53 insertions, 50 deletions

diff --git a/fs/autofs4/autofs_i.h b/fs/autofs4/autofs_i.h
index e0f16da00e54..a76803108d06 100644
--- a/fs/autofs4/autofs_i.h
+++ b/fs/autofs4/autofs_i.h
@@ -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>
diff --git a/fs/autofs4/dev-ioctl.c b/fs/autofs4/dev-ioctl.c
index 63b7c7afe8df..025e105bffea 100644
--- a/fs/autofs4/dev-ioctl.c
+++ b/fs/autofs4/dev-ioctl.c
@@ -124,7 +124,7 @@ static inline void free_dev_ioctl(struct autofs_dev_ioctl *param)
 
 /*
  * Check sanity of parameter control fields and if a path is present
- * check that it has a "/" and is terminated.
+ * check that it is terminated and contains at least one "/".
  */
 static int validate_dev_ioctl(int cmd, struct autofs_dev_ioctl *param)
 {
@@ -138,15 +138,16 @@ static int validate_dev_ioctl(int cmd, struct autofs_dev_ioctl *param)
         }
 
         if (param->size > sizeof(*param)) {
-                err = check_name(param->path);
+                err = invalid_str(param->path,
+                                 (void *) ((size_t) param + param->size));
                 if (err) {
-                        AUTOFS_WARN("invalid path supplied for cmd(0x%08x)",
-                                    cmd);
+                        AUTOFS_WARN(
+                          "path string terminator missing for cmd(0x%08x)",
+                          cmd);
                         goto out;
                 }
 
-                err = invalid_str(param->path,
-                                 (void *) ((size_t) param + param->size));
+                err = check_name(param->path);
                 if (err) {
                         AUTOFS_WARN("invalid path supplied for cmd(0x%08x)",
                                     cmd);
@@ -180,7 +181,7 @@ static int autofs_dev_ioctl_protover(struct file *fp,
                                      struct autofs_sb_info *sbi,
                                      struct autofs_dev_ioctl *param)
 {
-        param->arg1 = sbi->version;
+        param->protover.version = sbi->version;
         return 0;
 }
 
@@ -189,7 +190,7 @@ static int autofs_dev_ioctl_protosubver(struct file *fp,
                                         struct autofs_sb_info *sbi,
                                         struct autofs_dev_ioctl *param)
 {
-        param->arg1 = sbi->sub_version;
+        param->protosubver.sub_version = sbi->sub_version;
         return 0;
 }
 
@@ -335,13 +336,13 @@ static int autofs_dev_ioctl_openmount(struct file *fp,
         int err, fd;
 
         /* param->path has already been checked */
-        if (!param->arg1)
+        if (!param->openmount.devid)
                 return -EINVAL;
 
         param->ioctlfd = -1;
 
         path = param->path;
-        devid = param->arg1;
+        devid = param->openmount.devid;
 
         err = 0;
         fd = autofs_dev_ioctl_open_mountpoint(path, devid);
@@ -373,7 +374,7 @@ static int autofs_dev_ioctl_ready(struct file *fp,
 {
         autofs_wqt_t token;
 
-        token = (autofs_wqt_t) param->arg1;
+        token = (autofs_wqt_t) param->ready.token;
         return autofs4_wait_release(sbi, token, 0);
 }
 
@@ -388,8 +389,8 @@ static int autofs_dev_ioctl_fail(struct file *fp,
         autofs_wqt_t token;
         int status;
 
-        token = (autofs_wqt_t) param->arg1;
-        status = param->arg2 ? param->arg2 : -ENOENT;
+        token = (autofs_wqt_t) param->fail.token;
+        status = param->fail.status ? param->fail.status : -ENOENT;
         return autofs4_wait_release(sbi, token, status);
 }
 
@@ -412,10 +413,10 @@ static int autofs_dev_ioctl_setpipefd(struct file *fp,
         int pipefd;
         int err = 0;
 
-        if (param->arg1 == -1)
+        if (param->setpipefd.pipefd == -1)
                 return -EINVAL;
 
-        pipefd = param->arg1;
+        pipefd = param->setpipefd.pipefd;
 
         mutex_lock(&sbi->wq_mutex);
         if (!sbi->catatonic) {
@@ -457,8 +458,8 @@ static int autofs_dev_ioctl_timeout(struct file *fp,
 {
         unsigned long timeout;
 
-        timeout = param->arg1;
-        param->arg1 = sbi->exp_timeout / HZ;
+        timeout = param->timeout.timeout;
+        param->timeout.timeout = sbi->exp_timeout / HZ;
         sbi->exp_timeout = timeout * HZ;
         return 0;
 }
@@ -489,7 +490,7 @@ static int autofs_dev_ioctl_requester(struct file *fp,
         path = param->path;
         devid = sbi->sb->s_dev;
 
-        param->arg1 = param->arg2 = -1;
+        param->requester.uid = param->requester.gid = -1;
 
         /* Get nameidata of the parent directory */
         err = path_lookup(path, LOOKUP_PARENT, &nd);
@@ -505,8 +506,8 @@ static int autofs_dev_ioctl_requester(struct file *fp,
                 err = 0;
                 autofs4_expire_wait(nd.path.dentry);
                 spin_lock(&sbi->fs_lock);
-                param->arg1 = ino->uid;
-                param->arg2 = ino->gid;
+                param->requester.uid = ino->uid;
+                param->requester.gid = ino->gid;
                 spin_unlock(&sbi->fs_lock);
         }
 
@@ -529,10 +530,10 @@ static int autofs_dev_ioctl_expire(struct file *fp,
         int err = -EAGAIN;
         int how;
 
-        how = param->arg1;
+        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);
@@ -565,9 +566,9 @@ static int autofs_dev_ioctl_askumount(struct file *fp,
                                       struct autofs_sb_info *sbi,
                                       struct autofs_dev_ioctl *param)
 {
-        param->arg1 = 0;
+        param->askumount.may_umount = 0;
         if (may_umount(fp->f_path.mnt))
-                param->arg1 = 1;
+                param->askumount.may_umount = 1;
         return 0;
 }
 
@@ -600,6 +601,7 @@ static int autofs_dev_ioctl_ismountpoint(struct file *fp,
         struct nameidata nd;
         const char *path;
         unsigned int type;
+        unsigned int devid, magic;
         int err = -ENOENT;
 
         if (param->size <= sizeof(*param)) {
@@ -608,13 +610,13 @@ static int autofs_dev_ioctl_ismountpoint(struct file *fp,
         }
 
         path = param->path;
-        type = param->arg1;
+        type = param->ismountpoint.in.type;
 
-        param->arg1 = 0;
-        param->arg2 = 0;
+        param->ismountpoint.out.devid = devid = 0;
+        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);
@@ -622,7 +624,7 @@ static int autofs_dev_ioctl_ismountpoint(struct file *fp,
                                 goto out;
 
                         sb = nd.path.dentry->d_sb;
-                        param->arg1 = new_encode_dev(sb->s_dev);
+                        devid = new_encode_dev(sb->s_dev);
                 } else {
                         struct autofs_info *ino;
 
@@ -635,38 +637,41 @@ static int autofs_dev_ioctl_ismountpoint(struct file *fp,
                                 goto out_release;
 
                         ino = autofs4_dentry_ino(nd.path.dentry);
-                        param->arg1 = autofs4_get_dev(ino->sbi);
+                        devid = autofs4_get_dev(ino->sbi);
                 }
 
                 err = 0;
                 if (nd.path.dentry->d_inode &&
                     nd.path.mnt->mnt_root == nd.path.dentry) {
                         err = 1;
-                        param->arg2 = nd.path.dentry->d_inode->i_sb->s_magic;
+                        magic = nd.path.dentry->d_inode->i_sb->s_magic;
                 }
         } else {
-                dev_t devid = new_encode_dev(sbi->sb->s_dev);
+                dev_t dev = autofs4_get_dev(sbi);
 
                 err = path_lookup(path, LOOKUP_PARENT, &nd);
                 if (err)
                         goto out;
 
-                err = autofs_dev_ioctl_find_super(&nd, devid);
+                err = autofs_dev_ioctl_find_super(&nd, dev);
                 if (err)
                         goto out_release;
 
-                param->arg1 = autofs4_get_dev(sbi);
+                devid = dev;
 
                 err = have_submounts(nd.path.dentry);
 
                 if (nd.path.mnt->mnt_mountpoint != nd.path.mnt->mnt_root) {
                         if (follow_down(&nd.path.mnt, &nd.path.dentry)) {
                                 struct inode *inode = nd.path.dentry->d_inode;
-                                param->arg2 = inode->i_sb->s_magic;
+                                magic = inode->i_sb->s_magic;
                         }
                 }
         }
 
+        param->ismountpoint.out.devid = devid;
+        param->ismountpoint.out.magic = magic;
+
 out_release:
         path_put(&nd.path);
 out:
diff --git a/fs/autofs4/expire.c b/fs/autofs4/expire.c
index 4b6fb3f628c0..e3bd50776f9e 100644
--- a/fs/autofs4/expire.c
+++ b/fs/autofs4/expire.c
@@ -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);
diff --git a/fs/autofs4/inode.c b/fs/autofs4/inode.c
index cfc23e53b6f4..716e12b627b2 100644
--- a/fs/autofs4/inode.c
+++ b/fs/autofs4/inode.c
@@ -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;
 
diff --git a/fs/autofs4/waitq.c b/fs/autofs4/waitq.c
index e02cc8ae5eb3..eeb246845909 100644
--- a/fs/autofs4/waitq.c
+++ b/fs/autofs4/waitq.c
@@ -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;
                 }