1 /* -*- c -*- --------------------------------------------------------------- *
3 * linux/fs/autofs/root.c
5 * Copyright 1997-1998 Transmeta Corporation -- All Rights Reserved
6 * Copyright 1999-2000 Jeremy Fitzhardinge <jeremy@goop.org>
7 * Copyright 2001-2003 Ian Kent <raven@themaw.net>
9 * This file is part of the Linux kernel and is made available under
10 * the terms of the GNU General Public License, version 2, or at your
11 * option, any later version, incorporated herein by reference.
13 * ------------------------------------------------------------------------- */
15 #include <linux/capability.h>
16 #include <linux/errno.h>
17 #include <linux/stat.h>
18 #include <linux/param.h>
19 #include <linux/time.h>
20 #include <linux/smp_lock.h>
23 static int autofs4_dir_symlink(struct inode
*,struct dentry
*,const char *);
24 static int autofs4_dir_unlink(struct inode
*,struct dentry
*);
25 static int autofs4_dir_rmdir(struct inode
*,struct dentry
*);
26 static int autofs4_dir_mkdir(struct inode
*,struct dentry
*,int);
27 static int autofs4_root_ioctl(struct inode
*, struct file
*,unsigned int,unsigned long);
28 static int autofs4_dir_open(struct inode
*inode
, struct file
*file
);
29 static int autofs4_dir_close(struct inode
*inode
, struct file
*file
);
30 static int autofs4_dir_readdir(struct file
* filp
, void * dirent
, filldir_t filldir
);
31 static int autofs4_root_readdir(struct file
* filp
, void * dirent
, filldir_t filldir
);
32 static struct dentry
*autofs4_lookup(struct inode
*,struct dentry
*, struct nameidata
*);
34 struct file_operations autofs4_root_operations
= {
35 .open
= dcache_dir_open
,
36 .release
= dcache_dir_close
,
37 .read
= generic_read_dir
,
38 .readdir
= autofs4_root_readdir
,
39 .ioctl
= autofs4_root_ioctl
,
42 struct file_operations autofs4_dir_operations
= {
43 .open
= autofs4_dir_open
,
44 .release
= autofs4_dir_close
,
45 .read
= generic_read_dir
,
46 .readdir
= autofs4_dir_readdir
,
49 struct inode_operations autofs4_root_inode_operations
= {
50 .lookup
= autofs4_lookup
,
51 .unlink
= autofs4_dir_unlink
,
52 .symlink
= autofs4_dir_symlink
,
53 .mkdir
= autofs4_dir_mkdir
,
54 .rmdir
= autofs4_dir_rmdir
,
57 struct inode_operations autofs4_dir_inode_operations
= {
58 .lookup
= autofs4_lookup
,
59 .unlink
= autofs4_dir_unlink
,
60 .symlink
= autofs4_dir_symlink
,
61 .mkdir
= autofs4_dir_mkdir
,
62 .rmdir
= autofs4_dir_rmdir
,
65 static int autofs4_root_readdir(struct file
*file
, void *dirent
,
68 struct autofs_sb_info
*sbi
= autofs4_sbi(file
->f_dentry
->d_sb
);
69 int oz_mode
= autofs4_oz_mode(sbi
);
71 DPRINTK("called, filp->f_pos = %lld", file
->f_pos
);
74 * Don't set reghost flag if:
75 * 1) f_pos is larger than zero -- we've already been here.
76 * 2) we haven't even enabled reghosting in the 1st place.
77 * 3) this is the daemon doing a readdir
79 if (oz_mode
&& file
->f_pos
== 0 && sbi
->reghost_enabled
)
80 sbi
->needs_reghost
= 1;
82 DPRINTK("needs_reghost = %d", sbi
->needs_reghost
);
84 return dcache_readdir(file
, dirent
, filldir
);
87 /* Update usage from here to top of tree, so that scan of
88 top-level directories will give a useful result */
89 static void autofs4_update_usage(struct vfsmount
*mnt
, struct dentry
*dentry
)
91 struct dentry
*top
= dentry
->d_sb
->s_root
;
93 spin_lock(&dcache_lock
);
94 for(; dentry
!= top
; dentry
= dentry
->d_parent
) {
95 struct autofs_info
*ino
= autofs4_dentry_ino(dentry
);
98 touch_atime(mnt
, dentry
);
99 ino
->last_used
= jiffies
;
102 spin_unlock(&dcache_lock
);
105 static int autofs4_dir_open(struct inode
*inode
, struct file
*file
)
107 struct dentry
*dentry
= file
->f_dentry
;
108 struct vfsmount
*mnt
= file
->f_vfsmnt
;
109 struct autofs_sb_info
*sbi
= autofs4_sbi(dentry
->d_sb
);
110 struct dentry
*cursor
;
113 status
= dcache_dir_open(inode
, file
);
117 cursor
= file
->private_data
;
118 cursor
->d_fsdata
= NULL
;
120 DPRINTK("file=%p dentry=%p %.*s",
121 file
, dentry
, dentry
->d_name
.len
, dentry
->d_name
.name
);
123 if (autofs4_oz_mode(sbi
))
126 if (autofs4_ispending(dentry
)) {
127 DPRINTK("dentry busy");
128 dcache_dir_close(inode
, file
);
134 if (!d_mountpoint(dentry
) && dentry
->d_op
&& dentry
->d_op
->d_revalidate
) {
138 /* In case there are stale directory dentrys from a failed mount */
139 spin_lock(&dcache_lock
);
140 empty
= list_empty(&dentry
->d_subdirs
);
141 spin_unlock(&dcache_lock
);
144 d_invalidate(dentry
);
146 nd
.flags
= LOOKUP_DIRECTORY
;
147 ret
= (dentry
->d_op
->d_revalidate
)(dentry
, &nd
);
150 dcache_dir_close(inode
, file
);
155 if (d_mountpoint(dentry
)) {
156 struct file
*fp
= NULL
;
157 struct vfsmount
*fp_mnt
= mntget(mnt
);
158 struct dentry
*fp_dentry
= dget(dentry
);
160 if (!autofs4_follow_mount(&fp_mnt
, &fp_dentry
)) {
163 dcache_dir_close(inode
, file
);
167 fp
= dentry_open(fp_dentry
, fp_mnt
, file
->f_flags
);
168 status
= PTR_ERR(fp
);
170 dcache_dir_close(inode
, file
);
173 cursor
->d_fsdata
= fp
;
180 static int autofs4_dir_close(struct inode
*inode
, struct file
*file
)
182 struct dentry
*dentry
= file
->f_dentry
;
183 struct autofs_sb_info
*sbi
= autofs4_sbi(dentry
->d_sb
);
184 struct dentry
*cursor
= file
->private_data
;
187 DPRINTK("file=%p dentry=%p %.*s",
188 file
, dentry
, dentry
->d_name
.len
, dentry
->d_name
.name
);
190 if (autofs4_oz_mode(sbi
))
193 if (autofs4_ispending(dentry
)) {
194 DPRINTK("dentry busy");
199 if (d_mountpoint(dentry
)) {
200 struct file
*fp
= cursor
->d_fsdata
;
205 filp_close(fp
, current
->files
);
208 dcache_dir_close(inode
, file
);
212 static int autofs4_dir_readdir(struct file
*file
, void *dirent
, filldir_t filldir
)
214 struct dentry
*dentry
= file
->f_dentry
;
215 struct autofs_sb_info
*sbi
= autofs4_sbi(dentry
->d_sb
);
216 struct dentry
*cursor
= file
->private_data
;
219 DPRINTK("file=%p dentry=%p %.*s",
220 file
, dentry
, dentry
->d_name
.len
, dentry
->d_name
.name
);
222 if (autofs4_oz_mode(sbi
))
225 if (autofs4_ispending(dentry
)) {
226 DPRINTK("dentry busy");
230 if (d_mountpoint(dentry
)) {
231 struct file
*fp
= cursor
->d_fsdata
;
236 if (!fp
->f_op
|| !fp
->f_op
->readdir
)
239 status
= vfs_readdir(fp
, filldir
, dirent
);
240 file
->f_pos
= fp
->f_pos
;
242 autofs4_copy_atime(file
, fp
);
246 return dcache_readdir(file
, dirent
, filldir
);
249 static int try_to_fill_dentry(struct vfsmount
*mnt
, struct dentry
*dentry
, int flags
)
251 struct super_block
*sb
= mnt
->mnt_sb
;
252 struct autofs_sb_info
*sbi
= autofs4_sbi(sb
);
253 struct autofs_info
*ino
= autofs4_dentry_ino(dentry
);
256 /* Block on any pending expiry here; invalidate the dentry
257 when expiration is done to trigger mount request with a new
259 if (ino
&& (ino
->flags
& AUTOFS_INF_EXPIRING
)) {
260 DPRINTK("waiting for expire %p name=%.*s",
261 dentry
, dentry
->d_name
.len
, dentry
->d_name
.name
);
263 status
= autofs4_wait(sbi
, dentry
, NFY_NONE
);
265 DPRINTK("expire done status=%d", status
);
268 * If the directory still exists the mount request must
269 * continue otherwise it can't be followed at the right
270 * time during the walk.
272 status
= d_invalidate(dentry
);
273 if (status
!= -EBUSY
)
277 DPRINTK("dentry=%p %.*s ino=%p",
278 dentry
, dentry
->d_name
.len
, dentry
->d_name
.name
, dentry
->d_inode
);
281 * Wait for a pending mount, triggering one if there
284 if (dentry
->d_inode
== NULL
) {
285 DPRINTK("waiting for mount name=%.*s",
286 dentry
->d_name
.len
, dentry
->d_name
.name
);
288 status
= autofs4_wait(sbi
, dentry
, NFY_MOUNT
);
290 DPRINTK("mount done status=%d", status
);
292 if (status
&& dentry
->d_inode
)
293 return 0; /* Try to get the kernel to invalidate this dentry */
295 /* Turn this into a real negative dentry? */
296 if (status
== -ENOENT
) {
297 spin_lock(&dentry
->d_lock
);
298 dentry
->d_flags
&= ~DCACHE_AUTOFS_PENDING
;
299 spin_unlock(&dentry
->d_lock
);
302 /* Return a negative dentry, but leave it "pending" */
305 /* Trigger mount for path component or follow link */
306 } else if (flags
& (LOOKUP_CONTINUE
| LOOKUP_DIRECTORY
) ||
307 current
->link_count
) {
308 DPRINTK("waiting for mount name=%.*s",
309 dentry
->d_name
.len
, dentry
->d_name
.name
);
311 spin_lock(&dentry
->d_lock
);
312 dentry
->d_flags
|= DCACHE_AUTOFS_PENDING
;
313 spin_unlock(&dentry
->d_lock
);
314 status
= autofs4_wait(sbi
, dentry
, NFY_MOUNT
);
316 DPRINTK("mount done status=%d", status
);
319 spin_lock(&dentry
->d_lock
);
320 dentry
->d_flags
&= ~DCACHE_AUTOFS_PENDING
;
321 spin_unlock(&dentry
->d_lock
);
327 * We don't update the usages for the autofs daemon itself, this
328 * is necessary for recursive autofs mounts
330 if (!autofs4_oz_mode(sbi
))
331 autofs4_update_usage(mnt
, dentry
);
333 /* Initialize expiry counter after successful mount */
335 ino
->last_used
= jiffies
;
337 spin_lock(&dentry
->d_lock
);
338 dentry
->d_flags
&= ~DCACHE_AUTOFS_PENDING
;
339 spin_unlock(&dentry
->d_lock
);
344 * Revalidate is called on every cache lookup. Some of those
345 * cache lookups may actually happen while the dentry is not
346 * yet completely filled in, and revalidate has to delay such
349 static int autofs4_revalidate(struct dentry
*dentry
, struct nameidata
*nd
)
351 struct inode
*dir
= dentry
->d_parent
->d_inode
;
352 struct autofs_sb_info
*sbi
= autofs4_sbi(dir
->i_sb
);
353 int oz_mode
= autofs4_oz_mode(sbi
);
354 int flags
= nd
? nd
->flags
: 0;
358 if (autofs4_ispending(dentry
)) {
360 status
= try_to_fill_dentry(nd
->mnt
, dentry
, flags
);
364 /* Negative dentry.. invalidate if "old" */
365 if (dentry
->d_inode
== NULL
)
368 /* Check for a non-mountpoint directory with no contents */
369 spin_lock(&dcache_lock
);
370 if (S_ISDIR(dentry
->d_inode
->i_mode
) &&
371 !d_mountpoint(dentry
) &&
372 simple_empty_nolock(dentry
)) {
373 DPRINTK("dentry=%p %.*s, emptydir",
374 dentry
, dentry
->d_name
.len
, dentry
->d_name
.name
);
375 spin_unlock(&dcache_lock
);
377 status
= try_to_fill_dentry(nd
->mnt
, dentry
, flags
);
380 spin_unlock(&dcache_lock
);
382 /* Update the usage list */
384 autofs4_update_usage(nd
->mnt
, dentry
);
389 static void autofs4_dentry_release(struct dentry
*de
)
391 struct autofs_info
*inf
;
393 DPRINTK("releasing %p", de
);
395 inf
= autofs4_dentry_ino(de
);
402 autofs4_free_ino(inf
);
406 /* For dentries of directories in the root dir */
407 static struct dentry_operations autofs4_root_dentry_operations
= {
408 .d_revalidate
= autofs4_revalidate
,
409 .d_release
= autofs4_dentry_release
,
412 /* For other dentries */
413 static struct dentry_operations autofs4_dentry_operations
= {
414 .d_revalidate
= autofs4_revalidate
,
415 .d_release
= autofs4_dentry_release
,
418 /* Lookups in the root directory */
419 static struct dentry
*autofs4_lookup(struct inode
*dir
, struct dentry
*dentry
, struct nameidata
*nd
)
421 struct autofs_sb_info
*sbi
;
424 DPRINTK("name = %.*s",
425 dentry
->d_name
.len
, dentry
->d_name
.name
);
427 /* File name too long to exist */
428 if (dentry
->d_name
.len
> NAME_MAX
)
429 return ERR_PTR(-ENAMETOOLONG
);
431 sbi
= autofs4_sbi(dir
->i_sb
);
432 oz_mode
= autofs4_oz_mode(sbi
);
434 DPRINTK("pid = %u, pgrp = %u, catatonic = %d, oz_mode = %d",
435 current
->pid
, process_group(current
), sbi
->catatonic
, oz_mode
);
438 * Mark the dentry incomplete, but add it. This is needed so
439 * that the VFS layer knows about the dentry, and we can count
440 * on catching any lookups through the revalidate.
442 * Let all the hard work be done by the revalidate function that
443 * needs to be able to do this anyway..
445 * We need to do this before we release the directory semaphore.
447 dentry
->d_op
= &autofs4_root_dentry_operations
;
450 spin_lock(&dentry
->d_lock
);
451 dentry
->d_flags
|= DCACHE_AUTOFS_PENDING
;
452 spin_unlock(&dentry
->d_lock
);
454 dentry
->d_fsdata
= NULL
;
457 if (dentry
->d_op
&& dentry
->d_op
->d_revalidate
) {
458 mutex_unlock(&dir
->i_mutex
);
459 (dentry
->d_op
->d_revalidate
)(dentry
, nd
);
460 mutex_lock(&dir
->i_mutex
);
464 * If we are still pending, check if we had to handle
465 * a signal. If so we can force a restart..
467 if (dentry
->d_flags
& DCACHE_AUTOFS_PENDING
) {
468 /* See if we were interrupted */
469 if (signal_pending(current
)) {
470 sigset_t
*sigset
= ¤t
->pending
.signal
;
471 if (sigismember (sigset
, SIGKILL
) ||
472 sigismember (sigset
, SIGQUIT
) ||
473 sigismember (sigset
, SIGINT
)) {
474 return ERR_PTR(-ERESTARTNOINTR
);
480 * If this dentry is unhashed, then we shouldn't honour this
481 * lookup even if the dentry is positive. Returning ENOENT here
482 * doesn't do the right thing for all system calls, but it should
483 * be OK for the operations we permit from an autofs.
485 if (dentry
->d_inode
&& d_unhashed(dentry
))
486 return ERR_PTR(-ENOENT
);
491 static int autofs4_dir_symlink(struct inode
*dir
,
492 struct dentry
*dentry
,
495 struct autofs_sb_info
*sbi
= autofs4_sbi(dir
->i_sb
);
496 struct autofs_info
*ino
= autofs4_dentry_ino(dentry
);
497 struct autofs_info
*p_ino
;
501 DPRINTK("%s <- %.*s", symname
,
502 dentry
->d_name
.len
, dentry
->d_name
.name
);
504 if (!autofs4_oz_mode(sbi
))
507 ino
= autofs4_init_ino(ino
, sbi
, S_IFLNK
| 0555);
511 ino
->size
= strlen(symname
);
512 ino
->u
.symlink
= cp
= kmalloc(ino
->size
+ 1, GFP_KERNEL
);
521 inode
= autofs4_get_inode(dir
->i_sb
, ino
);
522 d_instantiate(dentry
, inode
);
524 if (dir
== dir
->i_sb
->s_root
->d_inode
)
525 dentry
->d_op
= &autofs4_root_dentry_operations
;
527 dentry
->d_op
= &autofs4_dentry_operations
;
529 dentry
->d_fsdata
= ino
;
530 ino
->dentry
= dget(dentry
);
531 atomic_inc(&ino
->count
);
532 p_ino
= autofs4_dentry_ino(dentry
->d_parent
);
533 if (p_ino
&& dentry
->d_parent
!= dentry
)
534 atomic_inc(&p_ino
->count
);
537 dir
->i_mtime
= CURRENT_TIME
;
545 * Normal filesystems would do a "d_delete()" to tell the VFS dcache
546 * that the file no longer exists. However, doing that means that the
547 * VFS layer can turn the dentry into a negative dentry. We don't want
548 * this, because since the unlink is probably the result of an expire.
549 * We simply d_drop it, which allows the dentry lookup to remount it
552 * If a process is blocked on the dentry waiting for the expire to finish,
553 * it will invalidate the dentry and try to mount with a new one.
555 * Also see autofs4_dir_rmdir()..
557 static int autofs4_dir_unlink(struct inode
*dir
, struct dentry
*dentry
)
559 struct autofs_sb_info
*sbi
= autofs4_sbi(dir
->i_sb
);
560 struct autofs_info
*ino
= autofs4_dentry_ino(dentry
);
561 struct autofs_info
*p_ino
;
563 /* This allows root to remove symlinks */
564 if ( !autofs4_oz_mode(sbi
) && !capable(CAP_SYS_ADMIN
) )
567 if (atomic_dec_and_test(&ino
->count
)) {
568 p_ino
= autofs4_dentry_ino(dentry
->d_parent
);
569 if (p_ino
&& dentry
->d_parent
!= dentry
)
570 atomic_dec(&p_ino
->count
);
574 dentry
->d_inode
->i_size
= 0;
575 dentry
->d_inode
->i_nlink
= 0;
577 dir
->i_mtime
= CURRENT_TIME
;
584 static int autofs4_dir_rmdir(struct inode
*dir
, struct dentry
*dentry
)
586 struct autofs_sb_info
*sbi
= autofs4_sbi(dir
->i_sb
);
587 struct autofs_info
*ino
= autofs4_dentry_ino(dentry
);
588 struct autofs_info
*p_ino
;
590 if (!autofs4_oz_mode(sbi
))
593 spin_lock(&dcache_lock
);
594 if (!list_empty(&dentry
->d_subdirs
)) {
595 spin_unlock(&dcache_lock
);
598 spin_lock(&dentry
->d_lock
);
600 spin_unlock(&dentry
->d_lock
);
601 spin_unlock(&dcache_lock
);
603 if (atomic_dec_and_test(&ino
->count
)) {
604 p_ino
= autofs4_dentry_ino(dentry
->d_parent
);
605 if (p_ino
&& dentry
->d_parent
!= dentry
)
606 atomic_dec(&p_ino
->count
);
609 dentry
->d_inode
->i_size
= 0;
610 dentry
->d_inode
->i_nlink
= 0;
618 static int autofs4_dir_mkdir(struct inode
*dir
, struct dentry
*dentry
, int mode
)
620 struct autofs_sb_info
*sbi
= autofs4_sbi(dir
->i_sb
);
621 struct autofs_info
*ino
= autofs4_dentry_ino(dentry
);
622 struct autofs_info
*p_ino
;
625 if ( !autofs4_oz_mode(sbi
) )
628 DPRINTK("dentry %p, creating %.*s",
629 dentry
, dentry
->d_name
.len
, dentry
->d_name
.name
);
631 ino
= autofs4_init_ino(ino
, sbi
, S_IFDIR
| 0555);
635 inode
= autofs4_get_inode(dir
->i_sb
, ino
);
636 d_instantiate(dentry
, inode
);
638 if (dir
== dir
->i_sb
->s_root
->d_inode
)
639 dentry
->d_op
= &autofs4_root_dentry_operations
;
641 dentry
->d_op
= &autofs4_dentry_operations
;
643 dentry
->d_fsdata
= ino
;
644 ino
->dentry
= dget(dentry
);
645 atomic_inc(&ino
->count
);
646 p_ino
= autofs4_dentry_ino(dentry
->d_parent
);
647 if (p_ino
&& dentry
->d_parent
!= dentry
)
648 atomic_inc(&p_ino
->count
);
651 dir
->i_mtime
= CURRENT_TIME
;
656 /* Get/set timeout ioctl() operation */
657 static inline int autofs4_get_set_timeout(struct autofs_sb_info
*sbi
,
658 unsigned long __user
*p
)
661 unsigned long ntimeout
;
663 if ( (rv
= get_user(ntimeout
, p
)) ||
664 (rv
= put_user(sbi
->exp_timeout
/HZ
, p
)) )
667 if ( ntimeout
> ULONG_MAX
/HZ
)
668 sbi
->exp_timeout
= 0;
670 sbi
->exp_timeout
= ntimeout
* HZ
;
675 /* Return protocol version */
676 static inline int autofs4_get_protover(struct autofs_sb_info
*sbi
, int __user
*p
)
678 return put_user(sbi
->version
, p
);
681 /* Return protocol sub version */
682 static inline int autofs4_get_protosubver(struct autofs_sb_info
*sbi
, int __user
*p
)
684 return put_user(sbi
->sub_version
, p
);
688 * Tells the daemon whether we need to reghost or not. Also, clears
689 * the reghost_needed flag.
691 static inline int autofs4_ask_reghost(struct autofs_sb_info
*sbi
, int __user
*p
)
695 DPRINTK("returning %d", sbi
->needs_reghost
);
697 status
= put_user(sbi
->needs_reghost
, p
);
701 sbi
->needs_reghost
= 0;
706 * Enable / Disable reghosting ioctl() operation
708 static inline int autofs4_toggle_reghost(struct autofs_sb_info
*sbi
, int __user
*p
)
713 status
= get_user(val
, p
);
715 DPRINTK("reghost = %d", val
);
720 /* turn on/off reghosting, with the val */
721 sbi
->reghost_enabled
= val
;
726 * Tells the daemon whether it can umount the autofs mount.
728 static inline int autofs4_ask_umount(struct vfsmount
*mnt
, int __user
*p
)
732 if (may_umount(mnt
) == 0)
735 DPRINTK("returning %d", status
);
737 status
= put_user(status
, p
);
742 /* Identify autofs4_dentries - this is so we can tell if there's
743 an extra dentry refcount or not. We only hold a refcount on the
744 dentry if its non-negative (ie, d_inode != NULL)
746 int is_autofs4_dentry(struct dentry
*dentry
)
748 return dentry
&& dentry
->d_inode
&&
749 (dentry
->d_op
== &autofs4_root_dentry_operations
||
750 dentry
->d_op
== &autofs4_dentry_operations
) &&
751 dentry
->d_fsdata
!= NULL
;
755 * ioctl()'s on the root directory is the chief method for the daemon to
756 * generate kernel reactions
758 static int autofs4_root_ioctl(struct inode
*inode
, struct file
*filp
,
759 unsigned int cmd
, unsigned long arg
)
761 struct autofs_sb_info
*sbi
= autofs4_sbi(inode
->i_sb
);
762 void __user
*p
= (void __user
*)arg
;
764 DPRINTK("cmd = 0x%08x, arg = 0x%08lx, sbi = %p, pgrp = %u",
765 cmd
,arg
,sbi
,process_group(current
));
767 if ( _IOC_TYPE(cmd
) != _IOC_TYPE(AUTOFS_IOC_FIRST
) ||
768 _IOC_NR(cmd
) - _IOC_NR(AUTOFS_IOC_FIRST
) >= AUTOFS_IOC_COUNT
)
771 if ( !autofs4_oz_mode(sbi
) && !capable(CAP_SYS_ADMIN
) )
775 case AUTOFS_IOC_READY
: /* Wait queue: go ahead and retry */
776 return autofs4_wait_release(sbi
,(autofs_wqt_t
)arg
,0);
777 case AUTOFS_IOC_FAIL
: /* Wait queue: fail with ENOENT */
778 return autofs4_wait_release(sbi
,(autofs_wqt_t
)arg
,-ENOENT
);
779 case AUTOFS_IOC_CATATONIC
: /* Enter catatonic mode (daemon shutdown) */
780 autofs4_catatonic_mode(sbi
);
782 case AUTOFS_IOC_PROTOVER
: /* Get protocol version */
783 return autofs4_get_protover(sbi
, p
);
784 case AUTOFS_IOC_PROTOSUBVER
: /* Get protocol sub version */
785 return autofs4_get_protosubver(sbi
, p
);
786 case AUTOFS_IOC_SETTIMEOUT
:
787 return autofs4_get_set_timeout(sbi
, p
);
789 case AUTOFS_IOC_TOGGLEREGHOST
:
790 return autofs4_toggle_reghost(sbi
, p
);
791 case AUTOFS_IOC_ASKREGHOST
:
792 return autofs4_ask_reghost(sbi
, p
);
794 case AUTOFS_IOC_ASKUMOUNT
:
795 return autofs4_ask_umount(filp
->f_vfsmnt
, p
);
797 /* return a single thing to expire */
798 case AUTOFS_IOC_EXPIRE
:
799 return autofs4_expire_run(inode
->i_sb
,filp
->f_vfsmnt
,sbi
, p
);
800 /* same as above, but can send multiple expires through pipe */
801 case AUTOFS_IOC_EXPIRE_MULTI
:
802 return autofs4_expire_multi(inode
->i_sb
,filp
->f_vfsmnt
,sbi
, p
);