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_TYPE_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;