705b9f057fb3b2ca35ad3e57ab57e5579fa067aa
[linux-2.6.git] / fs / autofs4 / expire.c
1 /* -*- c -*- --------------------------------------------------------------- *
2  *
3  * linux/fs/autofs/expire.c
4  *
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>
8  *
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.
12  *
13  * ------------------------------------------------------------------------- */
14
15 #include "autofs_i.h"
16
17 static unsigned long now;
18
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)
22 {
23         struct autofs_info *ino = autofs4_dentry_ino(dentry);
24
25         /* dentry in the process of being deleted */
26         if (ino == NULL)
27                 return 0;
28
29         /* No point expiring a pending mount */
30         if (dentry->d_flags & DCACHE_AUTOFS_PENDING)
31                 return 0;
32
33         if (!do_now) {
34                 /* Too young to die */
35                 if (!timeout || time_after(ino->last_used + timeout, now))
36                         return 0;
37
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 */
42                 ino->last_used = now;
43         }
44         return 1;
45 }
46
47 /* Check a mount point for busyness */
48 static int autofs4_mount_busy(struct vfsmount *mnt, struct dentry *dentry)
49 {
50         struct dentry *top = dentry;
51         int status = 1;
52
53         DPRINTK("dentry %p %.*s",
54                 dentry, (int)dentry->d_name.len, dentry->d_name.name);
55
56         mntget(mnt);
57         dget(dentry);
58
59         if (!autofs4_follow_mount(&mnt, &dentry))
60                 goto done;
61
62         /* This is an autofs submount, we can't expire it */
63         if (is_autofs4_dentry(dentry))
64                 goto done;
65
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;
70                 goto done;
71         }
72
73         status = 0;
74 done:
75         DPRINTK("returning = %d", status);
76         dput(dentry);
77         mntput(mnt);
78         return status;
79 }
80
81 /*
82  * Calculate next entry in top down tree traversal.
83  * From next_mnt in namespace.c - elegant.
84  */
85 static struct dentry *next_dentry(struct dentry *p, struct dentry *root)
86 {
87         struct list_head *next = p->d_subdirs.next;
88
89         if (next == &p->d_subdirs) {
90                 while (1) {
91                         if (p == root)
92                                 return NULL;
93                         next = p->d_u.d_child.next;
94                         if (next != &p->d_parent->d_subdirs)
95                                 break;
96                         p = p->d_parent;
97                 }
98         }
99         return list_entry(next, struct dentry, d_u.d_child);
100 }
101
102 /*
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
106  * autofs submounts.
107  */
108 static int autofs4_direct_busy(struct vfsmount *mnt,
109                                 struct dentry *top,
110                                 unsigned long timeout,
111                                 int do_now)
112 {
113         DPRINTK("top %p %.*s",
114                 top, (int) top->d_name.len, top->d_name.name);
115
116         /* If it's busy update the expiry counters */
117         if (!may_umount_tree(mnt)) {
118                 struct autofs_info *ino = autofs4_dentry_ino(top);
119                 if (ino)
120                         ino->last_used = jiffies;
121                 return 1;
122         }
123
124         /* Timeout of a direct mount is determined by its top dentry */
125         if (!autofs4_can_expire(top, timeout, do_now))
126                 return 1;
127
128         return 0;
129 }
130
131 /* Check a directory tree of mount points for busyness
132  * The tree is not busy iff no mountpoints are busy
133  */
134 static int autofs4_tree_busy(struct vfsmount *mnt,
135                              struct dentry *top,
136                              unsigned long timeout,
137                              int do_now)
138 {
139         struct autofs_info *top_ino = autofs4_dentry_ino(top);
140         struct dentry *p;
141
142         DPRINTK("top %p %.*s",
143                 top, (int)top->d_name.len, top->d_name.name);
144
145         /* Negative dentry - give up */
146         if (!simple_positive(top))
147                 return 1;
148
149         spin_lock(&dcache_lock);
150         for (p = top; p; p = next_dentry(p, top)) {
151                 /* Negative dentry - give up */
152                 if (!simple_positive(p))
153                         continue;
154
155                 DPRINTK("dentry %p %.*s",
156                         p, (int) p->d_name.len, p->d_name.name);
157
158                 p = dget(p);
159                 spin_unlock(&dcache_lock);
160
161                 /*
162                  * Is someone visiting anywhere in the subtree ?
163                  * If there's no mount we need to check the usage
164                  * count for the autofs dentry.
165                  * If the fs is busy update the expiry counter.
166                  */
167                 if (d_mountpoint(p)) {
168                         if (autofs4_mount_busy(mnt, p)) {
169                                 top_ino->last_used = jiffies;
170                                 dput(p);
171                                 return 1;
172                         }
173                 } else {
174                         struct autofs_info *ino = autofs4_dentry_ino(p);
175                         unsigned int ino_count = atomic_read(&ino->count);
176
177                         /*
178                          * Clean stale dentries below that have not been
179                          * invalidated after a mount fail during lookup
180                          */
181                         d_invalidate(p);
182
183                         /* allow for dget above and top is already dgot */
184                         if (p == top)
185                                 ino_count += 2;
186                         else
187                                 ino_count++;
188
189                         if (atomic_read(&p->d_count) > ino_count) {
190                                 top_ino->last_used = jiffies;
191                                 dput(p);
192                                 return 1;
193                         }
194                 }
195                 dput(p);
196                 spin_lock(&dcache_lock);
197         }
198         spin_unlock(&dcache_lock);
199
200         /* Timeout of a tree mount is ultimately determined by its top dentry */
201         if (!autofs4_can_expire(top, timeout, do_now))
202                 return 1;
203
204         return 0;
205 }
206
207 static struct dentry *autofs4_check_leaves(struct vfsmount *mnt,
208                                            struct dentry *parent,
209                                            unsigned long timeout,
210                                            int do_now)
211 {
212         struct dentry *p;
213
214         DPRINTK("parent %p %.*s",
215                 parent, (int)parent->d_name.len, parent->d_name.name);
216
217         spin_lock(&dcache_lock);
218         for (p = parent; p; p = next_dentry(p, parent)) {
219                 /* Negative dentry - give up */
220                 if (!simple_positive(p))
221                         continue;
222
223                 DPRINTK("dentry %p %.*s",
224                         p, (int) p->d_name.len, p->d_name.name);
225
226                 p = dget(p);
227                 spin_unlock(&dcache_lock);
228
229                 if (d_mountpoint(p)) {
230                         /* Can we umount this guy */
231                         if (autofs4_mount_busy(mnt, p))
232                                 goto cont;
233
234                         /* Can we expire this guy */
235                         if (autofs4_can_expire(p, timeout, do_now))
236                                 return p;
237                 }
238 cont:
239                 dput(p);
240                 spin_lock(&dcache_lock);
241         }
242         spin_unlock(&dcache_lock);
243         return NULL;
244 }
245
246 /* Check if we can expire a direct mount (possibly a tree) */
247 static struct dentry *autofs4_expire_direct(struct super_block *sb,
248                                             struct vfsmount *mnt,
249                                             struct autofs_sb_info *sbi,
250                                             int how)
251 {
252         unsigned long timeout;
253         struct dentry *root = dget(sb->s_root);
254         int do_now = how & AUTOFS_EXP_IMMEDIATE;
255
256         if (!root)
257                 return NULL;
258
259         now = jiffies;
260         timeout = sbi->exp_timeout;
261
262         spin_lock(&sbi->fs_lock);
263         if (!autofs4_direct_busy(mnt, root, timeout, do_now)) {
264                 struct autofs_info *ino = autofs4_dentry_ino(root);
265                 if (d_mountpoint(root)) {
266                         ino->flags |= AUTOFS_INF_MOUNTPOINT;
267                         root->d_mounted--;
268                 }
269                 ino->flags |= AUTOFS_INF_EXPIRING;
270                 init_completion(&ino->expire_complete);
271                 spin_unlock(&sbi->fs_lock);
272                 return root;
273         }
274         spin_unlock(&sbi->fs_lock);
275         dput(root);
276
277         return NULL;
278 }
279
280 /*
281  * Find an eligible tree to time-out
282  * A tree is eligible if :-
283  *  - it is unused by any user process
284  *  - it has been unused for exp_timeout time
285  */
286 static struct dentry *autofs4_expire_indirect(struct super_block *sb,
287                                               struct vfsmount *mnt,
288                                               struct autofs_sb_info *sbi,
289                                               int how)
290 {
291         unsigned long timeout;
292         struct dentry *root = sb->s_root;
293         struct dentry *expired = NULL;
294         struct list_head *next;
295         int do_now = how & AUTOFS_EXP_IMMEDIATE;
296         int exp_leaves = how & AUTOFS_EXP_LEAVES;
297         struct autofs_info *ino;
298         unsigned int ino_count;
299
300         if (!root)
301                 return NULL;
302
303         now = jiffies;
304         timeout = sbi->exp_timeout;
305
306         spin_lock(&dcache_lock);
307         next = root->d_subdirs.next;
308
309         /* On exit from the loop expire is set to a dgot dentry
310          * to expire or it's NULL */
311         while ( next != &root->d_subdirs ) {
312                 struct dentry *dentry = list_entry(next, struct dentry, d_u.d_child);
313
314                 /* Negative dentry - give up */
315                 if (!simple_positive(dentry)) {
316                         next = next->next;
317                         continue;
318                 }
319
320                 dentry = dget(dentry);
321                 spin_unlock(&dcache_lock);
322
323                 spin_lock(&sbi->fs_lock);
324                 ino = autofs4_dentry_ino(dentry);
325
326                 /*
327                  * Case 1: (i) indirect mount or top level pseudo direct mount
328                  *         (autofs-4.1).
329                  *         (ii) indirect mount with offset mount, check the "/"
330                  *         offset (autofs-5.0+).
331                  */
332                 if (d_mountpoint(dentry)) {
333                         DPRINTK("checking mountpoint %p %.*s",
334                                 dentry, (int)dentry->d_name.len, dentry->d_name.name);
335
336                         /* Path walk currently on this dentry? */
337                         ino_count = atomic_read(&ino->count) + 2;
338                         if (atomic_read(&dentry->d_count) > ino_count)
339                                 goto next;
340
341                         /* Can we umount this guy */
342                         if (autofs4_mount_busy(mnt, dentry))
343                                 goto next;
344
345                         /* Can we expire this guy */
346                         if (autofs4_can_expire(dentry, timeout, do_now)) {
347                                 expired = dentry;
348                                 goto found;
349                         }
350                         goto next;
351                 }
352
353                 if (simple_empty(dentry))
354                         goto next;
355
356                 /* Case 2: tree mount, expire iff entire tree is not busy */
357                 if (!exp_leaves) {
358                         /* Path walk currently on this dentry? */
359                         ino_count = atomic_read(&ino->count) + 1;
360                         if (atomic_read(&dentry->d_count) > ino_count)
361                                 goto next;
362
363                         if (!autofs4_tree_busy(mnt, dentry, timeout, do_now)) {
364                                 expired = dentry;
365                                 goto found;
366                         }
367                 /*
368                  * Case 3: pseudo direct mount, expire individual leaves
369                  *         (autofs-4.1).
370                  */
371                 } else {
372                         /* Path walk currently on this dentry? */
373                         ino_count = atomic_read(&ino->count) + 1;
374                         if (atomic_read(&dentry->d_count) > ino_count)
375                                 goto next;
376
377                         expired = autofs4_check_leaves(mnt, dentry, timeout, do_now);
378                         if (expired) {
379                                 dput(dentry);
380                                 goto found;
381                         }
382                 }
383 next:
384                 spin_unlock(&sbi->fs_lock);
385                 dput(dentry);
386                 spin_lock(&dcache_lock);
387                 next = next->next;
388         }
389         spin_unlock(&dcache_lock);
390         return NULL;
391
392 found:
393         DPRINTK("returning %p %.*s",
394                 expired, (int)expired->d_name.len, expired->d_name.name);
395         ino = autofs4_dentry_ino(expired);
396         ino->flags |= AUTOFS_INF_EXPIRING;
397         init_completion(&ino->expire_complete);
398         spin_unlock(&sbi->fs_lock);
399         spin_lock(&dcache_lock);
400         list_move(&expired->d_parent->d_subdirs, &expired->d_u.d_child);
401         spin_unlock(&dcache_lock);
402         return expired;
403 }
404
405 /* Perform an expiry operation */
406 int autofs4_expire_run(struct super_block *sb,
407                       struct vfsmount *mnt,
408                       struct autofs_sb_info *sbi,
409                       struct autofs_packet_expire __user *pkt_p)
410 {
411         struct autofs_packet_expire pkt;
412         struct autofs_info *ino;
413         struct dentry *dentry;
414         int ret = 0;
415
416         memset(&pkt,0,sizeof pkt);
417
418         pkt.hdr.proto_version = sbi->version;
419         pkt.hdr.type = autofs_ptype_expire;
420
421         if ((dentry = autofs4_expire_indirect(sb, mnt, sbi, 0)) == NULL)
422                 return -EAGAIN;
423
424         pkt.len = dentry->d_name.len;
425         memcpy(pkt.name, dentry->d_name.name, pkt.len);
426         pkt.name[pkt.len] = '\0';
427         dput(dentry);
428
429         if ( copy_to_user(pkt_p, &pkt, sizeof(struct autofs_packet_expire)) )
430                 ret = -EFAULT;
431
432         spin_lock(&sbi->fs_lock);
433         ino = autofs4_dentry_ino(dentry);
434         ino->flags &= ~AUTOFS_INF_EXPIRING;
435         complete_all(&ino->expire_complete);
436         spin_unlock(&sbi->fs_lock);
437
438         return ret;
439 }
440
441 /* Call repeatedly until it returns -EAGAIN, meaning there's nothing
442    more to be done */
443 int autofs4_expire_multi(struct super_block *sb, struct vfsmount *mnt,
444                         struct autofs_sb_info *sbi, int __user *arg)
445 {
446         struct dentry *dentry;
447         int ret = -EAGAIN;
448         int do_now = 0;
449
450         if (arg && get_user(do_now, arg))
451                 return -EFAULT;
452
453         if (sbi->type & AUTOFS_TYPE_DIRECT)
454                 dentry = autofs4_expire_direct(sb, mnt, sbi, do_now);
455         else
456                 dentry = autofs4_expire_indirect(sb, mnt, sbi, do_now);
457
458         if (dentry) {
459                 struct autofs_info *ino = autofs4_dentry_ino(dentry);
460
461                 /* This is synchronous because it makes the daemon a
462                    little easier */
463                 ret = autofs4_wait(sbi, dentry, NFY_EXPIRE);
464
465                 spin_lock(&sbi->fs_lock);
466                 if (ino->flags & AUTOFS_INF_MOUNTPOINT) {
467                         sb->s_root->d_mounted++;
468                         ino->flags &= ~AUTOFS_INF_MOUNTPOINT;
469                 }
470                 ino->flags &= ~AUTOFS_INF_EXPIRING;
471                 complete_all(&ino->expire_complete);
472                 spin_unlock(&sbi->fs_lock);
473                 dput(dentry);
474         }
475
476         return ret;
477 }
478