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