]> bbs.cooldavid.org Git - net-next-2.6.git/blame - fs/autofs4/dev-ioctl.c
switch rqst_exp_parent()
[net-next-2.6.git] / fs / autofs4 / dev-ioctl.c
CommitLineData
8d7b48e0
IK
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
43typedef int (*ioctl_fn)(struct file *, struct autofs_sb_info *,
44 struct autofs_dev_ioctl *);
45
46static 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 */
3eac8778 57static int invalid_str(char *str, size_t size)
8d7b48e0 58{
3eac8778
AV
59 if (memchr(str, 0, size))
60 return 0;
8d7b48e0
IK
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 */
71static 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 */
96static 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
118static 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
bae8ec66 126 * check that it is terminated and contains at least one "/".
8d7b48e0
IK
127 */
128static int validate_dev_ioctl(int cmd, struct autofs_dev_ioctl *param)
129{
96b03179 130 int err;
8d7b48e0 131
96b03179
IK
132 err = check_dev_ioctl_version(cmd, param);
133 if (err) {
8d7b48e0
IK
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)) {
3eac8778 140 err = invalid_str(param->path, param->size - sizeof(*param));
8d7b48e0 141 if (err) {
bae8ec66
IK
142 AUTOFS_WARN(
143 "path string terminator missing for cmd(0x%08x)",
144 cmd);
8d7b48e0
IK
145 goto out;
146 }
147
bae8ec66 148 err = check_name(param->path);
8d7b48e0
IK
149 if (err) {
150 AUTOFS_WARN("invalid path supplied for cmd(0x%08x)",
151 cmd);
152 goto out;
153 }
154 }
155
156 err = 0;
157out:
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 */
165static 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 */
178static int autofs_dev_ioctl_protover(struct file *fp,
179 struct autofs_sb_info *sbi,
180 struct autofs_dev_ioctl *param)
181{
730c9eec 182 param->protover.version = sbi->version;
8d7b48e0
IK
183 return 0;
184}
185
186/* Return autofs module protocol sub version */
187static int autofs_dev_ioctl_protosubver(struct file *fp,
188 struct autofs_sb_info *sbi,
189 struct autofs_dev_ioctl *param)
190{
730c9eec 191 param->protosubver.sub_version = sbi->sub_version;
8d7b48e0
IK
192 return 0;
193}
194
4e44b685
AV
195static int find_autofs_mount(const char *pathname,
196 struct path *res,
197 int test(struct path *path, void *data),
198 void *data)
8d7b48e0 199{
4e44b685
AV
200 struct path path;
201 int err = kern_path(pathname, 0, &path);
202 if (err)
203 return err;
8d7b48e0 204 err = -ENOENT;
4e44b685
AV
205 while (path.dentry == path.mnt->mnt_root) {
206 if (path.mnt->mnt_sb->s_magic == AUTOFS_SUPER_MAGIC) {
207 if (test(&path, data)) {
208 path_get(&path);
209 if (!err) /* already found some */
210 path_put(res);
211 *res = path;
8d7b48e0 212 err = 0;
8d7b48e0
IK
213 }
214 }
4e44b685
AV
215 if (!follow_up(&path.mnt, &path.dentry))
216 break;
8d7b48e0 217 }
4e44b685 218 path_put(&path);
8d7b48e0
IK
219 return err;
220}
221
4e44b685 222static int test_by_dev(struct path *path, void *p)
8d7b48e0 223{
4e44b685
AV
224 return path->mnt->mnt_sb->s_dev == *(dev_t *)p;
225}
8d7b48e0 226
4e44b685
AV
227static int test_by_type(struct path *path, void *p)
228{
229 struct autofs_info *ino = autofs4_dentry_ino(path->dentry);
230 return ino && ino->sbi->type & *(unsigned *)p;
8d7b48e0
IK
231}
232
233static void autofs_dev_ioctl_fd_install(unsigned int fd, struct file *file)
234{
235 struct files_struct *files = current->files;
236 struct fdtable *fdt;
237
238 spin_lock(&files->file_lock);
239 fdt = files_fdtable(files);
240 BUG_ON(fdt->fd[fd] != NULL);
241 rcu_assign_pointer(fdt->fd[fd], file);
242 FD_SET(fd, fdt->close_on_exec);
243 spin_unlock(&files->file_lock);
244}
245
246
247/*
248 * Open a file descriptor on the autofs mount point corresponding
249 * to the given path and device number (aka. new_encode_dev(sb->s_dev)).
250 */
4e44b685 251static int autofs_dev_ioctl_open_mountpoint(const char *name, dev_t devid)
8d7b48e0 252{
8d7b48e0
IK
253 int err, fd;
254
255 fd = get_unused_fd();
256 if (likely(fd >= 0)) {
4e44b685
AV
257 struct file *filp;
258 struct path path;
259
260 err = find_autofs_mount(name, &path, test_by_dev, &devid);
8d7b48e0
IK
261 if (err)
262 goto out;
263
264 /*
4e44b685 265 * Find autofs super block that has the device number
8d7b48e0
IK
266 * corresponding to the autofs fs we want to open.
267 */
8d7b48e0 268
4e44b685 269 filp = dentry_open(path.dentry, path.mnt, O_RDONLY,
745ca247 270 current_cred());
8d7b48e0
IK
271 if (IS_ERR(filp)) {
272 err = PTR_ERR(filp);
273 goto out;
274 }
275
276 autofs_dev_ioctl_fd_install(fd, filp);
277 }
278
279 return fd;
280
281out:
282 put_unused_fd(fd);
283 return err;
284}
285
286/* Open a file descriptor on an autofs mount point */
287static int autofs_dev_ioctl_openmount(struct file *fp,
288 struct autofs_sb_info *sbi,
289 struct autofs_dev_ioctl *param)
290{
291 const char *path;
292 dev_t devid;
293 int err, fd;
294
295 /* param->path has already been checked */
730c9eec 296 if (!param->openmount.devid)
8d7b48e0
IK
297 return -EINVAL;
298
299 param->ioctlfd = -1;
300
301 path = param->path;
4e44b685 302 devid = new_decode_dev(param->openmount.devid);
8d7b48e0
IK
303
304 err = 0;
305 fd = autofs_dev_ioctl_open_mountpoint(path, devid);
306 if (unlikely(fd < 0)) {
307 err = fd;
308 goto out;
309 }
310
311 param->ioctlfd = fd;
312out:
313 return err;
314}
315
316/* Close file descriptor allocated above (user can also use close(2)). */
317static int autofs_dev_ioctl_closemount(struct file *fp,
318 struct autofs_sb_info *sbi,
319 struct autofs_dev_ioctl *param)
320{
321 return sys_close(param->ioctlfd);
322}
323
324/*
325 * Send "ready" status for an existing wait (either a mount or an expire
326 * request).
327 */
328static int autofs_dev_ioctl_ready(struct file *fp,
329 struct autofs_sb_info *sbi,
330 struct autofs_dev_ioctl *param)
331{
332 autofs_wqt_t token;
333
730c9eec 334 token = (autofs_wqt_t) param->ready.token;
8d7b48e0
IK
335 return autofs4_wait_release(sbi, token, 0);
336}
337
338/*
339 * Send "fail" status for an existing wait (either a mount or an expire
340 * request).
341 */
342static int autofs_dev_ioctl_fail(struct file *fp,
343 struct autofs_sb_info *sbi,
344 struct autofs_dev_ioctl *param)
345{
346 autofs_wqt_t token;
347 int status;
348
730c9eec
IK
349 token = (autofs_wqt_t) param->fail.token;
350 status = param->fail.status ? param->fail.status : -ENOENT;
8d7b48e0
IK
351 return autofs4_wait_release(sbi, token, status);
352}
353
354/*
355 * Set the pipe fd for kernel communication to the daemon.
356 *
357 * Normally this is set at mount using an option but if we
358 * are reconnecting to a busy mount then we need to use this
359 * to tell the autofs mount about the new kernel pipe fd. In
360 * order to protect mounts against incorrectly setting the
361 * pipefd we also require that the autofs mount be catatonic.
362 *
363 * This also sets the process group id used to identify the
364 * controlling process (eg. the owning automount(8) daemon).
365 */
366static int autofs_dev_ioctl_setpipefd(struct file *fp,
367 struct autofs_sb_info *sbi,
368 struct autofs_dev_ioctl *param)
369{
370 int pipefd;
371 int err = 0;
372
730c9eec 373 if (param->setpipefd.pipefd == -1)
8d7b48e0
IK
374 return -EINVAL;
375
730c9eec 376 pipefd = param->setpipefd.pipefd;
8d7b48e0
IK
377
378 mutex_lock(&sbi->wq_mutex);
379 if (!sbi->catatonic) {
380 mutex_unlock(&sbi->wq_mutex);
381 return -EBUSY;
382 } else {
383 struct file *pipe = fget(pipefd);
384 if (!pipe->f_op || !pipe->f_op->write) {
385 err = -EPIPE;
386 fput(pipe);
387 goto out;
388 }
389 sbi->oz_pgrp = task_pgrp_nr(current);
390 sbi->pipefd = pipefd;
391 sbi->pipe = pipe;
392 sbi->catatonic = 0;
393 }
394out:
395 mutex_unlock(&sbi->wq_mutex);
396 return err;
397}
398
399/*
400 * Make the autofs mount point catatonic, no longer responsive to
401 * mount requests. Also closes the kernel pipe file descriptor.
402 */
403static int autofs_dev_ioctl_catatonic(struct file *fp,
404 struct autofs_sb_info *sbi,
405 struct autofs_dev_ioctl *param)
406{
407 autofs4_catatonic_mode(sbi);
408 return 0;
409}
410
411/* Set the autofs mount timeout */
412static int autofs_dev_ioctl_timeout(struct file *fp,
413 struct autofs_sb_info *sbi,
414 struct autofs_dev_ioctl *param)
415{
416 unsigned long timeout;
417
730c9eec
IK
418 timeout = param->timeout.timeout;
419 param->timeout.timeout = sbi->exp_timeout / HZ;
8d7b48e0
IK
420 sbi->exp_timeout = timeout * HZ;
421 return 0;
422}
423
424/*
425 * Return the uid and gid of the last request for the mount
426 *
427 * When reconstructing an autofs mount tree with active mounts
428 * we need to re-connect to mounts that may have used the original
429 * process uid and gid (or string variations of them) for mount
430 * lookups within the map entry.
431 */
432static int autofs_dev_ioctl_requester(struct file *fp,
433 struct autofs_sb_info *sbi,
434 struct autofs_dev_ioctl *param)
435{
436 struct autofs_info *ino;
4e44b685 437 struct path path;
8d7b48e0
IK
438 dev_t devid;
439 int err = -ENOENT;
440
441 if (param->size <= sizeof(*param)) {
442 err = -EINVAL;
443 goto out;
444 }
445
4e44b685 446 devid = sbi->sb->s_dev;
8d7b48e0 447
730c9eec 448 param->requester.uid = param->requester.gid = -1;
8d7b48e0 449
4e44b685 450 err = find_autofs_mount(param->path, &path, test_by_dev, &devid);
8d7b48e0
IK
451 if (err)
452 goto out;
453
4e44b685 454 ino = autofs4_dentry_ino(path.dentry);
8d7b48e0
IK
455 if (ino) {
456 err = 0;
4e44b685 457 autofs4_expire_wait(path.dentry);
8d7b48e0 458 spin_lock(&sbi->fs_lock);
730c9eec
IK
459 param->requester.uid = ino->uid;
460 param->requester.gid = ino->gid;
8d7b48e0
IK
461 spin_unlock(&sbi->fs_lock);
462 }
4e44b685 463 path_put(&path);
8d7b48e0
IK
464out:
465 return err;
466}
467
468/*
469 * Call repeatedly until it returns -EAGAIN, meaning there's nothing
470 * more that can be done.
471 */
472static int autofs_dev_ioctl_expire(struct file *fp,
473 struct autofs_sb_info *sbi,
474 struct autofs_dev_ioctl *param)
475{
8d7b48e0 476 struct vfsmount *mnt;
8d7b48e0
IK
477 int how;
478
730c9eec 479 how = param->expire.how;
8d7b48e0
IK
480 mnt = fp->f_path.mnt;
481
56fcef75 482 return autofs4_do_expire_multi(sbi->sb, mnt, sbi, how);
8d7b48e0
IK
483}
484
485/* Check if autofs mount point is in use */
486static int autofs_dev_ioctl_askumount(struct file *fp,
487 struct autofs_sb_info *sbi,
488 struct autofs_dev_ioctl *param)
489{
730c9eec 490 param->askumount.may_umount = 0;
8d7b48e0 491 if (may_umount(fp->f_path.mnt))
730c9eec 492 param->askumount.may_umount = 1;
8d7b48e0
IK
493 return 0;
494}
495
496/*
497 * Check if the given path is a mountpoint.
498 *
499 * If we are supplied with the file descriptor of an autofs
500 * mount we're looking for a specific mount. In this case
501 * the path is considered a mountpoint if it is itself a
502 * mountpoint or contains a mount, such as a multi-mount
503 * without a root mount. In this case we return 1 if the
504 * path is a mount point and the super magic of the covering
505 * mount if there is one or 0 if it isn't a mountpoint.
506 *
507 * If we aren't supplied with a file descriptor then we
508 * lookup the nameidata of the path and check if it is the
509 * root of a mount. If a type is given we are looking for
510 * a particular autofs mount and if we don't find a match
511 * we return fail. If the located nameidata path is the
512 * root of a mount we return 1 along with the super magic
513 * of the mount or 0 otherwise.
514 *
515 * In both cases the the device number (as returned by
516 * new_encode_dev()) is also returned.
517 */
518static int autofs_dev_ioctl_ismountpoint(struct file *fp,
519 struct autofs_sb_info *sbi,
520 struct autofs_dev_ioctl *param)
521{
4e44b685
AV
522 struct path path;
523 const char *name;
8d7b48e0 524 unsigned int type;
730c9eec 525 unsigned int devid, magic;
8d7b48e0
IK
526 int err = -ENOENT;
527
528 if (param->size <= sizeof(*param)) {
529 err = -EINVAL;
530 goto out;
531 }
532
4e44b685 533 name = param->path;
730c9eec 534 type = param->ismountpoint.in.type;
8d7b48e0 535
730c9eec
IK
536 param->ismountpoint.out.devid = devid = 0;
537 param->ismountpoint.out.magic = magic = 0;
8d7b48e0
IK
538
539 if (!fp || param->ioctlfd == -1) {
4e44b685
AV
540 if (autofs_type_any(type))
541 err = kern_path(name, LOOKUP_FOLLOW, &path);
542 else
543 err = find_autofs_mount(name, &path, test_by_type, &type);
544 if (err)
545 goto out;
546 devid = new_encode_dev(path.mnt->mnt_sb->s_dev);
8d7b48e0 547 err = 0;
4e44b685
AV
548 if (path.dentry->d_inode &&
549 path.mnt->mnt_root == path.dentry) {
8d7b48e0 550 err = 1;
4e44b685 551 magic = path.dentry->d_inode->i_sb->s_magic;
8d7b48e0
IK
552 }
553 } else {
4e44b685 554 dev_t dev = sbi->sb->s_dev;
8d7b48e0 555
4e44b685 556 err = find_autofs_mount(name, &path, test_by_dev, &dev);
8d7b48e0
IK
557 if (err)
558 goto out;
559
4e44b685 560 devid = new_encode_dev(dev);
8d7b48e0 561
4e44b685 562 err = have_submounts(path.dentry);
8d7b48e0 563
4e44b685
AV
564 if (path.mnt->mnt_mountpoint != path.mnt->mnt_root) {
565 if (follow_down(&path.mnt, &path.dentry))
566 magic = path.mnt->mnt_sb->s_magic;
8d7b48e0
IK
567 }
568 }
569
730c9eec
IK
570 param->ismountpoint.out.devid = devid;
571 param->ismountpoint.out.magic = magic;
4e44b685 572 path_put(&path);
8d7b48e0
IK
573out:
574 return err;
575}
576
577/*
578 * Our range of ioctl numbers isn't 0 based so we need to shift
579 * the array index by _IOC_NR(AUTOFS_CTL_IOC_FIRST) for the table
580 * lookup.
581 */
582#define cmd_idx(cmd) (cmd - _IOC_NR(AUTOFS_DEV_IOCTL_IOC_FIRST))
583
584static ioctl_fn lookup_dev_ioctl(unsigned int cmd)
585{
586 static struct {
587 int cmd;
588 ioctl_fn fn;
589 } _ioctls[] = {
590 {cmd_idx(AUTOFS_DEV_IOCTL_VERSION_CMD), NULL},
591 {cmd_idx(AUTOFS_DEV_IOCTL_PROTOVER_CMD),
592 autofs_dev_ioctl_protover},
593 {cmd_idx(AUTOFS_DEV_IOCTL_PROTOSUBVER_CMD),
594 autofs_dev_ioctl_protosubver},
595 {cmd_idx(AUTOFS_DEV_IOCTL_OPENMOUNT_CMD),
596 autofs_dev_ioctl_openmount},
597 {cmd_idx(AUTOFS_DEV_IOCTL_CLOSEMOUNT_CMD),
598 autofs_dev_ioctl_closemount},
599 {cmd_idx(AUTOFS_DEV_IOCTL_READY_CMD),
600 autofs_dev_ioctl_ready},
601 {cmd_idx(AUTOFS_DEV_IOCTL_FAIL_CMD),
602 autofs_dev_ioctl_fail},
603 {cmd_idx(AUTOFS_DEV_IOCTL_SETPIPEFD_CMD),
604 autofs_dev_ioctl_setpipefd},
605 {cmd_idx(AUTOFS_DEV_IOCTL_CATATONIC_CMD),
606 autofs_dev_ioctl_catatonic},
607 {cmd_idx(AUTOFS_DEV_IOCTL_TIMEOUT_CMD),
608 autofs_dev_ioctl_timeout},
609 {cmd_idx(AUTOFS_DEV_IOCTL_REQUESTER_CMD),
610 autofs_dev_ioctl_requester},
611 {cmd_idx(AUTOFS_DEV_IOCTL_EXPIRE_CMD),
612 autofs_dev_ioctl_expire},
613 {cmd_idx(AUTOFS_DEV_IOCTL_ASKUMOUNT_CMD),
614 autofs_dev_ioctl_askumount},
615 {cmd_idx(AUTOFS_DEV_IOCTL_ISMOUNTPOINT_CMD),
616 autofs_dev_ioctl_ismountpoint}
617 };
618 unsigned int idx = cmd_idx(cmd);
619
620 return (idx >= ARRAY_SIZE(_ioctls)) ? NULL : _ioctls[idx].fn;
621}
622
623/* ioctl dispatcher */
624static int _autofs_dev_ioctl(unsigned int command, struct autofs_dev_ioctl __user *user)
625{
626 struct autofs_dev_ioctl *param;
627 struct file *fp;
628 struct autofs_sb_info *sbi;
629 unsigned int cmd_first, cmd;
630 ioctl_fn fn = NULL;
631 int err = 0;
632
633 /* only root can play with this */
634 if (!capable(CAP_SYS_ADMIN))
635 return -EPERM;
636
637 cmd_first = _IOC_NR(AUTOFS_DEV_IOCTL_IOC_FIRST);
638 cmd = _IOC_NR(command);
639
640 if (_IOC_TYPE(command) != _IOC_TYPE(AUTOFS_DEV_IOCTL_IOC_FIRST) ||
641 cmd - cmd_first >= AUTOFS_DEV_IOCTL_IOC_COUNT) {
642 return -ENOTTY;
643 }
644
645 /* Copy the parameters into kernel space. */
646 param = copy_dev_ioctl(user);
647 if (IS_ERR(param))
648 return PTR_ERR(param);
649
650 err = validate_dev_ioctl(command, param);
651 if (err)
652 goto out;
653
654 /* The validate routine above always sets the version */
655 if (cmd == AUTOFS_DEV_IOCTL_VERSION_CMD)
656 goto done;
657
658 fn = lookup_dev_ioctl(cmd);
659 if (!fn) {
660 AUTOFS_WARN("unknown command 0x%08x", command);
661 return -ENOTTY;
662 }
663
664 fp = NULL;
665 sbi = NULL;
666
667 /*
668 * For obvious reasons the openmount can't have a file
669 * descriptor yet. We don't take a reference to the
670 * file during close to allow for immediate release.
671 */
672 if (cmd != AUTOFS_DEV_IOCTL_OPENMOUNT_CMD &&
673 cmd != AUTOFS_DEV_IOCTL_CLOSEMOUNT_CMD) {
674 fp = fget(param->ioctlfd);
675 if (!fp) {
676 if (cmd == AUTOFS_DEV_IOCTL_ISMOUNTPOINT_CMD)
677 goto cont;
678 err = -EBADF;
679 goto out;
680 }
681
682 if (!fp->f_op) {
683 err = -ENOTTY;
684 fput(fp);
685 goto out;
686 }
687
688 sbi = autofs_dev_ioctl_sbi(fp);
689 if (!sbi || sbi->magic != AUTOFS_SBI_MAGIC) {
690 err = -EINVAL;
691 fput(fp);
692 goto out;
693 }
694
695 /*
696 * Admin needs to be able to set the mount catatonic in
697 * order to be able to perform the re-open.
698 */
699 if (!autofs4_oz_mode(sbi) &&
700 cmd != AUTOFS_DEV_IOCTL_CATATONIC_CMD) {
701 err = -EACCES;
702 fput(fp);
703 goto out;
704 }
705 }
706cont:
707 err = fn(fp, sbi, param);
708
709 if (fp)
710 fput(fp);
711done:
712 if (err >= 0 && copy_to_user(user, param, AUTOFS_DEV_IOCTL_SIZE))
713 err = -EFAULT;
714out:
715 free_dev_ioctl(param);
716 return err;
717}
718
719static long autofs_dev_ioctl(struct file *file, uint command, ulong u)
720{
721 int err;
722 err = _autofs_dev_ioctl(command, (struct autofs_dev_ioctl __user *) u);
723 return (long) err;
724}
725
726#ifdef CONFIG_COMPAT
727static long autofs_dev_ioctl_compat(struct file *file, uint command, ulong u)
728{
729 return (long) autofs_dev_ioctl(file, command, (ulong) compat_ptr(u));
730}
731#else
732#define autofs_dev_ioctl_compat NULL
733#endif
734
735static const struct file_operations _dev_ioctl_fops = {
736 .unlocked_ioctl = autofs_dev_ioctl,
737 .compat_ioctl = autofs_dev_ioctl_compat,
738 .owner = THIS_MODULE,
739};
740
741static struct miscdevice _autofs_dev_ioctl_misc = {
742 .minor = MISC_DYNAMIC_MINOR,
743 .name = AUTOFS_DEVICE_NAME,
744 .fops = &_dev_ioctl_fops
745};
746
747/* Register/deregister misc character device */
748int autofs_dev_ioctl_init(void)
749{
750 int r;
751
752 r = misc_register(&_autofs_dev_ioctl_misc);
753 if (r) {
754 AUTOFS_ERROR("misc_register failed for control device");
755 return r;
756 }
757
758 return 0;
759}
760
761void autofs_dev_ioctl_exit(void)
762{
763 misc_deregister(&_autofs_dev_ioctl_misc);
764 return;
765}
766