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>
8 * This file is part of the Linux kernel and is made available under
9 * the terms of the GNU General Public License, version 2, or at your
10 * option, any later version, incorporated herein by reference.
12 * ------------------------------------------------------------------------- */
14 #include <linux/errno.h>
15 #include <linux/stat.h>
16 #include <linux/param.h>
17 #include <linux/time.h>
18 #include <linux/smp_lock.h>
21 static struct dentry
*autofs4_dir_lookup(struct inode
*,struct dentry
*, struct nameidata
*);
22 static int autofs4_dir_symlink(struct inode
*,struct dentry
*,const char *);
23 static int autofs4_dir_unlink(struct inode
*,struct dentry
*);
24 static int autofs4_dir_rmdir(struct inode
*,struct dentry
*);
25 static int autofs4_dir_mkdir(struct inode
*,struct dentry
*,int);
26 static int autofs4_root_ioctl(struct inode
*, struct file
*,unsigned int,unsigned long);
27 static struct dentry
*autofs4_root_lookup(struct inode
*,struct dentry
*, struct nameidata
*);
29 struct file_operations autofs4_root_operations
= {
30 .open
= dcache_dir_open
,
31 .release
= dcache_dir_close
,
32 .llseek
= dcache_dir_lseek
,
33 .read
= generic_read_dir
,
34 .readdir
= dcache_readdir
,
35 .ioctl
= autofs4_root_ioctl
,
38 struct inode_operations autofs4_root_inode_operations
= {
39 .lookup
= autofs4_root_lookup
,
40 .unlink
= autofs4_dir_unlink
,
41 .symlink
= autofs4_dir_symlink
,
42 .mkdir
= autofs4_dir_mkdir
,
43 .rmdir
= autofs4_dir_rmdir
,
46 struct inode_operations autofs4_dir_inode_operations
= {
47 .lookup
= autofs4_dir_lookup
,
48 .unlink
= autofs4_dir_unlink
,
49 .symlink
= autofs4_dir_symlink
,
50 .mkdir
= autofs4_dir_mkdir
,
51 .rmdir
= autofs4_dir_rmdir
,
54 /* Update usage from here to top of tree, so that scan of
55 top-level directories will give a useful result */
56 static void autofs4_update_usage(struct dentry
*dentry
)
58 struct dentry
*top
= dentry
->d_sb
->s_root
;
60 for(; dentry
!= top
; dentry
= dentry
->d_parent
) {
61 struct autofs_info
*ino
= autofs4_dentry_ino(dentry
);
64 update_atime(dentry
->d_inode
);
65 ino
->last_used
= jiffies
;
70 static int try_to_fill_dentry(struct dentry
*dentry
,
71 struct super_block
*sb
,
72 struct autofs_sb_info
*sbi
)
74 struct autofs_info
*de_info
= autofs4_dentry_ino(dentry
);
77 /* Block on any pending expiry here; invalidate the dentry
78 when expiration is done to trigger mount request with a new
80 if (de_info
&& (de_info
->flags
& AUTOFS_INF_EXPIRING
)) {
81 DPRINTK(("try_to_fill_entry: waiting for expire %p name=%.*s, flags&PENDING=%s de_info=%p de_info->flags=%x\n",
82 dentry
, dentry
->d_name
.len
, dentry
->d_name
.name
,
83 dentry
->d_flags
& DCACHE_AUTOFS_PENDING
?"t":"f",
84 de_info
, de_info
?de_info
->flags
:0));
85 status
= autofs4_wait(sbi
, &dentry
->d_name
, NFY_NONE
);
87 DPRINTK(("try_to_fill_entry: expire done status=%d\n", status
));
92 DPRINTK(("try_to_fill_entry: dentry=%p %.*s ino=%p\n",
93 dentry
, dentry
->d_name
.len
, dentry
->d_name
.name
, dentry
->d_inode
));
95 /* Wait for a pending mount, triggering one if there isn't one already */
96 while(dentry
->d_inode
== NULL
) {
97 DPRINTK(("try_to_fill_entry: waiting for mount name=%.*s, de_info=%p de_info->flags=%x\n",
98 dentry
->d_name
.len
, dentry
->d_name
.name
,
99 de_info
, de_info
?de_info
->flags
:0));
100 status
= autofs4_wait(sbi
, &dentry
->d_name
, NFY_MOUNT
);
102 DPRINTK(("try_to_fill_entry: mount done status=%d\n", status
));
104 if (status
&& dentry
->d_inode
)
105 return 0; /* Try to get the kernel to invalidate this dentry */
107 /* Turn this into a real negative dentry? */
108 if (status
== -ENOENT
) {
109 dentry
->d_time
= jiffies
+ AUTOFS_NEGATIVE_TIMEOUT
;
110 dentry
->d_flags
&= ~DCACHE_AUTOFS_PENDING
;
113 /* Return a negative dentry, but leave it "pending" */
118 /* If this is an unused directory that isn't a mount point,
119 bitch at the daemon and fix it in user space */
120 spin_lock(&dcache_lock
);
121 if (S_ISDIR(dentry
->d_inode
->i_mode
) &&
122 !d_mountpoint(dentry
) &&
123 list_empty(&dentry
->d_subdirs
)) {
124 DPRINTK(("try_to_fill_entry: mounting existing dir\n"));
125 spin_unlock(&dcache_lock
);
126 return autofs4_wait(sbi
, &dentry
->d_name
, NFY_MOUNT
) == 0;
128 spin_unlock(&dcache_lock
);
130 /* We don't update the usages for the autofs daemon itself, this
131 is necessary for recursive autofs mounts */
132 if (!autofs4_oz_mode(sbi
))
133 autofs4_update_usage(dentry
);
135 dentry
->d_flags
&= ~DCACHE_AUTOFS_PENDING
;
141 * Revalidate is called on every cache lookup. Some of those
142 * cache lookups may actually happen while the dentry is not
143 * yet completely filled in, and revalidate has to delay such
146 static int autofs4_root_revalidate(struct dentry
* dentry
, struct nameidata
*nd
)
148 struct inode
* dir
= dentry
->d_parent
->d_inode
;
149 struct autofs_sb_info
*sbi
= autofs4_sbi(dir
->i_sb
);
150 int oz_mode
= autofs4_oz_mode(sbi
);
153 if (autofs4_ispending(dentry
)) {
154 if (autofs4_oz_mode(sbi
))
157 return try_to_fill_dentry(dentry
, dir
->i_sb
, sbi
);
160 /* Negative dentry.. invalidate if "old" */
161 if (dentry
->d_inode
== NULL
)
162 return (dentry
->d_time
- jiffies
<= AUTOFS_NEGATIVE_TIMEOUT
);
164 /* Check for a non-mountpoint directory with no contents */
165 spin_lock(&dcache_lock
);
166 if (S_ISDIR(dentry
->d_inode
->i_mode
) &&
167 !d_mountpoint(dentry
) &&
168 list_empty(&dentry
->d_subdirs
)) {
169 DPRINTK(("autofs_root_revalidate: dentry=%p %.*s, emptydir\n",
170 dentry
, dentry
->d_name
.len
, dentry
->d_name
.name
));
171 spin_unlock(&dcache_lock
);
175 return try_to_fill_dentry(dentry
, dir
->i_sb
, sbi
);
177 spin_unlock(&dcache_lock
);
179 /* Update the usage list */
181 autofs4_update_usage(dentry
);
186 static int autofs4_revalidate(struct dentry
*dentry
, struct nameidata
*nd
)
188 struct autofs_sb_info
*sbi
= autofs4_sbi(dentry
->d_sb
);
190 if (!autofs4_oz_mode(sbi
))
191 autofs4_update_usage(dentry
);
196 static void autofs4_dentry_release(struct dentry
*de
)
198 struct autofs_info
*inf
;
200 DPRINTK(("autofs4_dentry_release: releasing %p\n", de
));
202 inf
= autofs4_dentry_ino(de
);
209 autofs4_free_ino(inf
);
213 /* For dentries of directories in the root dir */
214 static struct dentry_operations autofs4_root_dentry_operations
= {
215 .d_revalidate
= autofs4_root_revalidate
,
216 .d_release
= autofs4_dentry_release
,
219 /* For other dentries */
220 static struct dentry_operations autofs4_dentry_operations
= {
221 .d_revalidate
= autofs4_revalidate
,
222 .d_release
= autofs4_dentry_release
,
225 /* Lookups in non-root dirs never find anything - if it's there, it's
226 already in the dcache */
228 static struct dentry
*autofs4_dir_lookup(struct inode
*dir
, struct dentry
*dentry
, struct nameidata
*nd
)
231 DPRINTK(("autofs_dir_lookup: ignoring lookup of %.*s/%.*s\n",
232 dentry
->d_parent
->d_name
.len
, dentry
->d_parent
->d_name
.name
,
233 dentry
->d_name
.len
, dentry
->d_name
.name
));
236 dentry
->d_fsdata
= NULL
;
241 /* Lookups in the root directory */
242 static struct dentry
*autofs4_root_lookup(struct inode
*dir
, struct dentry
*dentry
, struct nameidata
*nd
)
244 struct autofs_sb_info
*sbi
;
247 DPRINTK(("autofs_root_lookup: name = %.*s\n",
248 dentry
->d_name
.len
, dentry
->d_name
.name
));
250 if (dentry
->d_name
.len
> NAME_MAX
)
251 return ERR_PTR(-ENAMETOOLONG
);/* File name too long to exist */
253 sbi
= autofs4_sbi(dir
->i_sb
);
256 oz_mode
= autofs4_oz_mode(sbi
);
257 DPRINTK(("autofs_lookup: pid = %u, pgrp = %u, catatonic = %d, oz_mode = %d\n",
258 current
->pid
, current
->pgrp
, sbi
->catatonic
, oz_mode
));
261 * Mark the dentry incomplete, but add it. This is needed so
262 * that the VFS layer knows about the dentry, and we can count
263 * on catching any lookups through the revalidate.
265 * Let all the hard work be done by the revalidate function that
266 * needs to be able to do this anyway..
268 * We need to do this before we release the directory semaphore.
270 dentry
->d_op
= &autofs4_root_dentry_operations
;
273 dentry
->d_flags
|= DCACHE_AUTOFS_PENDING
;
274 dentry
->d_fsdata
= NULL
;
277 if (dentry
->d_op
&& dentry
->d_op
->d_revalidate
) {
279 (dentry
->d_op
->d_revalidate
)(dentry
, nd
);
284 * If we are still pending, check if we had to handle
285 * a signal. If so we can force a restart..
287 if (dentry
->d_flags
& DCACHE_AUTOFS_PENDING
) {
288 if (signal_pending(current
)) {
290 return ERR_PTR(-ERESTARTNOINTR
);
296 * If this dentry is unhashed, then we shouldn't honour this
297 * lookup even if the dentry is positive. Returning ENOENT here
298 * doesn't do the right thing for all system calls, but it should
299 * be OK for the operations we permit from an autofs.
301 if ( dentry
->d_inode
&& d_unhashed(dentry
) )
302 return ERR_PTR(-ENOENT
);
307 static int autofs4_dir_symlink(struct inode
*dir
,
308 struct dentry
*dentry
,
311 struct autofs_sb_info
*sbi
= autofs4_sbi(dir
->i_sb
);
312 struct autofs_info
*ino
= autofs4_dentry_ino(dentry
);
316 DPRINTK(("autofs_dir_symlink: %s <- %.*s\n", symname
,
317 dentry
->d_name
.len
, dentry
->d_name
.name
));
320 if (!autofs4_oz_mode(sbi
)) {
325 ino
= autofs4_init_ino(ino
, sbi
, S_IFLNK
| 0555);
331 ino
->size
= strlen(symname
);
332 ino
->u
.symlink
= cp
= kmalloc(ino
->size
+ 1, GFP_KERNEL
);
342 inode
= autofs4_get_inode(dir
->i_sb
, ino
);
343 d_instantiate(dentry
, inode
);
345 if (dir
== dir
->i_sb
->s_root
->d_inode
)
346 dentry
->d_op
= &autofs4_root_dentry_operations
;
348 dentry
->d_op
= &autofs4_dentry_operations
;
350 dentry
->d_fsdata
= ino
;
351 ino
->dentry
= dget(dentry
);
354 dir
->i_mtime
= CURRENT_TIME
;
363 * Normal filesystems would do a "d_delete()" to tell the VFS dcache
364 * that the file no longer exists. However, doing that means that the
365 * VFS layer can turn the dentry into a negative dentry. We don't want
366 * this, because since the unlink is probably the result of an expire.
367 * We simply d_drop it, which allows the dentry lookup to remount it
370 * If a process is blocked on the dentry waiting for the expire to finish,
371 * it will invalidate the dentry and try to mount with a new one.
373 * Also see autofs_dir_rmdir()..
375 static int autofs4_dir_unlink(struct inode
*dir
, struct dentry
*dentry
)
377 struct autofs_sb_info
*sbi
= autofs4_sbi(dir
->i_sb
);
378 struct autofs_info
*ino
= autofs4_dentry_ino(dentry
);
380 /* This allows root to remove symlinks */
382 if ( !autofs4_oz_mode(sbi
) && !capable(CAP_SYS_ADMIN
) ) {
389 dentry
->d_inode
->i_size
= 0;
390 dentry
->d_inode
->i_nlink
= 0;
392 dir
->i_mtime
= CURRENT_TIME
;
401 static int autofs4_dir_rmdir(struct inode
*dir
, struct dentry
*dentry
)
403 struct autofs_sb_info
*sbi
= autofs4_sbi(dir
->i_sb
);
404 struct autofs_info
*ino
= autofs4_dentry_ino(dentry
);
407 if (!autofs4_oz_mode(sbi
)) {
412 spin_lock(&dcache_lock
);
413 if (!list_empty(&dentry
->d_subdirs
)) {
414 spin_unlock(&dcache_lock
);
419 spin_unlock(&dcache_lock
);
423 dentry
->d_inode
->i_size
= 0;
424 dentry
->d_inode
->i_nlink
= 0;
435 static int autofs4_dir_mkdir(struct inode
*dir
, struct dentry
*dentry
, int mode
)
437 struct autofs_sb_info
*sbi
= autofs4_sbi(dir
->i_sb
);
438 struct autofs_info
*ino
= autofs4_dentry_ino(dentry
);
442 if ( !autofs4_oz_mode(sbi
) ) {
447 DPRINTK(("autofs_dir_mkdir: dentry %p, creating %.*s\n",
448 dentry
, dentry
->d_name
.len
, dentry
->d_name
.name
));
450 ino
= autofs4_init_ino(ino
, sbi
, S_IFDIR
| 0555);
456 inode
= autofs4_get_inode(dir
->i_sb
, ino
);
457 d_instantiate(dentry
, inode
);
459 if (dir
== dir
->i_sb
->s_root
->d_inode
)
460 dentry
->d_op
= &autofs4_root_dentry_operations
;
462 dentry
->d_op
= &autofs4_dentry_operations
;
464 dentry
->d_fsdata
= ino
;
465 ino
->dentry
= dget(dentry
);
468 dir
->i_mtime
= CURRENT_TIME
;
474 /* Get/set timeout ioctl() operation */
475 static inline int autofs4_get_set_timeout(struct autofs_sb_info
*sbi
,
479 unsigned long ntimeout
;
481 if ( (rv
= get_user(ntimeout
, p
)) ||
482 (rv
= put_user(sbi
->exp_timeout
/HZ
, p
)) )
485 if ( ntimeout
> ULONG_MAX
/HZ
)
486 sbi
->exp_timeout
= 0;
488 sbi
->exp_timeout
= ntimeout
* HZ
;
493 /* Return protocol version */
494 static inline int autofs4_get_protover(struct autofs_sb_info
*sbi
, int *p
)
496 return put_user(sbi
->version
, p
);
499 /* Identify autofs_dentries - this is so we can tell if there's
500 an extra dentry refcount or not. We only hold a refcount on the
501 dentry if its non-negative (ie, d_inode != NULL)
503 int is_autofs4_dentry(struct dentry
*dentry
)
505 return dentry
&& dentry
->d_inode
&&
506 (dentry
->d_op
== &autofs4_root_dentry_operations
||
507 dentry
->d_op
== &autofs4_dentry_operations
) &&
508 dentry
->d_fsdata
!= NULL
;
512 * ioctl()'s on the root directory is the chief method for the daemon to
513 * generate kernel reactions
515 static int autofs4_root_ioctl(struct inode
*inode
, struct file
*filp
,
516 unsigned int cmd
, unsigned long arg
)
518 struct autofs_sb_info
*sbi
= autofs4_sbi(inode
->i_sb
);
520 DPRINTK(("autofs_ioctl: cmd = 0x%08x, arg = 0x%08lx, sbi = %p, pgrp = %u\n",
521 cmd
,arg
,sbi
,current
->pgrp
));
523 if ( _IOC_TYPE(cmd
) != _IOC_TYPE(AUTOFS_IOC_FIRST
) ||
524 _IOC_NR(cmd
) - _IOC_NR(AUTOFS_IOC_FIRST
) >= AUTOFS_IOC_COUNT
)
527 if ( !autofs4_oz_mode(sbi
) && !capable(CAP_SYS_ADMIN
) )
531 case AUTOFS_IOC_READY
: /* Wait queue: go ahead and retry */
532 return autofs4_wait_release(sbi
,(autofs_wqt_t
)arg
,0);
533 case AUTOFS_IOC_FAIL
: /* Wait queue: fail with ENOENT */
534 return autofs4_wait_release(sbi
,(autofs_wqt_t
)arg
,-ENOENT
);
535 case AUTOFS_IOC_CATATONIC
: /* Enter catatonic mode (daemon shutdown) */
536 autofs4_catatonic_mode(sbi
);
538 case AUTOFS_IOC_PROTOVER
: /* Get protocol version */
539 return autofs4_get_protover(sbi
, (int *)arg
);
540 case AUTOFS_IOC_SETTIMEOUT
:
541 return autofs4_get_set_timeout(sbi
,(unsigned long *)arg
);
543 /* return a single thing to expire */
544 case AUTOFS_IOC_EXPIRE
:
545 return autofs4_expire_run(inode
->i_sb
,filp
->f_vfsmnt
,sbi
,
546 (struct autofs_packet_expire
*)arg
);
547 /* same as above, but can send multiple expires through pipe */
548 case AUTOFS_IOC_EXPIRE_MULTI
:
549 return autofs4_expire_multi(inode
->i_sb
,filp
->f_vfsmnt
,sbi
,