]>
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 | if (!autofs4_direct_busy(mnt, root, timeout, do_now)) { |
1c4344a5 IK |
314 | spin_lock(&sbi->fs_lock); |
315 | ino = autofs4_dentry_ino(root); | |
316 | /* No point expiring a pending mount */ | |
317 | if (ino->flags & AUTOFS_INF_PENDING) { | |
318 | spin_unlock(&sbi->fs_lock); | |
319 | goto out; | |
320 | } | |
ea01a184 | 321 | ino->flags |= AUTOFS_INF_WANT_EXPIRE; |
3a15e2ab | 322 | spin_unlock(&sbi->fs_lock); |
4d885f90 | 323 | synchronize_rcu(); |
4d885f90 | 324 | if (!autofs4_direct_busy(mnt, root, timeout, do_now)) { |
1c4344a5 | 325 | spin_lock(&sbi->fs_lock); |
4d885f90 | 326 | ino->flags |= AUTOFS_INF_EXPIRING; |
4d885f90 N |
327 | init_completion(&ino->expire_complete); |
328 | spin_unlock(&sbi->fs_lock); | |
329 | return root; | |
330 | } | |
1c4344a5 | 331 | spin_lock(&sbi->fs_lock); |
ea01a184 | 332 | ino->flags &= ~AUTOFS_INF_WANT_EXPIRE; |
1c4344a5 | 333 | spin_unlock(&sbi->fs_lock); |
3a15e2ab | 334 | } |
f9398c23 | 335 | out: |
3a15e2ab IK |
336 | dput(root); |
337 | ||
338 | return NULL; | |
339 | } | |
340 | ||
a5d1dba1 N |
341 | /* Check if 'dentry' should expire, or return a nearby |
342 | * dentry that is suitable. | |
343 | * If returned dentry is different from arg dentry, | |
344 | * then a dget() reference was taken, else not. | |
345 | */ | |
346 | static struct dentry *should_expire(struct dentry *dentry, | |
347 | struct vfsmount *mnt, | |
348 | unsigned long timeout, | |
349 | int how) | |
350 | { | |
351 | int do_now = how & AUTOFS_EXP_IMMEDIATE; | |
352 | int exp_leaves = how & AUTOFS_EXP_LEAVES; | |
353 | struct autofs_info *ino = autofs4_dentry_ino(dentry); | |
354 | unsigned int ino_count; | |
355 | ||
356 | /* No point expiring a pending mount */ | |
357 | if (ino->flags & AUTOFS_INF_PENDING) | |
358 | return NULL; | |
359 | ||
360 | /* | |
361 | * Case 1: (i) indirect mount or top level pseudo direct mount | |
362 | * (autofs-4.1). | |
363 | * (ii) indirect mount with offset mount, check the "/" | |
364 | * offset (autofs-5.0+). | |
365 | */ | |
366 | if (d_mountpoint(dentry)) { | |
8a78d593 | 367 | pr_debug("checking mountpoint %p %pd\n", dentry, dentry); |
a5d1dba1 N |
368 | |
369 | /* Can we umount this guy */ | |
370 | if (autofs4_mount_busy(mnt, dentry)) | |
371 | return NULL; | |
372 | ||
373 | /* Can we expire this guy */ | |
374 | if (autofs4_can_expire(dentry, timeout, do_now)) | |
375 | return dentry; | |
376 | return NULL; | |
377 | } | |
378 | ||
2b0143b5 | 379 | if (d_really_is_positive(dentry) && d_is_symlink(dentry)) { |
8a78d593 | 380 | pr_debug("checking symlink %p %pd\n", dentry, dentry); |
a5d1dba1 N |
381 | /* |
382 | * A symlink can't be "busy" in the usual sense so | |
383 | * just check last used for expire timeout. | |
384 | */ | |
385 | if (autofs4_can_expire(dentry, timeout, do_now)) | |
386 | return dentry; | |
387 | return NULL; | |
388 | } | |
389 | ||
390 | if (simple_empty(dentry)) | |
391 | return NULL; | |
392 | ||
393 | /* Case 2: tree mount, expire iff entire tree is not busy */ | |
394 | if (!exp_leaves) { | |
395 | /* Path walk currently on this dentry? */ | |
396 | ino_count = atomic_read(&ino->count) + 1; | |
397 | if (d_count(dentry) > ino_count) | |
398 | return NULL; | |
399 | ||
400 | if (!autofs4_tree_busy(mnt, dentry, timeout, do_now)) | |
401 | return dentry; | |
402 | /* | |
403 | * Case 3: pseudo direct mount, expire individual leaves | |
404 | * (autofs-4.1). | |
405 | */ | |
406 | } else { | |
407 | /* Path walk currently on this dentry? */ | |
408 | struct dentry *expired; | |
e9a7c2f1 | 409 | |
a5d1dba1 N |
410 | ino_count = atomic_read(&ino->count) + 1; |
411 | if (d_count(dentry) > ino_count) | |
412 | return NULL; | |
413 | ||
414 | expired = autofs4_check_leaves(mnt, dentry, timeout, do_now); | |
415 | if (expired) { | |
416 | if (expired == dentry) | |
417 | dput(dentry); | |
418 | return expired; | |
419 | } | |
420 | } | |
421 | return NULL; | |
422 | } | |
7cbdb4a2 | 423 | |
1da177e4 LT |
424 | /* |
425 | * Find an eligible tree to time-out | |
426 | * A tree is eligible if :- | |
427 | * - it is unused by any user process | |
428 | * - it has been unused for exp_timeout time | |
429 | */ | |
8d7b48e0 IK |
430 | struct dentry *autofs4_expire_indirect(struct super_block *sb, |
431 | struct vfsmount *mnt, | |
432 | struct autofs_sb_info *sbi, | |
433 | int how) | |
1da177e4 LT |
434 | { |
435 | unsigned long timeout; | |
436 | struct dentry *root = sb->s_root; | |
2fd6b7f5 | 437 | struct dentry *dentry; |
a5d1dba1 | 438 | struct dentry *expired; |
7cbdb4a2 | 439 | struct dentry *found; |
97e7449a | 440 | struct autofs_info *ino; |
1da177e4 | 441 | |
c0ba7e51 | 442 | if (!root) |
1da177e4 LT |
443 | return NULL; |
444 | ||
445 | now = jiffies; | |
446 | timeout = sbi->exp_timeout; | |
447 | ||
2fd6b7f5 | 448 | dentry = NULL; |
d4a85e35 | 449 | while ((dentry = get_next_positive_subdir(dentry, root))) { |
7cbdb4a2 IK |
450 | int flags = how; |
451 | ||
97e7449a | 452 | spin_lock(&sbi->fs_lock); |
4d885f90 | 453 | ino = autofs4_dentry_ino(dentry); |
7cbdb4a2 | 454 | if (ino->flags & AUTOFS_INF_WANT_EXPIRE) { |
4d885f90 N |
455 | spin_unlock(&sbi->fs_lock); |
456 | continue; | |
457 | } | |
7cbdb4a2 IK |
458 | spin_unlock(&sbi->fs_lock); |
459 | ||
460 | expired = should_expire(dentry, mnt, timeout, flags); | |
461 | if (!expired) | |
462 | continue; | |
463 | ||
464 | spin_lock(&sbi->fs_lock); | |
4d885f90 | 465 | ino = autofs4_dentry_ino(expired); |
ea01a184 | 466 | ino->flags |= AUTOFS_INF_WANT_EXPIRE; |
4d885f90 N |
467 | spin_unlock(&sbi->fs_lock); |
468 | synchronize_rcu(); | |
4d885f90 | 469 | |
7cbdb4a2 IK |
470 | /* Make sure a reference is not taken on found if |
471 | * things have changed. | |
472 | */ | |
473 | flags &= ~AUTOFS_EXP_LEAVES; | |
474 | found = should_expire(expired, mnt, timeout, how); | |
475 | if (!found || found != expired) | |
476 | /* Something has changed, continue */ | |
477 | goto next; | |
478 | ||
479 | if (expired != dentry) | |
480 | dput(dentry); | |
481 | ||
482 | spin_lock(&sbi->fs_lock); | |
483 | goto found; | |
484 | next: | |
485 | spin_lock(&sbi->fs_lock); | |
ea01a184 | 486 | ino->flags &= ~AUTOFS_INF_WANT_EXPIRE; |
7cbdb4a2 | 487 | spin_unlock(&sbi->fs_lock); |
4d885f90 N |
488 | if (expired != dentry) |
489 | dput(expired); | |
1da177e4 | 490 | } |
1da177e4 | 491 | return NULL; |
afec570c IK |
492 | |
493 | found: | |
8a78d593 | 494 | pr_debug("returning %p %pd\n", expired, expired); |
97e7449a | 495 | ino->flags |= AUTOFS_INF_EXPIRING; |
6e60a9ab | 496 | init_completion(&ino->expire_complete); |
97e7449a | 497 | spin_unlock(&sbi->fs_lock); |
afec570c | 498 | return expired; |
1da177e4 LT |
499 | } |
500 | ||
74f504cf | 501 | int autofs4_expire_wait(const struct path *path, int rcu_walk) |
06a35985 | 502 | { |
74f504cf | 503 | struct dentry *dentry = path->dentry; |
06a35985 IK |
504 | struct autofs_sb_info *sbi = autofs4_sbi(dentry->d_sb); |
505 | struct autofs_info *ino = autofs4_dentry_ino(dentry); | |
506 | int status; | |
7cbdb4a2 | 507 | int state; |
06a35985 IK |
508 | |
509 | /* Block on any pending expire */ | |
ea01a184 | 510 | if (!(ino->flags & AUTOFS_INF_WANT_EXPIRE)) |
4d885f90 N |
511 | return 0; |
512 | if (rcu_walk) | |
513 | return -ECHILD; | |
514 | ||
7cbdb4a2 | 515 | retry: |
06a35985 | 516 | spin_lock(&sbi->fs_lock); |
7cbdb4a2 IK |
517 | state = ino->flags & (AUTOFS_INF_WANT_EXPIRE | AUTOFS_INF_EXPIRING); |
518 | if (state == AUTOFS_INF_WANT_EXPIRE) { | |
519 | spin_unlock(&sbi->fs_lock); | |
520 | /* | |
521 | * Possibly being selected for expire, wait until | |
522 | * it's selected or not. | |
523 | */ | |
524 | schedule_timeout_uninterruptible(HZ/10); | |
525 | goto retry; | |
526 | } | |
527 | if (state & AUTOFS_INF_EXPIRING) { | |
06a35985 IK |
528 | spin_unlock(&sbi->fs_lock); |
529 | ||
8a78d593 | 530 | pr_debug("waiting for expire %p name=%pd\n", dentry, dentry); |
06a35985 | 531 | |
dd36a882 | 532 | status = autofs4_wait(sbi, path, NFY_NONE); |
06a35985 IK |
533 | wait_for_completion(&ino->expire_complete); |
534 | ||
8a78d593 | 535 | pr_debug("expire done status=%d\n", status); |
06a35985 | 536 | |
4b1ae27a | 537 | if (d_unhashed(dentry)) |
06a35985 IK |
538 | return -EAGAIN; |
539 | ||
540 | return status; | |
541 | } | |
542 | spin_unlock(&sbi->fs_lock); | |
543 | ||
544 | return 0; | |
545 | } | |
546 | ||
1da177e4 LT |
547 | /* Perform an expiry operation */ |
548 | int autofs4_expire_run(struct super_block *sb, | |
e9a7c2f1 IK |
549 | struct vfsmount *mnt, |
550 | struct autofs_sb_info *sbi, | |
551 | struct autofs_packet_expire __user *pkt_p) | |
1da177e4 LT |
552 | { |
553 | struct autofs_packet_expire pkt; | |
97e7449a | 554 | struct autofs_info *ino; |
1da177e4 | 555 | struct dentry *dentry; |
97e7449a | 556 | int ret = 0; |
1da177e4 | 557 | |
e9a7c2f1 | 558 | memset(&pkt, 0, sizeof(pkt)); |
1da177e4 LT |
559 | |
560 | pkt.hdr.proto_version = sbi->version; | |
561 | pkt.hdr.type = autofs_ptype_expire; | |
562 | ||
e9a7c2f1 IK |
563 | dentry = autofs4_expire_indirect(sb, mnt, sbi, 0); |
564 | if (!dentry) | |
1da177e4 LT |
565 | return -EAGAIN; |
566 | ||
567 | pkt.len = dentry->d_name.len; | |
568 | memcpy(pkt.name, dentry->d_name.name, pkt.len); | |
569 | pkt.name[pkt.len] = '\0'; | |
570 | dput(dentry); | |
571 | ||
e9a7c2f1 | 572 | if (copy_to_user(pkt_p, &pkt, sizeof(struct autofs_packet_expire))) |
97e7449a | 573 | ret = -EFAULT; |
1da177e4 | 574 | |
97e7449a IK |
575 | spin_lock(&sbi->fs_lock); |
576 | ino = autofs4_dentry_ino(dentry); | |
6ece08e6 N |
577 | /* avoid rapid-fire expire attempts if expiry fails */ |
578 | ino->last_used = now; | |
ea01a184 | 579 | ino->flags &= ~(AUTOFS_INF_EXPIRING|AUTOFS_INF_WANT_EXPIRE); |
6e60a9ab | 580 | complete_all(&ino->expire_complete); |
97e7449a IK |
581 | spin_unlock(&sbi->fs_lock); |
582 | ||
583 | return ret; | |
1da177e4 LT |
584 | } |
585 | ||
56fcef75 IK |
586 | int autofs4_do_expire_multi(struct super_block *sb, struct vfsmount *mnt, |
587 | struct autofs_sb_info *sbi, int when) | |
1da177e4 LT |
588 | { |
589 | struct dentry *dentry; | |
590 | int ret = -EAGAIN; | |
1da177e4 | 591 | |
a92daf6b | 592 | if (autofs_type_trigger(sbi->type)) |
56fcef75 | 593 | dentry = autofs4_expire_direct(sb, mnt, sbi, when); |
3a15e2ab | 594 | else |
56fcef75 | 595 | dentry = autofs4_expire_indirect(sb, mnt, sbi, when); |
3a15e2ab IK |
596 | |
597 | if (dentry) { | |
1f5f2c30 | 598 | struct autofs_info *ino = autofs4_dentry_ino(dentry); |
455e8f10 | 599 | const struct path path = { .mnt = mnt, .dentry = dentry }; |
1da177e4 LT |
600 | |
601 | /* This is synchronous because it makes the daemon a | |
e9a7c2f1 IK |
602 | * little easier |
603 | */ | |
dd36a882 | 604 | ret = autofs4_wait(sbi, &path, NFY_EXPIRE); |
6e60a9ab | 605 | |
97e7449a | 606 | spin_lock(&sbi->fs_lock); |
6ece08e6 N |
607 | /* avoid rapid-fire expire attempts if expiry fails */ |
608 | ino->last_used = now; | |
ea01a184 | 609 | ino->flags &= ~(AUTOFS_INF_EXPIRING|AUTOFS_INF_WANT_EXPIRE); |
6e60a9ab | 610 | complete_all(&ino->expire_complete); |
97e7449a | 611 | spin_unlock(&sbi->fs_lock); |
1da177e4 LT |
612 | dput(dentry); |
613 | } | |
1f5f2c30 | 614 | |
1da177e4 LT |
615 | return ret; |
616 | } | |
617 | ||
e9a7c2f1 IK |
618 | /* |
619 | * Call repeatedly until it returns -EAGAIN, meaning there's nothing | |
620 | * more to be done. | |
621 | */ | |
56fcef75 IK |
622 | int autofs4_expire_multi(struct super_block *sb, struct vfsmount *mnt, |
623 | struct autofs_sb_info *sbi, int __user *arg) | |
624 | { | |
625 | int do_now = 0; | |
626 | ||
627 | if (arg && get_user(do_now, arg)) | |
628 | return -EFAULT; | |
629 | ||
630 | return autofs4_do_expire_multi(sb, mnt, sbi, do_now); | |
631 | } | |
632 |