2 * Copyright 2008 Red Hat, Inc. All rights reserved.
3 * Copyright 2008 Ian Kent <raven@themaw.net>
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.
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/magic.h>
23 #include <linux/dcache.h>
24 #include <linux/uaccess.h>
25 #include <linux/slab.h>
30 * This module implements an interface for routing autofs ioctl control
31 * commands via a miscellaneous device file.
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.
41 #define AUTOFS_DEV_IOCTL_SIZE sizeof(struct autofs_dev_ioctl)
43 typedef int (*ioctl_fn
)(struct file
*, struct autofs_sb_info
*,
44 struct autofs_dev_ioctl
*);
46 static int check_name(const char *name
)
48 if (!strchr(name
, '/'))
54 * Check a string doesn't overrun the chunk of
55 * memory we copied from user land.
57 static int invalid_str(char *str
, size_t size
)
59 if (memchr(str
, 0, size
))
65 * Check that the user compiled against correct version of autofs
68 * As well as checking the version compatibility this always copies
69 * the kernel interface version out.
71 static int check_dev_ioctl_version(int cmd
, struct autofs_dev_ioctl
*param
)
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
);
85 /* Fill in the kernel version. */
86 param
->ver_major
= AUTOFS_DEV_IOCTL_VERSION_MAJOR
;
87 param
->ver_minor
= AUTOFS_DEV_IOCTL_VERSION_MINOR
;
93 * Copy parameter control struct, including a possible path allocated
94 * at the end of the struct.
96 static struct autofs_dev_ioctl
*copy_dev_ioctl(struct autofs_dev_ioctl __user
*in
)
98 struct autofs_dev_ioctl tmp
;
100 if (copy_from_user(&tmp
, in
, sizeof(tmp
)))
101 return ERR_PTR(-EFAULT
);
103 if (tmp
.size
< sizeof(tmp
))
104 return ERR_PTR(-EINVAL
);
106 return memdup_user(in
, tmp
.size
);
109 static inline void free_dev_ioctl(struct autofs_dev_ioctl
*param
)
116 * Check sanity of parameter control fields and if a path is present
117 * check that it is terminated and contains at least one "/".
119 static int validate_dev_ioctl(int cmd
, struct autofs_dev_ioctl
*param
)
123 err
= check_dev_ioctl_version(cmd
, param
);
125 AUTOFS_WARN("invalid device control module version "
126 "supplied for cmd(0x%08x)", cmd
);
130 if (param
->size
> sizeof(*param
)) {
131 err
= invalid_str(param
->path
, param
->size
- sizeof(*param
));
134 "path string terminator missing for cmd(0x%08x)",
139 err
= check_name(param
->path
);
141 AUTOFS_WARN("invalid path supplied for cmd(0x%08x)",
153 * Get the autofs super block info struct from the file opened on
154 * the autofs mount point.
156 static struct autofs_sb_info
*autofs_dev_ioctl_sbi(struct file
*f
)
158 struct autofs_sb_info
*sbi
= NULL
;
162 inode
= f
->f_path
.dentry
->d_inode
;
163 sbi
= autofs4_sbi(inode
->i_sb
);
168 /* Return autofs module protocol version */
169 static int autofs_dev_ioctl_protover(struct file
*fp
,
170 struct autofs_sb_info
*sbi
,
171 struct autofs_dev_ioctl
*param
)
173 param
->protover
.version
= sbi
->version
;
177 /* Return autofs module protocol sub version */
178 static int autofs_dev_ioctl_protosubver(struct file
*fp
,
179 struct autofs_sb_info
*sbi
,
180 struct autofs_dev_ioctl
*param
)
182 param
->protosubver
.sub_version
= sbi
->sub_version
;
186 static int find_autofs_mount(const char *pathname
,
188 int test(struct path
*path
, void *data
),
192 int err
= kern_path(pathname
, 0, &path
);
196 while (path
.dentry
== path
.mnt
->mnt_root
) {
197 if (path
.dentry
->d_sb
->s_magic
== AUTOFS_SUPER_MAGIC
) {
198 if (test(&path
, data
)) {
200 if (!err
) /* already found some */
206 if (!follow_up(&path
))
213 static int test_by_dev(struct path
*path
, void *p
)
215 return path
->dentry
->d_sb
->s_dev
== *(dev_t
*)p
;
218 static int test_by_type(struct path
*path
, void *p
)
220 struct autofs_info
*ino
= autofs4_dentry_ino(path
->dentry
);
221 return ino
&& ino
->sbi
->type
& *(unsigned *)p
;
224 static void autofs_dev_ioctl_fd_install(unsigned int fd
, struct file
*file
)
226 struct files_struct
*files
= current
->files
;
229 spin_lock(&files
->file_lock
);
230 fdt
= files_fdtable(files
);
231 BUG_ON(fdt
->fd
[fd
] != NULL
);
232 rcu_assign_pointer(fdt
->fd
[fd
], file
);
233 __set_close_on_exec(fd
, fdt
);
234 spin_unlock(&files
->file_lock
);
239 * Open a file descriptor on the autofs mount point corresponding
240 * to the given path and device number (aka. new_encode_dev(sb->s_dev)).
242 static int autofs_dev_ioctl_open_mountpoint(const char *name
, dev_t devid
)
246 fd
= get_unused_fd();
247 if (likely(fd
>= 0)) {
251 err
= find_autofs_mount(name
, &path
, test_by_dev
, &devid
);
256 * Find autofs super block that has the device number
257 * corresponding to the autofs fs we want to open.
260 filp
= dentry_open(path
.dentry
, path
.mnt
, O_RDONLY
,
267 autofs_dev_ioctl_fd_install(fd
, filp
);
277 /* Open a file descriptor on an autofs mount point */
278 static int autofs_dev_ioctl_openmount(struct file
*fp
,
279 struct autofs_sb_info
*sbi
,
280 struct autofs_dev_ioctl
*param
)
286 /* param->path has already been checked */
287 if (!param
->openmount
.devid
)
293 devid
= new_decode_dev(param
->openmount
.devid
);
296 fd
= autofs_dev_ioctl_open_mountpoint(path
, devid
);
297 if (unlikely(fd
< 0)) {
307 /* Close file descriptor allocated above (user can also use close(2)). */
308 static int autofs_dev_ioctl_closemount(struct file
*fp
,
309 struct autofs_sb_info
*sbi
,
310 struct autofs_dev_ioctl
*param
)
312 return sys_close(param
->ioctlfd
);
316 * Send "ready" status for an existing wait (either a mount or an expire
319 static int autofs_dev_ioctl_ready(struct file
*fp
,
320 struct autofs_sb_info
*sbi
,
321 struct autofs_dev_ioctl
*param
)
325 token
= (autofs_wqt_t
) param
->ready
.token
;
326 return autofs4_wait_release(sbi
, token
, 0);
330 * Send "fail" status for an existing wait (either a mount or an expire
333 static int autofs_dev_ioctl_fail(struct file
*fp
,
334 struct autofs_sb_info
*sbi
,
335 struct autofs_dev_ioctl
*param
)
340 token
= (autofs_wqt_t
) param
->fail
.token
;
341 status
= param
->fail
.status
? param
->fail
.status
: -ENOENT
;
342 return autofs4_wait_release(sbi
, token
, status
);
346 * Set the pipe fd for kernel communication to the daemon.
348 * Normally this is set at mount using an option but if we
349 * are reconnecting to a busy mount then we need to use this
350 * to tell the autofs mount about the new kernel pipe fd. In
351 * order to protect mounts against incorrectly setting the
352 * pipefd we also require that the autofs mount be catatonic.
354 * This also sets the process group id used to identify the
355 * controlling process (eg. the owning automount(8) daemon).
357 static int autofs_dev_ioctl_setpipefd(struct file
*fp
,
358 struct autofs_sb_info
*sbi
,
359 struct autofs_dev_ioctl
*param
)
364 if (param
->setpipefd
.pipefd
== -1)
367 pipefd
= param
->setpipefd
.pipefd
;
369 mutex_lock(&sbi
->wq_mutex
);
370 if (!sbi
->catatonic
) {
371 mutex_unlock(&sbi
->wq_mutex
);
374 struct file
*pipe
= fget(pipefd
);
379 if (!pipe
->f_op
|| !pipe
->f_op
->write
) {
384 sbi
->oz_pgrp
= task_pgrp_nr(current
);
385 sbi
->pipefd
= pipefd
;
390 mutex_unlock(&sbi
->wq_mutex
);
395 * Make the autofs mount point catatonic, no longer responsive to
396 * mount requests. Also closes the kernel pipe file descriptor.
398 static int autofs_dev_ioctl_catatonic(struct file
*fp
,
399 struct autofs_sb_info
*sbi
,
400 struct autofs_dev_ioctl
*param
)
402 autofs4_catatonic_mode(sbi
);
406 /* Set the autofs mount timeout */
407 static int autofs_dev_ioctl_timeout(struct file
*fp
,
408 struct autofs_sb_info
*sbi
,
409 struct autofs_dev_ioctl
*param
)
411 unsigned long timeout
;
413 timeout
= param
->timeout
.timeout
;
414 param
->timeout
.timeout
= sbi
->exp_timeout
/ HZ
;
415 sbi
->exp_timeout
= timeout
* HZ
;
420 * Return the uid and gid of the last request for the mount
422 * When reconstructing an autofs mount tree with active mounts
423 * we need to re-connect to mounts that may have used the original
424 * process uid and gid (or string variations of them) for mount
425 * lookups within the map entry.
427 static int autofs_dev_ioctl_requester(struct file
*fp
,
428 struct autofs_sb_info
*sbi
,
429 struct autofs_dev_ioctl
*param
)
431 struct autofs_info
*ino
;
436 if (param
->size
<= sizeof(*param
)) {
441 devid
= sbi
->sb
->s_dev
;
443 param
->requester
.uid
= param
->requester
.gid
= -1;
445 err
= find_autofs_mount(param
->path
, &path
, test_by_dev
, &devid
);
449 ino
= autofs4_dentry_ino(path
.dentry
);
452 autofs4_expire_wait(path
.dentry
);
453 spin_lock(&sbi
->fs_lock
);
454 param
->requester
.uid
= ino
->uid
;
455 param
->requester
.gid
= ino
->gid
;
456 spin_unlock(&sbi
->fs_lock
);
464 * Call repeatedly until it returns -EAGAIN, meaning there's nothing
465 * more that can be done.
467 static int autofs_dev_ioctl_expire(struct file
*fp
,
468 struct autofs_sb_info
*sbi
,
469 struct autofs_dev_ioctl
*param
)
471 struct vfsmount
*mnt
;
474 how
= param
->expire
.how
;
475 mnt
= fp
->f_path
.mnt
;
477 return autofs4_do_expire_multi(sbi
->sb
, mnt
, sbi
, how
);
480 /* Check if autofs mount point is in use */
481 static int autofs_dev_ioctl_askumount(struct file
*fp
,
482 struct autofs_sb_info
*sbi
,
483 struct autofs_dev_ioctl
*param
)
485 param
->askumount
.may_umount
= 0;
486 if (may_umount(fp
->f_path
.mnt
))
487 param
->askumount
.may_umount
= 1;
492 * Check if the given path is a mountpoint.
494 * If we are supplied with the file descriptor of an autofs
495 * mount we're looking for a specific mount. In this case
496 * the path is considered a mountpoint if it is itself a
497 * mountpoint or contains a mount, such as a multi-mount
498 * without a root mount. In this case we return 1 if the
499 * path is a mount point and the super magic of the covering
500 * mount if there is one or 0 if it isn't a mountpoint.
502 * If we aren't supplied with a file descriptor then we
503 * lookup the nameidata of the path and check if it is the
504 * root of a mount. If a type is given we are looking for
505 * a particular autofs mount and if we don't find a match
506 * we return fail. If the located nameidata path is the
507 * root of a mount we return 1 along with the super magic
508 * of the mount or 0 otherwise.
510 * In both cases the the device number (as returned by
511 * new_encode_dev()) is also returned.
513 static int autofs_dev_ioctl_ismountpoint(struct file
*fp
,
514 struct autofs_sb_info
*sbi
,
515 struct autofs_dev_ioctl
*param
)
520 unsigned int devid
, magic
;
523 if (param
->size
<= sizeof(*param
)) {
529 type
= param
->ismountpoint
.in
.type
;
531 param
->ismountpoint
.out
.devid
= devid
= 0;
532 param
->ismountpoint
.out
.magic
= magic
= 0;
534 if (!fp
|| param
->ioctlfd
== -1) {
535 if (autofs_type_any(type
))
536 err
= kern_path(name
, LOOKUP_FOLLOW
, &path
);
538 err
= find_autofs_mount(name
, &path
, test_by_type
, &type
);
541 devid
= new_encode_dev(path
.dentry
->d_sb
->s_dev
);
543 if (path
.mnt
->mnt_root
== path
.dentry
) {
545 magic
= path
.dentry
->d_sb
->s_magic
;
548 dev_t dev
= sbi
->sb
->s_dev
;
550 err
= find_autofs_mount(name
, &path
, test_by_dev
, &dev
);
554 devid
= new_encode_dev(dev
);
556 err
= have_submounts(path
.dentry
);
558 if (follow_down_one(&path
))
559 magic
= path
.dentry
->d_sb
->s_magic
;
562 param
->ismountpoint
.out
.devid
= devid
;
563 param
->ismountpoint
.out
.magic
= magic
;
570 * Our range of ioctl numbers isn't 0 based so we need to shift
571 * the array index by _IOC_NR(AUTOFS_CTL_IOC_FIRST) for the table
574 #define cmd_idx(cmd) (cmd - _IOC_NR(AUTOFS_DEV_IOCTL_IOC_FIRST))
576 static ioctl_fn
lookup_dev_ioctl(unsigned int cmd
)
582 {cmd_idx(AUTOFS_DEV_IOCTL_VERSION_CMD
), NULL
},
583 {cmd_idx(AUTOFS_DEV_IOCTL_PROTOVER_CMD
),
584 autofs_dev_ioctl_protover
},
585 {cmd_idx(AUTOFS_DEV_IOCTL_PROTOSUBVER_CMD
),
586 autofs_dev_ioctl_protosubver
},
587 {cmd_idx(AUTOFS_DEV_IOCTL_OPENMOUNT_CMD
),
588 autofs_dev_ioctl_openmount
},
589 {cmd_idx(AUTOFS_DEV_IOCTL_CLOSEMOUNT_CMD
),
590 autofs_dev_ioctl_closemount
},
591 {cmd_idx(AUTOFS_DEV_IOCTL_READY_CMD
),
592 autofs_dev_ioctl_ready
},
593 {cmd_idx(AUTOFS_DEV_IOCTL_FAIL_CMD
),
594 autofs_dev_ioctl_fail
},
595 {cmd_idx(AUTOFS_DEV_IOCTL_SETPIPEFD_CMD
),
596 autofs_dev_ioctl_setpipefd
},
597 {cmd_idx(AUTOFS_DEV_IOCTL_CATATONIC_CMD
),
598 autofs_dev_ioctl_catatonic
},
599 {cmd_idx(AUTOFS_DEV_IOCTL_TIMEOUT_CMD
),
600 autofs_dev_ioctl_timeout
},
601 {cmd_idx(AUTOFS_DEV_IOCTL_REQUESTER_CMD
),
602 autofs_dev_ioctl_requester
},
603 {cmd_idx(AUTOFS_DEV_IOCTL_EXPIRE_CMD
),
604 autofs_dev_ioctl_expire
},
605 {cmd_idx(AUTOFS_DEV_IOCTL_ASKUMOUNT_CMD
),
606 autofs_dev_ioctl_askumount
},
607 {cmd_idx(AUTOFS_DEV_IOCTL_ISMOUNTPOINT_CMD
),
608 autofs_dev_ioctl_ismountpoint
}
610 unsigned int idx
= cmd_idx(cmd
);
612 return (idx
>= ARRAY_SIZE(_ioctls
)) ? NULL
: _ioctls
[idx
].fn
;
615 /* ioctl dispatcher */
616 static int _autofs_dev_ioctl(unsigned int command
, struct autofs_dev_ioctl __user
*user
)
618 struct autofs_dev_ioctl
*param
;
620 struct autofs_sb_info
*sbi
;
621 unsigned int cmd_first
, cmd
;
625 /* only root can play with this */
626 if (!capable(CAP_SYS_ADMIN
))
629 cmd_first
= _IOC_NR(AUTOFS_DEV_IOCTL_IOC_FIRST
);
630 cmd
= _IOC_NR(command
);
632 if (_IOC_TYPE(command
) != _IOC_TYPE(AUTOFS_DEV_IOCTL_IOC_FIRST
) ||
633 cmd
- cmd_first
>= AUTOFS_DEV_IOCTL_IOC_COUNT
) {
637 /* Copy the parameters into kernel space. */
638 param
= copy_dev_ioctl(user
);
640 return PTR_ERR(param
);
642 err
= validate_dev_ioctl(command
, param
);
646 /* The validate routine above always sets the version */
647 if (cmd
== AUTOFS_DEV_IOCTL_VERSION_CMD
)
650 fn
= lookup_dev_ioctl(cmd
);
652 AUTOFS_WARN("unknown command 0x%08x", command
);
660 * For obvious reasons the openmount can't have a file
661 * descriptor yet. We don't take a reference to the
662 * file during close to allow for immediate release.
664 if (cmd
!= AUTOFS_DEV_IOCTL_OPENMOUNT_CMD
&&
665 cmd
!= AUTOFS_DEV_IOCTL_CLOSEMOUNT_CMD
) {
666 fp
= fget(param
->ioctlfd
);
668 if (cmd
== AUTOFS_DEV_IOCTL_ISMOUNTPOINT_CMD
)
680 sbi
= autofs_dev_ioctl_sbi(fp
);
681 if (!sbi
|| sbi
->magic
!= AUTOFS_SBI_MAGIC
) {
688 * Admin needs to be able to set the mount catatonic in
689 * order to be able to perform the re-open.
691 if (!autofs4_oz_mode(sbi
) &&
692 cmd
!= AUTOFS_DEV_IOCTL_CATATONIC_CMD
) {
699 err
= fn(fp
, sbi
, param
);
704 if (err
>= 0 && copy_to_user(user
, param
, AUTOFS_DEV_IOCTL_SIZE
))
707 free_dev_ioctl(param
);
711 static long autofs_dev_ioctl(struct file
*file
, uint command
, ulong u
)
714 err
= _autofs_dev_ioctl(command
, (struct autofs_dev_ioctl __user
*) u
);
719 static long autofs_dev_ioctl_compat(struct file
*file
, uint command
, ulong u
)
721 return (long) autofs_dev_ioctl(file
, command
, (ulong
) compat_ptr(u
));
724 #define autofs_dev_ioctl_compat NULL
727 static const struct file_operations _dev_ioctl_fops
= {
728 .unlocked_ioctl
= autofs_dev_ioctl
,
729 .compat_ioctl
= autofs_dev_ioctl_compat
,
730 .owner
= THIS_MODULE
,
731 .llseek
= noop_llseek
,
734 static struct miscdevice _autofs_dev_ioctl_misc
= {
735 .minor
= AUTOFS_MINOR
,
736 .name
= AUTOFS_DEVICE_NAME
,
737 .fops
= &_dev_ioctl_fops
740 MODULE_ALIAS_MISCDEV(AUTOFS_MINOR
);
741 MODULE_ALIAS("devname:autofs");
743 /* Register/deregister misc character device */
744 int autofs_dev_ioctl_init(void)
748 r
= misc_register(&_autofs_dev_ioctl_misc
);
750 AUTOFS_ERROR("misc_register failed for control device");
757 void autofs_dev_ioctl_exit(void)
759 misc_deregister(&_autofs_dev_ioctl_misc
);