Merge branch 'power' into release
[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, void *end)
58 {
59         while ((void *) str <= end)
60                 if (!*str++)
61                         return 0;
62         return -EINVAL;
63 }
64
65 /*
66  * Check that the user compiled against correct version of autofs
67  * misc device code.
68  *
69  * As well as checking the version compatibility this always copies
70  * the kernel interface version out.
71  */
72 static int check_dev_ioctl_version(int cmd, struct autofs_dev_ioctl *param)
73 {
74         int err = 0;
75
76         if ((AUTOFS_DEV_IOCTL_VERSION_MAJOR != param->ver_major) ||
77             (AUTOFS_DEV_IOCTL_VERSION_MINOR < param->ver_minor)) {
78                 AUTOFS_WARN("ioctl control interface version mismatch: "
79                      "kernel(%u.%u), user(%u.%u), cmd(%d)",
80                      AUTOFS_DEV_IOCTL_VERSION_MAJOR,
81                      AUTOFS_DEV_IOCTL_VERSION_MINOR,
82                      param->ver_major, param->ver_minor, cmd);
83                 err = -EINVAL;
84         }
85
86         /* Fill in the kernel version. */
87         param->ver_major = AUTOFS_DEV_IOCTL_VERSION_MAJOR;
88         param->ver_minor = AUTOFS_DEV_IOCTL_VERSION_MINOR;
89
90         return err;
91 }
92
93 /*
94  * Copy parameter control struct, including a possible path allocated
95  * at the end of the struct.
96  */
97 static struct autofs_dev_ioctl *copy_dev_ioctl(struct autofs_dev_ioctl __user *in)
98 {
99         struct autofs_dev_ioctl tmp, *ads;
100
101         if (copy_from_user(&tmp, in, sizeof(tmp)))
102                 return ERR_PTR(-EFAULT);
103
104         if (tmp.size < sizeof(tmp))
105                 return ERR_PTR(-EINVAL);
106
107         ads = kmalloc(tmp.size, GFP_KERNEL);
108         if (!ads)
109                 return ERR_PTR(-ENOMEM);
110
111         if (copy_from_user(ads, in, tmp.size)) {
112                 kfree(ads);
113                 return ERR_PTR(-EFAULT);
114         }
115
116         return ads;
117 }
118
119 static inline void free_dev_ioctl(struct autofs_dev_ioctl *param)
120 {
121         kfree(param);
122         return;
123 }
124
125 /*
126  * Check sanity of parameter control fields and if a path is present
127  * check that it has a "/" and is terminated.
128  */
129 static int validate_dev_ioctl(int cmd, struct autofs_dev_ioctl *param)
130 {
131         int err;
132
133         err = check_dev_ioctl_version(cmd, param);
134         if (err) {
135                 AUTOFS_WARN("invalid device control module version "
136                      "supplied for cmd(0x%08x)", cmd);
137                 goto out;
138         }
139
140         if (param->size > sizeof(*param)) {
141                 err = check_name(param->path);
142                 if (err) {
143                         AUTOFS_WARN("invalid path supplied for cmd(0x%08x)",
144                                     cmd);
145                         goto out;
146                 }
147
148                 err = invalid_str(param->path,
149                                  (void *) ((size_t) param + param->size));
150                 if (err) {
151                         AUTOFS_WARN("invalid path supplied for cmd(0x%08x)",
152                                     cmd);
153                         goto out;
154                 }
155         }
156
157         err = 0;
158 out:
159         return err;
160 }
161
162 /*
163  * Get the autofs super block info struct from the file opened on
164  * the autofs mount point.
165  */
166 static struct autofs_sb_info *autofs_dev_ioctl_sbi(struct file *f)
167 {
168         struct autofs_sb_info *sbi = NULL;
169         struct inode *inode;
170
171         if (f) {
172                 inode = f->f_path.dentry->d_inode;
173                 sbi = autofs4_sbi(inode->i_sb);
174         }
175         return sbi;
176 }
177
178 /* Return autofs module protocol version */
179 static int autofs_dev_ioctl_protover(struct file *fp,
180                                      struct autofs_sb_info *sbi,
181                                      struct autofs_dev_ioctl *param)
182 {
183         param->arg1 = sbi->version;
184         return 0;
185 }
186
187 /* Return autofs module protocol sub version */
188 static int autofs_dev_ioctl_protosubver(struct file *fp,
189                                         struct autofs_sb_info *sbi,
190                                         struct autofs_dev_ioctl *param)
191 {
192         param->arg1 = sbi->sub_version;
193         return 0;
194 }
195
196 /*
197  * Walk down the mount stack looking for an autofs mount that
198  * has the requested device number (aka. new_encode_dev(sb->s_dev).
199  */
200 static int autofs_dev_ioctl_find_super(struct nameidata *nd, dev_t devno)
201 {
202         struct dentry *dentry;
203         struct inode *inode;
204         struct super_block *sb;
205         dev_t s_dev;
206         unsigned int err;
207
208         err = -ENOENT;
209
210         /* Lookup the dentry name at the base of our mount point */
211         dentry = d_lookup(nd->path.dentry, &nd->last);
212         if (!dentry)
213                 goto out;
214
215         dput(nd->path.dentry);
216         nd->path.dentry = dentry;
217
218         /* And follow the mount stack looking for our autofs mount */
219         while (follow_down(&nd->path.mnt, &nd->path.dentry)) {
220                 inode = nd->path.dentry->d_inode;
221                 if (!inode)
222                         break;
223
224                 sb = inode->i_sb;
225                 s_dev = new_encode_dev(sb->s_dev);
226                 if (devno == s_dev) {
227                         if (sb->s_magic == AUTOFS_SUPER_MAGIC) {
228                                 err = 0;
229                                 break;
230                         }
231                 }
232         }
233 out:
234         return err;
235 }
236
237 /*
238  * Walk down the mount stack looking for an autofs mount that
239  * has the requested mount type (ie. indirect, direct or offset).
240  */
241 static int autofs_dev_ioctl_find_sbi_type(struct nameidata *nd, unsigned int type)
242 {
243         struct dentry *dentry;
244         struct autofs_info *ino;
245         unsigned int err;
246
247         err = -ENOENT;
248
249         /* Lookup the dentry name at the base of our mount point */
250         dentry = d_lookup(nd->path.dentry, &nd->last);
251         if (!dentry)
252                 goto out;
253
254         dput(nd->path.dentry);
255         nd->path.dentry = dentry;
256
257         /* And follow the mount stack looking for our autofs mount */
258         while (follow_down(&nd->path.mnt, &nd->path.dentry)) {
259                 ino = autofs4_dentry_ino(nd->path.dentry);
260                 if (ino && ino->sbi->type & type) {
261                         err = 0;
262                         break;
263                 }
264         }
265 out:
266         return err;
267 }
268
269 static void autofs_dev_ioctl_fd_install(unsigned int fd, struct file *file)
270 {
271         struct files_struct *files = current->files;
272         struct fdtable *fdt;
273
274         spin_lock(&files->file_lock);
275         fdt = files_fdtable(files);
276         BUG_ON(fdt->fd[fd] != NULL);
277         rcu_assign_pointer(fdt->fd[fd], file);
278         FD_SET(fd, fdt->close_on_exec);
279         spin_unlock(&files->file_lock);
280 }
281
282
283 /*
284  * Open a file descriptor on the autofs mount point corresponding
285  * to the given path and device number (aka. new_encode_dev(sb->s_dev)).
286  */
287 static int autofs_dev_ioctl_open_mountpoint(const char *path, dev_t devid)
288 {
289         struct file *filp;
290         struct nameidata nd;
291         int err, fd;
292
293         fd = get_unused_fd();
294         if (likely(fd >= 0)) {
295                 /* Get nameidata of the parent directory */
296                 err = path_lookup(path, LOOKUP_PARENT, &nd);
297                 if (err)
298                         goto out;
299
300                 /*
301                  * Search down, within the parent, looking for an
302                  * autofs super block that has the device number
303                  * corresponding to the autofs fs we want to open.
304                  */
305                 err = autofs_dev_ioctl_find_super(&nd, devid);
306                 if (err) {
307                         path_put(&nd.path);
308                         goto out;
309                 }
310
311                 filp = dentry_open(nd.path.dentry, nd.path.mnt, O_RDONLY);
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->arg1)
338                 return -EINVAL;
339
340         param->ioctlfd = -1;
341
342         path = param->path;
343         devid = param->arg1;
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->arg1;
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->arg1;
391         status = param->arg2 ? param->arg2 : -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->arg1 == -1)
415                 return -EINVAL;
416
417         pipefd = param->arg1;
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->arg1;
460         param->arg1 = 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 = sbi->sb->s_dev;
490
491         param->arg1 = param->arg2 = -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->arg1 = ino->uid;
508                 param->arg2 = 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 dentry *dentry;
527         struct vfsmount *mnt;
528         int err = -EAGAIN;
529         int how;
530
531         how = param->arg1;
532         mnt = fp->f_path.mnt;
533
534         if (sbi->type & AUTOFS_TYPE_TRIGGER)
535                 dentry = autofs4_expire_direct(sbi->sb, mnt, sbi, how);
536         else
537                 dentry = autofs4_expire_indirect(sbi->sb, mnt, sbi, how);
538
539         if (dentry) {
540                 struct autofs_info *ino = autofs4_dentry_ino(dentry);
541
542                 /*
543                  * This is synchronous because it makes the daemon a
544                  * little easier
545                 */
546                 err = autofs4_wait(sbi, dentry, NFY_EXPIRE);
547
548                 spin_lock(&sbi->fs_lock);
549                 if (ino->flags & AUTOFS_INF_MOUNTPOINT) {
550                         ino->flags &= ~AUTOFS_INF_MOUNTPOINT;
551                         sbi->sb->s_root->d_mounted++;
552                 }
553                 ino->flags &= ~AUTOFS_INF_EXPIRING;
554                 complete_all(&ino->expire_complete);
555                 spin_unlock(&sbi->fs_lock);
556                 dput(dentry);
557         }
558
559         return err;
560 }
561
562 /* Check if autofs mount point is in use */
563 static int autofs_dev_ioctl_askumount(struct file *fp,
564                                       struct autofs_sb_info *sbi,
565                                       struct autofs_dev_ioctl *param)
566 {
567         param->arg1 = 0;
568         if (may_umount(fp->f_path.mnt))
569                 param->arg1 = 1;
570         return 0;
571 }
572
573 /*
574  * Check if the given path is a mountpoint.
575  *
576  * If we are supplied with the file descriptor of an autofs
577  * mount we're looking for a specific mount. In this case
578  * the path is considered a mountpoint if it is itself a
579  * mountpoint or contains a mount, such as a multi-mount
580  * without a root mount. In this case we return 1 if the
581  * path is a mount point and the super magic of the covering
582  * mount if there is one or 0 if it isn't a mountpoint.
583  *
584  * If we aren't supplied with a file descriptor then we
585  * lookup the nameidata of the path and check if it is the
586  * root of a mount. If a type is given we are looking for
587  * a particular autofs mount and if we don't find a match
588  * we return fail. If the located nameidata path is the
589  * root of a mount we return 1 along with the super magic
590  * of the mount or 0 otherwise.
591  *
592  * In both cases the the device number (as returned by
593  * new_encode_dev()) is also returned.
594  */
595 static int autofs_dev_ioctl_ismountpoint(struct file *fp,
596                                          struct autofs_sb_info *sbi,
597                                          struct autofs_dev_ioctl *param)
598 {
599         struct nameidata nd;
600         const char *path;
601         unsigned int type;
602         int err = -ENOENT;
603
604         if (param->size <= sizeof(*param)) {
605                 err = -EINVAL;
606                 goto out;
607         }
608
609         path = param->path;
610         type = param->arg1;
611
612         param->arg1 = 0;
613         param->arg2 = 0;
614
615         if (!fp || param->ioctlfd == -1) {
616                 if (type == AUTOFS_TYPE_ANY) {
617                         struct super_block *sb;
618
619                         err = path_lookup(path, LOOKUP_FOLLOW, &nd);
620                         if (err)
621                                 goto out;
622
623                         sb = nd.path.dentry->d_sb;
624                         param->arg1 = new_encode_dev(sb->s_dev);
625                 } else {
626                         struct autofs_info *ino;
627
628                         err = path_lookup(path, LOOKUP_PARENT, &nd);
629                         if (err)
630                                 goto out;
631
632                         err = autofs_dev_ioctl_find_sbi_type(&nd, type);
633                         if (err)
634                                 goto out_release;
635
636                         ino = autofs4_dentry_ino(nd.path.dentry);
637                         param->arg1 = autofs4_get_dev(ino->sbi);
638                 }
639
640                 err = 0;
641                 if (nd.path.dentry->d_inode &&
642                     nd.path.mnt->mnt_root == nd.path.dentry) {
643                         err = 1;
644                         param->arg2 = nd.path.dentry->d_inode->i_sb->s_magic;
645                 }
646         } else {
647                 dev_t devid = new_encode_dev(sbi->sb->s_dev);
648
649                 err = path_lookup(path, LOOKUP_PARENT, &nd);
650                 if (err)
651                         goto out;
652
653                 err = autofs_dev_ioctl_find_super(&nd, devid);
654                 if (err)
655                         goto out_release;
656
657                 param->arg1 = autofs4_get_dev(sbi);
658
659                 err = have_submounts(nd.path.dentry);
660
661                 if (nd.path.mnt->mnt_mountpoint != nd.path.mnt->mnt_root) {
662                         if (follow_down(&nd.path.mnt, &nd.path.dentry)) {
663                                 struct inode *inode = nd.path.dentry->d_inode;
664                                 param->arg2 = inode->i_sb->s_magic;
665                         }
666                 }
667         }
668
669 out_release:
670         path_put(&nd.path);
671 out:
672         return err;
673 }
674
675 /*
676  * Our range of ioctl numbers isn't 0 based so we need to shift
677  * the array index by _IOC_NR(AUTOFS_CTL_IOC_FIRST) for the table
678  * lookup.
679  */
680 #define cmd_idx(cmd)    (cmd - _IOC_NR(AUTOFS_DEV_IOCTL_IOC_FIRST))
681
682 static ioctl_fn lookup_dev_ioctl(unsigned int cmd)
683 {
684         static struct {
685                 int cmd;
686                 ioctl_fn fn;
687         } _ioctls[] = {
688                 {cmd_idx(AUTOFS_DEV_IOCTL_VERSION_CMD), NULL},
689                 {cmd_idx(AUTOFS_DEV_IOCTL_PROTOVER_CMD),
690                          autofs_dev_ioctl_protover},
691                 {cmd_idx(AUTOFS_DEV_IOCTL_PROTOSUBVER_CMD),
692                          autofs_dev_ioctl_protosubver},
693                 {cmd_idx(AUTOFS_DEV_IOCTL_OPENMOUNT_CMD),
694                          autofs_dev_ioctl_openmount},
695                 {cmd_idx(AUTOFS_DEV_IOCTL_CLOSEMOUNT_CMD),
696                          autofs_dev_ioctl_closemount},
697                 {cmd_idx(AUTOFS_DEV_IOCTL_READY_CMD),
698                          autofs_dev_ioctl_ready},
699                 {cmd_idx(AUTOFS_DEV_IOCTL_FAIL_CMD),
700                          autofs_dev_ioctl_fail},
701                 {cmd_idx(AUTOFS_DEV_IOCTL_SETPIPEFD_CMD),
702                          autofs_dev_ioctl_setpipefd},
703                 {cmd_idx(AUTOFS_DEV_IOCTL_CATATONIC_CMD),
704                          autofs_dev_ioctl_catatonic},
705                 {cmd_idx(AUTOFS_DEV_IOCTL_TIMEOUT_CMD),
706                          autofs_dev_ioctl_timeout},
707                 {cmd_idx(AUTOFS_DEV_IOCTL_REQUESTER_CMD),
708                          autofs_dev_ioctl_requester},
709                 {cmd_idx(AUTOFS_DEV_IOCTL_EXPIRE_CMD),
710                          autofs_dev_ioctl_expire},
711                 {cmd_idx(AUTOFS_DEV_IOCTL_ASKUMOUNT_CMD),
712                          autofs_dev_ioctl_askumount},
713                 {cmd_idx(AUTOFS_DEV_IOCTL_ISMOUNTPOINT_CMD),
714                          autofs_dev_ioctl_ismountpoint}
715         };
716         unsigned int idx = cmd_idx(cmd);
717
718         return (idx >= ARRAY_SIZE(_ioctls)) ? NULL : _ioctls[idx].fn;
719 }
720
721 /* ioctl dispatcher */
722 static int _autofs_dev_ioctl(unsigned int command, struct autofs_dev_ioctl __user *user)
723 {
724         struct autofs_dev_ioctl *param;
725         struct file *fp;
726         struct autofs_sb_info *sbi;
727         unsigned int cmd_first, cmd;
728         ioctl_fn fn = NULL;
729         int err = 0;
730
731         /* only root can play with this */
732         if (!capable(CAP_SYS_ADMIN))
733                 return -EPERM;
734
735         cmd_first = _IOC_NR(AUTOFS_DEV_IOCTL_IOC_FIRST);
736         cmd = _IOC_NR(command);
737
738         if (_IOC_TYPE(command) != _IOC_TYPE(AUTOFS_DEV_IOCTL_IOC_FIRST) ||
739             cmd - cmd_first >= AUTOFS_DEV_IOCTL_IOC_COUNT) {
740                 return -ENOTTY;
741         }
742
743         /* Copy the parameters into kernel space. */
744         param = copy_dev_ioctl(user);
745         if (IS_ERR(param))
746                 return PTR_ERR(param);
747
748         err = validate_dev_ioctl(command, param);
749         if (err)
750                 goto out;
751
752         /* The validate routine above always sets the version */
753         if (cmd == AUTOFS_DEV_IOCTL_VERSION_CMD)
754                 goto done;
755
756         fn = lookup_dev_ioctl(cmd);
757         if (!fn) {
758                 AUTOFS_WARN("unknown command 0x%08x", command);
759                 return -ENOTTY;
760         }
761
762         fp = NULL;
763         sbi = NULL;
764
765         /*
766          * For obvious reasons the openmount can't have a file
767          * descriptor yet. We don't take a reference to the
768          * file during close to allow for immediate release.
769          */
770         if (cmd != AUTOFS_DEV_IOCTL_OPENMOUNT_CMD &&
771             cmd != AUTOFS_DEV_IOCTL_CLOSEMOUNT_CMD) {
772                 fp = fget(param->ioctlfd);
773                 if (!fp) {
774                         if (cmd == AUTOFS_DEV_IOCTL_ISMOUNTPOINT_CMD)
775                                 goto cont;
776                         err = -EBADF;
777                         goto out;
778                 }
779
780                 if (!fp->f_op) {
781                         err = -ENOTTY;
782                         fput(fp);
783                         goto out;
784                 }
785
786                 sbi = autofs_dev_ioctl_sbi(fp);
787                 if (!sbi || sbi->magic != AUTOFS_SBI_MAGIC) {
788                         err = -EINVAL;
789                         fput(fp);
790                         goto out;
791                 }
792
793                 /*
794                  * Admin needs to be able to set the mount catatonic in
795                  * order to be able to perform the re-open.
796                  */
797                 if (!autofs4_oz_mode(sbi) &&
798                     cmd != AUTOFS_DEV_IOCTL_CATATONIC_CMD) {
799                         err = -EACCES;
800                         fput(fp);
801                         goto out;
802                 }
803         }
804 cont:
805         err = fn(fp, sbi, param);
806
807         if (fp)
808                 fput(fp);
809 done:
810         if (err >= 0 && copy_to_user(user, param, AUTOFS_DEV_IOCTL_SIZE))
811                 err = -EFAULT;
812 out:
813         free_dev_ioctl(param);
814         return err;
815 }
816
817 static long autofs_dev_ioctl(struct file *file, uint command, ulong u)
818 {
819         int err;
820         err = _autofs_dev_ioctl(command, (struct autofs_dev_ioctl __user *) u);
821         return (long) err;
822 }
823
824 #ifdef CONFIG_COMPAT
825 static long autofs_dev_ioctl_compat(struct file *file, uint command, ulong u)
826 {
827         return (long) autofs_dev_ioctl(file, command, (ulong) compat_ptr(u));
828 }
829 #else
830 #define autofs_dev_ioctl_compat NULL
831 #endif
832
833 static const struct file_operations _dev_ioctl_fops = {
834         .unlocked_ioctl  = autofs_dev_ioctl,
835         .compat_ioctl = autofs_dev_ioctl_compat,
836         .owner   = THIS_MODULE,
837 };
838
839 static struct miscdevice _autofs_dev_ioctl_misc = {
840         .minor          = MISC_DYNAMIC_MINOR,
841         .name           = AUTOFS_DEVICE_NAME,
842         .fops           = &_dev_ioctl_fops
843 };
844
845 /* Register/deregister misc character device */
846 int autofs_dev_ioctl_init(void)
847 {
848         int r;
849
850         r = misc_register(&_autofs_dev_ioctl_misc);
851         if (r) {
852                 AUTOFS_ERROR("misc_register failed for control device");
853                 return r;
854         }
855
856         return 0;
857 }
858
859 void autofs_dev_ioctl_exit(void)
860 {
861         misc_deregister(&_autofs_dev_ioctl_misc);
862         return;
863 }
864