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/slab.h>
19 #include <linux/param.h>
20 #include <linux/time.h>
21 #include <linux/compat.h>
22 #include <linux/mutex.h>
26 DEFINE_SPINLOCK(autofs4_lock
);
28 static int autofs4_dir_symlink(struct inode
*,struct dentry
*,const char *);
29 static int autofs4_dir_unlink(struct inode
*,struct dentry
*);
30 static int autofs4_dir_rmdir(struct inode
*,struct dentry
*);
31 static int autofs4_dir_mkdir(struct inode
*,struct dentry
*,int);
32 static long autofs4_root_ioctl(struct file
*,unsigned int,unsigned long);
34 static long autofs4_root_compat_ioctl(struct file
*,unsigned int,unsigned long);
36 static int autofs4_dir_open(struct inode
*inode
, struct file
*file
);
37 static struct dentry
*autofs4_lookup(struct inode
*,struct dentry
*, struct nameidata
*);
38 static void *autofs4_follow_link(struct dentry
*, struct nameidata
*);
40 #define TRIGGER_FLAGS (LOOKUP_CONTINUE | LOOKUP_DIRECTORY)
41 #define TRIGGER_INTENTS (LOOKUP_OPEN | LOOKUP_CREATE)
43 const struct file_operations autofs4_root_operations
= {
44 .open
= dcache_dir_open
,
45 .release
= dcache_dir_close
,
46 .read
= generic_read_dir
,
47 .readdir
= dcache_readdir
,
48 .llseek
= dcache_dir_lseek
,
49 .unlocked_ioctl
= autofs4_root_ioctl
,
51 .compat_ioctl
= autofs4_root_compat_ioctl
,
55 const struct file_operations autofs4_dir_operations
= {
56 .open
= autofs4_dir_open
,
57 .release
= dcache_dir_close
,
58 .read
= generic_read_dir
,
59 .readdir
= dcache_readdir
,
60 .llseek
= dcache_dir_lseek
,
63 const struct inode_operations autofs4_indirect_root_inode_operations
= {
64 .lookup
= autofs4_lookup
,
65 .unlink
= autofs4_dir_unlink
,
66 .symlink
= autofs4_dir_symlink
,
67 .mkdir
= autofs4_dir_mkdir
,
68 .rmdir
= autofs4_dir_rmdir
,
71 const struct inode_operations autofs4_direct_root_inode_operations
= {
72 .lookup
= autofs4_lookup
,
73 .unlink
= autofs4_dir_unlink
,
74 .mkdir
= autofs4_dir_mkdir
,
75 .rmdir
= autofs4_dir_rmdir
,
76 .follow_link
= autofs4_follow_link
,
79 const struct inode_operations autofs4_dir_inode_operations
= {
80 .lookup
= autofs4_lookup
,
81 .unlink
= autofs4_dir_unlink
,
82 .symlink
= autofs4_dir_symlink
,
83 .mkdir
= autofs4_dir_mkdir
,
84 .rmdir
= autofs4_dir_rmdir
,
87 static void autofs4_add_active(struct dentry
*dentry
)
89 struct autofs_sb_info
*sbi
= autofs4_sbi(dentry
->d_sb
);
90 struct autofs_info
*ino
= autofs4_dentry_ino(dentry
);
92 spin_lock(&sbi
->lookup_lock
);
93 if (!ino
->active_count
) {
94 if (list_empty(&ino
->active
))
95 list_add(&ino
->active
, &sbi
->active_list
);
98 spin_unlock(&sbi
->lookup_lock
);
103 static void autofs4_del_active(struct dentry
*dentry
)
105 struct autofs_sb_info
*sbi
= autofs4_sbi(dentry
->d_sb
);
106 struct autofs_info
*ino
= autofs4_dentry_ino(dentry
);
108 spin_lock(&sbi
->lookup_lock
);
110 if (!ino
->active_count
) {
111 if (!list_empty(&ino
->active
))
112 list_del_init(&ino
->active
);
114 spin_unlock(&sbi
->lookup_lock
);
119 static unsigned int autofs4_need_mount(unsigned int flags
)
121 unsigned int res
= 0;
122 if (flags
& (TRIGGER_FLAGS
| TRIGGER_INTENTS
))
127 static int autofs4_dir_open(struct inode
*inode
, struct file
*file
)
129 struct dentry
*dentry
= file
->f_path
.dentry
;
130 struct autofs_sb_info
*sbi
= autofs4_sbi(dentry
->d_sb
);
132 DPRINTK("file=%p dentry=%p %.*s",
133 file
, dentry
, dentry
->d_name
.len
, dentry
->d_name
.name
);
135 if (autofs4_oz_mode(sbi
))
139 * An empty directory in an autofs file system is always a
140 * mount point. The daemon must have failed to mount this
141 * during lookup so it doesn't exist. This can happen, for
142 * example, if user space returns an incorrect status for a
143 * mount request. Otherwise we're doing a readdir on the
144 * autofs file system so just let the libfs routines handle
147 spin_lock(&autofs4_lock
);
148 spin_lock(&dentry
->d_lock
);
149 if (!d_mountpoint(dentry
) && list_empty(&dentry
->d_subdirs
)) {
150 spin_unlock(&dentry
->d_lock
);
151 spin_unlock(&autofs4_lock
);
154 spin_unlock(&dentry
->d_lock
);
155 spin_unlock(&autofs4_lock
);
158 return dcache_dir_open(inode
, file
);
161 static int try_to_fill_dentry(struct dentry
*dentry
, int flags
)
163 struct autofs_sb_info
*sbi
= autofs4_sbi(dentry
->d_sb
);
164 struct autofs_info
*ino
= autofs4_dentry_ino(dentry
);
167 DPRINTK("dentry=%p %.*s ino=%p",
168 dentry
, dentry
->d_name
.len
, dentry
->d_name
.name
, dentry
->d_inode
);
171 * Wait for a pending mount, triggering one if there
174 if (dentry
->d_inode
== NULL
) {
175 DPRINTK("waiting for mount name=%.*s",
176 dentry
->d_name
.len
, dentry
->d_name
.name
);
178 status
= autofs4_wait(sbi
, dentry
, NFY_MOUNT
);
180 DPRINTK("mount done status=%d", status
);
182 /* Turn this into a real negative dentry? */
183 if (status
== -ENOENT
) {
184 spin_lock(&sbi
->fs_lock
);
185 ino
->flags
&= ~AUTOFS_INF_PENDING
;
186 spin_unlock(&sbi
->fs_lock
);
189 /* Return a negative dentry, but leave it "pending" */
192 /* Trigger mount for path component or follow link */
193 } else if (ino
->flags
& AUTOFS_INF_PENDING
||
194 autofs4_need_mount(flags
)) {
195 DPRINTK("waiting for mount name=%.*s",
196 dentry
->d_name
.len
, dentry
->d_name
.name
);
198 spin_lock(&sbi
->fs_lock
);
199 ino
->flags
|= AUTOFS_INF_PENDING
;
200 spin_unlock(&sbi
->fs_lock
);
201 status
= autofs4_wait(sbi
, dentry
, NFY_MOUNT
);
203 DPRINTK("mount done status=%d", status
);
206 spin_lock(&sbi
->fs_lock
);
207 ino
->flags
&= ~AUTOFS_INF_PENDING
;
208 spin_unlock(&sbi
->fs_lock
);
213 /* Initialize expiry counter after successful mount */
214 ino
->last_used
= jiffies
;
216 spin_lock(&sbi
->fs_lock
);
217 ino
->flags
&= ~AUTOFS_INF_PENDING
;
218 spin_unlock(&sbi
->fs_lock
);
223 /* For autofs direct mounts the follow link triggers the mount */
224 static void *autofs4_follow_link(struct dentry
*dentry
, struct nameidata
*nd
)
226 struct autofs_sb_info
*sbi
= autofs4_sbi(dentry
->d_sb
);
227 struct autofs_info
*ino
= autofs4_dentry_ino(dentry
);
228 int oz_mode
= autofs4_oz_mode(sbi
);
229 unsigned int lookup_type
;
232 DPRINTK("dentry=%p %.*s oz_mode=%d nd->flags=%d",
233 dentry
, dentry
->d_name
.len
, dentry
->d_name
.name
, oz_mode
,
236 * For an expire of a covered direct or offset mount we need
237 * to break out of follow_down() at the autofs mount trigger
238 * (d_mounted--), so we can see the expiring flag, and manage
239 * the blocking and following here until the expire is completed.
242 spin_lock(&sbi
->fs_lock
);
243 if (ino
->flags
& AUTOFS_INF_EXPIRING
) {
244 spin_unlock(&sbi
->fs_lock
);
245 /* Follow down to our covering mount. */
246 if (!follow_down(&nd
->path
))
250 spin_unlock(&sbi
->fs_lock
);
254 /* If an expire request is pending everyone must wait. */
255 autofs4_expire_wait(dentry
);
257 /* We trigger a mount for almost all flags */
258 lookup_type
= autofs4_need_mount(nd
->flags
);
259 spin_lock(&sbi
->fs_lock
);
260 spin_lock(&autofs4_lock
);
261 spin_lock(&dentry
->d_lock
);
262 if (!(lookup_type
|| ino
->flags
& AUTOFS_INF_PENDING
)) {
263 spin_unlock(&dentry
->d_lock
);
264 spin_unlock(&autofs4_lock
);
265 spin_unlock(&sbi
->fs_lock
);
270 * If the dentry contains directories then it is an autofs
271 * multi-mount with no root mount offset. So don't try to
274 if (ino
->flags
& AUTOFS_INF_PENDING
||
275 (!d_mountpoint(dentry
) && list_empty(&dentry
->d_subdirs
))) {
276 spin_unlock(&dentry
->d_lock
);
277 spin_unlock(&autofs4_lock
);
278 spin_unlock(&sbi
->fs_lock
);
280 status
= try_to_fill_dentry(dentry
, nd
->flags
);
286 spin_unlock(&dentry
->d_lock
);
287 spin_unlock(&autofs4_lock
);
288 spin_unlock(&sbi
->fs_lock
);
291 * If there is no root mount it must be an autofs
292 * multi-mount with no root offset so we don't need
295 if (d_mountpoint(dentry
)) {
296 if (!autofs4_follow_mount(&nd
->path
)) {
307 return ERR_PTR(status
);
311 * Revalidate is called on every cache lookup. Some of those
312 * cache lookups may actually happen while the dentry is not
313 * yet completely filled in, and revalidate has to delay such
316 static int autofs4_revalidate(struct dentry
*dentry
, struct nameidata
*nd
)
318 struct inode
*dir
= dentry
->d_parent
->d_inode
;
319 struct autofs_sb_info
*sbi
= autofs4_sbi(dir
->i_sb
);
320 int oz_mode
= autofs4_oz_mode(sbi
);
321 int flags
= nd
? nd
->flags
: 0;
325 spin_lock(&sbi
->fs_lock
);
326 if (autofs4_ispending(dentry
)) {
327 /* The daemon never causes a mount to trigger */
328 spin_unlock(&sbi
->fs_lock
);
334 * If the directory has gone away due to an expire
335 * we have been called as ->d_revalidate() and so
336 * we need to return false and proceed to ->lookup().
338 if (autofs4_expire_wait(dentry
) == -EAGAIN
)
342 * A zero status is success otherwise we have a
343 * negative error code.
345 status
= try_to_fill_dentry(dentry
, flags
);
351 spin_unlock(&sbi
->fs_lock
);
353 /* Negative dentry.. invalidate if "old" */
354 if (dentry
->d_inode
== NULL
)
357 /* Check for a non-mountpoint directory with no contents */
358 spin_lock(&autofs4_lock
);
359 spin_lock(&dentry
->d_lock
);
360 if (S_ISDIR(dentry
->d_inode
->i_mode
) &&
361 !d_mountpoint(dentry
) && list_empty(&dentry
->d_subdirs
)) {
362 DPRINTK("dentry=%p %.*s, emptydir",
363 dentry
, dentry
->d_name
.len
, dentry
->d_name
.name
);
364 spin_unlock(&dentry
->d_lock
);
365 spin_unlock(&autofs4_lock
);
367 /* The daemon never causes a mount to trigger */
372 * A zero status is success otherwise we have a
373 * negative error code.
375 status
= try_to_fill_dentry(dentry
, flags
);
381 spin_unlock(&dentry
->d_lock
);
382 spin_unlock(&autofs4_lock
);
387 void autofs4_dentry_release(struct dentry
*de
)
389 struct autofs_info
*inf
;
391 DPRINTK("releasing %p", de
);
393 inf
= autofs4_dentry_ino(de
);
397 struct autofs_sb_info
*sbi
= autofs4_sbi(de
->d_sb
);
400 spin_lock(&sbi
->lookup_lock
);
401 if (!list_empty(&inf
->active
))
402 list_del(&inf
->active
);
403 if (!list_empty(&inf
->expiring
))
404 list_del(&inf
->expiring
);
405 spin_unlock(&sbi
->lookup_lock
);
411 autofs4_free_ino(inf
);
415 /* For dentries of directories in the root dir */
416 static const struct dentry_operations autofs4_root_dentry_operations
= {
417 .d_revalidate
= autofs4_revalidate
,
418 .d_release
= autofs4_dentry_release
,
421 /* For other dentries */
422 static const struct dentry_operations autofs4_dentry_operations
= {
423 .d_revalidate
= autofs4_revalidate
,
424 .d_release
= autofs4_dentry_release
,
427 static struct dentry
*autofs4_lookup_active(struct dentry
*dentry
)
429 struct autofs_sb_info
*sbi
= autofs4_sbi(dentry
->d_sb
);
430 struct dentry
*parent
= dentry
->d_parent
;
431 struct qstr
*name
= &dentry
->d_name
;
432 unsigned int len
= name
->len
;
433 unsigned int hash
= name
->hash
;
434 const unsigned char *str
= name
->name
;
435 struct list_head
*p
, *head
;
437 spin_lock(&autofs4_lock
);
438 spin_lock(&sbi
->lookup_lock
);
439 head
= &sbi
->active_list
;
440 list_for_each(p
, head
) {
441 struct autofs_info
*ino
;
442 struct dentry
*active
;
445 ino
= list_entry(p
, struct autofs_info
, active
);
446 active
= ino
->dentry
;
448 spin_lock(&active
->d_lock
);
451 if (active
->d_count
== 0)
454 qstr
= &active
->d_name
;
456 if (active
->d_name
.hash
!= hash
)
458 if (active
->d_parent
!= parent
)
461 if (qstr
->len
!= len
)
463 if (memcmp(qstr
->name
, str
, len
))
466 if (d_unhashed(active
)) {
468 spin_unlock(&active
->d_lock
);
469 spin_unlock(&sbi
->lookup_lock
);
470 spin_unlock(&autofs4_lock
);
474 spin_unlock(&active
->d_lock
);
476 spin_unlock(&sbi
->lookup_lock
);
477 spin_unlock(&autofs4_lock
);
482 static struct dentry
*autofs4_lookup_expiring(struct dentry
*dentry
)
484 struct autofs_sb_info
*sbi
= autofs4_sbi(dentry
->d_sb
);
485 struct dentry
*parent
= dentry
->d_parent
;
486 struct qstr
*name
= &dentry
->d_name
;
487 unsigned int len
= name
->len
;
488 unsigned int hash
= name
->hash
;
489 const unsigned char *str
= name
->name
;
490 struct list_head
*p
, *head
;
492 spin_lock(&autofs4_lock
);
493 spin_lock(&sbi
->lookup_lock
);
494 head
= &sbi
->expiring_list
;
495 list_for_each(p
, head
) {
496 struct autofs_info
*ino
;
497 struct dentry
*expiring
;
500 ino
= list_entry(p
, struct autofs_info
, expiring
);
501 expiring
= ino
->dentry
;
503 spin_lock(&expiring
->d_lock
);
505 /* Bad luck, we've already been dentry_iput */
506 if (!expiring
->d_inode
)
509 qstr
= &expiring
->d_name
;
511 if (expiring
->d_name
.hash
!= hash
)
513 if (expiring
->d_parent
!= parent
)
516 if (qstr
->len
!= len
)
518 if (memcmp(qstr
->name
, str
, len
))
521 if (d_unhashed(expiring
)) {
522 dget_dlock(expiring
);
523 spin_unlock(&expiring
->d_lock
);
524 spin_unlock(&sbi
->lookup_lock
);
525 spin_unlock(&autofs4_lock
);
529 spin_unlock(&expiring
->d_lock
);
531 spin_unlock(&sbi
->lookup_lock
);
532 spin_unlock(&autofs4_lock
);
537 /* Lookups in the root directory */
538 static struct dentry
*autofs4_lookup(struct inode
*dir
, struct dentry
*dentry
, struct nameidata
*nd
)
540 struct autofs_sb_info
*sbi
;
541 struct autofs_info
*ino
;
542 struct dentry
*expiring
, *active
;
545 DPRINTK("name = %.*s",
546 dentry
->d_name
.len
, dentry
->d_name
.name
);
548 /* File name too long to exist */
549 if (dentry
->d_name
.len
> NAME_MAX
)
550 return ERR_PTR(-ENAMETOOLONG
);
552 sbi
= autofs4_sbi(dir
->i_sb
);
553 oz_mode
= autofs4_oz_mode(sbi
);
555 DPRINTK("pid = %u, pgrp = %u, catatonic = %d, oz_mode = %d",
556 current
->pid
, task_pgrp_nr(current
), sbi
->catatonic
, oz_mode
);
558 active
= autofs4_lookup_active(dentry
);
561 ino
= autofs4_dentry_ino(dentry
);
564 * Mark the dentry incomplete but don't hash it. We do this
565 * to serialize our inode creation operations (symlink and
566 * mkdir) which prevents deadlock during the callback to
567 * the daemon. Subsequent user space lookups for the same
568 * dentry are placed on the wait queue while the daemon
569 * itself is allowed passage unresticted so the create
570 * operation itself can then hash the dentry. Finally,
571 * we check for the hashed dentry and return the newly
574 dentry
->d_op
= &autofs4_root_dentry_operations
;
577 * And we need to ensure that the same dentry is used for
578 * all following lookup calls until it is hashed so that
579 * the dentry flags are persistent throughout the request.
581 ino
= autofs4_init_ino(NULL
, sbi
, 0555);
583 return ERR_PTR(-ENOMEM
);
585 dentry
->d_fsdata
= ino
;
586 ino
->dentry
= dentry
;
588 autofs4_add_active(dentry
);
590 d_instantiate(dentry
, NULL
);
594 mutex_unlock(&dir
->i_mutex
);
595 expiring
= autofs4_lookup_expiring(dentry
);
598 * If we are racing with expire the request might not
599 * be quite complete but the directory has been removed
600 * so it must have been successful, so just wait for it.
602 autofs4_expire_wait(expiring
);
603 autofs4_del_expiring(expiring
);
607 spin_lock(&sbi
->fs_lock
);
608 ino
->flags
|= AUTOFS_INF_PENDING
;
609 spin_unlock(&sbi
->fs_lock
);
610 if (dentry
->d_op
&& dentry
->d_op
->d_revalidate
)
611 (dentry
->d_op
->d_revalidate
)(dentry
, nd
);
612 mutex_lock(&dir
->i_mutex
);
616 * If we are still pending, check if we had to handle
617 * a signal. If so we can force a restart..
619 if (ino
->flags
& AUTOFS_INF_PENDING
) {
620 /* See if we were interrupted */
621 if (signal_pending(current
)) {
622 sigset_t
*sigset
= ¤t
->pending
.signal
;
623 if (sigismember (sigset
, SIGKILL
) ||
624 sigismember (sigset
, SIGQUIT
) ||
625 sigismember (sigset
, SIGINT
)) {
628 return ERR_PTR(-ERESTARTNOINTR
);
632 spin_lock(&sbi
->fs_lock
);
633 ino
->flags
&= ~AUTOFS_INF_PENDING
;
634 spin_unlock(&sbi
->fs_lock
);
639 * If this dentry is unhashed, then we shouldn't honour this
640 * lookup. Returning ENOENT here doesn't do the right thing
641 * for all system calls, but it should be OK for the operations
642 * we permit from an autofs.
644 if (!oz_mode
&& d_unhashed(dentry
)) {
646 * A user space application can (and has done in the past)
647 * remove and re-create this directory during the callback.
648 * This can leave us with an unhashed dentry, but a
649 * successful mount! So we need to perform another
650 * cached lookup in case the dentry now exists.
652 struct dentry
*parent
= dentry
->d_parent
;
653 struct dentry
*new = d_lookup(parent
, &dentry
->d_name
);
657 dentry
= ERR_PTR(-ENOENT
);
671 static int autofs4_dir_symlink(struct inode
*dir
,
672 struct dentry
*dentry
,
675 struct autofs_sb_info
*sbi
= autofs4_sbi(dir
->i_sb
);
676 struct autofs_info
*ino
= autofs4_dentry_ino(dentry
);
677 struct autofs_info
*p_ino
;
681 DPRINTK("%s <- %.*s", symname
,
682 dentry
->d_name
.len
, dentry
->d_name
.name
);
684 if (!autofs4_oz_mode(sbi
))
687 ino
= autofs4_init_ino(ino
, sbi
, S_IFLNK
| 0555);
691 autofs4_del_active(dentry
);
693 ino
->size
= strlen(symname
);
694 cp
= kmalloc(ino
->size
+ 1, GFP_KERNEL
);
696 if (!dentry
->d_fsdata
)
703 inode
= autofs4_get_inode(dir
->i_sb
, ino
);
706 if (!dentry
->d_fsdata
)
710 d_add(dentry
, inode
);
712 if (dir
== dir
->i_sb
->s_root
->d_inode
)
713 dentry
->d_op
= &autofs4_root_dentry_operations
;
715 dentry
->d_op
= &autofs4_dentry_operations
;
717 dentry
->d_fsdata
= ino
;
718 ino
->dentry
= dget(dentry
);
719 atomic_inc(&ino
->count
);
720 p_ino
= autofs4_dentry_ino(dentry
->d_parent
);
721 if (p_ino
&& dentry
->d_parent
!= dentry
)
722 atomic_inc(&p_ino
->count
);
726 dir
->i_mtime
= CURRENT_TIME
;
734 * Normal filesystems would do a "d_delete()" to tell the VFS dcache
735 * that the file no longer exists. However, doing that means that the
736 * VFS layer can turn the dentry into a negative dentry. We don't want
737 * this, because the unlink is probably the result of an expire.
738 * We simply d_drop it and add it to a expiring list in the super block,
739 * which allows the dentry lookup to check for an incomplete expire.
741 * If a process is blocked on the dentry waiting for the expire to finish,
742 * it will invalidate the dentry and try to mount with a new one.
744 * Also see autofs4_dir_rmdir()..
746 static int autofs4_dir_unlink(struct inode
*dir
, struct dentry
*dentry
)
748 struct autofs_sb_info
*sbi
= autofs4_sbi(dir
->i_sb
);
749 struct autofs_info
*ino
= autofs4_dentry_ino(dentry
);
750 struct autofs_info
*p_ino
;
752 /* This allows root to remove symlinks */
753 if (!autofs4_oz_mode(sbi
) && !capable(CAP_SYS_ADMIN
))
756 if (atomic_dec_and_test(&ino
->count
)) {
757 p_ino
= autofs4_dentry_ino(dentry
->d_parent
);
758 if (p_ino
&& dentry
->d_parent
!= dentry
)
759 atomic_dec(&p_ino
->count
);
763 dentry
->d_inode
->i_size
= 0;
764 clear_nlink(dentry
->d_inode
);
766 dir
->i_mtime
= CURRENT_TIME
;
768 spin_lock(&autofs4_lock
);
769 autofs4_add_expiring(dentry
);
770 spin_lock(&dentry
->d_lock
);
772 spin_unlock(&dentry
->d_lock
);
773 spin_unlock(&autofs4_lock
);
778 static int autofs4_dir_rmdir(struct inode
*dir
, struct dentry
*dentry
)
780 struct autofs_sb_info
*sbi
= autofs4_sbi(dir
->i_sb
);
781 struct autofs_info
*ino
= autofs4_dentry_ino(dentry
);
782 struct autofs_info
*p_ino
;
784 DPRINTK("dentry %p, removing %.*s",
785 dentry
, dentry
->d_name
.len
, dentry
->d_name
.name
);
787 if (!autofs4_oz_mode(sbi
))
790 spin_lock(&autofs4_lock
);
791 spin_lock(&sbi
->lookup_lock
);
792 spin_lock(&dentry
->d_lock
);
793 if (!list_empty(&dentry
->d_subdirs
)) {
794 spin_unlock(&dentry
->d_lock
);
795 spin_unlock(&sbi
->lookup_lock
);
796 spin_unlock(&autofs4_lock
);
799 __autofs4_add_expiring(dentry
);
800 spin_unlock(&sbi
->lookup_lock
);
802 spin_unlock(&dentry
->d_lock
);
803 spin_unlock(&autofs4_lock
);
805 if (atomic_dec_and_test(&ino
->count
)) {
806 p_ino
= autofs4_dentry_ino(dentry
->d_parent
);
807 if (p_ino
&& dentry
->d_parent
!= dentry
)
808 atomic_dec(&p_ino
->count
);
811 dentry
->d_inode
->i_size
= 0;
812 clear_nlink(dentry
->d_inode
);
820 static int autofs4_dir_mkdir(struct inode
*dir
, struct dentry
*dentry
, int mode
)
822 struct autofs_sb_info
*sbi
= autofs4_sbi(dir
->i_sb
);
823 struct autofs_info
*ino
= autofs4_dentry_ino(dentry
);
824 struct autofs_info
*p_ino
;
827 if (!autofs4_oz_mode(sbi
))
830 DPRINTK("dentry %p, creating %.*s",
831 dentry
, dentry
->d_name
.len
, dentry
->d_name
.name
);
833 ino
= autofs4_init_ino(ino
, sbi
, S_IFDIR
| 0555);
837 autofs4_del_active(dentry
);
839 inode
= autofs4_get_inode(dir
->i_sb
, ino
);
841 if (!dentry
->d_fsdata
)
845 d_add(dentry
, inode
);
847 if (dir
== dir
->i_sb
->s_root
->d_inode
)
848 dentry
->d_op
= &autofs4_root_dentry_operations
;
850 dentry
->d_op
= &autofs4_dentry_operations
;
852 dentry
->d_fsdata
= ino
;
853 ino
->dentry
= dget(dentry
);
854 atomic_inc(&ino
->count
);
855 p_ino
= autofs4_dentry_ino(dentry
->d_parent
);
856 if (p_ino
&& dentry
->d_parent
!= dentry
)
857 atomic_inc(&p_ino
->count
);
860 dir
->i_mtime
= CURRENT_TIME
;
865 /* Get/set timeout ioctl() operation */
867 static inline int autofs4_compat_get_set_timeout(struct autofs_sb_info
*sbi
,
868 compat_ulong_t __user
*p
)
871 unsigned long ntimeout
;
873 if ((rv
= get_user(ntimeout
, p
)) ||
874 (rv
= put_user(sbi
->exp_timeout
/HZ
, p
)))
877 if (ntimeout
> UINT_MAX
/HZ
)
878 sbi
->exp_timeout
= 0;
880 sbi
->exp_timeout
= ntimeout
* HZ
;
886 static inline int autofs4_get_set_timeout(struct autofs_sb_info
*sbi
,
887 unsigned long __user
*p
)
890 unsigned long ntimeout
;
892 if ((rv
= get_user(ntimeout
, p
)) ||
893 (rv
= put_user(sbi
->exp_timeout
/HZ
, p
)))
896 if (ntimeout
> ULONG_MAX
/HZ
)
897 sbi
->exp_timeout
= 0;
899 sbi
->exp_timeout
= ntimeout
* HZ
;
904 /* Return protocol version */
905 static inline int autofs4_get_protover(struct autofs_sb_info
*sbi
, int __user
*p
)
907 return put_user(sbi
->version
, p
);
910 /* Return protocol sub version */
911 static inline int autofs4_get_protosubver(struct autofs_sb_info
*sbi
, int __user
*p
)
913 return put_user(sbi
->sub_version
, p
);
917 * Tells the daemon whether it can umount the autofs mount.
919 static inline int autofs4_ask_umount(struct vfsmount
*mnt
, int __user
*p
)
926 DPRINTK("returning %d", status
);
928 status
= put_user(status
, p
);
933 /* Identify autofs4_dentries - this is so we can tell if there's
934 an extra dentry refcount or not. We only hold a refcount on the
935 dentry if its non-negative (ie, d_inode != NULL)
937 int is_autofs4_dentry(struct dentry
*dentry
)
939 return dentry
&& dentry
->d_inode
&&
940 (dentry
->d_op
== &autofs4_root_dentry_operations
||
941 dentry
->d_op
== &autofs4_dentry_operations
) &&
942 dentry
->d_fsdata
!= NULL
;
946 * ioctl()'s on the root directory is the chief method for the daemon to
947 * generate kernel reactions
949 static int autofs4_root_ioctl_unlocked(struct inode
*inode
, struct file
*filp
,
950 unsigned int cmd
, unsigned long arg
)
952 struct autofs_sb_info
*sbi
= autofs4_sbi(inode
->i_sb
);
953 void __user
*p
= (void __user
*)arg
;
955 DPRINTK("cmd = 0x%08x, arg = 0x%08lx, sbi = %p, pgrp = %u",
956 cmd
,arg
,sbi
,task_pgrp_nr(current
));
958 if (_IOC_TYPE(cmd
) != _IOC_TYPE(AUTOFS_IOC_FIRST
) ||
959 _IOC_NR(cmd
) - _IOC_NR(AUTOFS_IOC_FIRST
) >= AUTOFS_IOC_COUNT
)
962 if (!autofs4_oz_mode(sbi
) && !capable(CAP_SYS_ADMIN
))
966 case AUTOFS_IOC_READY
: /* Wait queue: go ahead and retry */
967 return autofs4_wait_release(sbi
,(autofs_wqt_t
)arg
,0);
968 case AUTOFS_IOC_FAIL
: /* Wait queue: fail with ENOENT */
969 return autofs4_wait_release(sbi
,(autofs_wqt_t
)arg
,-ENOENT
);
970 case AUTOFS_IOC_CATATONIC
: /* Enter catatonic mode (daemon shutdown) */
971 autofs4_catatonic_mode(sbi
);
973 case AUTOFS_IOC_PROTOVER
: /* Get protocol version */
974 return autofs4_get_protover(sbi
, p
);
975 case AUTOFS_IOC_PROTOSUBVER
: /* Get protocol sub version */
976 return autofs4_get_protosubver(sbi
, p
);
977 case AUTOFS_IOC_SETTIMEOUT
:
978 return autofs4_get_set_timeout(sbi
, p
);
980 case AUTOFS_IOC_SETTIMEOUT32
:
981 return autofs4_compat_get_set_timeout(sbi
, p
);
984 case AUTOFS_IOC_ASKUMOUNT
:
985 return autofs4_ask_umount(filp
->f_path
.mnt
, p
);
987 /* return a single thing to expire */
988 case AUTOFS_IOC_EXPIRE
:
989 return autofs4_expire_run(inode
->i_sb
,filp
->f_path
.mnt
,sbi
, p
);
990 /* same as above, but can send multiple expires through pipe */
991 case AUTOFS_IOC_EXPIRE_MULTI
:
992 return autofs4_expire_multi(inode
->i_sb
,filp
->f_path
.mnt
,sbi
, p
);
999 static long autofs4_root_ioctl(struct file
*filp
,
1000 unsigned int cmd
, unsigned long arg
)
1002 struct inode
*inode
= filp
->f_dentry
->d_inode
;
1003 return autofs4_root_ioctl_unlocked(inode
, filp
, cmd
, arg
);
1006 #ifdef CONFIG_COMPAT
1007 static long autofs4_root_compat_ioctl(struct file
*filp
,
1008 unsigned int cmd
, unsigned long arg
)
1010 struct inode
*inode
= filp
->f_path
.dentry
->d_inode
;
1013 if (cmd
== AUTOFS_IOC_READY
|| cmd
== AUTOFS_IOC_FAIL
)
1014 ret
= autofs4_root_ioctl_unlocked(inode
, filp
, cmd
, arg
);
1016 ret
= autofs4_root_ioctl_unlocked(inode
, filp
, cmd
,
1017 (unsigned long)compat_ptr(arg
));