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