cc1d013659051401f49afe701e835eb732a31ed7
[linux-3.10.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 (ino->flags & AUTOFS_INF_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         struct path path = {.mnt = mnt, .dentry = dentry};
52         int status = 1;
53
54         DPRINTK("dentry %p %.*s",
55                 dentry, (int)dentry->d_name.len, dentry->d_name.name);
56
57         path_get(&path);
58
59         if (!follow_down(&path))
60                 goto done;
61
62         if (is_autofs4_dentry(path.dentry)) {
63                 struct autofs_sb_info *sbi = autofs4_sbi(path.dentry->d_sb);
64
65                 /* This is an autofs submount, we can't expire it */
66                 if (autofs_type_indirect(sbi->type))
67                         goto done;
68
69                 /*
70                  * Otherwise it's an offset mount and we need to check
71                  * if we can umount its mount, if there is one.
72                  */
73                 if (!d_mountpoint(path.dentry)) {
74                         status = 0;
75                         goto done;
76                 }
77         }
78
79         /* Update the expiry counter if fs is busy */
80         if (!may_umount_tree(path.mnt)) {
81                 struct autofs_info *ino = autofs4_dentry_ino(top);
82                 ino->last_used = jiffies;
83                 goto done;
84         }
85
86         status = 0;
87 done:
88         DPRINTK("returning = %d", status);
89         path_put(&path);
90         return status;
91 }
92
93 /*
94  * Calculate and dget next entry in top down tree traversal.
95  */
96 static struct dentry *get_next_positive_dentry(struct dentry *prev,
97                                                 struct dentry *root)
98 {
99         struct list_head *next;
100         struct dentry *p, *ret;
101
102         if (prev == NULL)
103                 return dget(prev);
104
105         spin_lock(&autofs4_lock);
106 relock:
107         p = prev;
108         spin_lock(&p->d_lock);
109 again:
110         next = p->d_subdirs.next;
111         if (next == &p->d_subdirs) {
112                 while (1) {
113                         struct dentry *parent;
114
115                         if (p == root) {
116                                 spin_unlock(&p->d_lock);
117                                 spin_unlock(&autofs4_lock);
118                                 dput(prev);
119                                 return NULL;
120                         }
121
122                         parent = p->d_parent;
123                         if (!spin_trylock(&parent->d_lock)) {
124                                 spin_unlock(&p->d_lock);
125                                 cpu_relax();
126                                 goto relock;
127                         }
128                         spin_unlock(&p->d_lock);
129                         next = p->d_u.d_child.next;
130                         p = parent;
131                         if (next != &parent->d_subdirs)
132                                 break;
133                 }
134         }
135         ret = list_entry(next, struct dentry, d_u.d_child);
136
137         spin_lock_nested(&ret->d_lock, DENTRY_D_LOCK_NESTED);
138         /* Negative dentry - try next */
139         if (!simple_positive(ret)) {
140                 spin_unlock(&ret->d_lock);
141                 p = ret;
142                 goto again;
143         }
144         dget_dlock(ret);
145         spin_unlock(&ret->d_lock);
146         spin_unlock(&p->d_lock);
147         spin_unlock(&autofs4_lock);
148
149         dput(prev);
150
151         return ret;
152 }
153
154 /*
155  * Check a direct mount point for busyness.
156  * Direct mounts have similar expiry semantics to tree mounts.
157  * The tree is not busy iff no mountpoints are busy and there are no
158  * autofs submounts.
159  */
160 static int autofs4_direct_busy(struct vfsmount *mnt,
161                                 struct dentry *top,
162                                 unsigned long timeout,
163                                 int do_now)
164 {
165         DPRINTK("top %p %.*s",
166                 top, (int) top->d_name.len, top->d_name.name);
167
168         /* If it's busy update the expiry counters */
169         if (!may_umount_tree(mnt)) {
170                 struct autofs_info *ino = autofs4_dentry_ino(top);
171                 if (ino)
172                         ino->last_used = jiffies;
173                 return 1;
174         }
175
176         /* Timeout of a direct mount is determined by its top dentry */
177         if (!autofs4_can_expire(top, timeout, do_now))
178                 return 1;
179
180         return 0;
181 }
182
183 /* Check a directory tree of mount points for busyness
184  * The tree is not busy iff no mountpoints are busy
185  */
186 static int autofs4_tree_busy(struct vfsmount *mnt,
187                              struct dentry *top,
188                              unsigned long timeout,
189                              int do_now)
190 {
191         struct autofs_info *top_ino = autofs4_dentry_ino(top);
192         struct dentry *p;
193
194         DPRINTK("top %p %.*s",
195                 top, (int)top->d_name.len, top->d_name.name);
196
197         /* Negative dentry - give up */
198         if (!simple_positive(top))
199                 return 1;
200
201         p = NULL;
202         while ((p = get_next_positive_dentry(p, top))) {
203                 DPRINTK("dentry %p %.*s",
204                         p, (int) p->d_name.len, p->d_name.name);
205
206                 /*
207                  * Is someone visiting anywhere in the subtree ?
208                  * If there's no mount we need to check the usage
209                  * count for the autofs dentry.
210                  * If the fs is busy update the expiry counter.
211                  */
212                 if (d_mountpoint(p)) {
213                         if (autofs4_mount_busy(mnt, p)) {
214                                 top_ino->last_used = jiffies;
215                                 dput(p);
216                                 return 1;
217                         }
218                 } else {
219                         struct autofs_info *ino = autofs4_dentry_ino(p);
220                         unsigned int ino_count = atomic_read(&ino->count);
221
222                         /*
223                          * Clean stale dentries below that have not been
224                          * invalidated after a mount fail during lookup
225                          */
226                         d_invalidate(p);
227
228                         /* allow for dget above and top is already dgot */
229                         if (p == top)
230                                 ino_count += 2;
231                         else
232                                 ino_count++;
233
234                         if (p->d_count > ino_count) {
235                                 top_ino->last_used = jiffies;
236                                 dput(p);
237                                 return 1;
238                         }
239                 }
240         }
241
242         /* Timeout of a tree mount is ultimately determined by its top dentry */
243         if (!autofs4_can_expire(top, timeout, do_now))
244                 return 1;
245
246         return 0;
247 }
248
249 static struct dentry *autofs4_check_leaves(struct vfsmount *mnt,
250                                            struct dentry *parent,
251                                            unsigned long timeout,
252                                            int do_now)
253 {
254         struct dentry *p;
255
256         DPRINTK("parent %p %.*s",
257                 parent, (int)parent->d_name.len, parent->d_name.name);
258
259         p = NULL;
260         while ((p = get_next_positive_dentry(p, parent))) {
261                 DPRINTK("dentry %p %.*s",
262                         p, (int) p->d_name.len, p->d_name.name);
263
264                 if (d_mountpoint(p)) {
265                         /* Can we umount this guy */
266                         if (autofs4_mount_busy(mnt, p))
267                                 continue;
268
269                         /* Can we expire this guy */
270                         if (autofs4_can_expire(p, timeout, do_now))
271                                 return p;
272                 }
273         }
274         return NULL;
275 }
276
277 /* Check if we can expire a direct mount (possibly a tree) */
278 struct dentry *autofs4_expire_direct(struct super_block *sb,
279                                      struct vfsmount *mnt,
280                                      struct autofs_sb_info *sbi,
281                                      int how)
282 {
283         unsigned long timeout;
284         struct dentry *root = dget(sb->s_root);
285         int do_now = how & AUTOFS_EXP_IMMEDIATE;
286
287         if (!root)
288                 return NULL;
289
290         now = jiffies;
291         timeout = sbi->exp_timeout;
292
293         spin_lock(&sbi->fs_lock);
294         if (!autofs4_direct_busy(mnt, root, timeout, do_now)) {
295                 struct autofs_info *ino = autofs4_dentry_ino(root);
296                 if (d_mountpoint(root)) {
297                         ino->flags |= AUTOFS_INF_MOUNTPOINT;
298                         spin_lock(&root->d_lock);
299                         root->d_flags &= ~DCACHE_MOUNTED;
300                         spin_unlock(&root->d_lock);
301                 }
302                 ino->flags |= AUTOFS_INF_EXPIRING;
303                 init_completion(&ino->expire_complete);
304                 spin_unlock(&sbi->fs_lock);
305                 return root;
306         }
307         spin_unlock(&sbi->fs_lock);
308         dput(root);
309
310         return NULL;
311 }
312
313 /*
314  * Find an eligible tree to time-out
315  * A tree is eligible if :-
316  *  - it is unused by any user process
317  *  - it has been unused for exp_timeout time
318  */
319 struct dentry *autofs4_expire_indirect(struct super_block *sb,
320                                        struct vfsmount *mnt,
321                                        struct autofs_sb_info *sbi,
322                                        int how)
323 {
324         unsigned long timeout;
325         struct dentry *root = sb->s_root;
326         struct dentry *dentry;
327         struct dentry *expired = NULL;
328         int do_now = how & AUTOFS_EXP_IMMEDIATE;
329         int exp_leaves = how & AUTOFS_EXP_LEAVES;
330         struct autofs_info *ino;
331         unsigned int ino_count;
332
333         if (!root)
334                 return NULL;
335
336         now = jiffies;
337         timeout = sbi->exp_timeout;
338
339         dentry = NULL;
340         while ((dentry = get_next_positive_dentry(dentry, root))) {
341                 spin_lock(&sbi->fs_lock);
342                 ino = autofs4_dentry_ino(dentry);
343
344                 /*
345                  * Case 1: (i) indirect mount or top level pseudo direct mount
346                  *         (autofs-4.1).
347                  *         (ii) indirect mount with offset mount, check the "/"
348                  *         offset (autofs-5.0+).
349                  */
350                 if (d_mountpoint(dentry)) {
351                         DPRINTK("checking mountpoint %p %.*s",
352                                 dentry, (int)dentry->d_name.len, dentry->d_name.name);
353
354                         /* Path walk currently on this dentry? */
355                         ino_count = atomic_read(&ino->count) + 2;
356                         if (dentry->d_count > ino_count)
357                                 goto next;
358
359                         /* Can we umount this guy */
360                         if (autofs4_mount_busy(mnt, dentry))
361                                 goto next;
362
363                         /* Can we expire this guy */
364                         if (autofs4_can_expire(dentry, timeout, do_now)) {
365                                 expired = dentry;
366                                 goto found;
367                         }
368                         goto next;
369                 }
370
371                 if (simple_empty(dentry))
372                         goto next;
373
374                 /* Case 2: tree mount, expire iff entire tree is not busy */
375                 if (!exp_leaves) {
376                         /* Path walk currently on this dentry? */
377                         ino_count = atomic_read(&ino->count) + 1;
378                         if (dentry->d_count > ino_count)
379                                 goto next;
380
381                         if (!autofs4_tree_busy(mnt, dentry, timeout, do_now)) {
382                                 expired = dentry;
383                                 goto found;
384                         }
385                 /*
386                  * Case 3: pseudo direct mount, expire individual leaves
387                  *         (autofs-4.1).
388                  */
389                 } else {
390                         /* Path walk currently on this dentry? */
391                         ino_count = atomic_read(&ino->count) + 1;
392                         if (dentry->d_count > ino_count)
393                                 goto next;
394
395                         expired = autofs4_check_leaves(mnt, dentry, timeout, do_now);
396                         if (expired) {
397                                 dput(dentry);
398                                 goto found;
399                         }
400                 }
401 next:
402                 spin_unlock(&sbi->fs_lock);
403         }
404         return NULL;
405
406 found:
407         DPRINTK("returning %p %.*s",
408                 expired, (int)expired->d_name.len, expired->d_name.name);
409         ino = autofs4_dentry_ino(expired);
410         ino->flags |= AUTOFS_INF_EXPIRING;
411         init_completion(&ino->expire_complete);
412         spin_unlock(&sbi->fs_lock);
413         spin_lock(&autofs4_lock);
414         spin_lock(&expired->d_parent->d_lock);
415         spin_lock_nested(&expired->d_lock, DENTRY_D_LOCK_NESTED);
416         list_move(&expired->d_parent->d_subdirs, &expired->d_u.d_child);
417         spin_unlock(&expired->d_lock);
418         spin_unlock(&expired->d_parent->d_lock);
419         spin_unlock(&autofs4_lock);
420         return expired;
421 }
422
423 int autofs4_expire_wait(struct dentry *dentry)
424 {
425         struct autofs_sb_info *sbi = autofs4_sbi(dentry->d_sb);
426         struct autofs_info *ino = autofs4_dentry_ino(dentry);
427         int status;
428
429         /* Block on any pending expire */
430         spin_lock(&sbi->fs_lock);
431         if (ino->flags & AUTOFS_INF_EXPIRING) {
432                 spin_unlock(&sbi->fs_lock);
433
434                 DPRINTK("waiting for expire %p name=%.*s",
435                          dentry, dentry->d_name.len, dentry->d_name.name);
436
437                 status = autofs4_wait(sbi, dentry, NFY_NONE);
438                 wait_for_completion(&ino->expire_complete);
439
440                 DPRINTK("expire done status=%d", status);
441
442                 if (d_unhashed(dentry))
443                         return -EAGAIN;
444
445                 return status;
446         }
447         spin_unlock(&sbi->fs_lock);
448
449         return 0;
450 }
451
452 /* Perform an expiry operation */
453 int autofs4_expire_run(struct super_block *sb,
454                       struct vfsmount *mnt,
455                       struct autofs_sb_info *sbi,
456                       struct autofs_packet_expire __user *pkt_p)
457 {
458         struct autofs_packet_expire pkt;
459         struct autofs_info *ino;
460         struct dentry *dentry;
461         int ret = 0;
462
463         memset(&pkt,0,sizeof pkt);
464
465         pkt.hdr.proto_version = sbi->version;
466         pkt.hdr.type = autofs_ptype_expire;
467
468         if ((dentry = autofs4_expire_indirect(sb, mnt, sbi, 0)) == NULL)
469                 return -EAGAIN;
470
471         pkt.len = dentry->d_name.len;
472         memcpy(pkt.name, dentry->d_name.name, pkt.len);
473         pkt.name[pkt.len] = '\0';
474         dput(dentry);
475
476         if ( copy_to_user(pkt_p, &pkt, sizeof(struct autofs_packet_expire)) )
477                 ret = -EFAULT;
478
479         spin_lock(&sbi->fs_lock);
480         ino = autofs4_dentry_ino(dentry);
481         ino->flags &= ~AUTOFS_INF_EXPIRING;
482         complete_all(&ino->expire_complete);
483         spin_unlock(&sbi->fs_lock);
484
485         return ret;
486 }
487
488 int autofs4_do_expire_multi(struct super_block *sb, struct vfsmount *mnt,
489                             struct autofs_sb_info *sbi, int when)
490 {
491         struct dentry *dentry;
492         int ret = -EAGAIN;
493
494         if (autofs_type_trigger(sbi->type))
495                 dentry = autofs4_expire_direct(sb, mnt, sbi, when);
496         else
497                 dentry = autofs4_expire_indirect(sb, mnt, sbi, when);
498
499         if (dentry) {
500                 struct autofs_info *ino = autofs4_dentry_ino(dentry);
501
502                 /* This is synchronous because it makes the daemon a
503                    little easier */
504                 ret = autofs4_wait(sbi, dentry, NFY_EXPIRE);
505
506                 spin_lock(&sbi->fs_lock);
507                 if (ino->flags & AUTOFS_INF_MOUNTPOINT) {
508                         spin_lock(&sb->s_root->d_lock);
509                         /*
510                          * If we haven't been expired away, then reset
511                          * mounted status.
512                          */
513                         if (mnt->mnt_parent != mnt)
514                                 sb->s_root->d_flags |= DCACHE_MOUNTED;
515                         spin_unlock(&sb->s_root->d_lock);
516                         ino->flags &= ~AUTOFS_INF_MOUNTPOINT;
517                 }
518                 ino->flags &= ~AUTOFS_INF_EXPIRING;
519                 complete_all(&ino->expire_complete);
520                 spin_unlock(&sbi->fs_lock);
521                 dput(dentry);
522         }
523
524         return ret;
525 }
526
527 /* Call repeatedly until it returns -EAGAIN, meaning there's nothing
528    more to be done */
529 int autofs4_expire_multi(struct super_block *sb, struct vfsmount *mnt,
530                         struct autofs_sb_info *sbi, int __user *arg)
531 {
532         int do_now = 0;
533
534         if (arg && get_user(do_now, arg))
535                 return -EFAULT;
536
537         return autofs4_do_expire_multi(sb, mnt, sbi, do_now);
538 }
539