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-2006 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
*);
33 static void *autofs4_follow_link(struct dentry
*, struct nameidata
*);
35 const struct file_operations autofs4_root_operations
= {
36 .open
= dcache_dir_open
,
37 .release
= dcache_dir_close
,
38 .read
= generic_read_dir
,
39 .readdir
= autofs4_root_readdir
,
40 .ioctl
= autofs4_root_ioctl
,
43 const struct file_operations autofs4_dir_operations
= {
44 .open
= autofs4_dir_open
,
45 .release
= autofs4_dir_close
,
46 .read
= generic_read_dir
,
47 .readdir
= autofs4_dir_readdir
,
50 struct inode_operations autofs4_indirect_root_inode_operations
= {
51 .lookup
= autofs4_lookup
,
52 .unlink
= autofs4_dir_unlink
,
53 .symlink
= autofs4_dir_symlink
,
54 .mkdir
= autofs4_dir_mkdir
,
55 .rmdir
= autofs4_dir_rmdir
,
58 struct inode_operations autofs4_direct_root_inode_operations
= {
59 .lookup
= autofs4_lookup
,
60 .unlink
= autofs4_dir_unlink
,
61 .mkdir
= autofs4_dir_mkdir
,
62 .rmdir
= autofs4_dir_rmdir
,
63 .follow_link
= autofs4_follow_link
,
66 struct inode_operations autofs4_dir_inode_operations
= {
67 .lookup
= autofs4_lookup
,
68 .unlink
= autofs4_dir_unlink
,
69 .symlink
= autofs4_dir_symlink
,
70 .mkdir
= autofs4_dir_mkdir
,
71 .rmdir
= autofs4_dir_rmdir
,
74 static int autofs4_root_readdir(struct file
*file
, void *dirent
,
77 struct autofs_sb_info
*sbi
= autofs4_sbi(file
->f_dentry
->d_sb
);
78 int oz_mode
= autofs4_oz_mode(sbi
);
80 DPRINTK("called, filp->f_pos = %lld", file
->f_pos
);
83 * Don't set reghost flag if:
84 * 1) f_pos is larger than zero -- we've already been here.
85 * 2) we haven't even enabled reghosting in the 1st place.
86 * 3) this is the daemon doing a readdir
88 if (oz_mode
&& file
->f_pos
== 0 && sbi
->reghost_enabled
)
89 sbi
->needs_reghost
= 1;
91 DPRINTK("needs_reghost = %d", sbi
->needs_reghost
);
93 return dcache_readdir(file
, dirent
, filldir
);
96 static int autofs4_dir_open(struct inode
*inode
, struct file
*file
)
98 struct dentry
*dentry
= file
->f_dentry
;
99 struct vfsmount
*mnt
= file
->f_vfsmnt
;
100 struct autofs_sb_info
*sbi
= autofs4_sbi(dentry
->d_sb
);
101 struct dentry
*cursor
;
104 status
= dcache_dir_open(inode
, file
);
108 cursor
= file
->private_data
;
109 cursor
->d_fsdata
= NULL
;
111 DPRINTK("file=%p dentry=%p %.*s",
112 file
, dentry
, dentry
->d_name
.len
, dentry
->d_name
.name
);
114 if (autofs4_oz_mode(sbi
))
117 if (autofs4_ispending(dentry
)) {
118 DPRINTK("dentry busy");
119 dcache_dir_close(inode
, file
);
125 if (!d_mountpoint(dentry
) && dentry
->d_op
&& dentry
->d_op
->d_revalidate
) {
129 /* In case there are stale directory dentrys from a failed mount */
130 spin_lock(&dcache_lock
);
131 empty
= list_empty(&dentry
->d_subdirs
);
132 spin_unlock(&dcache_lock
);
135 d_invalidate(dentry
);
137 nd
.flags
= LOOKUP_DIRECTORY
;
138 ret
= (dentry
->d_op
->d_revalidate
)(dentry
, &nd
);
143 dcache_dir_close(inode
, file
);
148 if (d_mountpoint(dentry
)) {
149 struct file
*fp
= NULL
;
150 struct vfsmount
*fp_mnt
= mntget(mnt
);
151 struct dentry
*fp_dentry
= dget(dentry
);
153 if (!autofs4_follow_mount(&fp_mnt
, &fp_dentry
)) {
156 dcache_dir_close(inode
, file
);
160 fp
= dentry_open(fp_dentry
, fp_mnt
, file
->f_flags
);
161 status
= PTR_ERR(fp
);
163 dcache_dir_close(inode
, file
);
166 cursor
->d_fsdata
= fp
;
173 static int autofs4_dir_close(struct inode
*inode
, struct file
*file
)
175 struct dentry
*dentry
= file
->f_dentry
;
176 struct autofs_sb_info
*sbi
= autofs4_sbi(dentry
->d_sb
);
177 struct dentry
*cursor
= file
->private_data
;
180 DPRINTK("file=%p dentry=%p %.*s",
181 file
, dentry
, dentry
->d_name
.len
, dentry
->d_name
.name
);
183 if (autofs4_oz_mode(sbi
))
186 if (autofs4_ispending(dentry
)) {
187 DPRINTK("dentry busy");
192 if (d_mountpoint(dentry
)) {
193 struct file
*fp
= cursor
->d_fsdata
;
198 filp_close(fp
, current
->files
);
201 dcache_dir_close(inode
, file
);
205 static int autofs4_dir_readdir(struct file
*file
, void *dirent
, filldir_t filldir
)
207 struct dentry
*dentry
= file
->f_dentry
;
208 struct autofs_sb_info
*sbi
= autofs4_sbi(dentry
->d_sb
);
209 struct dentry
*cursor
= file
->private_data
;
212 DPRINTK("file=%p dentry=%p %.*s",
213 file
, dentry
, dentry
->d_name
.len
, dentry
->d_name
.name
);
215 if (autofs4_oz_mode(sbi
))
218 if (autofs4_ispending(dentry
)) {
219 DPRINTK("dentry busy");
223 if (d_mountpoint(dentry
)) {
224 struct file
*fp
= cursor
->d_fsdata
;
229 if (!fp
->f_op
|| !fp
->f_op
->readdir
)
232 status
= vfs_readdir(fp
, filldir
, dirent
);
233 file
->f_pos
= fp
->f_pos
;
235 autofs4_copy_atime(file
, fp
);
239 return dcache_readdir(file
, dirent
, filldir
);
242 static int try_to_fill_dentry(struct dentry
*dentry
, int flags
)
244 struct autofs_sb_info
*sbi
= autofs4_sbi(dentry
->d_sb
);
245 struct autofs_info
*ino
= autofs4_dentry_ino(dentry
);
248 /* Block on any pending expiry here; invalidate the dentry
249 when expiration is done to trigger mount request with a new
251 if (ino
&& (ino
->flags
& AUTOFS_INF_EXPIRING
)) {
252 DPRINTK("waiting for expire %p name=%.*s",
253 dentry
, dentry
->d_name
.len
, dentry
->d_name
.name
);
255 status
= autofs4_wait(sbi
, dentry
, NFY_NONE
);
257 DPRINTK("expire done status=%d", status
);
260 * If the directory still exists the mount request must
261 * continue otherwise it can't be followed at the right
262 * time during the walk.
264 status
= d_invalidate(dentry
);
265 if (status
!= -EBUSY
)
269 DPRINTK("dentry=%p %.*s ino=%p",
270 dentry
, dentry
->d_name
.len
, dentry
->d_name
.name
, dentry
->d_inode
);
273 * Wait for a pending mount, triggering one if there
276 if (dentry
->d_inode
== NULL
) {
277 DPRINTK("waiting for mount name=%.*s",
278 dentry
->d_name
.len
, dentry
->d_name
.name
);
280 status
= autofs4_wait(sbi
, dentry
, NFY_MOUNT
);
282 DPRINTK("mount done status=%d", status
);
284 if (status
&& dentry
->d_inode
)
285 return status
; /* Try to get the kernel to invalidate this dentry */
287 /* Turn this into a real negative dentry? */
288 if (status
== -ENOENT
) {
289 spin_lock(&dentry
->d_lock
);
290 dentry
->d_flags
&= ~DCACHE_AUTOFS_PENDING
;
291 spin_unlock(&dentry
->d_lock
);
294 /* Return a negative dentry, but leave it "pending" */
297 /* Trigger mount for path component or follow link */
298 } else if (flags
& (LOOKUP_CONTINUE
| LOOKUP_DIRECTORY
) ||
299 current
->link_count
) {
300 DPRINTK("waiting for mount name=%.*s",
301 dentry
->d_name
.len
, dentry
->d_name
.name
);
303 spin_lock(&dentry
->d_lock
);
304 dentry
->d_flags
|= DCACHE_AUTOFS_PENDING
;
305 spin_unlock(&dentry
->d_lock
);
306 status
= autofs4_wait(sbi
, dentry
, NFY_MOUNT
);
308 DPRINTK("mount done status=%d", status
);
311 spin_lock(&dentry
->d_lock
);
312 dentry
->d_flags
&= ~DCACHE_AUTOFS_PENDING
;
313 spin_unlock(&dentry
->d_lock
);
318 /* Initialize expiry counter after successful mount */
320 ino
->last_used
= jiffies
;
322 spin_lock(&dentry
->d_lock
);
323 dentry
->d_flags
&= ~DCACHE_AUTOFS_PENDING
;
324 spin_unlock(&dentry
->d_lock
);
328 /* For autofs direct mounts the follow link triggers the mount */
329 static void *autofs4_follow_link(struct dentry
*dentry
, struct nameidata
*nd
)
331 struct autofs_sb_info
*sbi
= autofs4_sbi(dentry
->d_sb
);
332 struct autofs_info
*ino
= autofs4_dentry_ino(dentry
);
333 int oz_mode
= autofs4_oz_mode(sbi
);
334 unsigned int lookup_type
;
337 DPRINTK("dentry=%p %.*s oz_mode=%d nd->flags=%d",
338 dentry
, dentry
->d_name
.len
, dentry
->d_name
.name
, oz_mode
,
341 /* If it's our master or we shouldn't trigger a mount we're done */
342 lookup_type
= nd
->flags
& (LOOKUP_CONTINUE
| LOOKUP_DIRECTORY
);
343 if (oz_mode
|| !lookup_type
)
346 /* If an expire request is pending wait for it. */
347 if (ino
&& (ino
->flags
& AUTOFS_INF_EXPIRING
)) {
348 DPRINTK("waiting for active request %p name=%.*s",
349 dentry
, dentry
->d_name
.len
, dentry
->d_name
.name
);
351 status
= autofs4_wait(sbi
, dentry
, NFY_NONE
);
353 DPRINTK("request done status=%d", status
);
357 * If the dentry contains directories then it is an
358 * autofs multi-mount with no root mount offset. So
359 * don't try to mount it again.
361 spin_lock(&dcache_lock
);
362 if (!d_mountpoint(dentry
) && list_empty(&dentry
->d_subdirs
)) {
363 spin_unlock(&dcache_lock
);
365 status
= try_to_fill_dentry(dentry
, 0);
370 * The mount succeeded but if there is no root mount
371 * it must be an autofs multi-mount with no root offset
372 * so we don't need to follow the mount.
374 if (d_mountpoint(dentry
)) {
375 if (!autofs4_follow_mount(&nd
->mnt
, &nd
->dentry
)) {
383 spin_unlock(&dcache_lock
);
390 return ERR_PTR(status
);
394 * Revalidate is called on every cache lookup. Some of those
395 * cache lookups may actually happen while the dentry is not
396 * yet completely filled in, and revalidate has to delay such
399 static int autofs4_revalidate(struct dentry
*dentry
, struct nameidata
*nd
)
401 struct inode
*dir
= dentry
->d_parent
->d_inode
;
402 struct autofs_sb_info
*sbi
= autofs4_sbi(dir
->i_sb
);
403 int oz_mode
= autofs4_oz_mode(sbi
);
404 int flags
= nd
? nd
->flags
: 0;
408 if (autofs4_ispending(dentry
)) {
409 /* The daemon never causes a mount to trigger */
414 * A zero status is success otherwise we have a
415 * negative error code.
417 status
= try_to_fill_dentry(dentry
, flags
);
424 /* Negative dentry.. invalidate if "old" */
425 if (dentry
->d_inode
== NULL
)
428 /* Check for a non-mountpoint directory with no contents */
429 spin_lock(&dcache_lock
);
430 if (S_ISDIR(dentry
->d_inode
->i_mode
) &&
431 !d_mountpoint(dentry
) &&
432 __simple_empty(dentry
)) {
433 DPRINTK("dentry=%p %.*s, emptydir",
434 dentry
, dentry
->d_name
.len
, dentry
->d_name
.name
);
435 spin_unlock(&dcache_lock
);
436 /* The daemon never causes a mount to trigger */
441 * A zero status is success otherwise we have a
442 * negative error code.
444 status
= try_to_fill_dentry(dentry
, flags
);
450 spin_unlock(&dcache_lock
);
455 void autofs4_dentry_release(struct dentry
*de
)
457 struct autofs_info
*inf
;
459 DPRINTK("releasing %p", de
);
461 inf
= autofs4_dentry_ino(de
);
468 autofs4_free_ino(inf
);
472 /* For dentries of directories in the root dir */
473 static struct dentry_operations autofs4_root_dentry_operations
= {
474 .d_revalidate
= autofs4_revalidate
,
475 .d_release
= autofs4_dentry_release
,
478 /* For other dentries */
479 static struct dentry_operations autofs4_dentry_operations
= {
480 .d_revalidate
= autofs4_revalidate
,
481 .d_release
= autofs4_dentry_release
,
484 /* Lookups in the root directory */
485 static struct dentry
*autofs4_lookup(struct inode
*dir
, struct dentry
*dentry
, struct nameidata
*nd
)
487 struct autofs_sb_info
*sbi
;
490 DPRINTK("name = %.*s",
491 dentry
->d_name
.len
, dentry
->d_name
.name
);
493 /* File name too long to exist */
494 if (dentry
->d_name
.len
> NAME_MAX
)
495 return ERR_PTR(-ENAMETOOLONG
);
497 sbi
= autofs4_sbi(dir
->i_sb
);
498 oz_mode
= autofs4_oz_mode(sbi
);
500 DPRINTK("pid = %u, pgrp = %u, catatonic = %d, oz_mode = %d",
501 current
->pid
, process_group(current
), sbi
->catatonic
, oz_mode
);
504 * Mark the dentry incomplete, but add it. This is needed so
505 * that the VFS layer knows about the dentry, and we can count
506 * on catching any lookups through the revalidate.
508 * Let all the hard work be done by the revalidate function that
509 * needs to be able to do this anyway..
511 * We need to do this before we release the directory semaphore.
513 dentry
->d_op
= &autofs4_root_dentry_operations
;
516 spin_lock(&dentry
->d_lock
);
517 dentry
->d_flags
|= DCACHE_AUTOFS_PENDING
;
518 spin_unlock(&dentry
->d_lock
);
520 dentry
->d_fsdata
= NULL
;
523 if (dentry
->d_op
&& dentry
->d_op
->d_revalidate
) {
524 mutex_unlock(&dir
->i_mutex
);
525 (dentry
->d_op
->d_revalidate
)(dentry
, nd
);
526 mutex_lock(&dir
->i_mutex
);
530 * If we are still pending, check if we had to handle
531 * a signal. If so we can force a restart..
533 if (dentry
->d_flags
& DCACHE_AUTOFS_PENDING
) {
534 /* See if we were interrupted */
535 if (signal_pending(current
)) {
536 sigset_t
*sigset
= ¤t
->pending
.signal
;
537 if (sigismember (sigset
, SIGKILL
) ||
538 sigismember (sigset
, SIGQUIT
) ||
539 sigismember (sigset
, SIGINT
)) {
540 return ERR_PTR(-ERESTARTNOINTR
);
546 * If this dentry is unhashed, then we shouldn't honour this
547 * lookup even if the dentry is positive. Returning ENOENT here
548 * doesn't do the right thing for all system calls, but it should
549 * be OK for the operations we permit from an autofs.
551 if (dentry
->d_inode
&& d_unhashed(dentry
))
552 return ERR_PTR(-ENOENT
);
557 static int autofs4_dir_symlink(struct inode
*dir
,
558 struct dentry
*dentry
,
561 struct autofs_sb_info
*sbi
= autofs4_sbi(dir
->i_sb
);
562 struct autofs_info
*ino
= autofs4_dentry_ino(dentry
);
563 struct autofs_info
*p_ino
;
567 DPRINTK("%s <- %.*s", symname
,
568 dentry
->d_name
.len
, dentry
->d_name
.name
);
570 if (!autofs4_oz_mode(sbi
))
573 ino
= autofs4_init_ino(ino
, sbi
, S_IFLNK
| 0555);
577 ino
->size
= strlen(symname
);
578 ino
->u
.symlink
= cp
= kmalloc(ino
->size
+ 1, GFP_KERNEL
);
587 inode
= autofs4_get_inode(dir
->i_sb
, ino
);
588 d_instantiate(dentry
, inode
);
590 if (dir
== dir
->i_sb
->s_root
->d_inode
)
591 dentry
->d_op
= &autofs4_root_dentry_operations
;
593 dentry
->d_op
= &autofs4_dentry_operations
;
595 dentry
->d_fsdata
= ino
;
596 ino
->dentry
= dget(dentry
);
597 atomic_inc(&ino
->count
);
598 p_ino
= autofs4_dentry_ino(dentry
->d_parent
);
599 if (p_ino
&& dentry
->d_parent
!= dentry
)
600 atomic_inc(&p_ino
->count
);
603 dir
->i_mtime
= CURRENT_TIME
;
611 * Normal filesystems would do a "d_delete()" to tell the VFS dcache
612 * that the file no longer exists. However, doing that means that the
613 * VFS layer can turn the dentry into a negative dentry. We don't want
614 * this, because since the unlink is probably the result of an expire.
615 * We simply d_drop it, which allows the dentry lookup to remount it
618 * If a process is blocked on the dentry waiting for the expire to finish,
619 * it will invalidate the dentry and try to mount with a new one.
621 * Also see autofs4_dir_rmdir()..
623 static int autofs4_dir_unlink(struct inode
*dir
, struct dentry
*dentry
)
625 struct autofs_sb_info
*sbi
= autofs4_sbi(dir
->i_sb
);
626 struct autofs_info
*ino
= autofs4_dentry_ino(dentry
);
627 struct autofs_info
*p_ino
;
629 /* This allows root to remove symlinks */
630 if ( !autofs4_oz_mode(sbi
) && !capable(CAP_SYS_ADMIN
) )
633 if (atomic_dec_and_test(&ino
->count
)) {
634 p_ino
= autofs4_dentry_ino(dentry
->d_parent
);
635 if (p_ino
&& dentry
->d_parent
!= dentry
)
636 atomic_dec(&p_ino
->count
);
640 dentry
->d_inode
->i_size
= 0;
641 dentry
->d_inode
->i_nlink
= 0;
643 dir
->i_mtime
= CURRENT_TIME
;
650 static int autofs4_dir_rmdir(struct inode
*dir
, struct dentry
*dentry
)
652 struct autofs_sb_info
*sbi
= autofs4_sbi(dir
->i_sb
);
653 struct autofs_info
*ino
= autofs4_dentry_ino(dentry
);
654 struct autofs_info
*p_ino
;
656 if (!autofs4_oz_mode(sbi
))
659 spin_lock(&dcache_lock
);
660 if (!list_empty(&dentry
->d_subdirs
)) {
661 spin_unlock(&dcache_lock
);
664 spin_lock(&dentry
->d_lock
);
666 spin_unlock(&dentry
->d_lock
);
667 spin_unlock(&dcache_lock
);
669 if (atomic_dec_and_test(&ino
->count
)) {
670 p_ino
= autofs4_dentry_ino(dentry
->d_parent
);
671 if (p_ino
&& dentry
->d_parent
!= dentry
)
672 atomic_dec(&p_ino
->count
);
675 dentry
->d_inode
->i_size
= 0;
676 dentry
->d_inode
->i_nlink
= 0;
684 static int autofs4_dir_mkdir(struct inode
*dir
, struct dentry
*dentry
, int mode
)
686 struct autofs_sb_info
*sbi
= autofs4_sbi(dir
->i_sb
);
687 struct autofs_info
*ino
= autofs4_dentry_ino(dentry
);
688 struct autofs_info
*p_ino
;
691 if ( !autofs4_oz_mode(sbi
) )
694 DPRINTK("dentry %p, creating %.*s",
695 dentry
, dentry
->d_name
.len
, dentry
->d_name
.name
);
697 ino
= autofs4_init_ino(ino
, sbi
, S_IFDIR
| 0555);
701 inode
= autofs4_get_inode(dir
->i_sb
, ino
);
702 d_instantiate(dentry
, inode
);
704 if (dir
== dir
->i_sb
->s_root
->d_inode
)
705 dentry
->d_op
= &autofs4_root_dentry_operations
;
707 dentry
->d_op
= &autofs4_dentry_operations
;
709 dentry
->d_fsdata
= ino
;
710 ino
->dentry
= dget(dentry
);
711 atomic_inc(&ino
->count
);
712 p_ino
= autofs4_dentry_ino(dentry
->d_parent
);
713 if (p_ino
&& dentry
->d_parent
!= dentry
)
714 atomic_inc(&p_ino
->count
);
717 dir
->i_mtime
= CURRENT_TIME
;
722 /* Get/set timeout ioctl() operation */
723 static inline int autofs4_get_set_timeout(struct autofs_sb_info
*sbi
,
724 unsigned long __user
*p
)
727 unsigned long ntimeout
;
729 if ( (rv
= get_user(ntimeout
, p
)) ||
730 (rv
= put_user(sbi
->exp_timeout
/HZ
, p
)) )
733 if ( ntimeout
> ULONG_MAX
/HZ
)
734 sbi
->exp_timeout
= 0;
736 sbi
->exp_timeout
= ntimeout
* HZ
;
741 /* Return protocol version */
742 static inline int autofs4_get_protover(struct autofs_sb_info
*sbi
, int __user
*p
)
744 return put_user(sbi
->version
, p
);
747 /* Return protocol sub version */
748 static inline int autofs4_get_protosubver(struct autofs_sb_info
*sbi
, int __user
*p
)
750 return put_user(sbi
->sub_version
, p
);
754 * Tells the daemon whether we need to reghost or not. Also, clears
755 * the reghost_needed flag.
757 static inline int autofs4_ask_reghost(struct autofs_sb_info
*sbi
, int __user
*p
)
761 DPRINTK("returning %d", sbi
->needs_reghost
);
763 status
= put_user(sbi
->needs_reghost
, p
);
767 sbi
->needs_reghost
= 0;
772 * Enable / Disable reghosting ioctl() operation
774 static inline int autofs4_toggle_reghost(struct autofs_sb_info
*sbi
, int __user
*p
)
779 status
= get_user(val
, p
);
781 DPRINTK("reghost = %d", val
);
786 /* turn on/off reghosting, with the val */
787 sbi
->reghost_enabled
= val
;
792 * Tells the daemon whether it can umount the autofs mount.
794 static inline int autofs4_ask_umount(struct vfsmount
*mnt
, int __user
*p
)
801 DPRINTK("returning %d", status
);
803 status
= put_user(status
, p
);
808 /* Identify autofs4_dentries - this is so we can tell if there's
809 an extra dentry refcount or not. We only hold a refcount on the
810 dentry if its non-negative (ie, d_inode != NULL)
812 int is_autofs4_dentry(struct dentry
*dentry
)
814 return dentry
&& dentry
->d_inode
&&
815 (dentry
->d_op
== &autofs4_root_dentry_operations
||
816 dentry
->d_op
== &autofs4_dentry_operations
) &&
817 dentry
->d_fsdata
!= NULL
;
821 * ioctl()'s on the root directory is the chief method for the daemon to
822 * generate kernel reactions
824 static int autofs4_root_ioctl(struct inode
*inode
, struct file
*filp
,
825 unsigned int cmd
, unsigned long arg
)
827 struct autofs_sb_info
*sbi
= autofs4_sbi(inode
->i_sb
);
828 void __user
*p
= (void __user
*)arg
;
830 DPRINTK("cmd = 0x%08x, arg = 0x%08lx, sbi = %p, pgrp = %u",
831 cmd
,arg
,sbi
,process_group(current
));
833 if ( _IOC_TYPE(cmd
) != _IOC_TYPE(AUTOFS_IOC_FIRST
) ||
834 _IOC_NR(cmd
) - _IOC_NR(AUTOFS_IOC_FIRST
) >= AUTOFS_IOC_COUNT
)
837 if ( !autofs4_oz_mode(sbi
) && !capable(CAP_SYS_ADMIN
) )
841 case AUTOFS_IOC_READY
: /* Wait queue: go ahead and retry */
842 return autofs4_wait_release(sbi
,(autofs_wqt_t
)arg
,0);
843 case AUTOFS_IOC_FAIL
: /* Wait queue: fail with ENOENT */
844 return autofs4_wait_release(sbi
,(autofs_wqt_t
)arg
,-ENOENT
);
845 case AUTOFS_IOC_CATATONIC
: /* Enter catatonic mode (daemon shutdown) */
846 autofs4_catatonic_mode(sbi
);
848 case AUTOFS_IOC_PROTOVER
: /* Get protocol version */
849 return autofs4_get_protover(sbi
, p
);
850 case AUTOFS_IOC_PROTOSUBVER
: /* Get protocol sub version */
851 return autofs4_get_protosubver(sbi
, p
);
852 case AUTOFS_IOC_SETTIMEOUT
:
853 return autofs4_get_set_timeout(sbi
, p
);
855 case AUTOFS_IOC_TOGGLEREGHOST
:
856 return autofs4_toggle_reghost(sbi
, p
);
857 case AUTOFS_IOC_ASKREGHOST
:
858 return autofs4_ask_reghost(sbi
, p
);
860 case AUTOFS_IOC_ASKUMOUNT
:
861 return autofs4_ask_umount(filp
->f_vfsmnt
, p
);
863 /* return a single thing to expire */
864 case AUTOFS_IOC_EXPIRE
:
865 return autofs4_expire_run(inode
->i_sb
,filp
->f_vfsmnt
,sbi
, p
);
866 /* same as above, but can send multiple expires through pipe */
867 case AUTOFS_IOC_EXPIRE_MULTI
:
868 return autofs4_expire_multi(inode
->i_sb
,filp
->f_vfsmnt
,sbi
, p
);