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/smp_lock.h>
23 #include <linux/magic.h>
24 #include <linux/dcache.h>
25 #include <linux/uaccess.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
, void *end
)
59 while ((void *) str
<= end
)
66 * Check that the user compiled against correct version of autofs
69 * As well as checking the version compatibility this always copies
70 * the kernel interface version out.
72 static int check_dev_ioctl_version(int cmd
, struct autofs_dev_ioctl
*param
)
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
);
86 /* Fill in the kernel version. */
87 param
->ver_major
= AUTOFS_DEV_IOCTL_VERSION_MAJOR
;
88 param
->ver_minor
= AUTOFS_DEV_IOCTL_VERSION_MINOR
;
94 * Copy parameter control struct, including a possible path allocated
95 * at the end of the struct.
97 static struct autofs_dev_ioctl
*copy_dev_ioctl(struct autofs_dev_ioctl __user
*in
)
99 struct autofs_dev_ioctl tmp
, *ads
;
101 if (copy_from_user(&tmp
, in
, sizeof(tmp
)))
102 return ERR_PTR(-EFAULT
);
104 if (tmp
.size
< sizeof(tmp
))
105 return ERR_PTR(-EINVAL
);
107 ads
= kmalloc(tmp
.size
, GFP_KERNEL
);
109 return ERR_PTR(-ENOMEM
);
111 if (copy_from_user(ads
, in
, tmp
.size
)) {
113 return ERR_PTR(-EFAULT
);
119 static inline void free_dev_ioctl(struct autofs_dev_ioctl
*param
)
126 * Check sanity of parameter control fields and if a path is present
127 * check that it has a "/" and is terminated.
129 static int validate_dev_ioctl(int cmd
, struct autofs_dev_ioctl
*param
)
133 if (check_dev_ioctl_version(cmd
, param
)) {
134 AUTOFS_WARN("invalid device control module version "
135 "supplied for cmd(0x%08x)", cmd
);
139 if (param
->size
> sizeof(*param
)) {
140 err
= check_name(param
->path
);
142 AUTOFS_WARN("invalid path supplied for cmd(0x%08x)",
147 err
= invalid_str(param
->path
,
148 (void *) ((size_t) param
+ param
->size
));
150 AUTOFS_WARN("invalid path supplied for cmd(0x%08x)",
162 * Get the autofs super block info struct from the file opened on
163 * the autofs mount point.
165 static struct autofs_sb_info
*autofs_dev_ioctl_sbi(struct file
*f
)
167 struct autofs_sb_info
*sbi
= NULL
;
171 inode
= f
->f_path
.dentry
->d_inode
;
172 sbi
= autofs4_sbi(inode
->i_sb
);
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
)
182 param
->arg1
= sbi
->version
;
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
)
191 param
->arg1
= sbi
->sub_version
;
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).
199 static int autofs_dev_ioctl_find_super(struct nameidata
*nd
, dev_t devno
)
201 struct dentry
*dentry
;
203 struct super_block
*sb
;
209 /* Lookup the dentry name at the base of our mount point */
210 dentry
= d_lookup(nd
->path
.dentry
, &nd
->last
);
214 dput(nd
->path
.dentry
);
215 nd
->path
.dentry
= dentry
;
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
;
224 s_dev
= new_encode_dev(sb
->s_dev
);
225 if (devno
== s_dev
) {
226 if (sb
->s_magic
== AUTOFS_SUPER_MAGIC
) {
237 * Walk down the mount stack looking for an autofs mount that
238 * has the requested mount type (ie. indirect, direct or offset).
240 static int autofs_dev_ioctl_find_sbi_type(struct nameidata
*nd
, unsigned int type
)
242 struct dentry
*dentry
;
243 struct autofs_info
*ino
;
248 /* Lookup the dentry name at the base of our mount point */
249 dentry
= d_lookup(nd
->path
.dentry
, &nd
->last
);
253 dput(nd
->path
.dentry
);
254 nd
->path
.dentry
= dentry
;
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
) {
268 static void autofs_dev_ioctl_fd_install(unsigned int fd
, struct file
*file
)
270 struct files_struct
*files
= current
->files
;
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
);
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)).
286 static int autofs_dev_ioctl_open_mountpoint(const char *path
, dev_t devid
)
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
);
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.
304 err
= autofs_dev_ioctl_find_super(&nd
, devid
);
310 filp
= dentry_open(nd
.path
.dentry
, nd
.path
.mnt
, O_RDONLY
);
316 autofs_dev_ioctl_fd_install(fd
, filp
);
326 /* Open a file descriptor on an autofs mount point */
327 static int autofs_dev_ioctl_openmount(struct file
*fp
,
328 struct autofs_sb_info
*sbi
,
329 struct autofs_dev_ioctl
*param
)
335 /* param->path has already been checked */
345 fd
= autofs_dev_ioctl_open_mountpoint(path
, devid
);
346 if (unlikely(fd
< 0)) {
356 /* Close file descriptor allocated above (user can also use close(2)). */
357 static int autofs_dev_ioctl_closemount(struct file
*fp
,
358 struct autofs_sb_info
*sbi
,
359 struct autofs_dev_ioctl
*param
)
361 return sys_close(param
->ioctlfd
);
365 * Send "ready" status for an existing wait (either a mount or an expire
368 static int autofs_dev_ioctl_ready(struct file
*fp
,
369 struct autofs_sb_info
*sbi
,
370 struct autofs_dev_ioctl
*param
)
374 token
= (autofs_wqt_t
) param
->arg1
;
375 return autofs4_wait_release(sbi
, token
, 0);
379 * Send "fail" status for an existing wait (either a mount or an expire
382 static int autofs_dev_ioctl_fail(struct file
*fp
,
383 struct autofs_sb_info
*sbi
,
384 struct autofs_dev_ioctl
*param
)
389 token
= (autofs_wqt_t
) param
->arg1
;
390 status
= param
->arg2
? param
->arg2
: -ENOENT
;
391 return autofs4_wait_release(sbi
, token
, status
);
395 * Set the pipe fd for kernel communication to the daemon.
397 * Normally this is set at mount using an option but if we
398 * are reconnecting to a busy mount then we need to use this
399 * to tell the autofs mount about the new kernel pipe fd. In
400 * order to protect mounts against incorrectly setting the
401 * pipefd we also require that the autofs mount be catatonic.
403 * This also sets the process group id used to identify the
404 * controlling process (eg. the owning automount(8) daemon).
406 static int autofs_dev_ioctl_setpipefd(struct file
*fp
,
407 struct autofs_sb_info
*sbi
,
408 struct autofs_dev_ioctl
*param
)
413 if (param
->arg1
== -1)
416 pipefd
= param
->arg1
;
418 mutex_lock(&sbi
->wq_mutex
);
419 if (!sbi
->catatonic
) {
420 mutex_unlock(&sbi
->wq_mutex
);
423 struct file
*pipe
= fget(pipefd
);
424 if (!pipe
->f_op
|| !pipe
->f_op
->write
) {
429 sbi
->oz_pgrp
= task_pgrp_nr(current
);
430 sbi
->pipefd
= pipefd
;
435 mutex_unlock(&sbi
->wq_mutex
);
440 * Make the autofs mount point catatonic, no longer responsive to
441 * mount requests. Also closes the kernel pipe file descriptor.
443 static int autofs_dev_ioctl_catatonic(struct file
*fp
,
444 struct autofs_sb_info
*sbi
,
445 struct autofs_dev_ioctl
*param
)
447 autofs4_catatonic_mode(sbi
);
451 /* Set the autofs mount timeout */
452 static int autofs_dev_ioctl_timeout(struct file
*fp
,
453 struct autofs_sb_info
*sbi
,
454 struct autofs_dev_ioctl
*param
)
456 unsigned long timeout
;
458 timeout
= param
->arg1
;
459 param
->arg1
= sbi
->exp_timeout
/ HZ
;
460 sbi
->exp_timeout
= timeout
* HZ
;
465 * Return the uid and gid of the last request for the mount
467 * When reconstructing an autofs mount tree with active mounts
468 * we need to re-connect to mounts that may have used the original
469 * process uid and gid (or string variations of them) for mount
470 * lookups within the map entry.
472 static int autofs_dev_ioctl_requester(struct file
*fp
,
473 struct autofs_sb_info
*sbi
,
474 struct autofs_dev_ioctl
*param
)
476 struct autofs_info
*ino
;
482 if (param
->size
<= sizeof(*param
)) {
488 devid
= sbi
->sb
->s_dev
;
490 param
->arg1
= param
->arg2
= -1;
492 /* Get nameidata of the parent directory */
493 err
= path_lookup(path
, LOOKUP_PARENT
, &nd
);
497 err
= autofs_dev_ioctl_find_super(&nd
, devid
);
501 ino
= autofs4_dentry_ino(nd
.path
.dentry
);
504 autofs4_expire_wait(nd
.path
.dentry
);
505 spin_lock(&sbi
->fs_lock
);
506 param
->arg1
= ino
->uid
;
507 param
->arg2
= ino
->gid
;
508 spin_unlock(&sbi
->fs_lock
);
518 * Call repeatedly until it returns -EAGAIN, meaning there's nothing
519 * more that can be done.
521 static int autofs_dev_ioctl_expire(struct file
*fp
,
522 struct autofs_sb_info
*sbi
,
523 struct autofs_dev_ioctl
*param
)
525 struct dentry
*dentry
;
526 struct vfsmount
*mnt
;
531 mnt
= fp
->f_path
.mnt
;
533 if (sbi
->type
& AUTOFS_TYPE_TRIGGER
)
534 dentry
= autofs4_expire_direct(sbi
->sb
, mnt
, sbi
, how
);
536 dentry
= autofs4_expire_indirect(sbi
->sb
, mnt
, sbi
, how
);
539 struct autofs_info
*ino
= autofs4_dentry_ino(dentry
);
542 * This is synchronous because it makes the daemon a
545 err
= autofs4_wait(sbi
, dentry
, NFY_EXPIRE
);
547 spin_lock(&sbi
->fs_lock
);
548 if (ino
->flags
& AUTOFS_INF_MOUNTPOINT
) {
549 ino
->flags
&= ~AUTOFS_INF_MOUNTPOINT
;
550 sbi
->sb
->s_root
->d_mounted
++;
552 ino
->flags
&= ~AUTOFS_INF_EXPIRING
;
553 complete_all(&ino
->expire_complete
);
554 spin_unlock(&sbi
->fs_lock
);
561 /* Check if autofs mount point is in use */
562 static int autofs_dev_ioctl_askumount(struct file
*fp
,
563 struct autofs_sb_info
*sbi
,
564 struct autofs_dev_ioctl
*param
)
567 if (may_umount(fp
->f_path
.mnt
))
573 * Check if the given path is a mountpoint.
575 * If we are supplied with the file descriptor of an autofs
576 * mount we're looking for a specific mount. In this case
577 * the path is considered a mountpoint if it is itself a
578 * mountpoint or contains a mount, such as a multi-mount
579 * without a root mount. In this case we return 1 if the
580 * path is a mount point and the super magic of the covering
581 * mount if there is one or 0 if it isn't a mountpoint.
583 * If we aren't supplied with a file descriptor then we
584 * lookup the nameidata of the path and check if it is the
585 * root of a mount. If a type is given we are looking for
586 * a particular autofs mount and if we don't find a match
587 * we return fail. If the located nameidata path is the
588 * root of a mount we return 1 along with the super magic
589 * of the mount or 0 otherwise.
591 * In both cases the the device number (as returned by
592 * new_encode_dev()) is also returned.
594 static int autofs_dev_ioctl_ismountpoint(struct file
*fp
,
595 struct autofs_sb_info
*sbi
,
596 struct autofs_dev_ioctl
*param
)
603 if (param
->size
<= sizeof(*param
)) {
614 if (!fp
|| param
->ioctlfd
== -1) {
615 if (type
== AUTOFS_TYPE_ANY
) {
616 struct super_block
*sb
;
618 err
= path_lookup(path
, LOOKUP_FOLLOW
, &nd
);
622 sb
= nd
.path
.dentry
->d_sb
;
623 param
->arg1
= new_encode_dev(sb
->s_dev
);
625 struct autofs_info
*ino
;
627 err
= path_lookup(path
, LOOKUP_PARENT
, &nd
);
631 err
= autofs_dev_ioctl_find_sbi_type(&nd
, type
);
635 ino
= autofs4_dentry_ino(nd
.path
.dentry
);
636 param
->arg1
= autofs4_get_dev(ino
->sbi
);
640 if (nd
.path
.dentry
->d_inode
&&
641 nd
.path
.mnt
->mnt_root
== nd
.path
.dentry
) {
643 param
->arg2
= nd
.path
.dentry
->d_inode
->i_sb
->s_magic
;
646 dev_t devid
= new_encode_dev(sbi
->sb
->s_dev
);
648 err
= path_lookup(path
, LOOKUP_PARENT
, &nd
);
652 err
= autofs_dev_ioctl_find_super(&nd
, devid
);
656 param
->arg1
= autofs4_get_dev(sbi
);
658 err
= have_submounts(nd
.path
.dentry
);
660 if (nd
.path
.mnt
->mnt_mountpoint
!= nd
.path
.mnt
->mnt_root
) {
661 if (follow_down(&nd
.path
.mnt
, &nd
.path
.dentry
)) {
662 struct inode
*inode
= nd
.path
.dentry
->d_inode
;
663 param
->arg2
= inode
->i_sb
->s_magic
;
675 * Our range of ioctl numbers isn't 0 based so we need to shift
676 * the array index by _IOC_NR(AUTOFS_CTL_IOC_FIRST) for the table
679 #define cmd_idx(cmd) (cmd - _IOC_NR(AUTOFS_DEV_IOCTL_IOC_FIRST))
681 static ioctl_fn
lookup_dev_ioctl(unsigned int cmd
)
687 {cmd_idx(AUTOFS_DEV_IOCTL_VERSION_CMD
), NULL
},
688 {cmd_idx(AUTOFS_DEV_IOCTL_PROTOVER_CMD
),
689 autofs_dev_ioctl_protover
},
690 {cmd_idx(AUTOFS_DEV_IOCTL_PROTOSUBVER_CMD
),
691 autofs_dev_ioctl_protosubver
},
692 {cmd_idx(AUTOFS_DEV_IOCTL_OPENMOUNT_CMD
),
693 autofs_dev_ioctl_openmount
},
694 {cmd_idx(AUTOFS_DEV_IOCTL_CLOSEMOUNT_CMD
),
695 autofs_dev_ioctl_closemount
},
696 {cmd_idx(AUTOFS_DEV_IOCTL_READY_CMD
),
697 autofs_dev_ioctl_ready
},
698 {cmd_idx(AUTOFS_DEV_IOCTL_FAIL_CMD
),
699 autofs_dev_ioctl_fail
},
700 {cmd_idx(AUTOFS_DEV_IOCTL_SETPIPEFD_CMD
),
701 autofs_dev_ioctl_setpipefd
},
702 {cmd_idx(AUTOFS_DEV_IOCTL_CATATONIC_CMD
),
703 autofs_dev_ioctl_catatonic
},
704 {cmd_idx(AUTOFS_DEV_IOCTL_TIMEOUT_CMD
),
705 autofs_dev_ioctl_timeout
},
706 {cmd_idx(AUTOFS_DEV_IOCTL_REQUESTER_CMD
),
707 autofs_dev_ioctl_requester
},
708 {cmd_idx(AUTOFS_DEV_IOCTL_EXPIRE_CMD
),
709 autofs_dev_ioctl_expire
},
710 {cmd_idx(AUTOFS_DEV_IOCTL_ASKUMOUNT_CMD
),
711 autofs_dev_ioctl_askumount
},
712 {cmd_idx(AUTOFS_DEV_IOCTL_ISMOUNTPOINT_CMD
),
713 autofs_dev_ioctl_ismountpoint
}
715 unsigned int idx
= cmd_idx(cmd
);
717 return (idx
>= ARRAY_SIZE(_ioctls
)) ? NULL
: _ioctls
[idx
].fn
;
720 /* ioctl dispatcher */
721 static int _autofs_dev_ioctl(unsigned int command
, struct autofs_dev_ioctl __user
*user
)
723 struct autofs_dev_ioctl
*param
;
725 struct autofs_sb_info
*sbi
;
726 unsigned int cmd_first
, cmd
;
730 /* only root can play with this */
731 if (!capable(CAP_SYS_ADMIN
))
734 cmd_first
= _IOC_NR(AUTOFS_DEV_IOCTL_IOC_FIRST
);
735 cmd
= _IOC_NR(command
);
737 if (_IOC_TYPE(command
) != _IOC_TYPE(AUTOFS_DEV_IOCTL_IOC_FIRST
) ||
738 cmd
- cmd_first
>= AUTOFS_DEV_IOCTL_IOC_COUNT
) {
742 /* Copy the parameters into kernel space. */
743 param
= copy_dev_ioctl(user
);
745 return PTR_ERR(param
);
747 err
= validate_dev_ioctl(command
, param
);
751 /* The validate routine above always sets the version */
752 if (cmd
== AUTOFS_DEV_IOCTL_VERSION_CMD
)
755 fn
= lookup_dev_ioctl(cmd
);
757 AUTOFS_WARN("unknown command 0x%08x", command
);
765 * For obvious reasons the openmount can't have a file
766 * descriptor yet. We don't take a reference to the
767 * file during close to allow for immediate release.
769 if (cmd
!= AUTOFS_DEV_IOCTL_OPENMOUNT_CMD
&&
770 cmd
!= AUTOFS_DEV_IOCTL_CLOSEMOUNT_CMD
) {
771 fp
= fget(param
->ioctlfd
);
773 if (cmd
== AUTOFS_DEV_IOCTL_ISMOUNTPOINT_CMD
)
785 sbi
= autofs_dev_ioctl_sbi(fp
);
786 if (!sbi
|| sbi
->magic
!= AUTOFS_SBI_MAGIC
) {
793 * Admin needs to be able to set the mount catatonic in
794 * order to be able to perform the re-open.
796 if (!autofs4_oz_mode(sbi
) &&
797 cmd
!= AUTOFS_DEV_IOCTL_CATATONIC_CMD
) {
804 err
= fn(fp
, sbi
, param
);
809 if (err
>= 0 && copy_to_user(user
, param
, AUTOFS_DEV_IOCTL_SIZE
))
812 free_dev_ioctl(param
);
816 static long autofs_dev_ioctl(struct file
*file
, uint command
, ulong u
)
819 err
= _autofs_dev_ioctl(command
, (struct autofs_dev_ioctl __user
*) u
);
824 static long autofs_dev_ioctl_compat(struct file
*file
, uint command
, ulong u
)
826 return (long) autofs_dev_ioctl(file
, command
, (ulong
) compat_ptr(u
));
829 #define autofs_dev_ioctl_compat NULL
832 static const struct file_operations _dev_ioctl_fops
= {
833 .unlocked_ioctl
= autofs_dev_ioctl
,
834 .compat_ioctl
= autofs_dev_ioctl_compat
,
835 .owner
= THIS_MODULE
,
838 static struct miscdevice _autofs_dev_ioctl_misc
= {
839 .minor
= MISC_DYNAMIC_MINOR
,
840 .name
= AUTOFS_DEVICE_NAME
,
841 .fops
= &_dev_ioctl_fops
844 /* Register/deregister misc character device */
845 int autofs_dev_ioctl_init(void)
849 r
= misc_register(&_autofs_dev_ioctl_misc
);
851 AUTOFS_ERROR("misc_register failed for control device");
858 void autofs_dev_ioctl_exit(void)
860 misc_deregister(&_autofs_dev_ioctl_misc
);