1 /* -*- c -*- --------------------------------------------------------------- *
3 * linux/fs/autofs/expire.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 * ------------------------------------------------------------------------- */
17 static unsigned long now
;
19 /* Check if a dentry can be expired */
20 static inline int autofs4_can_expire(struct dentry
*dentry
,
21 unsigned long timeout
, int do_now
)
23 struct autofs_info
*ino
= autofs4_dentry_ino(dentry
);
25 /* dentry in the process of being deleted */
29 /* No point expiring a pending mount */
30 if (dentry
->d_flags
& DCACHE_AUTOFS_PENDING
)
34 /* Too young to die */
35 if (time_after(ino
->last_used
+ timeout
, now
))
38 /* update last_used here :-
39 - obviously makes sense if it is in use now
40 - less obviously, prevents rapid-fire expire
41 attempts if expire fails the first time */
47 /* Check a mount point for busyness */
48 static int autofs4_mount_busy(struct vfsmount
*mnt
, struct dentry
*dentry
)
50 struct dentry
*top
= dentry
;
53 DPRINTK("dentry %p %.*s",
54 dentry
, (int)dentry
->d_name
.len
, dentry
->d_name
.name
);
59 if (!autofs4_follow_mount(&mnt
, &dentry
))
62 /* This is an autofs submount, we can't expire it */
63 if (is_autofs4_dentry(dentry
))
66 /* Update the expiry counter if fs is busy */
67 if (!may_umount_tree(mnt
)) {
68 struct autofs_info
*ino
= autofs4_dentry_ino(top
);
69 ino
->last_used
= jiffies
;
75 DPRINTK("returning = %d", status
);
82 * Calculate next entry in top down tree traversal.
83 * From next_mnt in namespace.c - elegant.
85 static struct dentry
*next_dentry(struct dentry
*p
, struct dentry
*root
)
87 struct list_head
*next
= p
->d_subdirs
.next
;
89 if (next
== &p
->d_subdirs
) {
93 next
= p
->d_u
.d_child
.next
;
94 if (next
!= &p
->d_parent
->d_subdirs
)
99 return list_entry(next
, struct dentry
, d_u
.d_child
);
103 * Check a direct mount point for busyness.
104 * Direct mounts have similar expiry semantics to tree mounts.
105 * The tree is not busy iff no mountpoints are busy and there are no
108 static int autofs4_direct_busy(struct vfsmount
*mnt
,
110 unsigned long timeout
,
113 DPRINTK("top %p %.*s",
114 top
, (int) top
->d_name
.len
, top
->d_name
.name
);
116 /* Not a mountpoint - give up */
117 if (!d_mountpoint(top
))
120 /* If it's busy update the expiry counters */
121 if (!may_umount_tree(mnt
)) {
122 struct autofs_info
*ino
= autofs4_dentry_ino(top
);
124 ino
->last_used
= jiffies
;
128 /* Timeout of a direct mount is determined by its top dentry */
129 if (!autofs4_can_expire(top
, timeout
, do_now
))
135 /* Check a directory tree of mount points for busyness
136 * The tree is not busy iff no mountpoints are busy
138 static int autofs4_tree_busy(struct vfsmount
*mnt
,
140 unsigned long timeout
,
143 struct autofs_info
*top_ino
= autofs4_dentry_ino(top
);
146 DPRINTK("top %p %.*s",
147 top
, (int)top
->d_name
.len
, top
->d_name
.name
);
149 /* Negative dentry - give up */
150 if (!simple_positive(top
))
153 spin_lock(&dcache_lock
);
154 for (p
= top
; p
; p
= next_dentry(p
, top
)) {
155 /* Negative dentry - give up */
156 if (!simple_positive(p
))
159 DPRINTK("dentry %p %.*s",
160 p
, (int) p
->d_name
.len
, p
->d_name
.name
);
163 spin_unlock(&dcache_lock
);
166 * Is someone visiting anywhere in the subtree ?
167 * If there's no mount we need to check the usage
168 * count for the autofs dentry.
169 * If the fs is busy update the expiry counter.
171 if (d_mountpoint(p
)) {
172 if (autofs4_mount_busy(mnt
, p
)) {
173 top_ino
->last_used
= jiffies
;
178 struct autofs_info
*ino
= autofs4_dentry_ino(p
);
179 unsigned int ino_count
= atomic_read(&ino
->count
);
181 /* allow for dget above and top is already dgot */
187 if (atomic_read(&p
->d_count
) > ino_count
) {
188 top_ino
->last_used
= jiffies
;
194 spin_lock(&dcache_lock
);
196 spin_unlock(&dcache_lock
);
198 /* Timeout of a tree mount is ultimately determined by its top dentry */
199 if (!autofs4_can_expire(top
, timeout
, do_now
))
205 static struct dentry
*autofs4_check_leaves(struct vfsmount
*mnt
,
206 struct dentry
*parent
,
207 unsigned long timeout
,
212 DPRINTK("parent %p %.*s",
213 parent
, (int)parent
->d_name
.len
, parent
->d_name
.name
);
215 spin_lock(&dcache_lock
);
216 for (p
= parent
; p
; p
= next_dentry(p
, parent
)) {
217 /* Negative dentry - give up */
218 if (!simple_positive(p
))
221 DPRINTK("dentry %p %.*s",
222 p
, (int) p
->d_name
.len
, p
->d_name
.name
);
225 spin_unlock(&dcache_lock
);
227 if (d_mountpoint(p
)) {
228 /* Can we umount this guy */
229 if (autofs4_mount_busy(mnt
, p
))
232 /* Can we expire this guy */
233 if (autofs4_can_expire(p
, timeout
, do_now
))
238 spin_lock(&dcache_lock
);
240 spin_unlock(&dcache_lock
);
244 /* Check if we can expire a direct mount (possibly a tree) */
245 static struct dentry
*autofs4_expire_direct(struct super_block
*sb
,
246 struct vfsmount
*mnt
,
247 struct autofs_sb_info
*sbi
,
250 unsigned long timeout
;
251 struct dentry
*root
= dget(sb
->s_root
);
252 int do_now
= how
& AUTOFS_EXP_IMMEDIATE
;
254 if (!sbi
->exp_timeout
|| !root
)
258 timeout
= sbi
->exp_timeout
;
260 /* Lock the tree as we must expire as a whole */
261 spin_lock(&sbi
->fs_lock
);
262 if (!autofs4_direct_busy(mnt
, root
, timeout
, do_now
)) {
263 struct autofs_info
*ino
= autofs4_dentry_ino(root
);
265 /* Set this flag early to catch sys_chdir and the like */
266 ino
->flags
|= AUTOFS_INF_EXPIRING
;
267 spin_unlock(&sbi
->fs_lock
);
270 spin_unlock(&sbi
->fs_lock
);
277 * Find an eligible tree to time-out
278 * A tree is eligible if :-
279 * - it is unused by any user process
280 * - it has been unused for exp_timeout time
282 static struct dentry
*autofs4_expire_indirect(struct super_block
*sb
,
283 struct vfsmount
*mnt
,
284 struct autofs_sb_info
*sbi
,
287 unsigned long timeout
;
288 struct dentry
*root
= sb
->s_root
;
289 struct dentry
*expired
= NULL
;
290 struct list_head
*next
;
291 int do_now
= how
& AUTOFS_EXP_IMMEDIATE
;
292 int exp_leaves
= how
& AUTOFS_EXP_LEAVES
;
294 if ( !sbi
->exp_timeout
|| !root
)
298 timeout
= sbi
->exp_timeout
;
300 spin_lock(&dcache_lock
);
301 next
= root
->d_subdirs
.next
;
303 /* On exit from the loop expire is set to a dgot dentry
304 * to expire or it's NULL */
305 while ( next
!= &root
->d_subdirs
) {
306 struct dentry
*dentry
= list_entry(next
, struct dentry
, d_u
.d_child
);
308 /* Negative dentry - give up */
309 if (!simple_positive(dentry
)) {
314 dentry
= dget(dentry
);
315 spin_unlock(&dcache_lock
);
318 * Case 1: (i) indirect mount or top level pseudo direct mount
320 * (ii) indirect mount with offset mount, check the "/"
321 * offset (autofs-5.0+).
323 if (d_mountpoint(dentry
)) {
324 DPRINTK("checking mountpoint %p %.*s",
325 dentry
, (int)dentry
->d_name
.len
, dentry
->d_name
.name
);
327 /* Can we umount this guy */
328 if (autofs4_mount_busy(mnt
, dentry
))
331 /* Can we expire this guy */
332 if (autofs4_can_expire(dentry
, timeout
, do_now
)) {
339 if (simple_empty(dentry
))
342 /* Case 2: tree mount, expire iff entire tree is not busy */
344 /* Lock the tree as we must expire as a whole */
345 spin_lock(&sbi
->fs_lock
);
346 if (!autofs4_tree_busy(mnt
, dentry
, timeout
, do_now
)) {
347 struct autofs_info
*inf
= autofs4_dentry_ino(dentry
);
349 /* Set this flag early to catch sys_chdir and the like */
350 inf
->flags
|= AUTOFS_INF_EXPIRING
;
351 spin_unlock(&sbi
->fs_lock
);
355 spin_unlock(&sbi
->fs_lock
);
357 * Case 3: pseudo direct mount, expire individual leaves
361 expired
= autofs4_check_leaves(mnt
, dentry
, timeout
, do_now
);
369 spin_lock(&dcache_lock
);
374 DPRINTK("returning %p %.*s",
375 expired
, (int)expired
->d_name
.len
, expired
->d_name
.name
);
376 spin_lock(&dcache_lock
);
377 list_del(&expired
->d_parent
->d_subdirs
);
378 list_add(&expired
->d_parent
->d_subdirs
, &expired
->d_u
.d_child
);
379 spin_unlock(&dcache_lock
);
382 spin_unlock(&dcache_lock
);
387 /* Perform an expiry operation */
388 int autofs4_expire_run(struct super_block
*sb
,
389 struct vfsmount
*mnt
,
390 struct autofs_sb_info
*sbi
,
391 struct autofs_packet_expire __user
*pkt_p
)
393 struct autofs_packet_expire pkt
;
394 struct dentry
*dentry
;
396 memset(&pkt
,0,sizeof pkt
);
398 pkt
.hdr
.proto_version
= sbi
->version
;
399 pkt
.hdr
.type
= autofs_ptype_expire
;
401 if ((dentry
= autofs4_expire_indirect(sb
, mnt
, sbi
, 0)) == NULL
)
404 pkt
.len
= dentry
->d_name
.len
;
405 memcpy(pkt
.name
, dentry
->d_name
.name
, pkt
.len
);
406 pkt
.name
[pkt
.len
] = '\0';
409 if ( copy_to_user(pkt_p
, &pkt
, sizeof(struct autofs_packet_expire
)) )
415 /* Call repeatedly until it returns -EAGAIN, meaning there's nothing
417 int autofs4_expire_multi(struct super_block
*sb
, struct vfsmount
*mnt
,
418 struct autofs_sb_info
*sbi
, int __user
*arg
)
420 struct dentry
*dentry
;
424 if (arg
&& get_user(do_now
, arg
))
427 if (sbi
->type
& AUTOFS_TYP_DIRECT
)
428 dentry
= autofs4_expire_direct(sb
, mnt
, sbi
, do_now
);
430 dentry
= autofs4_expire_indirect(sb
, mnt
, sbi
, do_now
);
433 struct autofs_info
*ino
= autofs4_dentry_ino(dentry
);
435 /* This is synchronous because it makes the daemon a
437 ino
->flags
|= AUTOFS_INF_EXPIRING
;
438 ret
= autofs4_wait(sbi
, dentry
, NFY_EXPIRE
);
439 ino
->flags
&= ~AUTOFS_INF_EXPIRING
;