]>
Commit | Line | Data |
---|---|---|
e9a7c2f1 IK |
1 | /* |
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> | |
1da177e4 LT |
5 | * |
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. | |
e9a7c2f1 | 9 | */ |
1da177e4 LT |
10 | |
11 | #include "autofs_i.h" | |
12 | ||
13 | static unsigned long now; | |
14 | ||
1f5f2c30 | 15 | /* Check if a dentry can be expired */ |
1da177e4 | 16 | static inline int autofs4_can_expire(struct dentry *dentry, |
e9a7c2f1 | 17 | unsigned long timeout, int do_now) |
1da177e4 LT |
18 | { |
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 | ||
1da177e4 LT |
25 | if (!do_now) { |
26 | /* Too young to die */ | |
c0ba7e51 | 27 | if (!timeout || time_after(ino->last_used + timeout, now)) |
1da177e4 | 28 | return 0; |
1da177e4 | 29 | } |
1da177e4 LT |
30 | return 1; |
31 | } | |
32 | ||
1f5f2c30 IK |
33 | /* Check a mount point for busyness */ |
34 | static int autofs4_mount_busy(struct vfsmount *mnt, struct dentry *dentry) | |
1da177e4 | 35 | { |
e0a7aae9 | 36 | struct dentry *top = dentry; |
9393bd07 | 37 | struct path path = {.mnt = mnt, .dentry = dentry}; |
1f5f2c30 | 38 | int status = 1; |
1da177e4 | 39 | |
8a78d593 | 40 | pr_debug("dentry %p %pd\n", dentry, dentry); |
1da177e4 | 41 | |
9393bd07 | 42 | path_get(&path); |
1da177e4 | 43 | |
cc53ce53 | 44 | if (!follow_down_one(&path)) |
1da177e4 LT |
45 | goto done; |
46 | ||
9393bd07 AV |
47 | if (is_autofs4_dentry(path.dentry)) { |
48 | struct autofs_sb_info *sbi = autofs4_sbi(path.dentry->d_sb); | |
bc9c4068 IK |
49 | |
50 | /* This is an autofs submount, we can't expire it */ | |
a92daf6b | 51 | if (autofs_type_indirect(sbi->type)) |
bc9c4068 | 52 | goto done; |
bc9c4068 | 53 | } |
1da177e4 | 54 | |
e0a7aae9 | 55 | /* Update the expiry counter if fs is busy */ |
37d0892c | 56 | if (!may_umount_tree(path.mnt)) { |
e9a7c2f1 IK |
57 | struct autofs_info *ino; |
58 | ||
59 | ino = autofs4_dentry_ino(top); | |
e0a7aae9 IK |
60 | ino->last_used = jiffies; |
61 | goto done; | |
62 | } | |
63 | ||
64 | status = 0; | |
1da177e4 | 65 | done: |
8a78d593 | 66 | pr_debug("returning = %d\n", status); |
9393bd07 | 67 | path_put(&path); |
1da177e4 LT |
68 | return status; |
69 | } | |
70 | ||
d4a85e35 IK |
71 | /* |
72 | * Calculate and dget next entry in the subdirs list under root. | |
73 | */ | |
74 | static struct dentry *get_next_positive_subdir(struct dentry *prev, | |
e9a7c2f1 | 75 | struct dentry *root) |
d4a85e35 | 76 | { |
e7854723 | 77 | struct autofs_sb_info *sbi = autofs4_sbi(root->d_sb); |
d4a85e35 | 78 | struct list_head *next; |
a45440f0 | 79 | struct dentry *q; |
d4a85e35 | 80 | |
e7854723 | 81 | spin_lock(&sbi->lookup_lock); |
a45440f0 | 82 | spin_lock(&root->d_lock); |
d4a85e35 | 83 | |
a45440f0 | 84 | if (prev) |
946e51f2 | 85 | next = prev->d_child.next; |
a45440f0 | 86 | else { |
d4a85e35 IK |
87 | prev = dget_dlock(root); |
88 | next = prev->d_subdirs.next; | |
d4a85e35 IK |
89 | } |
90 | ||
a45440f0 | 91 | cont: |
d4a85e35 | 92 | if (next == &root->d_subdirs) { |
a45440f0 | 93 | spin_unlock(&root->d_lock); |
e7854723 | 94 | spin_unlock(&sbi->lookup_lock); |
d4a85e35 IK |
95 | dput(prev); |
96 | return NULL; | |
97 | } | |
98 | ||
946e51f2 | 99 | q = list_entry(next, struct dentry, d_child); |
d4a85e35 IK |
100 | |
101 | spin_lock_nested(&q->d_lock, DENTRY_D_LOCK_NESTED); | |
a45440f0 | 102 | /* Already gone or negative dentry (under construction) - try next */ |
84d08fa8 | 103 | if (!d_count(q) || !simple_positive(q)) { |
a45440f0 | 104 | spin_unlock(&q->d_lock); |
946e51f2 | 105 | next = q->d_child.next; |
a45440f0 | 106 | goto cont; |
d4a85e35 IK |
107 | } |
108 | dget_dlock(q); | |
109 | spin_unlock(&q->d_lock); | |
a45440f0 | 110 | spin_unlock(&root->d_lock); |
e7854723 | 111 | spin_unlock(&sbi->lookup_lock); |
d4a85e35 IK |
112 | |
113 | dput(prev); | |
114 | ||
115 | return q; | |
116 | } | |
117 | ||
1ce12bad | 118 | /* |
2fd6b7f5 | 119 | * Calculate and dget next entry in top down tree traversal. |
1ce12bad | 120 | */ |
2fd6b7f5 | 121 | static struct dentry *get_next_positive_dentry(struct dentry *prev, |
e9a7c2f1 | 122 | struct dentry *root) |
1ce12bad | 123 | { |
e7854723 | 124 | struct autofs_sb_info *sbi = autofs4_sbi(root->d_sb); |
2fd6b7f5 NP |
125 | struct list_head *next; |
126 | struct dentry *p, *ret; | |
127 | ||
128 | if (prev == NULL) | |
c14cc63a | 129 | return dget(root); |
1ce12bad | 130 | |
e7854723 | 131 | spin_lock(&sbi->lookup_lock); |
2fd6b7f5 NP |
132 | relock: |
133 | p = prev; | |
134 | spin_lock(&p->d_lock); | |
135 | again: | |
136 | next = p->d_subdirs.next; | |
1ce12bad IK |
137 | if (next == &p->d_subdirs) { |
138 | while (1) { | |
2fd6b7f5 NP |
139 | struct dentry *parent; |
140 | ||
141 | if (p == root) { | |
142 | spin_unlock(&p->d_lock); | |
e7854723 | 143 | spin_unlock(&sbi->lookup_lock); |
2fd6b7f5 | 144 | dput(prev); |
1ce12bad | 145 | return NULL; |
2fd6b7f5 NP |
146 | } |
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); | |
946e51f2 | 155 | next = p->d_child.next; |
2fd6b7f5 NP |
156 | p = parent; |
157 | if (next != &parent->d_subdirs) | |
1ce12bad | 158 | break; |
1ce12bad IK |
159 | } |
160 | } | |
946e51f2 | 161 | ret = list_entry(next, struct dentry, d_child); |
2fd6b7f5 NP |
162 | |
163 | spin_lock_nested(&ret->d_lock, DENTRY_D_LOCK_NESTED); | |
164 | /* Negative dentry - try next */ | |
165 | if (!simple_positive(ret)) { | |
c14cc63a | 166 | spin_unlock(&p->d_lock); |
1d6f2097 | 167 | lock_set_subclass(&ret->d_lock.dep_map, 0, _RET_IP_); |
2fd6b7f5 NP |
168 | p = ret; |
169 | goto again; | |
170 | } | |
171 | dget_dlock(ret); | |
172 | spin_unlock(&ret->d_lock); | |
173 | spin_unlock(&p->d_lock); | |
e7854723 | 174 | spin_unlock(&sbi->lookup_lock); |
2fd6b7f5 NP |
175 | |
176 | dput(prev); | |
177 | ||
178 | return ret; | |
1ce12bad IK |
179 | } |
180 | ||
3a15e2ab IK |
181 | /* |
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 | */ | |
187 | static int autofs4_direct_busy(struct vfsmount *mnt, | |
e9a7c2f1 IK |
188 | struct dentry *top, |
189 | unsigned long timeout, | |
190 | int do_now) | |
3a15e2ab | 191 | { |
8a78d593 | 192 | pr_debug("top %p %pd\n", top, top); |
3a15e2ab | 193 | |
3a15e2ab IK |
194 | /* If it's busy update the expiry counters */ |
195 | if (!may_umount_tree(mnt)) { | |
e9a7c2f1 IK |
196 | struct autofs_info *ino; |
197 | ||
198 | ino = autofs4_dentry_ino(top); | |
3a15e2ab IK |
199 | 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 | ||
e9a7c2f1 IK |
211 | /* |
212 | * Check a directory tree of mount points for busyness | |
1da177e4 | 213 | * The tree is not busy iff no mountpoints are busy |
1da177e4 | 214 | */ |
1f5f2c30 IK |
215 | static int autofs4_tree_busy(struct vfsmount *mnt, |
216 | struct dentry *top, | |
217 | unsigned long timeout, | |
218 | int do_now) | |
1da177e4 | 219 | { |
e0a7aae9 | 220 | struct autofs_info *top_ino = autofs4_dentry_ino(top); |
1ce12bad | 221 | struct dentry *p; |
1da177e4 | 222 | |
8a78d593 | 223 | pr_debug("top %p %pd\n", top, top); |
1da177e4 LT |
224 | |
225 | /* Negative dentry - give up */ | |
226 | if (!simple_positive(top)) | |
1f5f2c30 | 227 | return 1; |
1da177e4 | 228 | |
2fd6b7f5 NP |
229 | p = NULL; |
230 | while ((p = get_next_positive_dentry(p, top))) { | |
8a78d593 | 231 | pr_debug("dentry %p %pd\n", p, p); |
1da177e4 | 232 | |
1aff3c8b IK |
233 | /* |
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. | |
e0a7aae9 | 237 | * If the fs is busy update the expiry counter. |
1aff3c8b | 238 | */ |
1ce12bad | 239 | if (d_mountpoint(p)) { |
1ce12bad | 240 | if (autofs4_mount_busy(mnt, p)) { |
e0a7aae9 | 241 | top_ino->last_used = jiffies; |
1ce12bad | 242 | dput(p); |
1f5f2c30 | 243 | return 1; |
1da177e4 | 244 | } |
1aff3c8b | 245 | } else { |
e0a7aae9 | 246 | struct autofs_info *ino = autofs4_dentry_ino(p); |
1aff3c8b IK |
247 | 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 | ||
84d08fa8 | 255 | if (d_count(p) > ino_count) { |
e0a7aae9 | 256 | top_ino->last_used = jiffies; |
1aff3c8b IK |
257 | dput(p); |
258 | return 1; | |
259 | } | |
1da177e4 | 260 | } |
1da177e4 | 261 | } |
1aff3c8b IK |
262 | |
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 | ||
1f5f2c30 | 267 | return 0; |
1da177e4 LT |
268 | } |
269 | ||
270 | static struct dentry *autofs4_check_leaves(struct vfsmount *mnt, | |
271 | struct dentry *parent, | |
272 | unsigned long timeout, | |
273 | int do_now) | |
274 | { | |
1ce12bad | 275 | struct dentry *p; |
1da177e4 | 276 | |
8a78d593 | 277 | pr_debug("parent %p %pd\n", parent, parent); |
1da177e4 | 278 | |
2fd6b7f5 NP |
279 | p = NULL; |
280 | while ((p = get_next_positive_dentry(p, parent))) { | |
8a78d593 | 281 | pr_debug("dentry %p %pd\n", p, p); |
1da177e4 | 282 | |
1ce12bad | 283 | if (d_mountpoint(p)) { |
e0a7aae9 IK |
284 | /* Can we umount this guy */ |
285 | if (autofs4_mount_busy(mnt, p)) | |
2fd6b7f5 | 286 | continue; |
1da177e4 | 287 | |
e0a7aae9 IK |
288 | /* Can we expire this guy */ |
289 | if (autofs4_can_expire(p, timeout, do_now)) | |
1ce12bad | 290 | return p; |
1da177e4 | 291 | } |
1da177e4 | 292 | } |
1da177e4 LT |
293 | return NULL; |
294 | } | |
295 | ||
3a15e2ab | 296 | /* Check if we can expire a direct mount (possibly a tree) */ |
8d7b48e0 IK |
297 | struct dentry *autofs4_expire_direct(struct super_block *sb, |
298 | struct vfsmount *mnt, | |
299 | struct autofs_sb_info *sbi, | |
300 | int how) | |
3a15e2ab IK |
301 | { |
302 | unsigned long timeout; | |
303 | struct dentry *root = dget(sb->s_root); | |
304 | int do_now = how & AUTOFS_EXP_IMMEDIATE; | |
b5b80177 | 305 | struct autofs_info *ino; |
3a15e2ab | 306 | |
c0ba7e51 | 307 | if (!root) |
3a15e2ab IK |
308 | return NULL; |
309 | ||
310 | now = jiffies; | |
311 | timeout = sbi->exp_timeout; | |
312 | ||
3a15e2ab | 313 | spin_lock(&sbi->fs_lock); |
b5b80177 IK |
314 | ino = autofs4_dentry_ino(root); |
315 | /* No point expiring a pending mount */ | |
f9398c23 IK |
316 | if (ino->flags & AUTOFS_INF_PENDING) |
317 | goto out; | |
3a15e2ab | 318 | if (!autofs4_direct_busy(mnt, root, timeout, do_now)) { |
ea01a184 | 319 | ino->flags |= AUTOFS_INF_WANT_EXPIRE; |
3a15e2ab | 320 | spin_unlock(&sbi->fs_lock); |
4d885f90 N |
321 | synchronize_rcu(); |
322 | spin_lock(&sbi->fs_lock); | |
323 | if (!autofs4_direct_busy(mnt, root, timeout, do_now)) { | |
324 | ino->flags |= AUTOFS_INF_EXPIRING; | |
4d885f90 N |
325 | init_completion(&ino->expire_complete); |
326 | spin_unlock(&sbi->fs_lock); | |
327 | return root; | |
328 | } | |
ea01a184 | 329 | ino->flags &= ~AUTOFS_INF_WANT_EXPIRE; |
3a15e2ab | 330 | } |
f9398c23 | 331 | out: |
3a15e2ab IK |
332 | spin_unlock(&sbi->fs_lock); |
333 | dput(root); | |
334 | ||
335 | return NULL; | |
336 | } | |
337 | ||
a5d1dba1 N |
338 | /* Check if 'dentry' should expire, or return a nearby |
339 | * dentry that is suitable. | |
340 | * If returned dentry is different from arg dentry, | |
341 | * then a dget() reference was taken, else not. | |
342 | */ | |
343 | static struct dentry *should_expire(struct dentry *dentry, | |
344 | struct vfsmount *mnt, | |
345 | unsigned long timeout, | |
346 | int how) | |
347 | { | |
348 | int do_now = how & AUTOFS_EXP_IMMEDIATE; | |
349 | int exp_leaves = how & AUTOFS_EXP_LEAVES; | |
350 | struct autofs_info *ino = autofs4_dentry_ino(dentry); | |
351 | unsigned int ino_count; | |
352 | ||
353 | /* No point expiring a pending mount */ | |
354 | if (ino->flags & AUTOFS_INF_PENDING) | |
355 | return NULL; | |
356 | ||
357 | /* | |
358 | * Case 1: (i) indirect mount or top level pseudo direct mount | |
359 | * (autofs-4.1). | |
360 | * (ii) indirect mount with offset mount, check the "/" | |
361 | * offset (autofs-5.0+). | |
362 | */ | |
363 | if (d_mountpoint(dentry)) { | |
8a78d593 | 364 | pr_debug("checking mountpoint %p %pd\n", dentry, dentry); |
a5d1dba1 N |
365 | |
366 | /* Can we umount this guy */ | |
367 | if (autofs4_mount_busy(mnt, dentry)) | |
368 | return NULL; | |
369 | ||
370 | /* Can we expire this guy */ | |
371 | if (autofs4_can_expire(dentry, timeout, do_now)) | |
372 | return dentry; | |
373 | return NULL; | |
374 | } | |
375 | ||
2b0143b5 | 376 | if (d_really_is_positive(dentry) && d_is_symlink(dentry)) { |
8a78d593 | 377 | pr_debug("checking symlink %p %pd\n", dentry, dentry); |
a5d1dba1 N |
378 | /* |
379 | * A symlink can't be "busy" in the usual sense so | |
380 | * just check last used for expire timeout. | |
381 | */ | |
382 | if (autofs4_can_expire(dentry, timeout, do_now)) | |
383 | return dentry; | |
384 | return NULL; | |
385 | } | |
386 | ||
387 | if (simple_empty(dentry)) | |
388 | return NULL; | |
389 | ||
390 | /* Case 2: tree mount, expire iff entire tree is not busy */ | |
391 | if (!exp_leaves) { | |
392 | /* Path walk currently on this dentry? */ | |
393 | ino_count = atomic_read(&ino->count) + 1; | |
394 | if (d_count(dentry) > ino_count) | |
395 | return NULL; | |
396 | ||
397 | if (!autofs4_tree_busy(mnt, dentry, timeout, do_now)) | |
398 | return dentry; | |
399 | /* | |
400 | * Case 3: pseudo direct mount, expire individual leaves | |
401 | * (autofs-4.1). | |
402 | */ | |
403 | } else { | |
404 | /* Path walk currently on this dentry? */ | |
405 | struct dentry *expired; | |
e9a7c2f1 | 406 | |
a5d1dba1 N |
407 | ino_count = atomic_read(&ino->count) + 1; |
408 | if (d_count(dentry) > ino_count) | |
409 | return NULL; | |
410 | ||
411 | expired = autofs4_check_leaves(mnt, dentry, timeout, do_now); | |
412 | if (expired) { | |
413 | if (expired == dentry) | |
414 | dput(dentry); | |
415 | return expired; | |
416 | } | |
417 | } | |
418 | return NULL; | |
419 | } | |
7cbdb4a2 | 420 | |
1da177e4 LT |
421 | /* |
422 | * Find an eligible tree to time-out | |
423 | * A tree is eligible if :- | |
424 | * - it is unused by any user process | |
425 | * - it has been unused for exp_timeout time | |
426 | */ | |
8d7b48e0 IK |
427 | struct dentry *autofs4_expire_indirect(struct super_block *sb, |
428 | struct vfsmount *mnt, | |
429 | struct autofs_sb_info *sbi, | |
430 | int how) | |
1da177e4 LT |
431 | { |
432 | unsigned long timeout; | |
433 | struct dentry *root = sb->s_root; | |
2fd6b7f5 | 434 | struct dentry *dentry; |
a5d1dba1 | 435 | struct dentry *expired; |
7cbdb4a2 | 436 | struct dentry *found; |
97e7449a | 437 | struct autofs_info *ino; |
1da177e4 | 438 | |
c0ba7e51 | 439 | if (!root) |
1da177e4 LT |
440 | return NULL; |
441 | ||
442 | now = jiffies; | |
443 | timeout = sbi->exp_timeout; | |
444 | ||
2fd6b7f5 | 445 | dentry = NULL; |
d4a85e35 | 446 | while ((dentry = get_next_positive_subdir(dentry, root))) { |
7cbdb4a2 IK |
447 | int flags = how; |
448 | ||
97e7449a | 449 | spin_lock(&sbi->fs_lock); |
4d885f90 | 450 | ino = autofs4_dentry_ino(dentry); |
7cbdb4a2 | 451 | if (ino->flags & AUTOFS_INF_WANT_EXPIRE) { |
4d885f90 N |
452 | spin_unlock(&sbi->fs_lock); |
453 | continue; | |
454 | } | |
7cbdb4a2 IK |
455 | spin_unlock(&sbi->fs_lock); |
456 | ||
457 | expired = should_expire(dentry, mnt, timeout, flags); | |
458 | if (!expired) | |
459 | continue; | |
460 | ||
461 | spin_lock(&sbi->fs_lock); | |
4d885f90 | 462 | ino = autofs4_dentry_ino(expired); |
ea01a184 | 463 | ino->flags |= AUTOFS_INF_WANT_EXPIRE; |
4d885f90 N |
464 | spin_unlock(&sbi->fs_lock); |
465 | synchronize_rcu(); | |
4d885f90 | 466 | |
7cbdb4a2 IK |
467 | /* Make sure a reference is not taken on found if |
468 | * things have changed. | |
469 | */ | |
470 | flags &= ~AUTOFS_EXP_LEAVES; | |
471 | found = should_expire(expired, mnt, timeout, how); | |
472 | if (!found || found != expired) | |
473 | /* Something has changed, continue */ | |
474 | goto next; | |
475 | ||
476 | if (expired != dentry) | |
477 | dput(dentry); | |
478 | ||
479 | spin_lock(&sbi->fs_lock); | |
480 | goto found; | |
481 | next: | |
482 | spin_lock(&sbi->fs_lock); | |
ea01a184 | 483 | ino->flags &= ~AUTOFS_INF_WANT_EXPIRE; |
7cbdb4a2 | 484 | spin_unlock(&sbi->fs_lock); |
4d885f90 N |
485 | if (expired != dentry) |
486 | dput(expired); | |
1da177e4 | 487 | } |
1da177e4 | 488 | return NULL; |
afec570c IK |
489 | |
490 | found: | |
8a78d593 | 491 | pr_debug("returning %p %pd\n", expired, expired); |
97e7449a | 492 | ino->flags |= AUTOFS_INF_EXPIRING; |
6e60a9ab | 493 | init_completion(&ino->expire_complete); |
97e7449a | 494 | spin_unlock(&sbi->fs_lock); |
afec570c | 495 | return expired; |
1da177e4 LT |
496 | } |
497 | ||
23bfc2a2 | 498 | int autofs4_expire_wait(struct dentry *dentry, int rcu_walk) |
06a35985 IK |
499 | { |
500 | struct autofs_sb_info *sbi = autofs4_sbi(dentry->d_sb); | |
501 | struct autofs_info *ino = autofs4_dentry_ino(dentry); | |
502 | int status; | |
7cbdb4a2 | 503 | int state; |
06a35985 IK |
504 | |
505 | /* Block on any pending expire */ | |
ea01a184 | 506 | if (!(ino->flags & AUTOFS_INF_WANT_EXPIRE)) |
4d885f90 N |
507 | return 0; |
508 | if (rcu_walk) | |
509 | return -ECHILD; | |
510 | ||
7cbdb4a2 | 511 | retry: |
06a35985 | 512 | spin_lock(&sbi->fs_lock); |
7cbdb4a2 IK |
513 | state = ino->flags & (AUTOFS_INF_WANT_EXPIRE | AUTOFS_INF_EXPIRING); |
514 | if (state == AUTOFS_INF_WANT_EXPIRE) { | |
515 | spin_unlock(&sbi->fs_lock); | |
516 | /* | |
517 | * Possibly being selected for expire, wait until | |
518 | * it's selected or not. | |
519 | */ | |
520 | schedule_timeout_uninterruptible(HZ/10); | |
521 | goto retry; | |
522 | } | |
523 | if (state & AUTOFS_INF_EXPIRING) { | |
06a35985 IK |
524 | spin_unlock(&sbi->fs_lock); |
525 | ||
8a78d593 | 526 | pr_debug("waiting for expire %p name=%pd\n", dentry, dentry); |
06a35985 IK |
527 | |
528 | status = autofs4_wait(sbi, dentry, NFY_NONE); | |
529 | wait_for_completion(&ino->expire_complete); | |
530 | ||
8a78d593 | 531 | pr_debug("expire done status=%d\n", status); |
06a35985 | 532 | |
4b1ae27a | 533 | if (d_unhashed(dentry)) |
06a35985 IK |
534 | return -EAGAIN; |
535 | ||
536 | return status; | |
537 | } | |
538 | spin_unlock(&sbi->fs_lock); | |
539 | ||
540 | return 0; | |
541 | } | |
542 | ||
1da177e4 LT |
543 | /* Perform an expiry operation */ |
544 | int autofs4_expire_run(struct super_block *sb, | |
e9a7c2f1 IK |
545 | struct vfsmount *mnt, |
546 | struct autofs_sb_info *sbi, | |
547 | struct autofs_packet_expire __user *pkt_p) | |
1da177e4 LT |
548 | { |
549 | struct autofs_packet_expire pkt; | |
97e7449a | 550 | struct autofs_info *ino; |
1da177e4 | 551 | struct dentry *dentry; |
97e7449a | 552 | int ret = 0; |
1da177e4 | 553 | |
e9a7c2f1 | 554 | memset(&pkt, 0, sizeof(pkt)); |
1da177e4 LT |
555 | |
556 | pkt.hdr.proto_version = sbi->version; | |
557 | pkt.hdr.type = autofs_ptype_expire; | |
558 | ||
e9a7c2f1 IK |
559 | dentry = autofs4_expire_indirect(sb, mnt, sbi, 0); |
560 | if (!dentry) | |
1da177e4 LT |
561 | return -EAGAIN; |
562 | ||
563 | pkt.len = dentry->d_name.len; | |
564 | memcpy(pkt.name, dentry->d_name.name, pkt.len); | |
565 | pkt.name[pkt.len] = '\0'; | |
566 | dput(dentry); | |
567 | ||
e9a7c2f1 | 568 | if (copy_to_user(pkt_p, &pkt, sizeof(struct autofs_packet_expire))) |
97e7449a | 569 | ret = -EFAULT; |
1da177e4 | 570 | |
97e7449a IK |
571 | spin_lock(&sbi->fs_lock); |
572 | ino = autofs4_dentry_ino(dentry); | |
6ece08e6 N |
573 | /* avoid rapid-fire expire attempts if expiry fails */ |
574 | ino->last_used = now; | |
ea01a184 | 575 | ino->flags &= ~(AUTOFS_INF_EXPIRING|AUTOFS_INF_WANT_EXPIRE); |
6e60a9ab | 576 | complete_all(&ino->expire_complete); |
97e7449a IK |
577 | spin_unlock(&sbi->fs_lock); |
578 | ||
579 | return ret; | |
1da177e4 LT |
580 | } |
581 | ||
56fcef75 IK |
582 | int autofs4_do_expire_multi(struct super_block *sb, struct vfsmount *mnt, |
583 | struct autofs_sb_info *sbi, int when) | |
1da177e4 LT |
584 | { |
585 | struct dentry *dentry; | |
586 | int ret = -EAGAIN; | |
1da177e4 | 587 | |
a92daf6b | 588 | if (autofs_type_trigger(sbi->type)) |
56fcef75 | 589 | dentry = autofs4_expire_direct(sb, mnt, sbi, when); |
3a15e2ab | 590 | else |
56fcef75 | 591 | dentry = autofs4_expire_indirect(sb, mnt, sbi, when); |
3a15e2ab IK |
592 | |
593 | if (dentry) { | |
1f5f2c30 | 594 | struct autofs_info *ino = autofs4_dentry_ino(dentry); |
1da177e4 LT |
595 | |
596 | /* This is synchronous because it makes the daemon a | |
e9a7c2f1 IK |
597 | * little easier |
598 | */ | |
1da177e4 | 599 | ret = autofs4_wait(sbi, dentry, NFY_EXPIRE); |
6e60a9ab | 600 | |
97e7449a | 601 | spin_lock(&sbi->fs_lock); |
6ece08e6 N |
602 | /* avoid rapid-fire expire attempts if expiry fails */ |
603 | ino->last_used = now; | |
ea01a184 | 604 | ino->flags &= ~(AUTOFS_INF_EXPIRING|AUTOFS_INF_WANT_EXPIRE); |
6e60a9ab | 605 | complete_all(&ino->expire_complete); |
97e7449a | 606 | spin_unlock(&sbi->fs_lock); |
1da177e4 LT |
607 | dput(dentry); |
608 | } | |
1f5f2c30 | 609 | |
1da177e4 LT |
610 | return ret; |
611 | } | |
612 | ||
e9a7c2f1 IK |
613 | /* |
614 | * Call repeatedly until it returns -EAGAIN, meaning there's nothing | |
615 | * more to be done. | |
616 | */ | |
56fcef75 IK |
617 | int autofs4_expire_multi(struct super_block *sb, struct vfsmount *mnt, |
618 | struct autofs_sb_info *sbi, int __user *arg) | |
619 | { | |
620 | int do_now = 0; | |
621 | ||
622 | if (arg && get_user(do_now, arg)) | |
623 | return -EFAULT; | |
624 | ||
625 | return autofs4_do_expire_multi(sb, mnt, sbi, do_now); | |
626 | } | |
627 |