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