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