1 | // SPDX-License-Identifier: GPL-2.0-or-later |
2 | /* |
3 | * Copyright 1997-1998 Transmeta Corporation -- All Rights Reserved |
4 | * Copyright 1999-2000 Jeremy Fitzhardinge <jeremy@goop.org> |
5 | * Copyright 2001-2006 Ian Kent <raven@themaw.net> |
6 | */ |
7 | |
8 | #include <linux/capability.h> |
9 | #include <linux/compat.h> |
10 | |
11 | #include "autofs_i.h" |
12 | |
13 | static int autofs_dir_permission(struct mnt_idmap *, struct inode *, int); |
14 | static int autofs_dir_symlink(struct mnt_idmap *, struct inode *, |
15 | struct dentry *, const char *); |
16 | static int autofs_dir_unlink(struct inode *, struct dentry *); |
17 | static int autofs_dir_rmdir(struct inode *, struct dentry *); |
18 | static int autofs_dir_mkdir(struct mnt_idmap *, struct inode *, |
19 | struct dentry *, umode_t); |
20 | static long autofs_root_ioctl(struct file *, unsigned int, unsigned long); |
21 | #ifdef CONFIG_COMPAT |
22 | static long autofs_root_compat_ioctl(struct file *, |
23 | unsigned int, unsigned long); |
24 | #endif |
25 | static int autofs_dir_open(struct inode *inode, struct file *file); |
26 | static struct dentry *autofs_lookup(struct inode *, |
27 | struct dentry *, unsigned int); |
28 | static struct vfsmount *autofs_d_automount(struct path *); |
29 | static int autofs_d_manage(const struct path *, bool); |
30 | static void autofs_dentry_release(struct dentry *); |
31 | |
32 | const struct file_operations autofs_root_operations = { |
33 | .open = dcache_dir_open, |
34 | .release = dcache_dir_close, |
35 | .read = generic_read_dir, |
36 | .iterate_shared = dcache_readdir, |
37 | .llseek = dcache_dir_lseek, |
38 | .unlocked_ioctl = autofs_root_ioctl, |
39 | #ifdef CONFIG_COMPAT |
40 | .compat_ioctl = autofs_root_compat_ioctl, |
41 | #endif |
42 | }; |
43 | |
44 | const struct file_operations autofs_dir_operations = { |
45 | .open = autofs_dir_open, |
46 | .release = dcache_dir_close, |
47 | .read = generic_read_dir, |
48 | .iterate_shared = dcache_readdir, |
49 | .llseek = dcache_dir_lseek, |
50 | }; |
51 | |
52 | const struct inode_operations autofs_dir_inode_operations = { |
53 | .lookup = autofs_lookup, |
54 | .permission = autofs_dir_permission, |
55 | .unlink = autofs_dir_unlink, |
56 | .symlink = autofs_dir_symlink, |
57 | .mkdir = autofs_dir_mkdir, |
58 | .rmdir = autofs_dir_rmdir, |
59 | }; |
60 | |
61 | const struct dentry_operations autofs_dentry_operations = { |
62 | .d_automount = autofs_d_automount, |
63 | .d_manage = autofs_d_manage, |
64 | .d_release = autofs_dentry_release, |
65 | }; |
66 | |
67 | static void autofs_del_active(struct dentry *dentry) |
68 | { |
69 | struct autofs_sb_info *sbi = autofs_sbi(sb: dentry->d_sb); |
70 | struct autofs_info *ino; |
71 | |
72 | ino = autofs_dentry_ino(dentry); |
73 | spin_lock(lock: &sbi->lookup_lock); |
74 | list_del_init(entry: &ino->active); |
75 | spin_unlock(lock: &sbi->lookup_lock); |
76 | } |
77 | |
78 | static int autofs_dir_open(struct inode *inode, struct file *file) |
79 | { |
80 | struct dentry *dentry = file->f_path.dentry; |
81 | struct autofs_sb_info *sbi = autofs_sbi(sb: dentry->d_sb); |
82 | struct autofs_info *ino = autofs_dentry_ino(dentry); |
83 | |
84 | pr_debug("file=%p dentry=%p %pd\n" , file, dentry, dentry); |
85 | |
86 | if (autofs_oz_mode(sbi)) |
87 | goto out; |
88 | |
89 | /* |
90 | * An empty directory in an autofs file system is always a |
91 | * mount point. The daemon must have failed to mount this |
92 | * during lookup so it doesn't exist. This can happen, for |
93 | * example, if user space returns an incorrect status for a |
94 | * mount request. Otherwise we're doing a readdir on the |
95 | * autofs file system so just let the libfs routines handle |
96 | * it. |
97 | */ |
98 | spin_lock(lock: &sbi->lookup_lock); |
99 | if (!path_is_mountpoint(path: &file->f_path) && autofs_empty(ino)) { |
100 | spin_unlock(lock: &sbi->lookup_lock); |
101 | return -ENOENT; |
102 | } |
103 | spin_unlock(lock: &sbi->lookup_lock); |
104 | |
105 | out: |
106 | return dcache_dir_open(inode, file); |
107 | } |
108 | |
109 | static void autofs_dentry_release(struct dentry *de) |
110 | { |
111 | struct autofs_info *ino = autofs_dentry_ino(dentry: de); |
112 | struct autofs_sb_info *sbi = autofs_sbi(sb: de->d_sb); |
113 | |
114 | pr_debug("releasing %p\n" , de); |
115 | |
116 | if (!ino) |
117 | return; |
118 | |
119 | if (sbi) { |
120 | spin_lock(lock: &sbi->lookup_lock); |
121 | if (!list_empty(head: &ino->active)) |
122 | list_del(entry: &ino->active); |
123 | if (!list_empty(head: &ino->expiring)) |
124 | list_del(entry: &ino->expiring); |
125 | spin_unlock(lock: &sbi->lookup_lock); |
126 | } |
127 | |
128 | autofs_free_ino(ino); |
129 | } |
130 | |
131 | static struct dentry *autofs_lookup_active(struct dentry *dentry) |
132 | { |
133 | struct autofs_sb_info *sbi = autofs_sbi(sb: dentry->d_sb); |
134 | struct dentry *parent = dentry->d_parent; |
135 | const struct qstr *name = &dentry->d_name; |
136 | unsigned int len = name->len; |
137 | unsigned int hash = name->hash; |
138 | const unsigned char *str = name->name; |
139 | struct list_head *p, *head; |
140 | |
141 | head = &sbi->active_list; |
142 | if (list_empty(head)) |
143 | return NULL; |
144 | spin_lock(lock: &sbi->lookup_lock); |
145 | list_for_each(p, head) { |
146 | struct autofs_info *ino; |
147 | struct dentry *active; |
148 | const struct qstr *qstr; |
149 | |
150 | ino = list_entry(p, struct autofs_info, active); |
151 | active = ino->dentry; |
152 | |
153 | spin_lock(lock: &active->d_lock); |
154 | |
155 | /* Already gone? */ |
156 | if ((int) d_count(dentry: active) <= 0) |
157 | goto next; |
158 | |
159 | qstr = &active->d_name; |
160 | |
161 | if (active->d_name.hash != hash) |
162 | goto next; |
163 | if (active->d_parent != parent) |
164 | goto next; |
165 | |
166 | if (qstr->len != len) |
167 | goto next; |
168 | if (memcmp(p: qstr->name, q: str, size: len)) |
169 | goto next; |
170 | |
171 | if (d_unhashed(dentry: active)) { |
172 | dget_dlock(dentry: active); |
173 | spin_unlock(lock: &active->d_lock); |
174 | spin_unlock(lock: &sbi->lookup_lock); |
175 | return active; |
176 | } |
177 | next: |
178 | spin_unlock(lock: &active->d_lock); |
179 | } |
180 | spin_unlock(lock: &sbi->lookup_lock); |
181 | |
182 | return NULL; |
183 | } |
184 | |
185 | static struct dentry *autofs_lookup_expiring(struct dentry *dentry, |
186 | bool rcu_walk) |
187 | { |
188 | struct autofs_sb_info *sbi = autofs_sbi(sb: dentry->d_sb); |
189 | struct dentry *parent = dentry->d_parent; |
190 | const struct qstr *name = &dentry->d_name; |
191 | unsigned int len = name->len; |
192 | unsigned int hash = name->hash; |
193 | const unsigned char *str = name->name; |
194 | struct list_head *p, *head; |
195 | |
196 | head = &sbi->expiring_list; |
197 | if (list_empty(head)) |
198 | return NULL; |
199 | spin_lock(lock: &sbi->lookup_lock); |
200 | list_for_each(p, head) { |
201 | struct autofs_info *ino; |
202 | struct dentry *expiring; |
203 | const struct qstr *qstr; |
204 | |
205 | if (rcu_walk) { |
206 | spin_unlock(lock: &sbi->lookup_lock); |
207 | return ERR_PTR(error: -ECHILD); |
208 | } |
209 | |
210 | ino = list_entry(p, struct autofs_info, expiring); |
211 | expiring = ino->dentry; |
212 | |
213 | spin_lock(lock: &expiring->d_lock); |
214 | |
215 | /* We've already been dentry_iput or unlinked */ |
216 | if (d_really_is_negative(dentry: expiring)) |
217 | goto next; |
218 | |
219 | qstr = &expiring->d_name; |
220 | |
221 | if (expiring->d_name.hash != hash) |
222 | goto next; |
223 | if (expiring->d_parent != parent) |
224 | goto next; |
225 | |
226 | if (qstr->len != len) |
227 | goto next; |
228 | if (memcmp(p: qstr->name, q: str, size: len)) |
229 | goto next; |
230 | |
231 | if (d_unhashed(dentry: expiring)) { |
232 | dget_dlock(dentry: expiring); |
233 | spin_unlock(lock: &expiring->d_lock); |
234 | spin_unlock(lock: &sbi->lookup_lock); |
235 | return expiring; |
236 | } |
237 | next: |
238 | spin_unlock(lock: &expiring->d_lock); |
239 | } |
240 | spin_unlock(lock: &sbi->lookup_lock); |
241 | |
242 | return NULL; |
243 | } |
244 | |
245 | static int autofs_mount_wait(const struct path *path, bool rcu_walk) |
246 | { |
247 | struct autofs_sb_info *sbi = autofs_sbi(sb: path->dentry->d_sb); |
248 | struct autofs_info *ino = autofs_dentry_ino(dentry: path->dentry); |
249 | int status = 0; |
250 | |
251 | if (ino->flags & AUTOFS_INF_PENDING) { |
252 | if (rcu_walk) |
253 | return -ECHILD; |
254 | pr_debug("waiting for mount name=%pd\n" , path->dentry); |
255 | status = autofs_wait(sbi, path, NFY_MOUNT); |
256 | pr_debug("mount wait done status=%d\n" , status); |
257 | ino->last_used = jiffies; |
258 | return status; |
259 | } |
260 | if (!(sbi->flags & AUTOFS_SBI_STRICTEXPIRE)) |
261 | ino->last_used = jiffies; |
262 | return status; |
263 | } |
264 | |
265 | static int do_expire_wait(const struct path *path, bool rcu_walk) |
266 | { |
267 | struct dentry *dentry = path->dentry; |
268 | struct dentry *expiring; |
269 | |
270 | expiring = autofs_lookup_expiring(dentry, rcu_walk); |
271 | if (IS_ERR(ptr: expiring)) |
272 | return PTR_ERR(ptr: expiring); |
273 | if (!expiring) |
274 | return autofs_expire_wait(path, rcu_walk); |
275 | else { |
276 | const struct path this = { .mnt = path->mnt, .dentry = expiring }; |
277 | /* |
278 | * If we are racing with expire the request might not |
279 | * be quite complete, but the directory has been removed |
280 | * so it must have been successful, just wait for it. |
281 | */ |
282 | autofs_expire_wait(path: &this, rcu_walk: 0); |
283 | autofs_del_expiring(dentry: expiring); |
284 | dput(expiring); |
285 | } |
286 | return 0; |
287 | } |
288 | |
289 | static struct dentry *autofs_mountpoint_changed(struct path *path) |
290 | { |
291 | struct dentry *dentry = path->dentry; |
292 | struct autofs_sb_info *sbi = autofs_sbi(sb: dentry->d_sb); |
293 | |
294 | /* If this is an indirect mount the dentry could have gone away |
295 | * and a new one created. |
296 | * |
297 | * This is unusual and I can't remember the case for which it |
298 | * was originally added now. But an example of how this can |
299 | * happen is an autofs indirect mount that has the "browse" |
300 | * option set and also has the "symlink" option in the autofs |
301 | * map entry. In this case the daemon will remove the browse |
302 | * directory and create a symlink as the mount leaving the |
303 | * struct path stale. |
304 | * |
305 | * Another not so obvious case is when a mount in an autofs |
306 | * indirect mount that uses the "nobrowse" option is being |
307 | * expired at the same time as a path walk. If the mount has |
308 | * been umounted but the mount point directory seen before |
309 | * becoming unhashed (during a lockless path walk) when a stat |
310 | * family system call is made the mount won't be re-mounted as |
311 | * it should. In this case the mount point that's been removed |
312 | * (by the daemon) will be stale and the a new mount point |
313 | * dentry created. |
314 | */ |
315 | if (autofs_type_indirect(type: sbi->type) && d_unhashed(dentry)) { |
316 | struct dentry *parent = dentry->d_parent; |
317 | struct autofs_info *ino; |
318 | struct dentry *new; |
319 | |
320 | new = d_lookup(parent, &dentry->d_name); |
321 | if (!new) |
322 | return NULL; |
323 | ino = autofs_dentry_ino(dentry: new); |
324 | ino->last_used = jiffies; |
325 | dput(path->dentry); |
326 | path->dentry = new; |
327 | } |
328 | return path->dentry; |
329 | } |
330 | |
331 | static struct vfsmount *autofs_d_automount(struct path *path) |
332 | { |
333 | struct dentry *dentry = path->dentry; |
334 | struct autofs_sb_info *sbi = autofs_sbi(sb: dentry->d_sb); |
335 | struct autofs_info *ino = autofs_dentry_ino(dentry); |
336 | int status; |
337 | |
338 | pr_debug("dentry=%p %pd\n" , dentry, dentry); |
339 | |
340 | /* The daemon never triggers a mount. */ |
341 | if (autofs_oz_mode(sbi)) |
342 | return NULL; |
343 | |
344 | /* |
345 | * If an expire request is pending everyone must wait. |
346 | * If the expire fails we're still mounted so continue |
347 | * the follow and return. A return of -EAGAIN (which only |
348 | * happens with indirect mounts) means the expire completed |
349 | * and the directory was removed, so just go ahead and try |
350 | * the mount. |
351 | */ |
352 | status = do_expire_wait(path, rcu_walk: 0); |
353 | if (status && status != -EAGAIN) |
354 | return NULL; |
355 | |
356 | /* Callback to the daemon to perform the mount or wait */ |
357 | spin_lock(lock: &sbi->fs_lock); |
358 | if (ino->flags & AUTOFS_INF_PENDING) { |
359 | spin_unlock(lock: &sbi->fs_lock); |
360 | status = autofs_mount_wait(path, rcu_walk: 0); |
361 | if (status) |
362 | return ERR_PTR(error: status); |
363 | goto done; |
364 | } |
365 | |
366 | /* |
367 | * If the dentry is a symlink it's equivalent to a directory |
368 | * having path_is_mountpoint() true, so there's no need to call |
369 | * back to the daemon. |
370 | */ |
371 | if (d_really_is_positive(dentry) && d_is_symlink(dentry)) { |
372 | spin_unlock(lock: &sbi->fs_lock); |
373 | goto done; |
374 | } |
375 | |
376 | if (!path_is_mountpoint(path)) { |
377 | /* |
378 | * It's possible that user space hasn't removed directories |
379 | * after umounting a rootless multi-mount, although it |
380 | * should. For v5 path_has_submounts() is sufficient to |
381 | * handle this because the leaves of the directory tree under |
382 | * the mount never trigger mounts themselves (they have an |
383 | * autofs trigger mount mounted on them). But v4 pseudo direct |
384 | * mounts do need the leaves to trigger mounts. In this case |
385 | * we have no choice but to use the autofs_empty() check and |
386 | * require user space behave. |
387 | */ |
388 | if (sbi->version > 4) { |
389 | if (path_has_submounts(path)) { |
390 | spin_unlock(lock: &sbi->fs_lock); |
391 | goto done; |
392 | } |
393 | } else { |
394 | if (!autofs_empty(ino)) { |
395 | spin_unlock(lock: &sbi->fs_lock); |
396 | goto done; |
397 | } |
398 | } |
399 | ino->flags |= AUTOFS_INF_PENDING; |
400 | spin_unlock(lock: &sbi->fs_lock); |
401 | status = autofs_mount_wait(path, rcu_walk: 0); |
402 | spin_lock(lock: &sbi->fs_lock); |
403 | ino->flags &= ~AUTOFS_INF_PENDING; |
404 | if (status) { |
405 | spin_unlock(lock: &sbi->fs_lock); |
406 | return ERR_PTR(error: status); |
407 | } |
408 | } |
409 | spin_unlock(lock: &sbi->fs_lock); |
410 | done: |
411 | /* Mount succeeded, check if we ended up with a new dentry */ |
412 | dentry = autofs_mountpoint_changed(path); |
413 | if (!dentry) |
414 | return ERR_PTR(error: -ENOENT); |
415 | |
416 | return NULL; |
417 | } |
418 | |
419 | static int autofs_d_manage(const struct path *path, bool rcu_walk) |
420 | { |
421 | struct dentry *dentry = path->dentry; |
422 | struct autofs_sb_info *sbi = autofs_sbi(sb: dentry->d_sb); |
423 | struct autofs_info *ino = autofs_dentry_ino(dentry); |
424 | int status; |
425 | |
426 | pr_debug("dentry=%p %pd\n" , dentry, dentry); |
427 | |
428 | /* The daemon never waits. */ |
429 | if (autofs_oz_mode(sbi)) { |
430 | if (!path_is_mountpoint(path)) |
431 | return -EISDIR; |
432 | return 0; |
433 | } |
434 | |
435 | /* Wait for pending expires */ |
436 | if (do_expire_wait(path, rcu_walk) == -ECHILD) |
437 | return -ECHILD; |
438 | |
439 | /* |
440 | * This dentry may be under construction so wait on mount |
441 | * completion. |
442 | */ |
443 | status = autofs_mount_wait(path, rcu_walk); |
444 | if (status) |
445 | return status; |
446 | |
447 | if (rcu_walk) { |
448 | /* We don't need fs_lock in rcu_walk mode, |
449 | * just testing 'AUTOFS_INF_WANT_EXPIRE' is enough. |
450 | * |
451 | * We only return -EISDIR when certain this isn't |
452 | * a mount-trap. |
453 | */ |
454 | struct inode *inode; |
455 | |
456 | if (ino->flags & AUTOFS_INF_WANT_EXPIRE) |
457 | return 0; |
458 | if (path_is_mountpoint(path)) |
459 | return 0; |
460 | inode = d_inode_rcu(dentry); |
461 | if (inode && S_ISLNK(inode->i_mode)) |
462 | return -EISDIR; |
463 | if (!autofs_empty(ino)) |
464 | return -EISDIR; |
465 | return 0; |
466 | } |
467 | |
468 | spin_lock(lock: &sbi->fs_lock); |
469 | /* |
470 | * If the dentry has been selected for expire while we slept |
471 | * on the lock then it might go away. We'll deal with that in |
472 | * ->d_automount() and wait on a new mount if the expire |
473 | * succeeds or return here if it doesn't (since there's no |
474 | * mount to follow with a rootless multi-mount). |
475 | */ |
476 | if (!(ino->flags & AUTOFS_INF_EXPIRING)) { |
477 | /* |
478 | * Any needed mounting has been completed and the path |
479 | * updated so check if this is a rootless multi-mount so |
480 | * we can avoid needless calls ->d_automount() and avoid |
481 | * an incorrect ELOOP error return. |
482 | */ |
483 | if ((!path_is_mountpoint(path) && !autofs_empty(ino)) || |
484 | (d_really_is_positive(dentry) && d_is_symlink(dentry))) |
485 | status = -EISDIR; |
486 | } |
487 | spin_unlock(lock: &sbi->fs_lock); |
488 | |
489 | return status; |
490 | } |
491 | |
492 | /* Lookups in the root directory */ |
493 | static struct dentry *autofs_lookup(struct inode *dir, |
494 | struct dentry *dentry, unsigned int flags) |
495 | { |
496 | struct autofs_sb_info *sbi; |
497 | struct autofs_info *ino; |
498 | struct dentry *active; |
499 | |
500 | pr_debug("name = %pd\n" , dentry); |
501 | |
502 | /* File name too long to exist */ |
503 | if (dentry->d_name.len > NAME_MAX) |
504 | return ERR_PTR(error: -ENAMETOOLONG); |
505 | |
506 | sbi = autofs_sbi(sb: dir->i_sb); |
507 | |
508 | pr_debug("pid = %u, pgrp = %u, catatonic = %d, oz_mode = %d\n" , |
509 | current->pid, task_pgrp_nr(current), |
510 | sbi->flags & AUTOFS_SBI_CATATONIC, |
511 | autofs_oz_mode(sbi)); |
512 | |
513 | active = autofs_lookup_active(dentry); |
514 | if (active) |
515 | return active; |
516 | else { |
517 | /* |
518 | * A dentry that is not within the root can never trigger a |
519 | * mount operation, unless the directory already exists, so we |
520 | * can return fail immediately. The daemon however does need |
521 | * to create directories within the file system. |
522 | */ |
523 | if (!autofs_oz_mode(sbi) && !IS_ROOT(dentry->d_parent)) |
524 | return ERR_PTR(error: -ENOENT); |
525 | |
526 | ino = autofs_new_ino(sbi); |
527 | if (!ino) |
528 | return ERR_PTR(error: -ENOMEM); |
529 | |
530 | spin_lock(lock: &sbi->lookup_lock); |
531 | spin_lock(lock: &dentry->d_lock); |
532 | /* Mark entries in the root as mount triggers */ |
533 | if (IS_ROOT(dentry->d_parent) && |
534 | autofs_type_indirect(type: sbi->type)) |
535 | __managed_dentry_set_managed(dentry); |
536 | dentry->d_fsdata = ino; |
537 | ino->dentry = dentry; |
538 | |
539 | list_add(new: &ino->active, head: &sbi->active_list); |
540 | spin_unlock(lock: &sbi->lookup_lock); |
541 | spin_unlock(lock: &dentry->d_lock); |
542 | } |
543 | return NULL; |
544 | } |
545 | |
546 | static int autofs_dir_permission(struct mnt_idmap *idmap, |
547 | struct inode *inode, int mask) |
548 | { |
549 | if (mask & MAY_WRITE) { |
550 | struct autofs_sb_info *sbi = autofs_sbi(sb: inode->i_sb); |
551 | |
552 | if (!autofs_oz_mode(sbi)) |
553 | return -EACCES; |
554 | |
555 | /* autofs_oz_mode() needs to allow path walks when the |
556 | * autofs mount is catatonic but the state of an autofs |
557 | * file system needs to be preserved over restarts. |
558 | */ |
559 | if (sbi->flags & AUTOFS_SBI_CATATONIC) |
560 | return -EACCES; |
561 | } |
562 | |
563 | return generic_permission(idmap, inode, mask); |
564 | } |
565 | |
566 | static int autofs_dir_symlink(struct mnt_idmap *idmap, |
567 | struct inode *dir, struct dentry *dentry, |
568 | const char *symname) |
569 | { |
570 | struct autofs_info *ino = autofs_dentry_ino(dentry); |
571 | struct autofs_info *p_ino; |
572 | struct inode *inode; |
573 | size_t size = strlen(symname); |
574 | char *cp; |
575 | |
576 | pr_debug("%s <- %pd\n" , symname, dentry); |
577 | |
578 | BUG_ON(!ino); |
579 | |
580 | autofs_clean_ino(ino); |
581 | |
582 | autofs_del_active(dentry); |
583 | |
584 | cp = kmalloc(size: size + 1, GFP_KERNEL); |
585 | if (!cp) |
586 | return -ENOMEM; |
587 | |
588 | strcpy(p: cp, q: symname); |
589 | |
590 | inode = autofs_get_inode(dir->i_sb, S_IFLNK | 0555); |
591 | if (!inode) { |
592 | kfree(objp: cp); |
593 | return -ENOMEM; |
594 | } |
595 | inode->i_private = cp; |
596 | inode->i_size = size; |
597 | d_add(dentry, inode); |
598 | |
599 | dget(dentry); |
600 | p_ino = autofs_dentry_ino(dentry: dentry->d_parent); |
601 | p_ino->count++; |
602 | |
603 | inode_set_mtime_to_ts(inode: dir, ts: inode_set_ctime_current(inode: dir)); |
604 | |
605 | return 0; |
606 | } |
607 | |
608 | /* |
609 | * NOTE! |
610 | * |
611 | * Normal filesystems would do a "d_delete()" to tell the VFS dcache |
612 | * that the file no longer exists. However, doing that means that the |
613 | * VFS layer can turn the dentry into a negative dentry. We don't want |
614 | * this, because the unlink is probably the result of an expire. |
615 | * We simply d_drop it and add it to a expiring list in the super block, |
616 | * which allows the dentry lookup to check for an incomplete expire. |
617 | * |
618 | * If a process is blocked on the dentry waiting for the expire to finish, |
619 | * it will invalidate the dentry and try to mount with a new one. |
620 | * |
621 | * Also see autofs_dir_rmdir().. |
622 | */ |
623 | static int autofs_dir_unlink(struct inode *dir, struct dentry *dentry) |
624 | { |
625 | struct autofs_sb_info *sbi = autofs_sbi(sb: dir->i_sb); |
626 | struct autofs_info *ino = autofs_dentry_ino(dentry); |
627 | struct autofs_info *p_ino; |
628 | |
629 | p_ino = autofs_dentry_ino(dentry: dentry->d_parent); |
630 | p_ino->count--; |
631 | dput(ino->dentry); |
632 | |
633 | d_inode(dentry)->i_size = 0; |
634 | clear_nlink(inode: d_inode(dentry)); |
635 | |
636 | inode_set_mtime_to_ts(inode: dir, ts: inode_set_ctime_current(inode: dir)); |
637 | |
638 | spin_lock(lock: &sbi->lookup_lock); |
639 | __autofs_add_expiring(dentry); |
640 | d_drop(dentry); |
641 | spin_unlock(lock: &sbi->lookup_lock); |
642 | |
643 | return 0; |
644 | } |
645 | |
646 | /* |
647 | * Version 4 of autofs provides a pseudo direct mount implementation |
648 | * that relies on directories at the leaves of a directory tree under |
649 | * an indirect mount to trigger mounts. To allow for this we need to |
650 | * set the DMANAGED_AUTOMOUNT and DMANAGED_TRANSIT flags on the leaves |
651 | * of the directory tree. There is no need to clear the automount flag |
652 | * following a mount or restore it after an expire because these mounts |
653 | * are always covered. However, it is necessary to ensure that these |
654 | * flags are clear on non-empty directories to avoid unnecessary calls |
655 | * during path walks. |
656 | */ |
657 | static void autofs_set_leaf_automount_flags(struct dentry *dentry) |
658 | { |
659 | struct dentry *parent; |
660 | |
661 | /* root and dentrys in the root are already handled */ |
662 | if (IS_ROOT(dentry->d_parent)) |
663 | return; |
664 | |
665 | managed_dentry_set_managed(dentry); |
666 | |
667 | parent = dentry->d_parent; |
668 | /* only consider parents below dentrys in the root */ |
669 | if (IS_ROOT(parent->d_parent)) |
670 | return; |
671 | managed_dentry_clear_managed(dentry: parent); |
672 | } |
673 | |
674 | static void autofs_clear_leaf_automount_flags(struct dentry *dentry) |
675 | { |
676 | struct dentry *parent; |
677 | |
678 | /* flags for dentrys in the root are handled elsewhere */ |
679 | if (IS_ROOT(dentry->d_parent)) |
680 | return; |
681 | |
682 | managed_dentry_clear_managed(dentry); |
683 | |
684 | parent = dentry->d_parent; |
685 | /* only consider parents below dentrys in the root */ |
686 | if (IS_ROOT(parent->d_parent)) |
687 | return; |
688 | if (autofs_dentry_ino(dentry: parent)->count == 2) |
689 | managed_dentry_set_managed(dentry: parent); |
690 | } |
691 | |
692 | static int autofs_dir_rmdir(struct inode *dir, struct dentry *dentry) |
693 | { |
694 | struct autofs_sb_info *sbi = autofs_sbi(sb: dir->i_sb); |
695 | struct autofs_info *ino = autofs_dentry_ino(dentry); |
696 | struct autofs_info *p_ino; |
697 | |
698 | pr_debug("dentry %p, removing %pd\n" , dentry, dentry); |
699 | |
700 | if (ino->count != 1) |
701 | return -ENOTEMPTY; |
702 | |
703 | spin_lock(lock: &sbi->lookup_lock); |
704 | __autofs_add_expiring(dentry); |
705 | d_drop(dentry); |
706 | spin_unlock(lock: &sbi->lookup_lock); |
707 | |
708 | if (sbi->version < 5) |
709 | autofs_clear_leaf_automount_flags(dentry); |
710 | |
711 | p_ino = autofs_dentry_ino(dentry: dentry->d_parent); |
712 | p_ino->count--; |
713 | dput(ino->dentry); |
714 | d_inode(dentry)->i_size = 0; |
715 | clear_nlink(inode: d_inode(dentry)); |
716 | |
717 | if (dir->i_nlink) |
718 | drop_nlink(inode: dir); |
719 | |
720 | return 0; |
721 | } |
722 | |
723 | static int autofs_dir_mkdir(struct mnt_idmap *idmap, |
724 | struct inode *dir, struct dentry *dentry, |
725 | umode_t mode) |
726 | { |
727 | struct autofs_sb_info *sbi = autofs_sbi(sb: dir->i_sb); |
728 | struct autofs_info *ino = autofs_dentry_ino(dentry); |
729 | struct autofs_info *p_ino; |
730 | struct inode *inode; |
731 | |
732 | pr_debug("dentry %p, creating %pd\n" , dentry, dentry); |
733 | |
734 | BUG_ON(!ino); |
735 | |
736 | autofs_clean_ino(ino); |
737 | |
738 | autofs_del_active(dentry); |
739 | |
740 | inode = autofs_get_inode(dir->i_sb, S_IFDIR | mode); |
741 | if (!inode) |
742 | return -ENOMEM; |
743 | d_add(dentry, inode); |
744 | |
745 | if (sbi->version < 5) |
746 | autofs_set_leaf_automount_flags(dentry); |
747 | |
748 | dget(dentry); |
749 | p_ino = autofs_dentry_ino(dentry: dentry->d_parent); |
750 | p_ino->count++; |
751 | inc_nlink(inode: dir); |
752 | inode_set_mtime_to_ts(inode: dir, ts: inode_set_ctime_current(inode: dir)); |
753 | |
754 | return 0; |
755 | } |
756 | |
757 | /* Get/set timeout ioctl() operation */ |
758 | #ifdef CONFIG_COMPAT |
759 | static inline int autofs_compat_get_set_timeout(struct autofs_sb_info *sbi, |
760 | compat_ulong_t __user *p) |
761 | { |
762 | unsigned long ntimeout; |
763 | int rv; |
764 | |
765 | rv = get_user(ntimeout, p); |
766 | if (rv) |
767 | goto error; |
768 | |
769 | rv = put_user(sbi->exp_timeout/HZ, p); |
770 | if (rv) |
771 | goto error; |
772 | |
773 | if (ntimeout > UINT_MAX/HZ) |
774 | sbi->exp_timeout = 0; |
775 | else |
776 | sbi->exp_timeout = ntimeout * HZ; |
777 | |
778 | return 0; |
779 | error: |
780 | return rv; |
781 | } |
782 | #endif |
783 | |
784 | static inline int autofs_get_set_timeout(struct autofs_sb_info *sbi, |
785 | unsigned long __user *p) |
786 | { |
787 | unsigned long ntimeout; |
788 | int rv; |
789 | |
790 | rv = get_user(ntimeout, p); |
791 | if (rv) |
792 | goto error; |
793 | |
794 | rv = put_user(sbi->exp_timeout/HZ, p); |
795 | if (rv) |
796 | goto error; |
797 | |
798 | if (ntimeout > ULONG_MAX/HZ) |
799 | sbi->exp_timeout = 0; |
800 | else |
801 | sbi->exp_timeout = ntimeout * HZ; |
802 | |
803 | return 0; |
804 | error: |
805 | return rv; |
806 | } |
807 | |
808 | /* Return protocol version */ |
809 | static inline int autofs_get_protover(struct autofs_sb_info *sbi, |
810 | int __user *p) |
811 | { |
812 | return put_user(sbi->version, p); |
813 | } |
814 | |
815 | /* Return protocol sub version */ |
816 | static inline int autofs_get_protosubver(struct autofs_sb_info *sbi, |
817 | int __user *p) |
818 | { |
819 | return put_user(sbi->sub_version, p); |
820 | } |
821 | |
822 | /* |
823 | * Tells the daemon whether it can umount the autofs mount. |
824 | */ |
825 | static inline int autofs_ask_umount(struct vfsmount *mnt, int __user *p) |
826 | { |
827 | int status = 0; |
828 | |
829 | if (may_umount(mnt)) |
830 | status = 1; |
831 | |
832 | pr_debug("may umount %d\n" , status); |
833 | |
834 | status = put_user(status, p); |
835 | |
836 | return status; |
837 | } |
838 | |
839 | /* Identify autofs_dentries - this is so we can tell if there's |
840 | * an extra dentry refcount or not. We only hold a refcount on the |
841 | * dentry if its non-negative (ie, d_inode != NULL) |
842 | */ |
843 | int is_autofs_dentry(struct dentry *dentry) |
844 | { |
845 | return dentry && d_really_is_positive(dentry) && |
846 | dentry->d_op == &autofs_dentry_operations && |
847 | dentry->d_fsdata != NULL; |
848 | } |
849 | |
850 | /* |
851 | * ioctl()'s on the root directory is the chief method for the daemon to |
852 | * generate kernel reactions |
853 | */ |
854 | static int autofs_root_ioctl_unlocked(struct inode *inode, struct file *filp, |
855 | unsigned int cmd, unsigned long arg) |
856 | { |
857 | struct autofs_sb_info *sbi = autofs_sbi(sb: inode->i_sb); |
858 | void __user *p = (void __user *)arg; |
859 | |
860 | pr_debug("cmd = 0x%08x, arg = 0x%08lx, sbi = %p, pgrp = %u\n" , |
861 | cmd, arg, sbi, task_pgrp_nr(current)); |
862 | |
863 | if (_IOC_TYPE(cmd) != _IOC_TYPE(AUTOFS_IOC_FIRST) || |
864 | _IOC_NR(cmd) - _IOC_NR(AUTOFS_IOC_FIRST) >= AUTOFS_IOC_COUNT) |
865 | return -ENOTTY; |
866 | |
867 | if (!autofs_oz_mode(sbi) && !capable(CAP_SYS_ADMIN)) |
868 | return -EPERM; |
869 | |
870 | switch (cmd) { |
871 | case AUTOFS_IOC_READY: /* Wait queue: go ahead and retry */ |
872 | return autofs_wait_release(sbi, (autofs_wqt_t) arg, 0); |
873 | case AUTOFS_IOC_FAIL: /* Wait queue: fail with ENOENT */ |
874 | return autofs_wait_release(sbi, (autofs_wqt_t) arg, -ENOENT); |
875 | case AUTOFS_IOC_CATATONIC: /* Enter catatonic mode (daemon shutdown) */ |
876 | autofs_catatonic_mode(sbi); |
877 | return 0; |
878 | case AUTOFS_IOC_PROTOVER: /* Get protocol version */ |
879 | return autofs_get_protover(sbi, p); |
880 | case AUTOFS_IOC_PROTOSUBVER: /* Get protocol sub version */ |
881 | return autofs_get_protosubver(sbi, p); |
882 | case AUTOFS_IOC_SETTIMEOUT: |
883 | return autofs_get_set_timeout(sbi, p); |
884 | #ifdef CONFIG_COMPAT |
885 | case AUTOFS_IOC_SETTIMEOUT32: |
886 | return autofs_compat_get_set_timeout(sbi, p); |
887 | #endif |
888 | |
889 | case AUTOFS_IOC_ASKUMOUNT: |
890 | return autofs_ask_umount(mnt: filp->f_path.mnt, p); |
891 | |
892 | /* return a single thing to expire */ |
893 | case AUTOFS_IOC_EXPIRE: |
894 | return autofs_expire_run(inode->i_sb, filp->f_path.mnt, sbi, p); |
895 | /* same as above, but can send multiple expires through pipe */ |
896 | case AUTOFS_IOC_EXPIRE_MULTI: |
897 | return autofs_expire_multi(inode->i_sb, |
898 | filp->f_path.mnt, sbi, p); |
899 | |
900 | default: |
901 | return -EINVAL; |
902 | } |
903 | } |
904 | |
905 | static long autofs_root_ioctl(struct file *filp, |
906 | unsigned int cmd, unsigned long arg) |
907 | { |
908 | struct inode *inode = file_inode(f: filp); |
909 | |
910 | return autofs_root_ioctl_unlocked(inode, filp, cmd, arg); |
911 | } |
912 | |
913 | #ifdef CONFIG_COMPAT |
914 | static long autofs_root_compat_ioctl(struct file *filp, |
915 | unsigned int cmd, unsigned long arg) |
916 | { |
917 | struct inode *inode = file_inode(f: filp); |
918 | int ret; |
919 | |
920 | if (cmd == AUTOFS_IOC_READY || cmd == AUTOFS_IOC_FAIL) |
921 | ret = autofs_root_ioctl_unlocked(inode, filp, cmd, arg); |
922 | else |
923 | ret = autofs_root_ioctl_unlocked(inode, filp, cmd, |
924 | arg: (unsigned long) compat_ptr(uptr: arg)); |
925 | |
926 | return ret; |
927 | } |
928 | #endif |
929 | |