Merge branch 'fix/hda' into for-linus
[linux-2.6] / fs / autofs4 / dev-ioctl.c
1 /*
2  * Copyright 2008 Red Hat, Inc. All rights reserved.
3  * Copyright 2008 Ian Kent <raven@themaw.net>
4  *
5  * This file is part of the Linux kernel and is made available under
6  * the terms of the GNU General Public License, version 2, or at your
7  * option, any later version, incorporated herein by reference.
8  */
9
10 #include <linux/module.h>
11 #include <linux/vmalloc.h>
12 #include <linux/miscdevice.h>
13 #include <linux/init.h>
14 #include <linux/wait.h>
15 #include <linux/namei.h>
16 #include <linux/fcntl.h>
17 #include <linux/file.h>
18 #include <linux/fdtable.h>
19 #include <linux/sched.h>
20 #include <linux/compat.h>
21 #include <linux/syscalls.h>
22 #include <linux/smp_lock.h>
23 #include <linux/magic.h>
24 #include <linux/dcache.h>
25 #include <linux/uaccess.h>
26
27 #include "autofs_i.h"
28
29 /*
30  * This module implements an interface for routing autofs ioctl control
31  * commands via a miscellaneous device file.
32  *
33  * The alternate interface is needed because we need to be able open
34  * an ioctl file descriptor on an autofs mount that may be covered by
35  * another mount. This situation arises when starting automount(8)
36  * or other user space daemon which uses direct mounts or offset
37  * mounts (used for autofs lazy mount/umount of nested mount trees),
38  * which have been left busy at at service shutdown.
39  */
40
41 #define AUTOFS_DEV_IOCTL_SIZE   sizeof(struct autofs_dev_ioctl)
42
43 typedef int (*ioctl_fn)(struct file *, struct autofs_sb_info *,
44                         struct autofs_dev_ioctl *);
45
46 static int check_name(const char *name)
47 {
48         if (!strchr(name, '/'))
49                 return -EINVAL;
50         return 0;
51 }
52
53 /*
54  * Check a string doesn't overrun the chunk of
55  * memory we copied from user land.
56  */
57 static int invalid_str(char *str, size_t size)
58 {
59         if (memchr(str, 0, size))
60                 return 0;
61         return -EINVAL;
62 }
63
64 /*
65  * Check that the user compiled against correct version of autofs
66  * misc device code.
67  *
68  * As well as checking the version compatibility this always copies
69  * the kernel interface version out.
70  */
71 static int check_dev_ioctl_version(int cmd, struct autofs_dev_ioctl *param)
72 {
73         int err = 0;
74
75         if ((AUTOFS_DEV_IOCTL_VERSION_MAJOR != param->ver_major) ||
76             (AUTOFS_DEV_IOCTL_VERSION_MINOR < param->ver_minor)) {
77                 AUTOFS_WARN("ioctl control interface version mismatch: "
78                      "kernel(%u.%u), user(%u.%u), cmd(%d)",
79                      AUTOFS_DEV_IOCTL_VERSION_MAJOR,
80                      AUTOFS_DEV_IOCTL_VERSION_MINOR,
81                      param->ver_major, param->ver_minor, cmd);
82                 err = -EINVAL;
83         }
84
85         /* Fill in the kernel version. */
86         param->ver_major = AUTOFS_DEV_IOCTL_VERSION_MAJOR;
87         param->ver_minor = AUTOFS_DEV_IOCTL_VERSION_MINOR;
88
89         return err;
90 }
91
92 /*
93  * Copy parameter control struct, including a possible path allocated
94  * at the end of the struct.
95  */
96 static struct autofs_dev_ioctl *copy_dev_ioctl(struct autofs_dev_ioctl __user *in)
97 {
98         struct autofs_dev_ioctl tmp, *ads;
99
100         if (copy_from_user(&tmp, in, sizeof(tmp)))
101                 return ERR_PTR(-EFAULT);
102
103         if (tmp.size < sizeof(tmp))
104                 return ERR_PTR(-EINVAL);
105
106         ads = kmalloc(tmp.size, GFP_KERNEL);
107         if (!ads)
108                 return ERR_PTR(-ENOMEM);
109
110         if (copy_from_user(ads, in, tmp.size)) {
111                 kfree(ads);
112                 return ERR_PTR(-EFAULT);
113         }
114
115         return ads;
116 }
117
118 static inline void free_dev_ioctl(struct autofs_dev_ioctl *param)
119 {
120         kfree(param);
121         return;
122 }
123
124 /*
125  * Check sanity of parameter control fields and if a path is present
126  * check that it is terminated and contains at least one "/".
127  */
128 static int validate_dev_ioctl(int cmd, struct autofs_dev_ioctl *param)
129 {
130         int err;
131
132         err = check_dev_ioctl_version(cmd, param);
133         if (err) {
134                 AUTOFS_WARN("invalid device control module version "
135                      "supplied for cmd(0x%08x)", cmd);
136                 goto out;
137         }
138
139         if (param->size > sizeof(*param)) {
140                 err = invalid_str(param->path, param->size - sizeof(*param));
141                 if (err) {
142                         AUTOFS_WARN(
143                           "path string terminator missing for cmd(0x%08x)",
144                           cmd);
145                         goto out;
146                 }
147
148                 err = check_name(param->path);
149                 if (err) {
150                         AUTOFS_WARN("invalid path supplied for cmd(0x%08x)",
151                                     cmd);
152                         goto out;
153                 }
154         }
155
156         err = 0;
157 out:
158         return err;
159 }
160
161 /*
162  * Get the autofs super block info struct from the file opened on
163  * the autofs mount point.
164  */
165 static struct autofs_sb_info *autofs_dev_ioctl_sbi(struct file *f)
166 {
167         struct autofs_sb_info *sbi = NULL;
168         struct inode *inode;
169
170         if (f) {
171                 inode = f->f_path.dentry->d_inode;
172                 sbi = autofs4_sbi(inode->i_sb);
173         }
174         return sbi;
175 }
176
177 /* Return autofs module protocol version */
178 static int autofs_dev_ioctl_protover(struct file *fp,
179                                      struct autofs_sb_info *sbi,
180                                      struct autofs_dev_ioctl *param)
181 {
182         param->protover.version = sbi->version;
183         return 0;
184 }
185
186 /* Return autofs module protocol sub version */
187 static int autofs_dev_ioctl_protosubver(struct file *fp,
188                                         struct autofs_sb_info *sbi,
189                                         struct autofs_dev_ioctl *param)
190 {
191         param->protosubver.sub_version = sbi->sub_version;
192         return 0;
193 }
194
195 /*
196  * Walk down the mount stack looking for an autofs mount that
197  * has the requested device number (aka. new_encode_dev(sb->s_dev).
198  */
199 static int autofs_dev_ioctl_find_super(struct nameidata *nd, dev_t devno)
200 {
201         struct dentry *dentry;
202         struct inode *inode;
203         struct super_block *sb;
204         dev_t s_dev;
205         unsigned int err;
206
207         err = -ENOENT;
208
209         /* Lookup the dentry name at the base of our mount point */
210         dentry = d_lookup(nd->path.dentry, &nd->last);
211         if (!dentry)
212                 goto out;
213
214         dput(nd->path.dentry);
215         nd->path.dentry = dentry;
216
217         /* And follow the mount stack looking for our autofs mount */
218         while (follow_down(&nd->path.mnt, &nd->path.dentry)) {
219                 inode = nd->path.dentry->d_inode;
220                 if (!inode)
221                         break;
222
223                 sb = inode->i_sb;
224                 s_dev = new_encode_dev(sb->s_dev);
225                 if (devno == s_dev) {
226                         if (sb->s_magic == AUTOFS_SUPER_MAGIC) {
227                                 err = 0;
228                                 break;
229                         }
230                 }
231         }
232 out:
233         return err;
234 }
235
236 /*
237  * Walk down the mount stack looking for an autofs mount that
238  * has the requested mount type (ie. indirect, direct or offset).
239  */
240 static int autofs_dev_ioctl_find_sbi_type(struct nameidata *nd, unsigned int type)
241 {
242         struct dentry *dentry;
243         struct autofs_info *ino;
244         unsigned int err;
245
246         err = -ENOENT;
247
248         /* Lookup the dentry name at the base of our mount point */
249         dentry = d_lookup(nd->path.dentry, &nd->last);
250         if (!dentry)
251                 goto out;
252
253         dput(nd->path.dentry);
254         nd->path.dentry = dentry;
255
256         /* And follow the mount stack looking for our autofs mount */
257         while (follow_down(&nd->path.mnt, &nd->path.dentry)) {
258                 ino = autofs4_dentry_ino(nd->path.dentry);
259                 if (ino && ino->sbi->type & type) {
260                         err = 0;
261                         break;
262                 }
263         }
264 out:
265         return err;
266 }
267
268 static void autofs_dev_ioctl_fd_install(unsigned int fd, struct file *file)
269 {
270         struct files_struct *files = current->files;
271         struct fdtable *fdt;
272
273         spin_lock(&files->file_lock);
274         fdt = files_fdtable(files);
275         BUG_ON(fdt->fd[fd] != NULL);
276         rcu_assign_pointer(fdt->fd[fd], file);
277         FD_SET(fd, fdt->close_on_exec);
278         spin_unlock(&files->file_lock);
279 }
280
281
282 /*
283  * Open a file descriptor on the autofs mount point corresponding
284  * to the given path and device number (aka. new_encode_dev(sb->s_dev)).
285  */
286 static int autofs_dev_ioctl_open_mountpoint(const char *path, dev_t devid)
287 {
288         struct file *filp;
289         struct nameidata nd;
290         int err, fd;
291
292         fd = get_unused_fd();
293         if (likely(fd >= 0)) {
294                 /* Get nameidata of the parent directory */
295                 err = path_lookup(path, LOOKUP_PARENT, &nd);
296                 if (err)
297                         goto out;
298
299                 /*
300                  * Search down, within the parent, looking for an
301                  * autofs super block that has the device number
302                  * corresponding to the autofs fs we want to open.
303                  */
304                 err = autofs_dev_ioctl_find_super(&nd, devid);
305                 if (err) {
306                         path_put(&nd.path);
307                         goto out;
308                 }
309
310                 filp = dentry_open(nd.path.dentry, nd.path.mnt, O_RDONLY,
311                                    current_cred());
312                 if (IS_ERR(filp)) {
313                         err = PTR_ERR(filp);
314                         goto out;
315                 }
316
317                 autofs_dev_ioctl_fd_install(fd, filp);
318         }
319
320         return fd;
321
322 out:
323         put_unused_fd(fd);
324         return err;
325 }
326
327 /* Open a file descriptor on an autofs mount point */
328 static int autofs_dev_ioctl_openmount(struct file *fp,
329                                       struct autofs_sb_info *sbi,
330                                       struct autofs_dev_ioctl *param)
331 {
332         const char *path;
333         dev_t devid;
334         int err, fd;
335
336         /* param->path has already been checked */
337         if (!param->openmount.devid)
338                 return -EINVAL;
339
340         param->ioctlfd = -1;
341
342         path = param->path;
343         devid = param->openmount.devid;
344
345         err = 0;
346         fd = autofs_dev_ioctl_open_mountpoint(path, devid);
347         if (unlikely(fd < 0)) {
348                 err = fd;
349                 goto out;
350         }
351
352         param->ioctlfd = fd;
353 out:
354         return err;
355 }
356
357 /* Close file descriptor allocated above (user can also use close(2)). */
358 static int autofs_dev_ioctl_closemount(struct file *fp,
359                                        struct autofs_sb_info *sbi,
360                                        struct autofs_dev_ioctl *param)
361 {
362         return sys_close(param->ioctlfd);
363 }
364
365 /*
366  * Send "ready" status for an existing wait (either a mount or an expire
367  * request).
368  */
369 static int autofs_dev_ioctl_ready(struct file *fp,
370                                   struct autofs_sb_info *sbi,
371                                   struct autofs_dev_ioctl *param)
372 {
373         autofs_wqt_t token;
374
375         token = (autofs_wqt_t) param->ready.token;
376         return autofs4_wait_release(sbi, token, 0);
377 }
378
379 /*
380  * Send "fail" status for an existing wait (either a mount or an expire
381  * request).
382  */
383 static int autofs_dev_ioctl_fail(struct file *fp,
384                                  struct autofs_sb_info *sbi,
385                                  struct autofs_dev_ioctl *param)
386 {
387         autofs_wqt_t token;
388         int status;
389
390         token = (autofs_wqt_t) param->fail.token;
391         status = param->fail.status ? param->fail.status : -ENOENT;
392         return autofs4_wait_release(sbi, token, status);
393 }
394
395 /*
396  * Set the pipe fd for kernel communication to the daemon.
397  *
398  * Normally this is set at mount using an option but if we
399  * are reconnecting to a busy mount then we need to use this
400  * to tell the autofs mount about the new kernel pipe fd. In
401  * order to protect mounts against incorrectly setting the
402  * pipefd we also require that the autofs mount be catatonic.
403  *
404  * This also sets the process group id used to identify the
405  * controlling process (eg. the owning automount(8) daemon).
406  */
407 static int autofs_dev_ioctl_setpipefd(struct file *fp,
408                                       struct autofs_sb_info *sbi,
409                                       struct autofs_dev_ioctl *param)
410 {
411         int pipefd;
412         int err = 0;
413
414         if (param->setpipefd.pipefd == -1)
415                 return -EINVAL;
416
417         pipefd = param->setpipefd.pipefd;
418
419         mutex_lock(&sbi->wq_mutex);
420         if (!sbi->catatonic) {
421                 mutex_unlock(&sbi->wq_mutex);
422                 return -EBUSY;
423         } else {
424                 struct file *pipe = fget(pipefd);
425                 if (!pipe->f_op || !pipe->f_op->write) {
426                         err = -EPIPE;
427                         fput(pipe);
428                         goto out;
429                 }
430                 sbi->oz_pgrp = task_pgrp_nr(current);
431                 sbi->pipefd = pipefd;
432                 sbi->pipe = pipe;
433                 sbi->catatonic = 0;
434         }
435 out:
436         mutex_unlock(&sbi->wq_mutex);
437         return err;
438 }
439
440 /*
441  * Make the autofs mount point catatonic, no longer responsive to
442  * mount requests. Also closes the kernel pipe file descriptor.
443  */
444 static int autofs_dev_ioctl_catatonic(struct file *fp,
445                                       struct autofs_sb_info *sbi,
446                                       struct autofs_dev_ioctl *param)
447 {
448         autofs4_catatonic_mode(sbi);
449         return 0;
450 }
451
452 /* Set the autofs mount timeout */
453 static int autofs_dev_ioctl_timeout(struct file *fp,
454                                     struct autofs_sb_info *sbi,
455                                     struct autofs_dev_ioctl *param)
456 {
457         unsigned long timeout;
458
459         timeout = param->timeout.timeout;
460         param->timeout.timeout = sbi->exp_timeout / HZ;
461         sbi->exp_timeout = timeout * HZ;
462         return 0;
463 }
464
465 /*
466  * Return the uid and gid of the last request for the mount
467  *
468  * When reconstructing an autofs mount tree with active mounts
469  * we need to re-connect to mounts that may have used the original
470  * process uid and gid (or string variations of them) for mount
471  * lookups within the map entry.
472  */
473 static int autofs_dev_ioctl_requester(struct file *fp,
474                                       struct autofs_sb_info *sbi,
475                                       struct autofs_dev_ioctl *param)
476 {
477         struct autofs_info *ino;
478         struct nameidata nd;
479         const char *path;
480         dev_t devid;
481         int err = -ENOENT;
482
483         if (param->size <= sizeof(*param)) {
484                 err = -EINVAL;
485                 goto out;
486         }
487
488         path = param->path;
489         devid = new_encode_dev(sbi->sb->s_dev);
490
491         param->requester.uid = param->requester.gid = -1;
492
493         /* Get nameidata of the parent directory */
494         err = path_lookup(path, LOOKUP_PARENT, &nd);
495         if (err)
496                 goto out;
497
498         err = autofs_dev_ioctl_find_super(&nd, devid);
499         if (err)
500                 goto out_release;
501
502         ino = autofs4_dentry_ino(nd.path.dentry);
503         if (ino) {
504                 err = 0;
505                 autofs4_expire_wait(nd.path.dentry);
506                 spin_lock(&sbi->fs_lock);
507                 param->requester.uid = ino->uid;
508                 param->requester.gid = ino->gid;
509                 spin_unlock(&sbi->fs_lock);
510         }
511
512 out_release:
513         path_put(&nd.path);
514 out:
515         return err;
516 }
517
518 /*
519  * Call repeatedly until it returns -EAGAIN, meaning there's nothing
520  * more that can be done.
521  */
522 static int autofs_dev_ioctl_expire(struct file *fp,
523                                    struct autofs_sb_info *sbi,
524                                    struct autofs_dev_ioctl *param)
525 {
526         struct vfsmount *mnt;
527         int how;
528
529         how = param->expire.how;
530         mnt = fp->f_path.mnt;
531
532         return autofs4_do_expire_multi(sbi->sb, mnt, sbi, how);
533 }
534
535 /* Check if autofs mount point is in use */
536 static int autofs_dev_ioctl_askumount(struct file *fp,
537                                       struct autofs_sb_info *sbi,
538                                       struct autofs_dev_ioctl *param)
539 {
540         param->askumount.may_umount = 0;
541         if (may_umount(fp->f_path.mnt))
542                 param->askumount.may_umount = 1;
543         return 0;
544 }
545
546 /*
547  * Check if the given path is a mountpoint.
548  *
549  * If we are supplied with the file descriptor of an autofs
550  * mount we're looking for a specific mount. In this case
551  * the path is considered a mountpoint if it is itself a
552  * mountpoint or contains a mount, such as a multi-mount
553  * without a root mount. In this case we return 1 if the
554  * path is a mount point and the super magic of the covering
555  * mount if there is one or 0 if it isn't a mountpoint.
556  *
557  * If we aren't supplied with a file descriptor then we
558  * lookup the nameidata of the path and check if it is the
559  * root of a mount. If a type is given we are looking for
560  * a particular autofs mount and if we don't find a match
561  * we return fail. If the located nameidata path is the
562  * root of a mount we return 1 along with the super magic
563  * of the mount or 0 otherwise.
564  *
565  * In both cases the the device number (as returned by
566  * new_encode_dev()) is also returned.
567  */
568 static int autofs_dev_ioctl_ismountpoint(struct file *fp,
569                                          struct autofs_sb_info *sbi,
570                                          struct autofs_dev_ioctl *param)
571 {
572         struct nameidata nd;
573         const char *path;
574         unsigned int type;
575         unsigned int devid, magic;
576         int err = -ENOENT;
577
578         if (param->size <= sizeof(*param)) {
579                 err = -EINVAL;
580                 goto out;
581         }
582
583         path = param->path;
584         type = param->ismountpoint.in.type;
585
586         param->ismountpoint.out.devid = devid = 0;
587         param->ismountpoint.out.magic = magic = 0;
588
589         if (!fp || param->ioctlfd == -1) {
590                 if (autofs_type_any(type)) {
591                         struct super_block *sb;
592
593                         err = path_lookup(path, LOOKUP_FOLLOW, &nd);
594                         if (err)
595                                 goto out;
596
597                         sb = nd.path.dentry->d_sb;
598                         devid = new_encode_dev(sb->s_dev);
599                 } else {
600                         struct autofs_info *ino;
601
602                         err = path_lookup(path, LOOKUP_PARENT, &nd);
603                         if (err)
604                                 goto out;
605
606                         err = autofs_dev_ioctl_find_sbi_type(&nd, type);
607                         if (err)
608                                 goto out_release;
609
610                         ino = autofs4_dentry_ino(nd.path.dentry);
611                         devid = autofs4_get_dev(ino->sbi);
612                 }
613
614                 err = 0;
615                 if (nd.path.dentry->d_inode &&
616                     nd.path.mnt->mnt_root == nd.path.dentry) {
617                         err = 1;
618                         magic = nd.path.dentry->d_inode->i_sb->s_magic;
619                 }
620         } else {
621                 dev_t dev = autofs4_get_dev(sbi);
622
623                 err = path_lookup(path, LOOKUP_PARENT, &nd);
624                 if (err)
625                         goto out;
626
627                 err = autofs_dev_ioctl_find_super(&nd, dev);
628                 if (err)
629                         goto out_release;
630
631                 devid = dev;
632
633                 err = have_submounts(nd.path.dentry);
634
635                 if (nd.path.mnt->mnt_mountpoint != nd.path.mnt->mnt_root) {
636                         if (follow_down(&nd.path.mnt, &nd.path.dentry)) {
637                                 struct inode *inode = nd.path.dentry->d_inode;
638                                 magic = inode->i_sb->s_magic;
639                         }
640                 }
641         }
642
643         param->ismountpoint.out.devid = devid;
644         param->ismountpoint.out.magic = magic;
645
646 out_release:
647         path_put(&nd.path);
648 out:
649         return err;
650 }
651
652 /*
653  * Our range of ioctl numbers isn't 0 based so we need to shift
654  * the array index by _IOC_NR(AUTOFS_CTL_IOC_FIRST) for the table
655  * lookup.
656  */
657 #define cmd_idx(cmd)    (cmd - _IOC_NR(AUTOFS_DEV_IOCTL_IOC_FIRST))
658
659 static ioctl_fn lookup_dev_ioctl(unsigned int cmd)
660 {
661         static struct {
662                 int cmd;
663                 ioctl_fn fn;
664         } _ioctls[] = {
665                 {cmd_idx(AUTOFS_DEV_IOCTL_VERSION_CMD), NULL},
666                 {cmd_idx(AUTOFS_DEV_IOCTL_PROTOVER_CMD),
667                          autofs_dev_ioctl_protover},
668                 {cmd_idx(AUTOFS_DEV_IOCTL_PROTOSUBVER_CMD),
669                          autofs_dev_ioctl_protosubver},
670                 {cmd_idx(AUTOFS_DEV_IOCTL_OPENMOUNT_CMD),
671                          autofs_dev_ioctl_openmount},
672                 {cmd_idx(AUTOFS_DEV_IOCTL_CLOSEMOUNT_CMD),
673                          autofs_dev_ioctl_closemount},
674                 {cmd_idx(AUTOFS_DEV_IOCTL_READY_CMD),
675                          autofs_dev_ioctl_ready},
676                 {cmd_idx(AUTOFS_DEV_IOCTL_FAIL_CMD),
677                          autofs_dev_ioctl_fail},
678                 {cmd_idx(AUTOFS_DEV_IOCTL_SETPIPEFD_CMD),
679                          autofs_dev_ioctl_setpipefd},
680                 {cmd_idx(AUTOFS_DEV_IOCTL_CATATONIC_CMD),
681                          autofs_dev_ioctl_catatonic},
682                 {cmd_idx(AUTOFS_DEV_IOCTL_TIMEOUT_CMD),
683                          autofs_dev_ioctl_timeout},
684                 {cmd_idx(AUTOFS_DEV_IOCTL_REQUESTER_CMD),
685                          autofs_dev_ioctl_requester},
686                 {cmd_idx(AUTOFS_DEV_IOCTL_EXPIRE_CMD),
687                          autofs_dev_ioctl_expire},
688                 {cmd_idx(AUTOFS_DEV_IOCTL_ASKUMOUNT_CMD),
689                          autofs_dev_ioctl_askumount},
690                 {cmd_idx(AUTOFS_DEV_IOCTL_ISMOUNTPOINT_CMD),
691                          autofs_dev_ioctl_ismountpoint}
692         };
693         unsigned int idx = cmd_idx(cmd);
694
695         return (idx >= ARRAY_SIZE(_ioctls)) ? NULL : _ioctls[idx].fn;
696 }
697
698 /* ioctl dispatcher */
699 static int _autofs_dev_ioctl(unsigned int command, struct autofs_dev_ioctl __user *user)
700 {
701         struct autofs_dev_ioctl *param;
702         struct file *fp;
703         struct autofs_sb_info *sbi;
704         unsigned int cmd_first, cmd;
705         ioctl_fn fn = NULL;
706         int err = 0;
707
708         /* only root can play with this */
709         if (!capable(CAP_SYS_ADMIN))
710                 return -EPERM;
711
712         cmd_first = _IOC_NR(AUTOFS_DEV_IOCTL_IOC_FIRST);
713         cmd = _IOC_NR(command);
714
715         if (_IOC_TYPE(command) != _IOC_TYPE(AUTOFS_DEV_IOCTL_IOC_FIRST) ||
716             cmd - cmd_first >= AUTOFS_DEV_IOCTL_IOC_COUNT) {
717                 return -ENOTTY;
718         }
719
720         /* Copy the parameters into kernel space. */
721         param = copy_dev_ioctl(user);
722         if (IS_ERR(param))
723                 return PTR_ERR(param);
724
725         err = validate_dev_ioctl(command, param);
726         if (err)
727                 goto out;
728
729         /* The validate routine above always sets the version */
730         if (cmd == AUTOFS_DEV_IOCTL_VERSION_CMD)
731                 goto done;
732
733         fn = lookup_dev_ioctl(cmd);
734         if (!fn) {
735                 AUTOFS_WARN("unknown command 0x%08x", command);
736                 return -ENOTTY;
737         }
738
739         fp = NULL;
740         sbi = NULL;
741
742         /*
743          * For obvious reasons the openmount can't have a file
744          * descriptor yet. We don't take a reference to the
745          * file during close to allow for immediate release.
746          */
747         if (cmd != AUTOFS_DEV_IOCTL_OPENMOUNT_CMD &&
748             cmd != AUTOFS_DEV_IOCTL_CLOSEMOUNT_CMD) {
749                 fp = fget(param->ioctlfd);
750                 if (!fp) {
751                         if (cmd == AUTOFS_DEV_IOCTL_ISMOUNTPOINT_CMD)
752                                 goto cont;
753                         err = -EBADF;
754                         goto out;
755                 }
756
757                 if (!fp->f_op) {
758                         err = -ENOTTY;
759                         fput(fp);
760                         goto out;
761                 }
762
763                 sbi = autofs_dev_ioctl_sbi(fp);
764                 if (!sbi || sbi->magic != AUTOFS_SBI_MAGIC) {
765                         err = -EINVAL;
766                         fput(fp);
767                         goto out;
768                 }
769
770                 /*
771                  * Admin needs to be able to set the mount catatonic in
772                  * order to be able to perform the re-open.
773                  */
774                 if (!autofs4_oz_mode(sbi) &&
775                     cmd != AUTOFS_DEV_IOCTL_CATATONIC_CMD) {
776                         err = -EACCES;
777                         fput(fp);
778                         goto out;
779                 }
780         }
781 cont:
782         err = fn(fp, sbi, param);
783
784         if (fp)
785                 fput(fp);
786 done:
787         if (err >= 0 && copy_to_user(user, param, AUTOFS_DEV_IOCTL_SIZE))
788                 err = -EFAULT;
789 out:
790         free_dev_ioctl(param);
791         return err;
792 }
793
794 static long autofs_dev_ioctl(struct file *file, uint command, ulong u)
795 {
796         int err;
797         err = _autofs_dev_ioctl(command, (struct autofs_dev_ioctl __user *) u);
798         return (long) err;
799 }
800
801 #ifdef CONFIG_COMPAT
802 static long autofs_dev_ioctl_compat(struct file *file, uint command, ulong u)
803 {
804         return (long) autofs_dev_ioctl(file, command, (ulong) compat_ptr(u));
805 }
806 #else
807 #define autofs_dev_ioctl_compat NULL
808 #endif
809
810 static const struct file_operations _dev_ioctl_fops = {
811         .unlocked_ioctl  = autofs_dev_ioctl,
812         .compat_ioctl = autofs_dev_ioctl_compat,
813         .owner   = THIS_MODULE,
814 };
815
816 static struct miscdevice _autofs_dev_ioctl_misc = {
817         .minor          = MISC_DYNAMIC_MINOR,
818         .name           = AUTOFS_DEVICE_NAME,
819         .fops           = &_dev_ioctl_fops
820 };
821
822 /* Register/deregister misc character device */
823 int autofs_dev_ioctl_init(void)
824 {
825         int r;
826
827         r = misc_register(&_autofs_dev_ioctl_misc);
828         if (r) {
829                 AUTOFS_ERROR("misc_register failed for control device");
830                 return r;
831         }
832
833         return 0;
834 }
835
836 void autofs_dev_ioctl_exit(void)
837 {
838         misc_deregister(&_autofs_dev_ioctl_misc);
839         return;
840 }
841