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 is terminated and contains at least one "/".
129 static int validate_dev_ioctl(int cmd
, struct autofs_dev_ioctl
*param
)
133 err
= check_dev_ioctl_version(cmd
, param
);
135 AUTOFS_WARN("invalid device control module version "
136 "supplied for cmd(0x%08x)", cmd
);
140 if (param
->size
> sizeof(*param
)) {
141 err
= invalid_str(param
->path
,
142 (void *) ((size_t) param
+ param
->size
));
145 "path string terminator missing for cmd(0x%08x)",
150 err
= check_name(param
->path
);
152 AUTOFS_WARN("invalid path supplied for cmd(0x%08x)",
164 * Get the autofs super block info struct from the file opened on
165 * the autofs mount point.
167 static struct autofs_sb_info
*autofs_dev_ioctl_sbi(struct file
*f
)
169 struct autofs_sb_info
*sbi
= NULL
;
173 inode
= f
->f_path
.dentry
->d_inode
;
174 sbi
= autofs4_sbi(inode
->i_sb
);
179 /* Return autofs module protocol version */
180 static int autofs_dev_ioctl_protover(struct file
*fp
,
181 struct autofs_sb_info
*sbi
,
182 struct autofs_dev_ioctl
*param
)
184 param
->protover
.version
= sbi
->version
;
188 /* Return autofs module protocol sub version */
189 static int autofs_dev_ioctl_protosubver(struct file
*fp
,
190 struct autofs_sb_info
*sbi
,
191 struct autofs_dev_ioctl
*param
)
193 param
->protosubver
.sub_version
= sbi
->sub_version
;
198 * Walk down the mount stack looking for an autofs mount that
199 * has the requested device number (aka. new_encode_dev(sb->s_dev).
201 static int autofs_dev_ioctl_find_super(struct nameidata
*nd
, dev_t devno
)
203 struct dentry
*dentry
;
205 struct super_block
*sb
;
211 /* Lookup the dentry name at the base of our mount point */
212 dentry
= d_lookup(nd
->path
.dentry
, &nd
->last
);
216 dput(nd
->path
.dentry
);
217 nd
->path
.dentry
= dentry
;
219 /* And follow the mount stack looking for our autofs mount */
220 while (follow_down(&nd
->path
.mnt
, &nd
->path
.dentry
)) {
221 inode
= nd
->path
.dentry
->d_inode
;
226 s_dev
= new_encode_dev(sb
->s_dev
);
227 if (devno
== s_dev
) {
228 if (sb
->s_magic
== AUTOFS_SUPER_MAGIC
) {
239 * Walk down the mount stack looking for an autofs mount that
240 * has the requested mount type (ie. indirect, direct or offset).
242 static int autofs_dev_ioctl_find_sbi_type(struct nameidata
*nd
, unsigned int type
)
244 struct dentry
*dentry
;
245 struct autofs_info
*ino
;
250 /* Lookup the dentry name at the base of our mount point */
251 dentry
= d_lookup(nd
->path
.dentry
, &nd
->last
);
255 dput(nd
->path
.dentry
);
256 nd
->path
.dentry
= dentry
;
258 /* And follow the mount stack looking for our autofs mount */
259 while (follow_down(&nd
->path
.mnt
, &nd
->path
.dentry
)) {
260 ino
= autofs4_dentry_ino(nd
->path
.dentry
);
261 if (ino
&& ino
->sbi
->type
& type
) {
270 static void autofs_dev_ioctl_fd_install(unsigned int fd
, struct file
*file
)
272 struct files_struct
*files
= current
->files
;
275 spin_lock(&files
->file_lock
);
276 fdt
= files_fdtable(files
);
277 BUG_ON(fdt
->fd
[fd
] != NULL
);
278 rcu_assign_pointer(fdt
->fd
[fd
], file
);
279 FD_SET(fd
, fdt
->close_on_exec
);
280 spin_unlock(&files
->file_lock
);
285 * Open a file descriptor on the autofs mount point corresponding
286 * to the given path and device number (aka. new_encode_dev(sb->s_dev)).
288 static int autofs_dev_ioctl_open_mountpoint(const char *path
, dev_t devid
)
294 fd
= get_unused_fd();
295 if (likely(fd
>= 0)) {
296 /* Get nameidata of the parent directory */
297 err
= path_lookup(path
, LOOKUP_PARENT
, &nd
);
302 * Search down, within the parent, looking for an
303 * autofs super block that has the device number
304 * corresponding to the autofs fs we want to open.
306 err
= autofs_dev_ioctl_find_super(&nd
, devid
);
312 filp
= dentry_open(nd
.path
.dentry
, nd
.path
.mnt
, O_RDONLY
,
319 autofs_dev_ioctl_fd_install(fd
, filp
);
329 /* Open a file descriptor on an autofs mount point */
330 static int autofs_dev_ioctl_openmount(struct file
*fp
,
331 struct autofs_sb_info
*sbi
,
332 struct autofs_dev_ioctl
*param
)
338 /* param->path has already been checked */
339 if (!param
->openmount
.devid
)
345 devid
= param
->openmount
.devid
;
348 fd
= autofs_dev_ioctl_open_mountpoint(path
, devid
);
349 if (unlikely(fd
< 0)) {
359 /* Close file descriptor allocated above (user can also use close(2)). */
360 static int autofs_dev_ioctl_closemount(struct file
*fp
,
361 struct autofs_sb_info
*sbi
,
362 struct autofs_dev_ioctl
*param
)
364 return sys_close(param
->ioctlfd
);
368 * Send "ready" status for an existing wait (either a mount or an expire
371 static int autofs_dev_ioctl_ready(struct file
*fp
,
372 struct autofs_sb_info
*sbi
,
373 struct autofs_dev_ioctl
*param
)
377 token
= (autofs_wqt_t
) param
->ready
.token
;
378 return autofs4_wait_release(sbi
, token
, 0);
382 * Send "fail" status for an existing wait (either a mount or an expire
385 static int autofs_dev_ioctl_fail(struct file
*fp
,
386 struct autofs_sb_info
*sbi
,
387 struct autofs_dev_ioctl
*param
)
392 token
= (autofs_wqt_t
) param
->fail
.token
;
393 status
= param
->fail
.status
? param
->fail
.status
: -ENOENT
;
394 return autofs4_wait_release(sbi
, token
, status
);
398 * Set the pipe fd for kernel communication to the daemon.
400 * Normally this is set at mount using an option but if we
401 * are reconnecting to a busy mount then we need to use this
402 * to tell the autofs mount about the new kernel pipe fd. In
403 * order to protect mounts against incorrectly setting the
404 * pipefd we also require that the autofs mount be catatonic.
406 * This also sets the process group id used to identify the
407 * controlling process (eg. the owning automount(8) daemon).
409 static int autofs_dev_ioctl_setpipefd(struct file
*fp
,
410 struct autofs_sb_info
*sbi
,
411 struct autofs_dev_ioctl
*param
)
416 if (param
->setpipefd
.pipefd
== -1)
419 pipefd
= param
->setpipefd
.pipefd
;
421 mutex_lock(&sbi
->wq_mutex
);
422 if (!sbi
->catatonic
) {
423 mutex_unlock(&sbi
->wq_mutex
);
426 struct file
*pipe
= fget(pipefd
);
427 if (!pipe
->f_op
|| !pipe
->f_op
->write
) {
432 sbi
->oz_pgrp
= task_pgrp_nr(current
);
433 sbi
->pipefd
= pipefd
;
438 mutex_unlock(&sbi
->wq_mutex
);
443 * Make the autofs mount point catatonic, no longer responsive to
444 * mount requests. Also closes the kernel pipe file descriptor.
446 static int autofs_dev_ioctl_catatonic(struct file
*fp
,
447 struct autofs_sb_info
*sbi
,
448 struct autofs_dev_ioctl
*param
)
450 autofs4_catatonic_mode(sbi
);
454 /* Set the autofs mount timeout */
455 static int autofs_dev_ioctl_timeout(struct file
*fp
,
456 struct autofs_sb_info
*sbi
,
457 struct autofs_dev_ioctl
*param
)
459 unsigned long timeout
;
461 timeout
= param
->timeout
.timeout
;
462 param
->timeout
.timeout
= sbi
->exp_timeout
/ HZ
;
463 sbi
->exp_timeout
= timeout
* HZ
;
468 * Return the uid and gid of the last request for the mount
470 * When reconstructing an autofs mount tree with active mounts
471 * we need to re-connect to mounts that may have used the original
472 * process uid and gid (or string variations of them) for mount
473 * lookups within the map entry.
475 static int autofs_dev_ioctl_requester(struct file
*fp
,
476 struct autofs_sb_info
*sbi
,
477 struct autofs_dev_ioctl
*param
)
479 struct autofs_info
*ino
;
485 if (param
->size
<= sizeof(*param
)) {
491 devid
= sbi
->sb
->s_dev
;
493 param
->requester
.uid
= param
->requester
.gid
= -1;
495 /* Get nameidata of the parent directory */
496 err
= path_lookup(path
, LOOKUP_PARENT
, &nd
);
500 err
= autofs_dev_ioctl_find_super(&nd
, devid
);
504 ino
= autofs4_dentry_ino(nd
.path
.dentry
);
507 autofs4_expire_wait(nd
.path
.dentry
);
508 spin_lock(&sbi
->fs_lock
);
509 param
->requester
.uid
= ino
->uid
;
510 param
->requester
.gid
= ino
->gid
;
511 spin_unlock(&sbi
->fs_lock
);
521 * Call repeatedly until it returns -EAGAIN, meaning there's nothing
522 * more that can be done.
524 static int autofs_dev_ioctl_expire(struct file
*fp
,
525 struct autofs_sb_info
*sbi
,
526 struct autofs_dev_ioctl
*param
)
528 struct vfsmount
*mnt
;
531 how
= param
->expire
.how
;
532 mnt
= fp
->f_path
.mnt
;
534 return autofs4_do_expire_multi(sbi
->sb
, mnt
, sbi
, how
);
537 /* Check if autofs mount point is in use */
538 static int autofs_dev_ioctl_askumount(struct file
*fp
,
539 struct autofs_sb_info
*sbi
,
540 struct autofs_dev_ioctl
*param
)
542 param
->askumount
.may_umount
= 0;
543 if (may_umount(fp
->f_path
.mnt
))
544 param
->askumount
.may_umount
= 1;
549 * Check if the given path is a mountpoint.
551 * If we are supplied with the file descriptor of an autofs
552 * mount we're looking for a specific mount. In this case
553 * the path is considered a mountpoint if it is itself a
554 * mountpoint or contains a mount, such as a multi-mount
555 * without a root mount. In this case we return 1 if the
556 * path is a mount point and the super magic of the covering
557 * mount if there is one or 0 if it isn't a mountpoint.
559 * If we aren't supplied with a file descriptor then we
560 * lookup the nameidata of the path and check if it is the
561 * root of a mount. If a type is given we are looking for
562 * a particular autofs mount and if we don't find a match
563 * we return fail. If the located nameidata path is the
564 * root of a mount we return 1 along with the super magic
565 * of the mount or 0 otherwise.
567 * In both cases the the device number (as returned by
568 * new_encode_dev()) is also returned.
570 static int autofs_dev_ioctl_ismountpoint(struct file
*fp
,
571 struct autofs_sb_info
*sbi
,
572 struct autofs_dev_ioctl
*param
)
577 unsigned int devid
, magic
;
580 if (param
->size
<= sizeof(*param
)) {
586 type
= param
->ismountpoint
.in
.type
;
588 param
->ismountpoint
.out
.devid
= devid
= 0;
589 param
->ismountpoint
.out
.magic
= magic
= 0;
591 if (!fp
|| param
->ioctlfd
== -1) {
592 if (autofs_type_any(type
)) {
593 struct super_block
*sb
;
595 err
= path_lookup(path
, LOOKUP_FOLLOW
, &nd
);
599 sb
= nd
.path
.dentry
->d_sb
;
600 devid
= new_encode_dev(sb
->s_dev
);
602 struct autofs_info
*ino
;
604 err
= path_lookup(path
, LOOKUP_PARENT
, &nd
);
608 err
= autofs_dev_ioctl_find_sbi_type(&nd
, type
);
612 ino
= autofs4_dentry_ino(nd
.path
.dentry
);
613 devid
= autofs4_get_dev(ino
->sbi
);
617 if (nd
.path
.dentry
->d_inode
&&
618 nd
.path
.mnt
->mnt_root
== nd
.path
.dentry
) {
620 magic
= nd
.path
.dentry
->d_inode
->i_sb
->s_magic
;
623 dev_t dev
= autofs4_get_dev(sbi
);
625 err
= path_lookup(path
, LOOKUP_PARENT
, &nd
);
629 err
= autofs_dev_ioctl_find_super(&nd
, dev
);
635 err
= have_submounts(nd
.path
.dentry
);
637 if (nd
.path
.mnt
->mnt_mountpoint
!= nd
.path
.mnt
->mnt_root
) {
638 if (follow_down(&nd
.path
.mnt
, &nd
.path
.dentry
)) {
639 struct inode
*inode
= nd
.path
.dentry
->d_inode
;
640 magic
= inode
->i_sb
->s_magic
;
645 param
->ismountpoint
.out
.devid
= devid
;
646 param
->ismountpoint
.out
.magic
= magic
;
655 * Our range of ioctl numbers isn't 0 based so we need to shift
656 * the array index by _IOC_NR(AUTOFS_CTL_IOC_FIRST) for the table
659 #define cmd_idx(cmd) (cmd - _IOC_NR(AUTOFS_DEV_IOCTL_IOC_FIRST))
661 static ioctl_fn
lookup_dev_ioctl(unsigned int cmd
)
667 {cmd_idx(AUTOFS_DEV_IOCTL_VERSION_CMD
), NULL
},
668 {cmd_idx(AUTOFS_DEV_IOCTL_PROTOVER_CMD
),
669 autofs_dev_ioctl_protover
},
670 {cmd_idx(AUTOFS_DEV_IOCTL_PROTOSUBVER_CMD
),
671 autofs_dev_ioctl_protosubver
},
672 {cmd_idx(AUTOFS_DEV_IOCTL_OPENMOUNT_CMD
),
673 autofs_dev_ioctl_openmount
},
674 {cmd_idx(AUTOFS_DEV_IOCTL_CLOSEMOUNT_CMD
),
675 autofs_dev_ioctl_closemount
},
676 {cmd_idx(AUTOFS_DEV_IOCTL_READY_CMD
),
677 autofs_dev_ioctl_ready
},
678 {cmd_idx(AUTOFS_DEV_IOCTL_FAIL_CMD
),
679 autofs_dev_ioctl_fail
},
680 {cmd_idx(AUTOFS_DEV_IOCTL_SETPIPEFD_CMD
),
681 autofs_dev_ioctl_setpipefd
},
682 {cmd_idx(AUTOFS_DEV_IOCTL_CATATONIC_CMD
),
683 autofs_dev_ioctl_catatonic
},
684 {cmd_idx(AUTOFS_DEV_IOCTL_TIMEOUT_CMD
),
685 autofs_dev_ioctl_timeout
},
686 {cmd_idx(AUTOFS_DEV_IOCTL_REQUESTER_CMD
),
687 autofs_dev_ioctl_requester
},
688 {cmd_idx(AUTOFS_DEV_IOCTL_EXPIRE_CMD
),
689 autofs_dev_ioctl_expire
},
690 {cmd_idx(AUTOFS_DEV_IOCTL_ASKUMOUNT_CMD
),
691 autofs_dev_ioctl_askumount
},
692 {cmd_idx(AUTOFS_DEV_IOCTL_ISMOUNTPOINT_CMD
),
693 autofs_dev_ioctl_ismountpoint
}
695 unsigned int idx
= cmd_idx(cmd
);
697 return (idx
>= ARRAY_SIZE(_ioctls
)) ? NULL
: _ioctls
[idx
].fn
;
700 /* ioctl dispatcher */
701 static int _autofs_dev_ioctl(unsigned int command
, struct autofs_dev_ioctl __user
*user
)
703 struct autofs_dev_ioctl
*param
;
705 struct autofs_sb_info
*sbi
;
706 unsigned int cmd_first
, cmd
;
710 /* only root can play with this */
711 if (!capable(CAP_SYS_ADMIN
))
714 cmd_first
= _IOC_NR(AUTOFS_DEV_IOCTL_IOC_FIRST
);
715 cmd
= _IOC_NR(command
);
717 if (_IOC_TYPE(command
) != _IOC_TYPE(AUTOFS_DEV_IOCTL_IOC_FIRST
) ||
718 cmd
- cmd_first
>= AUTOFS_DEV_IOCTL_IOC_COUNT
) {
722 /* Copy the parameters into kernel space. */
723 param
= copy_dev_ioctl(user
);
725 return PTR_ERR(param
);
727 err
= validate_dev_ioctl(command
, param
);
731 /* The validate routine above always sets the version */
732 if (cmd
== AUTOFS_DEV_IOCTL_VERSION_CMD
)
735 fn
= lookup_dev_ioctl(cmd
);
737 AUTOFS_WARN("unknown command 0x%08x", command
);
745 * For obvious reasons the openmount can't have a file
746 * descriptor yet. We don't take a reference to the
747 * file during close to allow for immediate release.
749 if (cmd
!= AUTOFS_DEV_IOCTL_OPENMOUNT_CMD
&&
750 cmd
!= AUTOFS_DEV_IOCTL_CLOSEMOUNT_CMD
) {
751 fp
= fget(param
->ioctlfd
);
753 if (cmd
== AUTOFS_DEV_IOCTL_ISMOUNTPOINT_CMD
)
765 sbi
= autofs_dev_ioctl_sbi(fp
);
766 if (!sbi
|| sbi
->magic
!= AUTOFS_SBI_MAGIC
) {
773 * Admin needs to be able to set the mount catatonic in
774 * order to be able to perform the re-open.
776 if (!autofs4_oz_mode(sbi
) &&
777 cmd
!= AUTOFS_DEV_IOCTL_CATATONIC_CMD
) {
784 err
= fn(fp
, sbi
, param
);
789 if (err
>= 0 && copy_to_user(user
, param
, AUTOFS_DEV_IOCTL_SIZE
))
792 free_dev_ioctl(param
);
796 static long autofs_dev_ioctl(struct file
*file
, uint command
, ulong u
)
799 err
= _autofs_dev_ioctl(command
, (struct autofs_dev_ioctl __user
*) u
);
804 static long autofs_dev_ioctl_compat(struct file
*file
, uint command
, ulong u
)
806 return (long) autofs_dev_ioctl(file
, command
, (ulong
) compat_ptr(u
));
809 #define autofs_dev_ioctl_compat NULL
812 static const struct file_operations _dev_ioctl_fops
= {
813 .unlocked_ioctl
= autofs_dev_ioctl
,
814 .compat_ioctl
= autofs_dev_ioctl_compat
,
815 .owner
= THIS_MODULE
,
818 static struct miscdevice _autofs_dev_ioctl_misc
= {
819 .minor
= MISC_DYNAMIC_MINOR
,
820 .name
= AUTOFS_DEVICE_NAME
,
821 .fops
= &_dev_ioctl_fops
824 /* Register/deregister misc character device */
825 int autofs_dev_ioctl_init(void)
829 r
= misc_register(&_autofs_dev_ioctl_misc
);
831 AUTOFS_ERROR("misc_register failed for control device");
838 void autofs_dev_ioctl_exit(void)
840 misc_deregister(&_autofs_dev_ioctl_misc
);