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