blob: 9510d8d2e9cd2fa4ac7919c7bd8bee48c30d6165 [file] [log] [blame]
Ian Kente9a7c2f2016-03-15 14:58:25 -07001/*
2 * Copyright 1997-1998 Transmeta Corporation -- All Rights Reserved
3 * Copyright 1999-2000 Jeremy Fitzhardinge <jeremy@goop.org>
4 * Copyright 2001-2006 Ian Kent <raven@themaw.net>
Linus Torvalds1da177e2005-04-16 15:20:36 -07005 *
6 * This file is part of the Linux kernel and is made available under
7 * the terms of the GNU General Public License, version 2, or at your
8 * option, any later version, incorporated herein by reference.
Ian Kente9a7c2f2016-03-15 14:58:25 -07009 */
Linus Torvalds1da177e2005-04-16 15:20:36 -070010
11#include "autofs_i.h"
12
13static unsigned long now;
14
Ian Kent1f5f2c32006-03-27 01:14:44 -080015/* Check if a dentry can be expired */
Linus Torvalds1da177e2005-04-16 15:20:36 -070016static inline int autofs4_can_expire(struct dentry *dentry,
Ian Kente9a7c2f2016-03-15 14:58:25 -070017 unsigned long timeout, int do_now)
Linus Torvalds1da177e2005-04-16 15:20:36 -070018{
19 struct autofs_info *ino = autofs4_dentry_ino(dentry);
20
21 /* dentry in the process of being deleted */
22 if (ino == NULL)
23 return 0;
24
Linus Torvalds1da177e2005-04-16 15:20:36 -070025 if (!do_now) {
26 /* Too young to die */
Ian Kentc0ba7e52006-09-25 16:24:16 -070027 if (!timeout || time_after(ino->last_used + timeout, now))
Linus Torvalds1da177e2005-04-16 15:20:36 -070028 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -070029 }
Linus Torvalds1da177e2005-04-16 15:20:36 -070030 return 1;
31}
32
Ian Kent1f5f2c32006-03-27 01:14:44 -080033/* Check a mount point for busyness */
34static int autofs4_mount_busy(struct vfsmount *mnt, struct dentry *dentry)
Linus Torvalds1da177e2005-04-16 15:20:36 -070035{
Ian Kente0a7aae2006-03-27 01:14:47 -080036 struct dentry *top = dentry;
Al Viro9393bd02009-04-18 13:58:15 -040037 struct path path = {.mnt = mnt, .dentry = dentry};
Ian Kent1f5f2c32006-03-27 01:14:44 -080038 int status = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -070039
Ian Kent8a78d592016-03-15 14:58:45 -070040 pr_debug("dentry %p %pd\n", dentry, dentry);
Linus Torvalds1da177e2005-04-16 15:20:36 -070041
Al Viro9393bd02009-04-18 13:58:15 -040042 path_get(&path);
Linus Torvalds1da177e2005-04-16 15:20:36 -070043
David Howellscc53ce52011-01-14 18:45:26 +000044 if (!follow_down_one(&path))
Linus Torvalds1da177e2005-04-16 15:20:36 -070045 goto done;
46
Al Viro9393bd02009-04-18 13:58:15 -040047 if (is_autofs4_dentry(path.dentry)) {
48 struct autofs_sb_info *sbi = autofs4_sbi(path.dentry->d_sb);
Ian Kentbc9c4062008-11-06 12:53:22 -080049
50 /* This is an autofs submount, we can't expire it */
Ian Kenta92daf62009-01-06 14:42:08 -080051 if (autofs_type_indirect(sbi->type))
Ian Kentbc9c4062008-11-06 12:53:22 -080052 goto done;
Ian Kentbc9c4062008-11-06 12:53:22 -080053 }
Linus Torvalds1da177e2005-04-16 15:20:36 -070054
Ian Kente0a7aae2006-03-27 01:14:47 -080055 /* Update the expiry counter if fs is busy */
Ian Kent37d08922009-09-01 11:26:22 +080056 if (!may_umount_tree(path.mnt)) {
Ian Kente9a7c2f2016-03-15 14:58:25 -070057 struct autofs_info *ino;
58
59 ino = autofs4_dentry_ino(top);
Ian Kente0a7aae2006-03-27 01:14:47 -080060 ino->last_used = jiffies;
61 goto done;
62 }
63
64 status = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -070065done:
Ian Kent8a78d592016-03-15 14:58:45 -070066 pr_debug("returning = %d\n", status);
Al Viro9393bd02009-04-18 13:58:15 -040067 path_put(&path);
Linus Torvalds1da177e2005-04-16 15:20:36 -070068 return status;
69}
70
Ian Kent1ce12ba2006-03-27 01:14:45 -080071/*
Ian Kentd4a85e32011-03-25 01:51:20 +080072 * Calculate and dget next entry in the subdirs list under root.
73 */
74static struct dentry *get_next_positive_subdir(struct dentry *prev,
Ian Kente9a7c2f2016-03-15 14:58:25 -070075 struct dentry *root)
Ian Kentd4a85e32011-03-25 01:51:20 +080076{
Ian Kente7854722011-03-25 01:51:31 +080077 struct autofs_sb_info *sbi = autofs4_sbi(root->d_sb);
Ian Kentd4a85e32011-03-25 01:51:20 +080078 struct list_head *next;
Ian Kenta45440f2012-08-06 09:37:47 +080079 struct dentry *q;
Ian Kentd4a85e32011-03-25 01:51:20 +080080
Ian Kente7854722011-03-25 01:51:31 +080081 spin_lock(&sbi->lookup_lock);
Ian Kenta45440f2012-08-06 09:37:47 +080082 spin_lock(&root->d_lock);
Ian Kentd4a85e32011-03-25 01:51:20 +080083
Ian Kenta45440f2012-08-06 09:37:47 +080084 if (prev)
Al Viro946e51f2014-10-26 19:19:16 -040085 next = prev->d_child.next;
Ian Kenta45440f2012-08-06 09:37:47 +080086 else {
Ian Kentd4a85e32011-03-25 01:51:20 +080087 prev = dget_dlock(root);
88 next = prev->d_subdirs.next;
Ian Kentd4a85e32011-03-25 01:51:20 +080089 }
90
Ian Kenta45440f2012-08-06 09:37:47 +080091cont:
Ian Kentd4a85e32011-03-25 01:51:20 +080092 if (next == &root->d_subdirs) {
Ian Kenta45440f2012-08-06 09:37:47 +080093 spin_unlock(&root->d_lock);
Ian Kente7854722011-03-25 01:51:31 +080094 spin_unlock(&sbi->lookup_lock);
Ian Kentd4a85e32011-03-25 01:51:20 +080095 dput(prev);
96 return NULL;
97 }
98
Al Viro946e51f2014-10-26 19:19:16 -040099 q = list_entry(next, struct dentry, d_child);
Ian Kentd4a85e32011-03-25 01:51:20 +0800100
101 spin_lock_nested(&q->d_lock, DENTRY_D_LOCK_NESTED);
Ian Kenta45440f2012-08-06 09:37:47 +0800102 /* Already gone or negative dentry (under construction) - try next */
Al Viro84d08fa2013-07-05 18:59:33 +0400103 if (!d_count(q) || !simple_positive(q)) {
Ian Kenta45440f2012-08-06 09:37:47 +0800104 spin_unlock(&q->d_lock);
Al Viro946e51f2014-10-26 19:19:16 -0400105 next = q->d_child.next;
Ian Kenta45440f2012-08-06 09:37:47 +0800106 goto cont;
Ian Kentd4a85e32011-03-25 01:51:20 +0800107 }
108 dget_dlock(q);
109 spin_unlock(&q->d_lock);
Ian Kenta45440f2012-08-06 09:37:47 +0800110 spin_unlock(&root->d_lock);
Ian Kente7854722011-03-25 01:51:31 +0800111 spin_unlock(&sbi->lookup_lock);
Ian Kentd4a85e32011-03-25 01:51:20 +0800112
113 dput(prev);
114
115 return q;
116}
117
118/*
Nick Piggin2fd6b7f2011-01-07 17:49:34 +1100119 * Calculate and dget next entry in top down tree traversal.
Ian Kent1ce12ba2006-03-27 01:14:45 -0800120 */
Nick Piggin2fd6b7f2011-01-07 17:49:34 +1100121static struct dentry *get_next_positive_dentry(struct dentry *prev,
Ian Kente9a7c2f2016-03-15 14:58:25 -0700122 struct dentry *root)
Ian Kent1ce12ba2006-03-27 01:14:45 -0800123{
Ian Kente7854722011-03-25 01:51:31 +0800124 struct autofs_sb_info *sbi = autofs4_sbi(root->d_sb);
Nick Piggin2fd6b7f2011-01-07 17:49:34 +1100125 struct list_head *next;
126 struct dentry *p, *ret;
Ian Kent1ce12ba2006-03-27 01:14:45 -0800127
Nick Piggin2fd6b7f2011-01-07 17:49:34 +1100128 if (prev == NULL)
Ian Kentc14cc632011-01-18 12:06:04 +0800129 return dget(root);
Nick Piggin2fd6b7f2011-01-07 17:49:34 +1100130
Ian Kente7854722011-03-25 01:51:31 +0800131 spin_lock(&sbi->lookup_lock);
Nick Piggin2fd6b7f2011-01-07 17:49:34 +1100132relock:
133 p = prev;
134 spin_lock(&p->d_lock);
135again:
136 next = p->d_subdirs.next;
Ian Kent1ce12ba2006-03-27 01:14:45 -0800137 if (next == &p->d_subdirs) {
138 while (1) {
Nick Piggin2fd6b7f2011-01-07 17:49:34 +1100139 struct dentry *parent;
140
141 if (p == root) {
142 spin_unlock(&p->d_lock);
Ian Kente7854722011-03-25 01:51:31 +0800143 spin_unlock(&sbi->lookup_lock);
Nick Piggin2fd6b7f2011-01-07 17:49:34 +1100144 dput(prev);
Ian Kent1ce12ba2006-03-27 01:14:45 -0800145 return NULL;
Nick Piggin2fd6b7f2011-01-07 17:49:34 +1100146 }
147
148 parent = p->d_parent;
149 if (!spin_trylock(&parent->d_lock)) {
150 spin_unlock(&p->d_lock);
151 cpu_relax();
152 goto relock;
153 }
154 spin_unlock(&p->d_lock);
Al Viro946e51f2014-10-26 19:19:16 -0400155 next = p->d_child.next;
Nick Piggin2fd6b7f2011-01-07 17:49:34 +1100156 p = parent;
157 if (next != &parent->d_subdirs)
Ian Kent1ce12ba2006-03-27 01:14:45 -0800158 break;
Ian Kent1ce12ba2006-03-27 01:14:45 -0800159 }
160 }
Al Viro946e51f2014-10-26 19:19:16 -0400161 ret = list_entry(next, struct dentry, d_child);
Nick Piggin2fd6b7f2011-01-07 17:49:34 +1100162
163 spin_lock_nested(&ret->d_lock, DENTRY_D_LOCK_NESTED);
164 /* Negative dentry - try next */
165 if (!simple_positive(ret)) {
Ian Kentc14cc632011-01-18 12:06:04 +0800166 spin_unlock(&p->d_lock);
Steven Rostedt1d6f2092011-08-22 11:52:28 +0800167 lock_set_subclass(&ret->d_lock.dep_map, 0, _RET_IP_);
Nick Piggin2fd6b7f2011-01-07 17:49:34 +1100168 p = ret;
169 goto again;
170 }
171 dget_dlock(ret);
172 spin_unlock(&ret->d_lock);
173 spin_unlock(&p->d_lock);
Ian Kente7854722011-03-25 01:51:31 +0800174 spin_unlock(&sbi->lookup_lock);
Nick Piggin2fd6b7f2011-01-07 17:49:34 +1100175
176 dput(prev);
177
178 return ret;
Ian Kent1ce12ba2006-03-27 01:14:45 -0800179}
180
Ian Kent3a15e2a2006-03-27 01:14:55 -0800181/*
182 * Check a direct mount point for busyness.
183 * Direct mounts have similar expiry semantics to tree mounts.
184 * The tree is not busy iff no mountpoints are busy and there are no
185 * autofs submounts.
186 */
187static int autofs4_direct_busy(struct vfsmount *mnt,
Ian Kente9a7c2f2016-03-15 14:58:25 -0700188 struct dentry *top,
189 unsigned long timeout,
190 int do_now)
Ian Kent3a15e2a2006-03-27 01:14:55 -0800191{
Ian Kent8a78d592016-03-15 14:58:45 -0700192 pr_debug("top %p %pd\n", top, top);
Ian Kent3a15e2a2006-03-27 01:14:55 -0800193
Ian Kent3a15e2a2006-03-27 01:14:55 -0800194 /* If it's busy update the expiry counters */
195 if (!may_umount_tree(mnt)) {
Ian Kente9a7c2f2016-03-15 14:58:25 -0700196 struct autofs_info *ino;
197
198 ino = autofs4_dentry_ino(top);
Ian Kent3a15e2a2006-03-27 01:14:55 -0800199 if (ino)
200 ino->last_used = jiffies;
201 return 1;
202 }
203
204 /* Timeout of a direct mount is determined by its top dentry */
205 if (!autofs4_can_expire(top, timeout, do_now))
206 return 1;
207
208 return 0;
209}
210
Ian Kente9a7c2f2016-03-15 14:58:25 -0700211/*
212 * Check a directory tree of mount points for busyness
Linus Torvalds1da177e2005-04-16 15:20:36 -0700213 * The tree is not busy iff no mountpoints are busy
Linus Torvalds1da177e2005-04-16 15:20:36 -0700214 */
Ian Kent1f5f2c32006-03-27 01:14:44 -0800215static int autofs4_tree_busy(struct vfsmount *mnt,
216 struct dentry *top,
217 unsigned long timeout,
218 int do_now)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700219{
Ian Kente0a7aae2006-03-27 01:14:47 -0800220 struct autofs_info *top_ino = autofs4_dentry_ino(top);
Ian Kent1ce12ba2006-03-27 01:14:45 -0800221 struct dentry *p;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700222
Ian Kent8a78d592016-03-15 14:58:45 -0700223 pr_debug("top %p %pd\n", top, top);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700224
225 /* Negative dentry - give up */
226 if (!simple_positive(top))
Ian Kent1f5f2c32006-03-27 01:14:44 -0800227 return 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700228
Nick Piggin2fd6b7f2011-01-07 17:49:34 +1100229 p = NULL;
230 while ((p = get_next_positive_dentry(p, top))) {
Ian Kent8a78d592016-03-15 14:58:45 -0700231 pr_debug("dentry %p %pd\n", p, p);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700232
Ian Kent1aff3c82006-03-27 01:14:46 -0800233 /*
234 * Is someone visiting anywhere in the subtree ?
235 * If there's no mount we need to check the usage
236 * count for the autofs dentry.
Ian Kente0a7aae2006-03-27 01:14:47 -0800237 * If the fs is busy update the expiry counter.
Ian Kent1aff3c82006-03-27 01:14:46 -0800238 */
Ian Kent1ce12ba2006-03-27 01:14:45 -0800239 if (d_mountpoint(p)) {
Ian Kent1ce12ba2006-03-27 01:14:45 -0800240 if (autofs4_mount_busy(mnt, p)) {
Ian Kente0a7aae2006-03-27 01:14:47 -0800241 top_ino->last_used = jiffies;
Ian Kent1ce12ba2006-03-27 01:14:45 -0800242 dput(p);
Ian Kent1f5f2c32006-03-27 01:14:44 -0800243 return 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700244 }
Ian Kent1aff3c82006-03-27 01:14:46 -0800245 } else {
Ian Kente0a7aae2006-03-27 01:14:47 -0800246 struct autofs_info *ino = autofs4_dentry_ino(p);
Ian Kent1aff3c82006-03-27 01:14:46 -0800247 unsigned int ino_count = atomic_read(&ino->count);
248
249 /* allow for dget above and top is already dgot */
250 if (p == top)
251 ino_count += 2;
252 else
253 ino_count++;
254
Al Viro84d08fa2013-07-05 18:59:33 +0400255 if (d_count(p) > ino_count) {
Ian Kente0a7aae2006-03-27 01:14:47 -0800256 top_ino->last_used = jiffies;
Ian Kent1aff3c82006-03-27 01:14:46 -0800257 dput(p);
258 return 1;
259 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700260 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700261 }
Ian Kent1aff3c82006-03-27 01:14:46 -0800262
263 /* Timeout of a tree mount is ultimately determined by its top dentry */
264 if (!autofs4_can_expire(top, timeout, do_now))
265 return 1;
266
Ian Kent1f5f2c32006-03-27 01:14:44 -0800267 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700268}
269
270static struct dentry *autofs4_check_leaves(struct vfsmount *mnt,
271 struct dentry *parent,
272 unsigned long timeout,
273 int do_now)
274{
Ian Kent1ce12ba2006-03-27 01:14:45 -0800275 struct dentry *p;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700276
Ian Kent8a78d592016-03-15 14:58:45 -0700277 pr_debug("parent %p %pd\n", parent, parent);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700278
Nick Piggin2fd6b7f2011-01-07 17:49:34 +1100279 p = NULL;
280 while ((p = get_next_positive_dentry(p, parent))) {
Ian Kent8a78d592016-03-15 14:58:45 -0700281 pr_debug("dentry %p %pd\n", p, p);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700282
Ian Kent1ce12ba2006-03-27 01:14:45 -0800283 if (d_mountpoint(p)) {
Ian Kente0a7aae2006-03-27 01:14:47 -0800284 /* Can we umount this guy */
285 if (autofs4_mount_busy(mnt, p))
Nick Piggin2fd6b7f2011-01-07 17:49:34 +1100286 continue;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700287
Ian Kente0a7aae2006-03-27 01:14:47 -0800288 /* Can we expire this guy */
289 if (autofs4_can_expire(p, timeout, do_now))
Ian Kent1ce12ba2006-03-27 01:14:45 -0800290 return p;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700291 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700292 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700293 return NULL;
294}
295
Ian Kent3a15e2a2006-03-27 01:14:55 -0800296/* Check if we can expire a direct mount (possibly a tree) */
Ian Kent8d7b48e2008-10-15 22:02:54 -0700297struct dentry *autofs4_expire_direct(struct super_block *sb,
298 struct vfsmount *mnt,
299 struct autofs_sb_info *sbi,
300 int how)
Ian Kent3a15e2a2006-03-27 01:14:55 -0800301{
302 unsigned long timeout;
303 struct dentry *root = dget(sb->s_root);
304 int do_now = how & AUTOFS_EXP_IMMEDIATE;
Ian Kentb5b80172011-01-14 18:46:03 +0000305 struct autofs_info *ino;
Ian Kent3a15e2a2006-03-27 01:14:55 -0800306
Ian Kentc0ba7e52006-09-25 16:24:16 -0700307 if (!root)
Ian Kent3a15e2a2006-03-27 01:14:55 -0800308 return NULL;
309
310 now = jiffies;
311 timeout = sbi->exp_timeout;
312
Ian Kent3a15e2a2006-03-27 01:14:55 -0800313 spin_lock(&sbi->fs_lock);
Ian Kentb5b80172011-01-14 18:46:03 +0000314 ino = autofs4_dentry_ino(root);
315 /* No point expiring a pending mount */
Ian Kentf9398c22011-03-25 01:51:14 +0800316 if (ino->flags & AUTOFS_INF_PENDING)
317 goto out;
Ian Kent3a15e2a2006-03-27 01:14:55 -0800318 if (!autofs4_direct_busy(mnt, root, timeout, do_now)) {
NeilBrown4d885f92014-10-13 15:52:20 -0700319 ino->flags |= AUTOFS_INF_NO_RCU;
Ian Kent3a15e2a2006-03-27 01:14:55 -0800320 spin_unlock(&sbi->fs_lock);
NeilBrown4d885f92014-10-13 15:52:20 -0700321 synchronize_rcu();
322 spin_lock(&sbi->fs_lock);
323 if (!autofs4_direct_busy(mnt, root, timeout, do_now)) {
324 ino->flags |= AUTOFS_INF_EXPIRING;
325 smp_mb();
326 ino->flags &= ~AUTOFS_INF_NO_RCU;
327 init_completion(&ino->expire_complete);
328 spin_unlock(&sbi->fs_lock);
329 return root;
330 }
331 ino->flags &= ~AUTOFS_INF_NO_RCU;
Ian Kent3a15e2a2006-03-27 01:14:55 -0800332 }
Ian Kentf9398c22011-03-25 01:51:14 +0800333out:
Ian Kent3a15e2a2006-03-27 01:14:55 -0800334 spin_unlock(&sbi->fs_lock);
335 dput(root);
336
337 return NULL;
338}
339
NeilBrowna5d1dba2014-10-13 15:52:16 -0700340/* Check if 'dentry' should expire, or return a nearby
341 * dentry that is suitable.
342 * If returned dentry is different from arg dentry,
343 * then a dget() reference was taken, else not.
344 */
345static struct dentry *should_expire(struct dentry *dentry,
346 struct vfsmount *mnt,
347 unsigned long timeout,
348 int how)
349{
350 int do_now = how & AUTOFS_EXP_IMMEDIATE;
351 int exp_leaves = how & AUTOFS_EXP_LEAVES;
352 struct autofs_info *ino = autofs4_dentry_ino(dentry);
353 unsigned int ino_count;
354
355 /* No point expiring a pending mount */
356 if (ino->flags & AUTOFS_INF_PENDING)
357 return NULL;
358
359 /*
360 * Case 1: (i) indirect mount or top level pseudo direct mount
361 * (autofs-4.1).
362 * (ii) indirect mount with offset mount, check the "/"
363 * offset (autofs-5.0+).
364 */
365 if (d_mountpoint(dentry)) {
Ian Kent8a78d592016-03-15 14:58:45 -0700366 pr_debug("checking mountpoint %p %pd\n", dentry, dentry);
NeilBrowna5d1dba2014-10-13 15:52:16 -0700367
368 /* Can we umount this guy */
369 if (autofs4_mount_busy(mnt, dentry))
370 return NULL;
371
372 /* Can we expire this guy */
373 if (autofs4_can_expire(dentry, timeout, do_now))
374 return dentry;
375 return NULL;
376 }
377
David Howells2b0143b2015-03-17 22:25:59 +0000378 if (d_really_is_positive(dentry) && d_is_symlink(dentry)) {
Ian Kent8a78d592016-03-15 14:58:45 -0700379 pr_debug("checking symlink %p %pd\n", dentry, dentry);
NeilBrowna5d1dba2014-10-13 15:52:16 -0700380 /*
381 * A symlink can't be "busy" in the usual sense so
382 * just check last used for expire timeout.
383 */
384 if (autofs4_can_expire(dentry, timeout, do_now))
385 return dentry;
386 return NULL;
387 }
388
389 if (simple_empty(dentry))
390 return NULL;
391
392 /* Case 2: tree mount, expire iff entire tree is not busy */
393 if (!exp_leaves) {
394 /* Path walk currently on this dentry? */
395 ino_count = atomic_read(&ino->count) + 1;
396 if (d_count(dentry) > ino_count)
397 return NULL;
398
399 if (!autofs4_tree_busy(mnt, dentry, timeout, do_now))
400 return dentry;
401 /*
402 * Case 3: pseudo direct mount, expire individual leaves
403 * (autofs-4.1).
404 */
405 } else {
406 /* Path walk currently on this dentry? */
407 struct dentry *expired;
Ian Kente9a7c2f2016-03-15 14:58:25 -0700408
NeilBrowna5d1dba2014-10-13 15:52:16 -0700409 ino_count = atomic_read(&ino->count) + 1;
410 if (d_count(dentry) > ino_count)
411 return NULL;
412
413 expired = autofs4_check_leaves(mnt, dentry, timeout, do_now);
414 if (expired) {
415 if (expired == dentry)
416 dput(dentry);
417 return expired;
418 }
419 }
420 return NULL;
421}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700422/*
423 * Find an eligible tree to time-out
424 * A tree is eligible if :-
425 * - it is unused by any user process
426 * - it has been unused for exp_timeout time
427 */
Ian Kent8d7b48e2008-10-15 22:02:54 -0700428struct dentry *autofs4_expire_indirect(struct super_block *sb,
429 struct vfsmount *mnt,
430 struct autofs_sb_info *sbi,
431 int how)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700432{
433 unsigned long timeout;
434 struct dentry *root = sb->s_root;
Nick Piggin2fd6b7f2011-01-07 17:49:34 +1100435 struct dentry *dentry;
NeilBrowna5d1dba2014-10-13 15:52:16 -0700436 struct dentry *expired;
Ian Kent97e74492008-07-23 21:30:26 -0700437 struct autofs_info *ino;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700438
Ian Kentc0ba7e52006-09-25 16:24:16 -0700439 if (!root)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700440 return NULL;
441
442 now = jiffies;
443 timeout = sbi->exp_timeout;
444
Nick Piggin2fd6b7f2011-01-07 17:49:34 +1100445 dentry = NULL;
Ian Kentd4a85e32011-03-25 01:51:20 +0800446 while ((dentry = get_next_positive_subdir(dentry, root))) {
Ian Kent97e74492008-07-23 21:30:26 -0700447 spin_lock(&sbi->fs_lock);
NeilBrown4d885f92014-10-13 15:52:20 -0700448 ino = autofs4_dentry_ino(dentry);
449 if (ino->flags & AUTOFS_INF_NO_RCU)
450 expired = NULL;
451 else
452 expired = should_expire(dentry, mnt, timeout, how);
453 if (!expired) {
454 spin_unlock(&sbi->fs_lock);
455 continue;
456 }
457 ino = autofs4_dentry_ino(expired);
458 ino->flags |= AUTOFS_INF_NO_RCU;
459 spin_unlock(&sbi->fs_lock);
460 synchronize_rcu();
461 spin_lock(&sbi->fs_lock);
462 if (should_expire(expired, mnt, timeout, how)) {
NeilBrowna5d1dba2014-10-13 15:52:16 -0700463 if (expired != dentry)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700464 dput(dentry);
NeilBrowna5d1dba2014-10-13 15:52:16 -0700465 goto found;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700466 }
NeilBrown4d885f92014-10-13 15:52:20 -0700467
468 ino->flags &= ~AUTOFS_INF_NO_RCU;
469 if (expired != dentry)
470 dput(expired);
Ian Kent97e74492008-07-23 21:30:26 -0700471 spin_unlock(&sbi->fs_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700472 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700473 return NULL;
Ian Kentafec5702008-05-01 04:35:06 -0700474
475found:
Ian Kent8a78d592016-03-15 14:58:45 -0700476 pr_debug("returning %p %pd\n", expired, expired);
Ian Kent97e74492008-07-23 21:30:26 -0700477 ino->flags |= AUTOFS_INF_EXPIRING;
NeilBrown4d885f92014-10-13 15:52:20 -0700478 smp_mb();
479 ino->flags &= ~AUTOFS_INF_NO_RCU;
Ian Kent6e60a9a2008-07-23 21:30:27 -0700480 init_completion(&ino->expire_complete);
Ian Kent97e74492008-07-23 21:30:26 -0700481 spin_unlock(&sbi->fs_lock);
Ian Kente7854722011-03-25 01:51:31 +0800482 spin_lock(&sbi->lookup_lock);
Nick Piggin2fd6b7f2011-01-07 17:49:34 +1100483 spin_lock(&expired->d_parent->d_lock);
484 spin_lock_nested(&expired->d_lock, DENTRY_D_LOCK_NESTED);
Al Viro946e51f2014-10-26 19:19:16 -0400485 list_move(&expired->d_parent->d_subdirs, &expired->d_child);
Nick Piggin2fd6b7f2011-01-07 17:49:34 +1100486 spin_unlock(&expired->d_lock);
487 spin_unlock(&expired->d_parent->d_lock);
Ian Kente7854722011-03-25 01:51:31 +0800488 spin_unlock(&sbi->lookup_lock);
Ian Kentafec5702008-05-01 04:35:06 -0700489 return expired;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700490}
491
NeilBrown23bfc2a2014-10-13 15:52:14 -0700492int autofs4_expire_wait(struct dentry *dentry, int rcu_walk)
Ian Kent06a35982008-07-23 21:30:28 -0700493{
494 struct autofs_sb_info *sbi = autofs4_sbi(dentry->d_sb);
495 struct autofs_info *ino = autofs4_dentry_ino(dentry);
496 int status;
497
498 /* Block on any pending expire */
NeilBrown4d885f92014-10-13 15:52:20 -0700499 if (!(ino->flags & (AUTOFS_INF_EXPIRING | AUTOFS_INF_NO_RCU)))
500 return 0;
501 if (rcu_walk)
502 return -ECHILD;
503
Ian Kent06a35982008-07-23 21:30:28 -0700504 spin_lock(&sbi->fs_lock);
505 if (ino->flags & AUTOFS_INF_EXPIRING) {
506 spin_unlock(&sbi->fs_lock);
507
Ian Kent8a78d592016-03-15 14:58:45 -0700508 pr_debug("waiting for expire %p name=%pd\n", dentry, dentry);
Ian Kent06a35982008-07-23 21:30:28 -0700509
510 status = autofs4_wait(sbi, dentry, NFY_NONE);
511 wait_for_completion(&ino->expire_complete);
512
Ian Kent8a78d592016-03-15 14:58:45 -0700513 pr_debug("expire done status=%d\n", status);
Ian Kent06a35982008-07-23 21:30:28 -0700514
Al Viro4b1ae272010-03-03 12:58:31 -0500515 if (d_unhashed(dentry))
Ian Kent06a35982008-07-23 21:30:28 -0700516 return -EAGAIN;
517
518 return status;
519 }
520 spin_unlock(&sbi->fs_lock);
521
522 return 0;
523}
524
Linus Torvalds1da177e2005-04-16 15:20:36 -0700525/* Perform an expiry operation */
526int autofs4_expire_run(struct super_block *sb,
Ian Kente9a7c2f2016-03-15 14:58:25 -0700527 struct vfsmount *mnt,
528 struct autofs_sb_info *sbi,
529 struct autofs_packet_expire __user *pkt_p)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700530{
531 struct autofs_packet_expire pkt;
Ian Kent97e74492008-07-23 21:30:26 -0700532 struct autofs_info *ino;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700533 struct dentry *dentry;
Ian Kent97e74492008-07-23 21:30:26 -0700534 int ret = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700535
Ian Kente9a7c2f2016-03-15 14:58:25 -0700536 memset(&pkt, 0, sizeof(pkt));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700537
538 pkt.hdr.proto_version = sbi->version;
539 pkt.hdr.type = autofs_ptype_expire;
540
Ian Kente9a7c2f2016-03-15 14:58:25 -0700541 dentry = autofs4_expire_indirect(sb, mnt, sbi, 0);
542 if (!dentry)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700543 return -EAGAIN;
544
545 pkt.len = dentry->d_name.len;
546 memcpy(pkt.name, dentry->d_name.name, pkt.len);
547 pkt.name[pkt.len] = '\0';
548 dput(dentry);
549
Ian Kente9a7c2f2016-03-15 14:58:25 -0700550 if (copy_to_user(pkt_p, &pkt, sizeof(struct autofs_packet_expire)))
Ian Kent97e74492008-07-23 21:30:26 -0700551 ret = -EFAULT;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700552
Ian Kent97e74492008-07-23 21:30:26 -0700553 spin_lock(&sbi->fs_lock);
554 ino = autofs4_dentry_ino(dentry);
NeilBrown6ece08e2014-10-13 15:52:18 -0700555 /* avoid rapid-fire expire attempts if expiry fails */
556 ino->last_used = now;
Ian Kent97e74492008-07-23 21:30:26 -0700557 ino->flags &= ~AUTOFS_INF_EXPIRING;
Ian Kent6e60a9a2008-07-23 21:30:27 -0700558 complete_all(&ino->expire_complete);
Ian Kent97e74492008-07-23 21:30:26 -0700559 spin_unlock(&sbi->fs_lock);
560
561 return ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700562}
563
Ian Kent56fcef72009-03-31 15:24:43 -0700564int autofs4_do_expire_multi(struct super_block *sb, struct vfsmount *mnt,
565 struct autofs_sb_info *sbi, int when)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700566{
567 struct dentry *dentry;
568 int ret = -EAGAIN;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700569
Ian Kenta92daf62009-01-06 14:42:08 -0800570 if (autofs_type_trigger(sbi->type))
Ian Kent56fcef72009-03-31 15:24:43 -0700571 dentry = autofs4_expire_direct(sb, mnt, sbi, when);
Ian Kent3a15e2a2006-03-27 01:14:55 -0800572 else
Ian Kent56fcef72009-03-31 15:24:43 -0700573 dentry = autofs4_expire_indirect(sb, mnt, sbi, when);
Ian Kent3a15e2a2006-03-27 01:14:55 -0800574
575 if (dentry) {
Ian Kent1f5f2c32006-03-27 01:14:44 -0800576 struct autofs_info *ino = autofs4_dentry_ino(dentry);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700577
578 /* This is synchronous because it makes the daemon a
Ian Kente9a7c2f2016-03-15 14:58:25 -0700579 * little easier
580 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700581 ret = autofs4_wait(sbi, dentry, NFY_EXPIRE);
Ian Kent6e60a9a2008-07-23 21:30:27 -0700582
Ian Kent97e74492008-07-23 21:30:26 -0700583 spin_lock(&sbi->fs_lock);
NeilBrown6ece08e2014-10-13 15:52:18 -0700584 /* avoid rapid-fire expire attempts if expiry fails */
585 ino->last_used = now;
Ian Kent1f5f2c32006-03-27 01:14:44 -0800586 ino->flags &= ~AUTOFS_INF_EXPIRING;
Ian Kent6e60a9a2008-07-23 21:30:27 -0700587 complete_all(&ino->expire_complete);
Ian Kent97e74492008-07-23 21:30:26 -0700588 spin_unlock(&sbi->fs_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700589 dput(dentry);
590 }
Ian Kent1f5f2c32006-03-27 01:14:44 -0800591
Linus Torvalds1da177e2005-04-16 15:20:36 -0700592 return ret;
593}
594
Ian Kente9a7c2f2016-03-15 14:58:25 -0700595/*
596 * Call repeatedly until it returns -EAGAIN, meaning there's nothing
597 * more to be done.
598 */
Ian Kent56fcef72009-03-31 15:24:43 -0700599int autofs4_expire_multi(struct super_block *sb, struct vfsmount *mnt,
600 struct autofs_sb_info *sbi, int __user *arg)
601{
602 int do_now = 0;
603
604 if (arg && get_user(do_now, arg))
605 return -EFAULT;
606
607 return autofs4_do_expire_multi(sb, mnt, sbi, do_now);
608}
609