1/*-
2 * SPDX-License-Identifier: BSD-2-Clause-FreeBSD
3 *
4 * Copyright (c) 2014 The FreeBSD Foundation
5 *
6 * This software was developed by Edward Tomasz Napierala under sponsorship
7 * from the FreeBSD Foundation.
8 *
9 * Redistribution and use in source and binary forms, with or without
10 * modification, are permitted provided that the following conditions
11 * are met:
12 * 1. Redistributions of source code must retain the above copyright
13 *    notice, this list of conditions and the following disclaimer.
14 * 2. Redistributions in binary form must reproduce the above copyright
15 *    notice, this list of conditions and the following disclaimer in the
16 *    documentation and/or other materials provided with the distribution.
17 *
18 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
19 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
20 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
21 * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
22 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
23 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
24 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
25 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
26 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
27 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
28 * SUCH DAMAGE.
29 *
30 */
31
32#include <sys/cdefs.h>
33__FBSDID("$FreeBSD$");
34
35#include <sys/param.h>
36#include <sys/systm.h>
37#include <sys/kernel.h>
38#include <sys/condvar.h>
39#include <sys/dirent.h>
40#include <sys/fcntl.h>
41#include <sys/lock.h>
42#include <sys/mount.h>
43#include <sys/mutex.h>
44#include <sys/namei.h>
45#include <sys/signalvar.h>
46#include <sys/stat.h>
47#include <sys/taskqueue.h>
48#include <sys/tree.h>
49#include <sys/vnode.h>
50#include <machine/atomic.h>
51#include <vm/uma.h>
52
53#include <fs/autofs/autofs.h>
54
55static int	autofs_trigger_vn(struct vnode *vp, const char *path,
56		    int pathlen, struct vnode **newvp);
57
58extern struct autofs_softc	*autofs_softc;
59
60static int
61autofs_access(struct vop_access_args *ap)
62{
63
64	/*
65	 * Nothing to do here; the only kind of access control
66	 * needed is in autofs_mkdir().
67	 */
68
69	return (0);
70}
71
72static int
73autofs_getattr(struct vop_getattr_args *ap)
74{
75	struct vnode *vp, *newvp;
76	struct autofs_node *anp;
77	struct mount *mp;
78	struct vattr *vap;
79	int error;
80
81	vp = ap->a_vp;
82	anp = vp->v_data;
83	mp = vp->v_mount;
84	vap = ap->a_vap;
85
86	KASSERT(ap->a_vp->v_type == VDIR, ("!VDIR"));
87
88	/*
89	 * The reason we must do this is that some tree-walking software,
90	 * namely fts(3), assumes that stat(".") results will not change
91	 * between chdir("subdir") and chdir(".."), and fails with ENOENT
92	 * otherwise.
93	 */
94	if (autofs_mount_on_stat && autofs_cached(anp, NULL, 0) == false &&
95	    autofs_ignore_thread(curthread) == false) {
96		error = autofs_trigger_vn(vp, "", 0, &newvp);
97		if (error != 0)
98			return (error);
99
100		if (newvp != NULL) {
101			error = VOP_GETATTR(newvp, ap->a_vap,
102			    ap->a_cred);
103			vput(newvp);
104			return (error);
105		}
106	}
107
108	vap->va_type = VDIR;
109	vap->va_mode = 0755;
110	vap->va_nlink = 3; /* XXX */
111	vap->va_uid = 0;
112	vap->va_gid = 0;
113	vap->va_rdev = NODEV;
114	vap->va_fsid = mp->mnt_stat.f_fsid.val[0];
115	vap->va_fileid = anp->an_fileno;
116	vap->va_size = S_BLKSIZE;
117	vap->va_blocksize = S_BLKSIZE;
118	vap->va_mtime = anp->an_ctime;
119	vap->va_atime = anp->an_ctime;
120	vap->va_ctime = anp->an_ctime;
121	vap->va_birthtime = anp->an_ctime;
122	vap->va_gen = 0;
123	vap->va_flags = 0;
124	vap->va_rdev = 0;
125	vap->va_bytes = S_BLKSIZE;
126	vap->va_filerev = 0;
127	vap->va_spare = 0;
128
129	return (0);
130}
131
132/*
133 * Unlock the vnode, request automountd(8) action, and then lock it back.
134 * If anything got mounted on top of the vnode, return the new filesystem's
135 * root vnode in 'newvp', locked.
136 */
137static int
138autofs_trigger_vn(struct vnode *vp, const char *path, int pathlen,
139    struct vnode **newvp)
140{
141	struct autofs_node *anp;
142	int error, lock_flags;
143
144	anp = vp->v_data;
145
146	/*
147	 * Release the vnode lock, so that other operations, in partcular
148	 * mounting a filesystem on top of it, can proceed.  Increase use
149	 * count, to prevent the vnode from being deallocated and to prevent
150	 * filesystem from being unmounted.
151	 */
152	lock_flags = VOP_ISLOCKED(vp);
153	vref(vp);
154	VOP_UNLOCK(vp);
155
156	sx_xlock(&autofs_softc->sc_lock);
157
158	/*
159	 * XXX: Workaround for mounting the same thing multiple times; revisit.
160	 */
161	if (vp->v_mountedhere != NULL) {
162		error = 0;
163		goto mounted;
164	}
165
166	error = autofs_trigger(anp, path, pathlen);
167mounted:
168	sx_xunlock(&autofs_softc->sc_lock);
169	vn_lock(vp, lock_flags | LK_RETRY);
170	vunref(vp);
171	if (VN_IS_DOOMED(vp)) {
172		AUTOFS_DEBUG("VIRF_DOOMED");
173		return (ENOENT);
174	}
175
176	if (error != 0)
177		return (error);
178
179	if (vp->v_mountedhere == NULL) {
180		*newvp = NULL;
181		return (0);
182	} else {
183		/*
184		 * If the operation that succeeded was mount, then mark
185		 * the node as non-cached.  Otherwise, if someone unmounts
186		 * the filesystem before the cache times out, we will fail
187		 * to trigger.
188		 */
189		anp->an_cached = false;
190	}
191
192	error = VFS_ROOT(vp->v_mountedhere, lock_flags, newvp);
193	if (error != 0) {
194		AUTOFS_WARN("VFS_ROOT() failed with error %d", error);
195		return (error);
196	}
197
198	return (0);
199}
200
201static int
202autofs_vget_callback(struct mount *mp, void *arg, int flags,
203    struct vnode **vpp)
204{
205
206	return (autofs_node_vn(arg, mp, flags, vpp));
207}
208
209static int
210autofs_lookup(struct vop_lookup_args *ap)
211{
212	struct vnode *dvp, *newvp, **vpp;
213	struct mount *mp;
214	struct autofs_mount *amp;
215	struct autofs_node *anp, *child;
216	struct componentname *cnp;
217	int error;
218
219	dvp = ap->a_dvp;
220	vpp = ap->a_vpp;
221	mp = dvp->v_mount;
222	amp = VFSTOAUTOFS(mp);
223	anp = dvp->v_data;
224	cnp = ap->a_cnp;
225
226	if (cnp->cn_flags & ISDOTDOT) {
227		KASSERT(anp->an_parent != NULL, ("NULL parent"));
228		/*
229		 * Note that in this case, dvp is the child vnode, and we
230		 * are looking up the parent vnode - exactly reverse from
231		 * normal operation.  Unlocking dvp requires some rather
232		 * tricky unlock/relock dance to prevent mp from being freed;
233		 * use vn_vget_ino_gen() which takes care of all that.
234		 */
235		error = vn_vget_ino_gen(dvp, autofs_vget_callback,
236		    anp->an_parent, cnp->cn_lkflags, vpp);
237		if (error != 0) {
238			AUTOFS_WARN("vn_vget_ino_gen() failed with error %d",
239			    error);
240			return (error);
241		}
242		return (error);
243	}
244
245	if (cnp->cn_namelen == 1 && cnp->cn_nameptr[0] == '.') {
246		vref(dvp);
247		*vpp = dvp;
248
249		return (0);
250	}
251
252	if (autofs_cached(anp, cnp->cn_nameptr, cnp->cn_namelen) == false &&
253	    autofs_ignore_thread(cnp->cn_thread) == false) {
254		error = autofs_trigger_vn(dvp,
255		    cnp->cn_nameptr, cnp->cn_namelen, &newvp);
256		if (error != 0)
257			return (error);
258
259		if (newvp != NULL) {
260			/*
261			 * The target filesystem got automounted.
262			 * Let the lookup(9) go around with the same
263			 * path component.
264			 */
265			vput(newvp);
266			return (ERELOOKUP);
267		}
268	}
269
270	AUTOFS_SLOCK(amp);
271	error = autofs_node_find(anp, cnp->cn_nameptr, cnp->cn_namelen, &child);
272	if (error != 0) {
273		if ((cnp->cn_flags & ISLASTCN) && cnp->cn_nameiop == CREATE) {
274			AUTOFS_SUNLOCK(amp);
275			return (EJUSTRETURN);
276		}
277
278		AUTOFS_SUNLOCK(amp);
279		return (ENOENT);
280	}
281
282	/*
283	 * XXX: Dropping the node here is ok, because we never remove nodes.
284	 */
285	AUTOFS_SUNLOCK(amp);
286
287	error = autofs_node_vn(child, mp, cnp->cn_lkflags, vpp);
288	if (error != 0) {
289		if ((cnp->cn_flags & ISLASTCN) && cnp->cn_nameiop == CREATE)
290			return (EJUSTRETURN);
291
292		return (error);
293	}
294
295	return (0);
296}
297
298static int
299autofs_mkdir(struct vop_mkdir_args *ap)
300{
301	struct vnode *vp;
302	struct autofs_node *anp;
303	struct autofs_mount *amp;
304	struct autofs_node *child;
305	int error;
306
307	vp = ap->a_dvp;
308	anp = vp->v_data;
309	amp = VFSTOAUTOFS(vp->v_mount);
310
311	/*
312	 * Do not allow mkdir() if the calling thread is not
313	 * automountd(8) descendant.
314	 */
315	if (autofs_ignore_thread(curthread) == false)
316		return (EPERM);
317
318	AUTOFS_XLOCK(amp);
319	error = autofs_node_new(anp, amp, ap->a_cnp->cn_nameptr,
320	    ap->a_cnp->cn_namelen, &child);
321	if (error != 0) {
322		AUTOFS_XUNLOCK(amp);
323		return (error);
324	}
325	AUTOFS_XUNLOCK(amp);
326
327	error = autofs_node_vn(child, vp->v_mount, LK_EXCLUSIVE, ap->a_vpp);
328
329	return (error);
330}
331
332static int
333autofs_print(struct vop_print_args *ap)
334{
335	struct vnode *vp;
336	struct autofs_node *anp;
337
338	vp = ap->a_vp;
339	anp = vp->v_data;
340
341	printf("    name \"%s\", fileno %d, cached %d, wildcards %d\n",
342	    anp->an_name, anp->an_fileno, anp->an_cached, anp->an_wildcards);
343
344	return (0);
345}
346
347/*
348 * Write out a single 'struct dirent', based on 'name' and 'fileno' arguments.
349 */
350static int
351autofs_readdir_one(struct uio *uio, const char *name, int fileno,
352    size_t *reclenp)
353{
354	struct dirent dirent;
355	size_t namlen, reclen;
356	int error;
357
358	namlen = strlen(name);
359	reclen = _GENERIC_DIRLEN(namlen);
360	if (reclenp != NULL)
361		*reclenp = reclen;
362
363	if (uio == NULL)
364		return (0);
365
366	if (uio->uio_resid < reclen)
367		return (EINVAL);
368
369	dirent.d_fileno = fileno;
370	dirent.d_off = uio->uio_offset + reclen;
371	dirent.d_reclen = reclen;
372	dirent.d_type = DT_DIR;
373	dirent.d_namlen = namlen;
374	memcpy(dirent.d_name, name, namlen);
375	dirent_terminate(&dirent);
376	error = uiomove(&dirent, reclen, uio);
377
378	return (error);
379}
380
381static size_t
382autofs_dirent_reclen(const char *name)
383{
384	size_t reclen;
385
386	(void)autofs_readdir_one(NULL, name, -1, &reclen);
387
388	return (reclen);
389}
390
391static int
392autofs_readdir(struct vop_readdir_args *ap)
393{
394	struct vnode *vp, *newvp;
395	struct autofs_mount *amp;
396	struct autofs_node *anp, *child;
397	struct uio *uio;
398	size_t reclen, reclens;
399	ssize_t initial_resid;
400	int error;
401
402	vp = ap->a_vp;
403	amp = VFSTOAUTOFS(vp->v_mount);
404	anp = vp->v_data;
405	uio = ap->a_uio;
406	initial_resid = ap->a_uio->uio_resid;
407
408	KASSERT(vp->v_type == VDIR, ("!VDIR"));
409
410	if (autofs_cached(anp, NULL, 0) == false &&
411	    autofs_ignore_thread(curthread) == false) {
412		error = autofs_trigger_vn(vp, "", 0, &newvp);
413		if (error != 0)
414			return (error);
415
416		if (newvp != NULL) {
417			error = VOP_READDIR(newvp, ap->a_uio, ap->a_cred,
418			    ap->a_eofflag, ap->a_ncookies, ap->a_cookies);
419			vput(newvp);
420			return (error);
421		}
422	}
423
424	if (uio->uio_offset < 0)
425		return (EINVAL);
426
427	if (ap->a_eofflag != NULL)
428		*ap->a_eofflag = FALSE;
429
430	/*
431	 * Write out the directory entry for ".".  This is conditional
432	 * on the current offset into the directory; same applies to the
433	 * other two cases below.
434	 */
435	if (uio->uio_offset == 0) {
436		error = autofs_readdir_one(uio, ".", anp->an_fileno, &reclen);
437		if (error != 0)
438			goto out;
439	}
440	reclens = autofs_dirent_reclen(".");
441
442	/*
443	 * Write out the directory entry for "..".
444	 */
445	if (uio->uio_offset <= reclens) {
446		if (uio->uio_offset != reclens)
447			return (EINVAL);
448		if (anp->an_parent == NULL) {
449			error = autofs_readdir_one(uio, "..",
450			    anp->an_fileno, &reclen);
451		} else {
452			error = autofs_readdir_one(uio, "..",
453			    anp->an_parent->an_fileno, &reclen);
454		}
455		if (error != 0)
456			goto out;
457	}
458
459	reclens += autofs_dirent_reclen("..");
460
461	/*
462	 * Write out the directory entries for subdirectories.
463	 */
464	AUTOFS_SLOCK(amp);
465	RB_FOREACH(child, autofs_node_tree, &anp->an_children) {
466		/*
467		 * Check the offset to skip entries returned by previous
468		 * calls to getdents().
469		 */
470		if (uio->uio_offset > reclens) {
471			reclens += autofs_dirent_reclen(child->an_name);
472			continue;
473		}
474
475		/*
476		 * Prevent seeking into the middle of dirent.
477		 */
478		if (uio->uio_offset != reclens) {
479			AUTOFS_SUNLOCK(amp);
480			return (EINVAL);
481		}
482
483		error = autofs_readdir_one(uio, child->an_name,
484		    child->an_fileno, &reclen);
485		reclens += reclen;
486		if (error != 0) {
487			AUTOFS_SUNLOCK(amp);
488			goto out;
489		}
490	}
491	AUTOFS_SUNLOCK(amp);
492
493	if (ap->a_eofflag != NULL)
494		*ap->a_eofflag = TRUE;
495
496	return (0);
497
498out:
499	/*
500	 * Return error if the initial buffer was too small to do anything.
501	 */
502	if (uio->uio_resid == initial_resid)
503		return (error);
504
505	/*
506	 * Don't return an error if we managed to copy out some entries.
507	 */
508	if (uio->uio_resid < reclen)
509		return (0);
510
511	return (error);
512}
513
514static int
515autofs_reclaim(struct vop_reclaim_args *ap)
516{
517	struct vnode *vp;
518	struct autofs_node *anp;
519
520	vp = ap->a_vp;
521	anp = vp->v_data;
522
523	/*
524	 * We do not free autofs_node here; instead we are
525	 * destroying them in autofs_node_delete().
526	 */
527	sx_xlock(&anp->an_vnode_lock);
528	anp->an_vnode = NULL;
529	vp->v_data = NULL;
530	sx_xunlock(&anp->an_vnode_lock);
531
532	return (0);
533}
534
535struct vop_vector autofs_vnodeops = {
536	.vop_default =		&default_vnodeops,
537
538	.vop_access =		autofs_access,
539	.vop_lookup =		autofs_lookup,
540	.vop_create =		VOP_EOPNOTSUPP,
541	.vop_getattr =		autofs_getattr,
542	.vop_link =		VOP_EOPNOTSUPP,
543	.vop_mkdir =		autofs_mkdir,
544	.vop_mknod =		VOP_EOPNOTSUPP,
545	.vop_print =		autofs_print,
546	.vop_read =		VOP_EOPNOTSUPP,
547	.vop_readdir =		autofs_readdir,
548	.vop_remove =		VOP_EOPNOTSUPP,
549	.vop_rename =		VOP_EOPNOTSUPP,
550	.vop_rmdir =		VOP_EOPNOTSUPP,
551	.vop_setattr =		VOP_EOPNOTSUPP,
552	.vop_symlink =		VOP_EOPNOTSUPP,
553	.vop_write =		VOP_EOPNOTSUPP,
554	.vop_reclaim =		autofs_reclaim,
555};
556VFS_VOP_VECTOR_REGISTER(autofs_vnodeops);
557
558int
559autofs_node_new(struct autofs_node *parent, struct autofs_mount *amp,
560    const char *name, int namelen, struct autofs_node **anpp)
561{
562	struct autofs_node *anp;
563
564	if (parent != NULL) {
565		AUTOFS_ASSERT_XLOCKED(parent->an_mount);
566
567		KASSERT(autofs_node_find(parent, name, namelen, NULL) == ENOENT,
568		    ("node \"%s\" already exists", name));
569	}
570
571	anp = uma_zalloc(autofs_node_zone, M_WAITOK | M_ZERO);
572	if (namelen >= 0)
573		anp->an_name = strndup(name, namelen, M_AUTOFS);
574	else
575		anp->an_name = strdup(name, M_AUTOFS);
576	anp->an_fileno = atomic_fetchadd_int(&amp->am_last_fileno, 1);
577	callout_init(&anp->an_callout, 1);
578	/*
579	 * The reason for SX_NOWITNESS here is that witness(4)
580	 * cannot tell vnodes apart, so the following perfectly
581	 * valid lock order...
582	 *
583	 * vnode lock A -> autofsvlk B -> vnode lock B
584	 *
585	 * ... gets reported as a LOR.
586	 */
587	sx_init_flags(&anp->an_vnode_lock, "autofsvlk", SX_NOWITNESS);
588	getnanotime(&anp->an_ctime);
589	anp->an_parent = parent;
590	anp->an_mount = amp;
591	if (parent != NULL)
592		RB_INSERT(autofs_node_tree, &parent->an_children, anp);
593	RB_INIT(&anp->an_children);
594
595	*anpp = anp;
596	return (0);
597}
598
599int
600autofs_node_find(struct autofs_node *parent, const char *name,
601    int namelen, struct autofs_node **anpp)
602{
603	struct autofs_node *anp, find;
604	int error;
605
606	AUTOFS_ASSERT_LOCKED(parent->an_mount);
607
608	if (namelen >= 0)
609		find.an_name = strndup(name, namelen, M_AUTOFS);
610	else
611		find.an_name = strdup(name, M_AUTOFS);
612
613	anp = RB_FIND(autofs_node_tree, &parent->an_children, &find);
614	if (anp != NULL) {
615		error = 0;
616		if (anpp != NULL)
617			*anpp = anp;
618	} else {
619		error = ENOENT;
620	}
621
622	free(find.an_name, M_AUTOFS);
623
624	return (error);
625}
626
627void
628autofs_node_delete(struct autofs_node *anp)
629{
630	struct autofs_node *parent;
631
632	AUTOFS_ASSERT_XLOCKED(anp->an_mount);
633	KASSERT(RB_EMPTY(&anp->an_children), ("have children"));
634
635	callout_drain(&anp->an_callout);
636
637	parent = anp->an_parent;
638	if (parent != NULL)
639		RB_REMOVE(autofs_node_tree, &parent->an_children, anp);
640	sx_destroy(&anp->an_vnode_lock);
641	free(anp->an_name, M_AUTOFS);
642	uma_zfree(autofs_node_zone, anp);
643}
644
645int
646autofs_node_vn(struct autofs_node *anp, struct mount *mp, int flags,
647    struct vnode **vpp)
648{
649	struct vnode *vp;
650	int error;
651
652	AUTOFS_ASSERT_UNLOCKED(anp->an_mount);
653
654	sx_xlock(&anp->an_vnode_lock);
655
656	vp = anp->an_vnode;
657	if (vp != NULL) {
658		error = vget(vp, flags | LK_RETRY);
659		if (error != 0) {
660			AUTOFS_WARN("vget failed with error %d", error);
661			sx_xunlock(&anp->an_vnode_lock);
662			return (error);
663		}
664		if (VN_IS_DOOMED(vp)) {
665			/*
666			 * We got forcibly unmounted.
667			 */
668			AUTOFS_DEBUG("doomed vnode");
669			sx_xunlock(&anp->an_vnode_lock);
670			vput(vp);
671
672			return (ENOENT);
673		}
674
675		*vpp = vp;
676		sx_xunlock(&anp->an_vnode_lock);
677		return (0);
678	}
679
680	error = getnewvnode("autofs", mp, &autofs_vnodeops, &vp);
681	if (error != 0) {
682		sx_xunlock(&anp->an_vnode_lock);
683		return (error);
684	}
685
686	error = vn_lock(vp, LK_EXCLUSIVE | LK_RETRY);
687	if (error != 0) {
688		sx_xunlock(&anp->an_vnode_lock);
689		vdrop(vp);
690		return (error);
691	}
692
693	vp->v_type = VDIR;
694	if (anp->an_parent == NULL)
695		vp->v_vflag |= VV_ROOT;
696	vp->v_data = anp;
697
698	VN_LOCK_ASHARE(vp);
699
700	error = insmntque(vp, mp);
701	if (error != 0) {
702		AUTOFS_DEBUG("insmntque() failed with error %d", error);
703		sx_xunlock(&anp->an_vnode_lock);
704		return (error);
705	}
706
707	KASSERT(anp->an_vnode == NULL, ("lost race"));
708	anp->an_vnode = vp;
709
710	sx_xunlock(&anp->an_vnode_lock);
711
712	*vpp = vp;
713	return (0);
714}
715