xref: /freebsd/sys/fs/unionfs/union_vnops.c (revision f4b37ed0f8b307b1f3f0f630ca725d68f1dff30d)
1 /*-
2  * Copyright (c) 1992, 1993, 1994, 1995 Jan-Simon Pendry.
3  * Copyright (c) 1992, 1993, 1994, 1995
4  *      The Regents of the University of California.
5  * Copyright (c) 2005, 2006, 2012 Masanori Ozawa <ozawa@ongs.co.jp>, ONGS Inc.
6  * Copyright (c) 2006, 2012 Daichi Goto <daichi@freebsd.org>
7  * All rights reserved.
8  *
9  * This code is derived from software contributed to Berkeley by
10  * Jan-Simon Pendry.
11  *
12  * Redistribution and use in source and binary forms, with or without
13  * modification, are permitted provided that the following conditions
14  * are met:
15  * 1. Redistributions of source code must retain the above copyright
16  *    notice, this list of conditions and the following disclaimer.
17  * 2. Redistributions in binary form must reproduce the above copyright
18  *    notice, this list of conditions and the following disclaimer in the
19  *    documentation and/or other materials provided with the distribution.
20  * 4. Neither the name of the University nor the names of its contributors
21  *    may be used to endorse or promote products derived from this software
22  *    without specific prior written permission.
23  *
24  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
25  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
26  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
27  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
28  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
29  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
30  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
31  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
32  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
33  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
34  * SUCH DAMAGE.
35  *
36  *	@(#)union_vnops.c	8.32 (Berkeley) 6/23/95
37  * $FreeBSD$
38  *
39  */
40 
41 #include <sys/param.h>
42 #include <sys/systm.h>
43 #include <sys/conf.h>
44 #include <sys/kernel.h>
45 #include <sys/lock.h>
46 #include <sys/malloc.h>
47 #include <sys/mount.h>
48 #include <sys/mutex.h>
49 #include <sys/namei.h>
50 #include <sys/sysctl.h>
51 #include <sys/vnode.h>
52 #include <sys/kdb.h>
53 #include <sys/fcntl.h>
54 #include <sys/stat.h>
55 #include <sys/dirent.h>
56 #include <sys/proc.h>
57 #include <sys/bio.h>
58 #include <sys/buf.h>
59 
60 #include <fs/unionfs/union.h>
61 
62 #include <vm/vm.h>
63 #include <vm/vm_extern.h>
64 #include <vm/vm_object.h>
65 #include <vm/vnode_pager.h>
66 
67 #if 0
68 #define UNIONFS_INTERNAL_DEBUG(msg, args...)    printf(msg, ## args)
69 #define UNIONFS_IDBG_RENAME
70 #else
71 #define UNIONFS_INTERNAL_DEBUG(msg, args...)
72 #endif
73 
74 #define KASSERT_UNIONFS_VNODE(vp) \
75 	KASSERT(((vp)->v_op == &unionfs_vnodeops), \
76 	    ("unionfs: it is not unionfs-vnode"))
77 
78 static int
79 unionfs_lookup(struct vop_cachedlookup_args *ap)
80 {
81 	int		iswhiteout;
82 	int		lockflag;
83 	int		error , uerror, lerror;
84 	u_long		nameiop;
85 	u_long		cnflags, cnflagsbk;
86 	struct unionfs_node *dunp;
87 	struct vnode   *dvp, *udvp, *ldvp, *vp, *uvp, *lvp, *dtmpvp;
88 	struct vattr	va;
89 	struct componentname *cnp;
90 	struct thread  *td;
91 
92 	iswhiteout = 0;
93 	lockflag = 0;
94 	error = uerror = lerror = ENOENT;
95 	cnp = ap->a_cnp;
96 	nameiop = cnp->cn_nameiop;
97 	cnflags = cnp->cn_flags;
98 	dvp = ap->a_dvp;
99 	dunp = VTOUNIONFS(dvp);
100 	udvp = dunp->un_uppervp;
101 	ldvp = dunp->un_lowervp;
102 	vp = uvp = lvp = NULLVP;
103 	td = curthread;
104 	*(ap->a_vpp) = NULLVP;
105 
106 	UNIONFS_INTERNAL_DEBUG("unionfs_lookup: enter: nameiop=%ld, flags=%lx, path=%s\n", nameiop, cnflags, cnp->cn_nameptr);
107 
108 	if (dvp->v_type != VDIR)
109 		return (ENOTDIR);
110 
111 	/*
112 	 * If read-only and op is not LOOKUP, will return EROFS.
113 	 */
114 	if ((cnflags & ISLASTCN) &&
115 	    (dvp->v_mount->mnt_flag & MNT_RDONLY) &&
116 	    LOOKUP != nameiop)
117 		return (EROFS);
118 
119 	/*
120 	 * lookup dotdot
121 	 */
122 	if (cnflags & ISDOTDOT) {
123 		if (LOOKUP != nameiop && udvp == NULLVP)
124 			return (EROFS);
125 
126 		if (udvp != NULLVP) {
127 			dtmpvp = udvp;
128 			if (ldvp != NULLVP)
129 				VOP_UNLOCK(ldvp, LK_RELEASE);
130 		}
131 		else
132 			dtmpvp = ldvp;
133 
134 		error = VOP_LOOKUP(dtmpvp, &vp, cnp);
135 
136 		if (dtmpvp == udvp && ldvp != NULLVP) {
137 			VOP_UNLOCK(udvp, LK_RELEASE);
138 			vn_lock(dvp, LK_EXCLUSIVE | LK_RETRY);
139 		}
140 
141 		if (error == 0) {
142 			/*
143 			 * Exchange lock and reference from vp to
144 			 * dunp->un_dvp. vp is upper/lower vnode, but it
145 			 * will need to return the unionfs vnode.
146 			 */
147 			if (nameiop == DELETE  || nameiop == RENAME ||
148 			    (cnp->cn_lkflags & LK_TYPE_MASK))
149 				VOP_UNLOCK(vp, LK_RELEASE);
150 			vrele(vp);
151 
152 			VOP_UNLOCK(dvp, LK_RELEASE);
153 			*(ap->a_vpp) = dunp->un_dvp;
154 			vref(dunp->un_dvp);
155 
156 			if (nameiop == DELETE || nameiop == RENAME)
157 				vn_lock(dunp->un_dvp, LK_EXCLUSIVE | LK_RETRY);
158 			else if (cnp->cn_lkflags & LK_TYPE_MASK)
159 				vn_lock(dunp->un_dvp, cnp->cn_lkflags |
160 				    LK_RETRY);
161 
162 			vn_lock(dvp, LK_EXCLUSIVE | LK_RETRY);
163 		} else if (error == ENOENT && (cnflags & MAKEENTRY) != 0)
164 			cache_enter(dvp, NULLVP, cnp);
165 
166 		UNIONFS_INTERNAL_DEBUG("unionfs_lookup: leave (%d)\n", error);
167 
168 		return (error);
169 	}
170 
171 	/*
172 	 * lookup upper layer
173 	 */
174 	if (udvp != NULLVP) {
175 		uerror = VOP_LOOKUP(udvp, &uvp, cnp);
176 
177 		if (uerror == 0) {
178 			if (udvp == uvp) {	/* is dot */
179 				vrele(uvp);
180 				*(ap->a_vpp) = dvp;
181 				vref(dvp);
182 
183 				UNIONFS_INTERNAL_DEBUG("unionfs_lookup: leave (%d)\n", uerror);
184 
185 				return (uerror);
186 			}
187 			if (nameiop == DELETE || nameiop == RENAME ||
188 			    (cnp->cn_lkflags & LK_TYPE_MASK))
189 				VOP_UNLOCK(uvp, LK_RELEASE);
190 		}
191 
192 		/* check whiteout */
193 		if (uerror == ENOENT || uerror == EJUSTRETURN)
194 			if (cnp->cn_flags & ISWHITEOUT)
195 				iswhiteout = 1;	/* don't lookup lower */
196 		if (iswhiteout == 0 && ldvp != NULLVP)
197 			if (!VOP_GETATTR(udvp, &va, cnp->cn_cred) &&
198 			    (va.va_flags & OPAQUE))
199 				iswhiteout = 1;	/* don't lookup lower */
200 #if 0
201 		UNIONFS_INTERNAL_DEBUG("unionfs_lookup: debug: whiteout=%d, path=%s\n", iswhiteout, cnp->cn_nameptr);
202 #endif
203 	}
204 
205 	/*
206 	 * lookup lower layer
207 	 */
208 	if (ldvp != NULLVP && !(cnflags & DOWHITEOUT) && iswhiteout == 0) {
209 		/* always op is LOOKUP */
210 		cnp->cn_nameiop = LOOKUP;
211 		cnflagsbk = cnp->cn_flags;
212 		cnp->cn_flags = cnflags;
213 
214 		lerror = VOP_LOOKUP(ldvp, &lvp, cnp);
215 
216 		cnp->cn_nameiop = nameiop;
217 		if (udvp != NULLVP && (uerror == 0 || uerror == EJUSTRETURN))
218 			cnp->cn_flags = cnflagsbk;
219 
220 		if (lerror == 0) {
221 			if (ldvp == lvp) {	/* is dot */
222 				if (uvp != NULLVP)
223 					vrele(uvp);	/* no need? */
224 				vrele(lvp);
225 				*(ap->a_vpp) = dvp;
226 				vref(dvp);
227 
228 				UNIONFS_INTERNAL_DEBUG("unionfs_lookup: leave (%d)\n", lerror);
229 
230 				return (lerror);
231 			}
232 			if (cnp->cn_lkflags & LK_TYPE_MASK)
233 				VOP_UNLOCK(lvp, LK_RELEASE);
234 		}
235 	}
236 
237 	/*
238 	 * check lookup result
239 	 */
240 	if (uvp == NULLVP && lvp == NULLVP) {
241 		UNIONFS_INTERNAL_DEBUG("unionfs_lookup: leave (%d)\n",
242 		    (udvp != NULLVP ? uerror : lerror));
243 		return (udvp != NULLVP ? uerror : lerror);
244 	}
245 
246 	/*
247 	 * check vnode type
248 	 */
249 	if (uvp != NULLVP && lvp != NULLVP && uvp->v_type != lvp->v_type) {
250 		vrele(lvp);
251 		lvp = NULLVP;
252 	}
253 
254 	/*
255 	 * check shadow dir
256 	 */
257 	if (uerror != 0 && uerror != EJUSTRETURN && udvp != NULLVP &&
258 	    lerror == 0 && lvp != NULLVP && lvp->v_type == VDIR &&
259 	    !(dvp->v_mount->mnt_flag & MNT_RDONLY) &&
260 	    (1 < cnp->cn_namelen || '.' != *(cnp->cn_nameptr))) {
261 		/* get unionfs vnode in order to create a new shadow dir. */
262 		error = unionfs_nodeget(dvp->v_mount, NULLVP, lvp, dvp, &vp,
263 		    cnp, td);
264 		if (error != 0)
265 			goto unionfs_lookup_out;
266 
267 		if (LK_SHARED == (cnp->cn_lkflags & LK_TYPE_MASK))
268 			VOP_UNLOCK(vp, LK_RELEASE);
269 		if (LK_EXCLUSIVE != VOP_ISLOCKED(vp)) {
270 			vn_lock(vp, LK_EXCLUSIVE | LK_RETRY);
271 			lockflag = 1;
272 		}
273 		error = unionfs_mkshadowdir(MOUNTTOUNIONFSMOUNT(dvp->v_mount),
274 		    udvp, VTOUNIONFS(vp), cnp, td);
275 		if (lockflag != 0)
276 			VOP_UNLOCK(vp, LK_RELEASE);
277 		if (error != 0) {
278 			UNIONFSDEBUG("unionfs_lookup: Unable to create shadow dir.");
279 			if ((cnp->cn_lkflags & LK_TYPE_MASK) == LK_EXCLUSIVE)
280 				vput(vp);
281 			else
282 				vrele(vp);
283 			goto unionfs_lookup_out;
284 		}
285 		if ((cnp->cn_lkflags & LK_TYPE_MASK) == LK_SHARED)
286 			vn_lock(vp, LK_SHARED | LK_RETRY);
287 	}
288 	/*
289 	 * get unionfs vnode.
290 	 */
291 	else {
292 		if (uvp != NULLVP)
293 			error = uerror;
294 		else
295 			error = lerror;
296 		if (error != 0)
297 			goto unionfs_lookup_out;
298 		/*
299 		 * get socket vnode.
300 		 */
301 		if (uvp != NULLVP && uvp->v_type == VSOCK) {
302 			vp = uvp;
303 			vref(vp);
304 			if (cnp->cn_lkflags & LK_TYPE_MASK)
305 				vn_lock(vp, cnp->cn_lkflags | LK_RETRY);
306 		}
307 		else if (lvp != NULLVP && lvp->v_type == VSOCK) {
308 			vp = lvp;
309 			vref(vp);
310 			if (cnp->cn_lkflags & LK_TYPE_MASK)
311 				vn_lock(vp, cnp->cn_lkflags | LK_RETRY);
312 		}
313 		/*
314 		 * get unionfs vnode.
315 		 */
316 		else
317 			error = unionfs_nodeget(dvp->v_mount, uvp, lvp,
318 			    dvp, &vp, cnp, td);
319 		if (error != 0) {
320 			UNIONFSDEBUG("unionfs_lookup: Unable to create unionfs vnode.");
321 			goto unionfs_lookup_out;
322 		}
323 		if ((nameiop == DELETE || nameiop == RENAME) &&
324 		    (cnp->cn_lkflags & LK_TYPE_MASK) == 0)
325 			vn_lock(vp, LK_EXCLUSIVE | LK_RETRY);
326 	}
327 
328 	*(ap->a_vpp) = vp;
329 
330 	if ((cnflags & MAKEENTRY) && vp->v_type != VSOCK)
331 		cache_enter(dvp, vp, cnp);
332 
333 unionfs_lookup_out:
334 	if (uvp != NULLVP)
335 		vrele(uvp);
336 	if (lvp != NULLVP)
337 		vrele(lvp);
338 
339 	if (error == ENOENT && (cnflags & MAKEENTRY) != 0)
340 		cache_enter(dvp, NULLVP, cnp);
341 
342 	UNIONFS_INTERNAL_DEBUG("unionfs_lookup: leave (%d)\n", error);
343 
344 	return (error);
345 }
346 
347 static int
348 unionfs_create(struct vop_create_args *ap)
349 {
350 	struct unionfs_node *dunp;
351 	struct componentname *cnp;
352 	struct vnode   *udvp;
353 	struct vnode   *vp;
354 	int		error;
355 
356 	UNIONFS_INTERNAL_DEBUG("unionfs_create: enter\n");
357 
358 	KASSERT_UNIONFS_VNODE(ap->a_dvp);
359 
360 	dunp = VTOUNIONFS(ap->a_dvp);
361 	cnp = ap->a_cnp;
362 	udvp = dunp->un_uppervp;
363 	error = EROFS;
364 
365 	if (udvp != NULLVP) {
366 		error = VOP_CREATE(udvp, &vp, cnp, ap->a_vap);
367 		if (error != 0)
368 			goto unionfs_create_abort;
369 
370 		if (vp->v_type == VSOCK)
371 			*(ap->a_vpp) = vp;
372 		else {
373 			VOP_UNLOCK(vp, LK_RELEASE);
374 			error = unionfs_nodeget(ap->a_dvp->v_mount, vp, NULLVP,
375 			    ap->a_dvp, ap->a_vpp, cnp, curthread);
376 			vrele(vp);
377 		}
378 	}
379 
380 unionfs_create_abort:
381 	UNIONFS_INTERNAL_DEBUG("unionfs_create: leave (%d)\n", error);
382 
383 	return (error);
384 }
385 
386 static int
387 unionfs_whiteout(struct vop_whiteout_args *ap)
388 {
389 	struct unionfs_node *dunp;
390 	struct componentname *cnp;
391 	struct vnode   *udvp;
392 	int		error;
393 
394 	UNIONFS_INTERNAL_DEBUG("unionfs_whiteout: enter\n");
395 
396 	KASSERT_UNIONFS_VNODE(ap->a_dvp);
397 
398 	dunp = VTOUNIONFS(ap->a_dvp);
399 	cnp = ap->a_cnp;
400 	udvp = dunp->un_uppervp;
401 	error = EOPNOTSUPP;
402 
403 	if (udvp != NULLVP) {
404 		switch (ap->a_flags) {
405 		case CREATE:
406 		case DELETE:
407 		case LOOKUP:
408 			error = VOP_WHITEOUT(udvp, cnp, ap->a_flags);
409 			break;
410 		default:
411 			error = EINVAL;
412 			break;
413 		}
414 	}
415 
416 	UNIONFS_INTERNAL_DEBUG("unionfs_whiteout: leave (%d)\n", error);
417 
418 	return (error);
419 }
420 
421 static int
422 unionfs_mknod(struct vop_mknod_args *ap)
423 {
424 	struct unionfs_node *dunp;
425 	struct componentname *cnp;
426 	struct vnode   *udvp;
427 	struct vnode   *vp;
428 	int		error;
429 
430 	UNIONFS_INTERNAL_DEBUG("unionfs_mknod: enter\n");
431 
432 	KASSERT_UNIONFS_VNODE(ap->a_dvp);
433 
434 	dunp = VTOUNIONFS(ap->a_dvp);
435 	cnp = ap->a_cnp;
436 	udvp = dunp->un_uppervp;
437 	error = EROFS;
438 
439 	if (udvp != NULLVP) {
440 		error = VOP_MKNOD(udvp, &vp, cnp, ap->a_vap);
441 		if (error != 0)
442 			goto unionfs_mknod_abort;
443 
444 		if (vp->v_type == VSOCK)
445 			*(ap->a_vpp) = vp;
446 		else {
447 			VOP_UNLOCK(vp, LK_RELEASE);
448 			error = unionfs_nodeget(ap->a_dvp->v_mount, vp, NULLVP,
449 			    ap->a_dvp, ap->a_vpp, cnp, curthread);
450 			vrele(vp);
451 		}
452 	}
453 
454 unionfs_mknod_abort:
455 	UNIONFS_INTERNAL_DEBUG("unionfs_mknod: leave (%d)\n", error);
456 
457 	return (error);
458 }
459 
460 static int
461 unionfs_open(struct vop_open_args *ap)
462 {
463 	int		error;
464 	struct unionfs_node *unp;
465 	struct unionfs_node_status *unsp;
466 	struct vnode   *uvp;
467 	struct vnode   *lvp;
468 	struct vnode   *targetvp;
469 	struct ucred   *cred;
470 	struct thread  *td;
471 
472 	UNIONFS_INTERNAL_DEBUG("unionfs_open: enter\n");
473 
474 	KASSERT_UNIONFS_VNODE(ap->a_vp);
475 
476 	error = 0;
477 	unp = VTOUNIONFS(ap->a_vp);
478 	uvp = unp->un_uppervp;
479 	lvp = unp->un_lowervp;
480 	targetvp = NULLVP;
481 	cred = ap->a_cred;
482 	td = ap->a_td;
483 
484 	unionfs_get_node_status(unp, td, &unsp);
485 
486 	if (unsp->uns_lower_opencnt > 0 || unsp->uns_upper_opencnt > 0) {
487 		/* vnode is already opend. */
488 		if (unsp->uns_upper_opencnt > 0)
489 			targetvp = uvp;
490 		else
491 			targetvp = lvp;
492 
493 		if (targetvp == lvp &&
494 		    (ap->a_mode & FWRITE) && lvp->v_type == VREG)
495 			targetvp = NULLVP;
496 	}
497 	if (targetvp == NULLVP) {
498 		if (uvp == NULLVP) {
499 			if ((ap->a_mode & FWRITE) && lvp->v_type == VREG) {
500 				error = unionfs_copyfile(unp,
501 				    !(ap->a_mode & O_TRUNC), cred, td);
502 				if (error != 0)
503 					goto unionfs_open_abort;
504 				targetvp = uvp = unp->un_uppervp;
505 			} else
506 				targetvp = lvp;
507 		} else
508 			targetvp = uvp;
509 	}
510 
511 	error = VOP_OPEN(targetvp, ap->a_mode, cred, td, ap->a_fp);
512 	if (error == 0) {
513 		if (targetvp == uvp) {
514 			if (uvp->v_type == VDIR && lvp != NULLVP &&
515 			    unsp->uns_lower_opencnt <= 0) {
516 				/* open lower for readdir */
517 				error = VOP_OPEN(lvp, FREAD, cred, td, NULL);
518 				if (error != 0) {
519 					VOP_CLOSE(uvp, ap->a_mode, cred, td);
520 					goto unionfs_open_abort;
521 				}
522 				unsp->uns_node_flag |= UNS_OPENL_4_READDIR;
523 				unsp->uns_lower_opencnt++;
524 			}
525 			unsp->uns_upper_opencnt++;
526 		} else {
527 			unsp->uns_lower_opencnt++;
528 			unsp->uns_lower_openmode = ap->a_mode;
529 		}
530 		ap->a_vp->v_object = targetvp->v_object;
531 	}
532 
533 unionfs_open_abort:
534 	if (error != 0)
535 		unionfs_tryrem_node_status(unp, unsp);
536 
537 	UNIONFS_INTERNAL_DEBUG("unionfs_open: leave (%d)\n", error);
538 
539 	return (error);
540 }
541 
542 static int
543 unionfs_close(struct vop_close_args *ap)
544 {
545 	int		error;
546 	int		locked;
547 	struct unionfs_node *unp;
548 	struct unionfs_node_status *unsp;
549 	struct ucred   *cred;
550 	struct thread  *td;
551 	struct vnode   *vp;
552 	struct vnode   *ovp;
553 
554 	UNIONFS_INTERNAL_DEBUG("unionfs_close: enter\n");
555 
556 	KASSERT_UNIONFS_VNODE(ap->a_vp);
557 
558 	locked = 0;
559 	vp = ap->a_vp;
560 	unp = VTOUNIONFS(vp);
561 	cred = ap->a_cred;
562 	td = ap->a_td;
563 
564 	if (VOP_ISLOCKED(vp) != LK_EXCLUSIVE) {
565 		if (vn_lock(vp, LK_UPGRADE) != 0)
566 			vn_lock(vp, LK_EXCLUSIVE | LK_RETRY);
567 		locked = 1;
568 	}
569 	unionfs_get_node_status(unp, td, &unsp);
570 
571 	if (unsp->uns_lower_opencnt <= 0 && unsp->uns_upper_opencnt <= 0) {
572 #ifdef DIAGNOSTIC
573 		printf("unionfs_close: warning: open count is 0\n");
574 #endif
575 		if (unp->un_uppervp != NULLVP)
576 			ovp = unp->un_uppervp;
577 		else
578 			ovp = unp->un_lowervp;
579 	} else if (unsp->uns_upper_opencnt > 0)
580 		ovp = unp->un_uppervp;
581 	else
582 		ovp = unp->un_lowervp;
583 
584 	error = VOP_CLOSE(ovp, ap->a_fflag, cred, td);
585 
586 	if (error != 0)
587 		goto unionfs_close_abort;
588 
589 	vp->v_object = ovp->v_object;
590 
591 	if (ovp == unp->un_uppervp) {
592 		unsp->uns_upper_opencnt--;
593 		if (unsp->uns_upper_opencnt == 0) {
594 			if (unsp->uns_node_flag & UNS_OPENL_4_READDIR) {
595 				VOP_CLOSE(unp->un_lowervp, FREAD, cred, td);
596 				unsp->uns_node_flag &= ~UNS_OPENL_4_READDIR;
597 				unsp->uns_lower_opencnt--;
598 			}
599 			if (unsp->uns_lower_opencnt > 0)
600 				vp->v_object = unp->un_lowervp->v_object;
601 		}
602 	} else
603 		unsp->uns_lower_opencnt--;
604 
605 unionfs_close_abort:
606 	unionfs_tryrem_node_status(unp, unsp);
607 
608 	if (locked != 0)
609 		vn_lock(vp, LK_DOWNGRADE | LK_RETRY);
610 
611 	UNIONFS_INTERNAL_DEBUG("unionfs_close: leave (%d)\n", error);
612 
613 	return (error);
614 }
615 
616 /*
617  * Check the access mode toward shadow file/dir.
618  */
619 static int
620 unionfs_check_corrected_access(accmode_t accmode,
621 			     struct vattr *va,
622 			     struct ucred *cred)
623 {
624 	int		count;
625 	uid_t		uid;	/* upper side vnode's uid */
626 	gid_t		gid;	/* upper side vnode's gid */
627 	u_short		vmode;	/* upper side vnode's mode */
628 	u_short		mask;
629 
630 	mask = 0;
631 	uid = va->va_uid;
632 	gid = va->va_gid;
633 	vmode = va->va_mode;
634 
635 	/* check owner */
636 	if (cred->cr_uid == uid) {
637 		if (accmode & VEXEC)
638 			mask |= S_IXUSR;
639 		if (accmode & VREAD)
640 			mask |= S_IRUSR;
641 		if (accmode & VWRITE)
642 			mask |= S_IWUSR;
643 		return ((vmode & mask) == mask ? 0 : EACCES);
644 	}
645 
646 	/* check group */
647 	count = 0;
648 	if (groupmember(gid, cred)) {
649 		if (accmode & VEXEC)
650 			mask |= S_IXGRP;
651 		if (accmode & VREAD)
652 			mask |= S_IRGRP;
653 		if (accmode & VWRITE)
654 			mask |= S_IWGRP;
655 		return ((vmode & mask) == mask ? 0 : EACCES);
656 	}
657 
658 	/* check other */
659 	if (accmode & VEXEC)
660 		mask |= S_IXOTH;
661 	if (accmode & VREAD)
662 		mask |= S_IROTH;
663 	if (accmode & VWRITE)
664 		mask |= S_IWOTH;
665 
666 	return ((vmode & mask) == mask ? 0 : EACCES);
667 }
668 
669 static int
670 unionfs_access(struct vop_access_args *ap)
671 {
672 	struct unionfs_mount *ump;
673 	struct unionfs_node *unp;
674 	struct vnode   *uvp;
675 	struct vnode   *lvp;
676 	struct thread  *td;
677 	struct vattr	va;
678 	accmode_t	accmode;
679 	int		error;
680 
681 	UNIONFS_INTERNAL_DEBUG("unionfs_access: enter\n");
682 
683 	KASSERT_UNIONFS_VNODE(ap->a_vp);
684 
685 	ump = MOUNTTOUNIONFSMOUNT(ap->a_vp->v_mount);
686 	unp = VTOUNIONFS(ap->a_vp);
687 	uvp = unp->un_uppervp;
688 	lvp = unp->un_lowervp;
689 	td = ap->a_td;
690 	accmode = ap->a_accmode;
691 	error = EACCES;
692 
693 	if ((accmode & VWRITE) &&
694 	    (ap->a_vp->v_mount->mnt_flag & MNT_RDONLY)) {
695 		switch (ap->a_vp->v_type) {
696 		case VREG:
697 		case VDIR:
698 		case VLNK:
699 			return (EROFS);
700 		default:
701 			break;
702 		}
703 	}
704 
705 	if (uvp != NULLVP) {
706 		error = VOP_ACCESS(uvp, accmode, ap->a_cred, td);
707 
708 		UNIONFS_INTERNAL_DEBUG("unionfs_access: leave (%d)\n", error);
709 
710 		return (error);
711 	}
712 
713 	if (lvp != NULLVP) {
714 		if (accmode & VWRITE) {
715 			if (ump->um_uppervp->v_mount->mnt_flag & MNT_RDONLY) {
716 				switch (ap->a_vp->v_type) {
717 				case VREG:
718 				case VDIR:
719 				case VLNK:
720 					return (EROFS);
721 				default:
722 					break;
723 				}
724 			} else if (ap->a_vp->v_type == VREG || ap->a_vp->v_type == VDIR) {
725 				/* check shadow file/dir */
726 				if (ump->um_copymode != UNIONFS_TRANSPARENT) {
727 					error = unionfs_create_uppervattr(ump,
728 					    lvp, &va, ap->a_cred, td);
729 					if (error != 0)
730 						return (error);
731 
732 					error = unionfs_check_corrected_access(
733 					    accmode, &va, ap->a_cred);
734 					if (error != 0)
735 						return (error);
736 				}
737 			}
738 			accmode &= ~(VWRITE | VAPPEND);
739 			accmode |= VREAD; /* will copy to upper */
740 		}
741 		error = VOP_ACCESS(lvp, accmode, ap->a_cred, td);
742 	}
743 
744 	UNIONFS_INTERNAL_DEBUG("unionfs_access: leave (%d)\n", error);
745 
746 	return (error);
747 }
748 
749 static int
750 unionfs_getattr(struct vop_getattr_args *ap)
751 {
752 	int		error;
753 	struct unionfs_node *unp;
754 	struct unionfs_mount *ump;
755 	struct vnode   *uvp;
756 	struct vnode   *lvp;
757 	struct thread  *td;
758 	struct vattr	va;
759 
760 	UNIONFS_INTERNAL_DEBUG("unionfs_getattr: enter\n");
761 
762 	KASSERT_UNIONFS_VNODE(ap->a_vp);
763 
764 	unp = VTOUNIONFS(ap->a_vp);
765 	ump = MOUNTTOUNIONFSMOUNT(ap->a_vp->v_mount);
766 	uvp = unp->un_uppervp;
767 	lvp = unp->un_lowervp;
768 	td = curthread;
769 
770 	if (uvp != NULLVP) {
771 		if ((error = VOP_GETATTR(uvp, ap->a_vap, ap->a_cred)) == 0)
772 			ap->a_vap->va_fsid = ap->a_vp->v_mount->mnt_stat.f_fsid.val[0];
773 
774 		UNIONFS_INTERNAL_DEBUG("unionfs_getattr: leave mode=%o, uid=%d, gid=%d (%d)\n",
775 		    ap->a_vap->va_mode, ap->a_vap->va_uid,
776 		    ap->a_vap->va_gid, error);
777 
778 		return (error);
779 	}
780 
781 	error = VOP_GETATTR(lvp, ap->a_vap, ap->a_cred);
782 
783 	if (error == 0 && !(ump->um_uppervp->v_mount->mnt_flag & MNT_RDONLY)) {
784 		/* correct the attr toward shadow file/dir. */
785 		if (ap->a_vp->v_type == VREG || ap->a_vp->v_type == VDIR) {
786 			unionfs_create_uppervattr_core(ump, ap->a_vap, &va, td);
787 			ap->a_vap->va_mode = va.va_mode;
788 			ap->a_vap->va_uid = va.va_uid;
789 			ap->a_vap->va_gid = va.va_gid;
790 		}
791 	}
792 
793 	if (error == 0)
794 		ap->a_vap->va_fsid = ap->a_vp->v_mount->mnt_stat.f_fsid.val[0];
795 
796 	UNIONFS_INTERNAL_DEBUG("unionfs_getattr: leave mode=%o, uid=%d, gid=%d (%d)\n",
797 	    ap->a_vap->va_mode, ap->a_vap->va_uid, ap->a_vap->va_gid, error);
798 
799 	return (error);
800 }
801 
802 static int
803 unionfs_setattr(struct vop_setattr_args *ap)
804 {
805 	int		error;
806 	struct unionfs_node *unp;
807 	struct vnode   *uvp;
808 	struct vnode   *lvp;
809 	struct thread  *td;
810 	struct vattr   *vap;
811 
812 	UNIONFS_INTERNAL_DEBUG("unionfs_setattr: enter\n");
813 
814 	KASSERT_UNIONFS_VNODE(ap->a_vp);
815 
816 	error = EROFS;
817 	unp = VTOUNIONFS(ap->a_vp);
818 	uvp = unp->un_uppervp;
819 	lvp = unp->un_lowervp;
820 	td = curthread;
821 	vap = ap->a_vap;
822 
823 	if ((ap->a_vp->v_mount->mnt_flag & MNT_RDONLY) &&
824 	    (vap->va_flags != VNOVAL || vap->va_uid != (uid_t)VNOVAL ||
825 	     vap->va_gid != (gid_t)VNOVAL || vap->va_atime.tv_sec != VNOVAL ||
826 	     vap->va_mtime.tv_sec != VNOVAL || vap->va_mode != (mode_t)VNOVAL))
827 		return (EROFS);
828 
829 	if (uvp == NULLVP && lvp->v_type == VREG) {
830 		error = unionfs_copyfile(unp, (vap->va_size != 0),
831 		    ap->a_cred, td);
832 		if (error != 0)
833 			return (error);
834 		uvp = unp->un_uppervp;
835 	}
836 
837 	if (uvp != NULLVP)
838 		error = VOP_SETATTR(uvp, vap, ap->a_cred);
839 
840 	UNIONFS_INTERNAL_DEBUG("unionfs_setattr: leave (%d)\n", error);
841 
842 	return (error);
843 }
844 
845 static int
846 unionfs_read(struct vop_read_args *ap)
847 {
848 	int		error;
849 	struct unionfs_node *unp;
850 	struct vnode   *tvp;
851 
852 	/* UNIONFS_INTERNAL_DEBUG("unionfs_read: enter\n"); */
853 
854 	KASSERT_UNIONFS_VNODE(ap->a_vp);
855 
856 	unp = VTOUNIONFS(ap->a_vp);
857 	tvp = (unp->un_uppervp != NULLVP ? unp->un_uppervp : unp->un_lowervp);
858 
859 	error = VOP_READ(tvp, ap->a_uio, ap->a_ioflag, ap->a_cred);
860 
861 	/* UNIONFS_INTERNAL_DEBUG("unionfs_read: leave (%d)\n", error); */
862 
863 	return (error);
864 }
865 
866 static int
867 unionfs_write(struct vop_write_args *ap)
868 {
869 	int		error;
870 	struct unionfs_node *unp;
871 	struct vnode   *tvp;
872 
873 	/* UNIONFS_INTERNAL_DEBUG("unionfs_write: enter\n"); */
874 
875 	KASSERT_UNIONFS_VNODE(ap->a_vp);
876 
877 	unp = VTOUNIONFS(ap->a_vp);
878 	tvp = (unp->un_uppervp != NULLVP ? unp->un_uppervp : unp->un_lowervp);
879 
880 	error = VOP_WRITE(tvp, ap->a_uio, ap->a_ioflag, ap->a_cred);
881 
882 	/* UNIONFS_INTERNAL_DEBUG("unionfs_write: leave (%d)\n", error); */
883 
884 	return (error);
885 }
886 
887 static int
888 unionfs_ioctl(struct vop_ioctl_args *ap)
889 {
890 	int error;
891 	struct unionfs_node *unp;
892 	struct unionfs_node_status *unsp;
893 	struct vnode   *ovp;
894 
895 	UNIONFS_INTERNAL_DEBUG("unionfs_ioctl: enter\n");
896 
897 	KASSERT_UNIONFS_VNODE(ap->a_vp);
898 
899  	vn_lock(ap->a_vp, LK_EXCLUSIVE | LK_RETRY);
900 	unp = VTOUNIONFS(ap->a_vp);
901 	unionfs_get_node_status(unp, ap->a_td, &unsp);
902 	ovp = (unsp->uns_upper_opencnt ? unp->un_uppervp : unp->un_lowervp);
903 	unionfs_tryrem_node_status(unp, unsp);
904 	VOP_UNLOCK(ap->a_vp, LK_RELEASE);
905 
906 	if (ovp == NULLVP)
907 		return (EBADF);
908 
909 	error = VOP_IOCTL(ovp, ap->a_command, ap->a_data, ap->a_fflag,
910 	    ap->a_cred, ap->a_td);
911 
912 	UNIONFS_INTERNAL_DEBUG("unionfs_ioctl: leave (%d)\n", error);
913 
914 	return (error);
915 }
916 
917 static int
918 unionfs_poll(struct vop_poll_args *ap)
919 {
920 	struct unionfs_node *unp;
921 	struct unionfs_node_status *unsp;
922 	struct vnode   *ovp;
923 
924 	KASSERT_UNIONFS_VNODE(ap->a_vp);
925 
926  	vn_lock(ap->a_vp, LK_EXCLUSIVE | LK_RETRY);
927 	unp = VTOUNIONFS(ap->a_vp);
928 	unionfs_get_node_status(unp, ap->a_td, &unsp);
929 	ovp = (unsp->uns_upper_opencnt ? unp->un_uppervp : unp->un_lowervp);
930 	unionfs_tryrem_node_status(unp, unsp);
931 	VOP_UNLOCK(ap->a_vp, LK_RELEASE);
932 
933 	if (ovp == NULLVP)
934 		return (EBADF);
935 
936 	return (VOP_POLL(ovp, ap->a_events, ap->a_cred, ap->a_td));
937 }
938 
939 static int
940 unionfs_fsync(struct vop_fsync_args *ap)
941 {
942 	struct unionfs_node *unp;
943 	struct unionfs_node_status *unsp;
944 	struct vnode   *ovp;
945 
946 	KASSERT_UNIONFS_VNODE(ap->a_vp);
947 
948 	unp = VTOUNIONFS(ap->a_vp);
949 	unionfs_get_node_status(unp, ap->a_td, &unsp);
950 	ovp = (unsp->uns_upper_opencnt ? unp->un_uppervp : unp->un_lowervp);
951 	unionfs_tryrem_node_status(unp, unsp);
952 
953 	if (ovp == NULLVP)
954 		return (EBADF);
955 
956 	return (VOP_FSYNC(ovp, ap->a_waitfor, ap->a_td));
957 }
958 
959 static int
960 unionfs_remove(struct vop_remove_args *ap)
961 {
962 	int		error;
963 	char	       *path;
964 	struct unionfs_node *dunp;
965 	struct unionfs_node *unp;
966 	struct unionfs_mount *ump;
967 	struct vnode   *udvp;
968 	struct vnode   *uvp;
969 	struct vnode   *lvp;
970 	struct vnode   *vp;
971 	struct componentname *cnp;
972 	struct componentname cn;
973 	struct thread  *td;
974 
975 	UNIONFS_INTERNAL_DEBUG("unionfs_remove: enter\n");
976 
977 	KASSERT_UNIONFS_VNODE(ap->a_dvp);
978 
979 	error = 0;
980 	dunp = VTOUNIONFS(ap->a_dvp);
981 	udvp = dunp->un_uppervp;
982 	cnp = ap->a_cnp;
983 	td = curthread;
984 
985 	if (ap->a_vp->v_op != &unionfs_vnodeops) {
986 		if (ap->a_vp->v_type != VSOCK)
987 			return (EINVAL);
988 		ump = NULL;
989 		vp = uvp = lvp = NULLVP;
990 		/* search vnode */
991 		VOP_UNLOCK(ap->a_vp, LK_RELEASE);
992 		error = unionfs_relookup(udvp, &vp, cnp, &cn, td,
993 		    cnp->cn_nameptr, strlen(cnp->cn_nameptr), DELETE);
994 		if (error != 0 && error != ENOENT) {
995 			vn_lock(ap->a_vp, LK_EXCLUSIVE | LK_RETRY);
996 			return (error);
997 		}
998 
999 		if (error == 0 && vp == ap->a_vp) {
1000 			/* target vnode in upper */
1001 			uvp = vp;
1002 			vrele(vp);
1003 			path = NULL;
1004 		} else {
1005 			/* target vnode in lower */
1006 			if (vp != NULLVP) {
1007 				if (udvp == vp)
1008 					vrele(vp);
1009 				else
1010 					vput(vp);
1011 			}
1012 			vn_lock(ap->a_vp, LK_EXCLUSIVE | LK_RETRY);
1013 			lvp = ap->a_vp;
1014 			path = ap->a_cnp->cn_nameptr;
1015 		}
1016 	} else {
1017 		ump = MOUNTTOUNIONFSMOUNT(ap->a_vp->v_mount);
1018 		unp = VTOUNIONFS(ap->a_vp);
1019 		uvp = unp->un_uppervp;
1020 		lvp = unp->un_lowervp;
1021 		path = unp->un_path;
1022 	}
1023 
1024 	if (udvp == NULLVP)
1025 		return (EROFS);
1026 
1027 	if (uvp != NULLVP) {
1028 		/*
1029 		 * XXX: if the vnode type is VSOCK, it will create whiteout
1030 		 *      after remove.
1031 		 */
1032 		if (ump == NULL || ump->um_whitemode == UNIONFS_WHITE_ALWAYS ||
1033 		    lvp != NULLVP)
1034 			cnp->cn_flags |= DOWHITEOUT;
1035 		error = VOP_REMOVE(udvp, uvp, cnp);
1036 	} else if (lvp != NULLVP)
1037 		error = unionfs_mkwhiteout(udvp, cnp, td, path);
1038 
1039 	UNIONFS_INTERNAL_DEBUG("unionfs_remove: leave (%d)\n", error);
1040 
1041 	return (error);
1042 }
1043 
1044 static int
1045 unionfs_link(struct vop_link_args *ap)
1046 {
1047 	int		error;
1048 	int		needrelookup;
1049 	struct unionfs_node *dunp;
1050 	struct unionfs_node *unp;
1051 	struct vnode   *udvp;
1052 	struct vnode   *uvp;
1053 	struct componentname *cnp;
1054 	struct thread  *td;
1055 
1056 	UNIONFS_INTERNAL_DEBUG("unionfs_link: enter\n");
1057 
1058 	KASSERT_UNIONFS_VNODE(ap->a_tdvp);
1059 	KASSERT_UNIONFS_VNODE(ap->a_vp);
1060 
1061 	error = 0;
1062 	needrelookup = 0;
1063 	dunp = VTOUNIONFS(ap->a_tdvp);
1064 	unp = NULL;
1065 	udvp = dunp->un_uppervp;
1066 	uvp = NULLVP;
1067 	cnp = ap->a_cnp;
1068 	td = curthread;
1069 
1070 	if (udvp == NULLVP)
1071 		return (EROFS);
1072 
1073 	if (ap->a_vp->v_op != &unionfs_vnodeops)
1074 		uvp = ap->a_vp;
1075 	else {
1076 		unp = VTOUNIONFS(ap->a_vp);
1077 
1078 		if (unp->un_uppervp == NULLVP) {
1079 			if (ap->a_vp->v_type != VREG)
1080 				return (EOPNOTSUPP);
1081 
1082 			error = unionfs_copyfile(unp, 1, cnp->cn_cred, td);
1083 			if (error != 0)
1084 				return (error);
1085 			needrelookup = 1;
1086 		}
1087 		uvp = unp->un_uppervp;
1088 	}
1089 
1090 	if (needrelookup != 0)
1091 		error = unionfs_relookup_for_create(ap->a_tdvp, cnp, td);
1092 
1093 	if (error == 0)
1094 		error = VOP_LINK(udvp, uvp, cnp);
1095 
1096 	UNIONFS_INTERNAL_DEBUG("unionfs_link: leave (%d)\n", error);
1097 
1098 	return (error);
1099 }
1100 
1101 static int
1102 unionfs_rename(struct vop_rename_args *ap)
1103 {
1104 	int		error;
1105 	struct vnode   *fdvp;
1106 	struct vnode   *fvp;
1107 	struct componentname *fcnp;
1108 	struct vnode   *tdvp;
1109 	struct vnode   *tvp;
1110 	struct componentname *tcnp;
1111 	struct vnode   *ltdvp;
1112 	struct vnode   *ltvp;
1113 	struct thread  *td;
1114 
1115 	/* rename target vnodes */
1116 	struct vnode   *rfdvp;
1117 	struct vnode   *rfvp;
1118 	struct vnode   *rtdvp;
1119 	struct vnode   *rtvp;
1120 
1121 	int		needrelookup;
1122 	struct unionfs_mount *ump;
1123 	struct unionfs_node *unp;
1124 
1125 	UNIONFS_INTERNAL_DEBUG("unionfs_rename: enter\n");
1126 
1127 	error = 0;
1128 	fdvp = ap->a_fdvp;
1129 	fvp = ap->a_fvp;
1130 	fcnp = ap->a_fcnp;
1131 	tdvp = ap->a_tdvp;
1132 	tvp = ap->a_tvp;
1133 	tcnp = ap->a_tcnp;
1134 	ltdvp = NULLVP;
1135 	ltvp = NULLVP;
1136 	td = curthread;
1137 	rfdvp = fdvp;
1138 	rfvp = fvp;
1139 	rtdvp = tdvp;
1140 	rtvp = tvp;
1141 	needrelookup = 0;
1142 
1143 #ifdef DIAGNOSTIC
1144 	if (!(fcnp->cn_flags & HASBUF) || !(tcnp->cn_flags & HASBUF))
1145 		panic("unionfs_rename: no name");
1146 #endif
1147 
1148 	/* check for cross device rename */
1149 	if (fvp->v_mount != tdvp->v_mount ||
1150 	    (tvp != NULLVP && fvp->v_mount != tvp->v_mount)) {
1151 		if (fvp->v_op != &unionfs_vnodeops)
1152 			error = ENODEV;
1153 		else
1154 			error = EXDEV;
1155 		goto unionfs_rename_abort;
1156 	}
1157 
1158 	/* Renaming a file to itself has no effect. */
1159 	if (fvp == tvp)
1160 		goto unionfs_rename_abort;
1161 
1162 	/*
1163 	 * from/to vnode is unionfs node.
1164 	 */
1165 
1166 	KASSERT_UNIONFS_VNODE(fdvp);
1167 	KASSERT_UNIONFS_VNODE(fvp);
1168 	KASSERT_UNIONFS_VNODE(tdvp);
1169 	if (tvp != NULLVP)
1170 		KASSERT_UNIONFS_VNODE(tvp);
1171 
1172 	unp = VTOUNIONFS(fdvp);
1173 #ifdef UNIONFS_IDBG_RENAME
1174 	UNIONFS_INTERNAL_DEBUG("fdvp=%p, ufdvp=%p, lfdvp=%p\n", fdvp, unp->un_uppervp, unp->un_lowervp);
1175 #endif
1176 	if (unp->un_uppervp == NULLVP) {
1177 		error = ENODEV;
1178 		goto unionfs_rename_abort;
1179 	}
1180 	rfdvp = unp->un_uppervp;
1181 	vref(rfdvp);
1182 
1183 	unp = VTOUNIONFS(fvp);
1184 #ifdef UNIONFS_IDBG_RENAME
1185 	UNIONFS_INTERNAL_DEBUG("fvp=%p, ufvp=%p, lfvp=%p\n", fvp, unp->un_uppervp, unp->un_lowervp);
1186 #endif
1187 	ump = MOUNTTOUNIONFSMOUNT(fvp->v_mount);
1188 	if (unp->un_uppervp == NULLVP) {
1189 		switch (fvp->v_type) {
1190 		case VREG:
1191 			if ((error = vn_lock(fvp, LK_EXCLUSIVE)) != 0)
1192 				goto unionfs_rename_abort;
1193 			error = unionfs_copyfile(unp, 1, fcnp->cn_cred, td);
1194 			VOP_UNLOCK(fvp, LK_RELEASE);
1195 			if (error != 0)
1196 				goto unionfs_rename_abort;
1197 			break;
1198 		case VDIR:
1199 			if ((error = vn_lock(fvp, LK_EXCLUSIVE)) != 0)
1200 				goto unionfs_rename_abort;
1201 			error = unionfs_mkshadowdir(ump, rfdvp, unp, fcnp, td);
1202 			VOP_UNLOCK(fvp, LK_RELEASE);
1203 			if (error != 0)
1204 				goto unionfs_rename_abort;
1205 			break;
1206 		default:
1207 			error = ENODEV;
1208 			goto unionfs_rename_abort;
1209 		}
1210 
1211 		needrelookup = 1;
1212 	}
1213 
1214 	if (unp->un_lowervp != NULLVP)
1215 		fcnp->cn_flags |= DOWHITEOUT;
1216 	rfvp = unp->un_uppervp;
1217 	vref(rfvp);
1218 
1219 	unp = VTOUNIONFS(tdvp);
1220 #ifdef UNIONFS_IDBG_RENAME
1221 	UNIONFS_INTERNAL_DEBUG("tdvp=%p, utdvp=%p, ltdvp=%p\n", tdvp, unp->un_uppervp, unp->un_lowervp);
1222 #endif
1223 	if (unp->un_uppervp == NULLVP) {
1224 		error = ENODEV;
1225 		goto unionfs_rename_abort;
1226 	}
1227 	rtdvp = unp->un_uppervp;
1228 	ltdvp = unp->un_lowervp;
1229 	vref(rtdvp);
1230 
1231 	if (tdvp == tvp) {
1232 		rtvp = rtdvp;
1233 		vref(rtvp);
1234 	} else if (tvp != NULLVP) {
1235 		unp = VTOUNIONFS(tvp);
1236 #ifdef UNIONFS_IDBG_RENAME
1237 		UNIONFS_INTERNAL_DEBUG("tvp=%p, utvp=%p, ltvp=%p\n", tvp, unp->un_uppervp, unp->un_lowervp);
1238 #endif
1239 		if (unp->un_uppervp == NULLVP)
1240 			rtvp = NULLVP;
1241 		else {
1242 			if (tvp->v_type == VDIR) {
1243 				error = EINVAL;
1244 				goto unionfs_rename_abort;
1245 			}
1246 			rtvp = unp->un_uppervp;
1247 			ltvp = unp->un_lowervp;
1248 			vref(rtvp);
1249 		}
1250 	}
1251 
1252 	if (rfvp == rtvp)
1253 		goto unionfs_rename_abort;
1254 
1255 	if (needrelookup != 0) {
1256 		if ((error = vn_lock(fdvp, LK_EXCLUSIVE)) != 0)
1257 			goto unionfs_rename_abort;
1258 		error = unionfs_relookup_for_delete(fdvp, fcnp, td);
1259 		VOP_UNLOCK(fdvp, LK_RELEASE);
1260 		if (error != 0)
1261 			goto unionfs_rename_abort;
1262 
1263 		/* Locke of tvp is canceled in order to avoid recursive lock. */
1264 		if (tvp != NULLVP && tvp != tdvp)
1265 			VOP_UNLOCK(tvp, LK_RELEASE);
1266 		error = unionfs_relookup_for_rename(tdvp, tcnp, td);
1267 		if (tvp != NULLVP && tvp != tdvp)
1268 			vn_lock(tvp, LK_EXCLUSIVE | LK_RETRY);
1269 		if (error != 0)
1270 			goto unionfs_rename_abort;
1271 	}
1272 
1273 	error = VOP_RENAME(rfdvp, rfvp, fcnp, rtdvp, rtvp, tcnp);
1274 
1275 	if (error == 0) {
1276 		if (rtvp != NULLVP && rtvp->v_type == VDIR)
1277 			cache_purge(tdvp);
1278 		if (fvp->v_type == VDIR && fdvp != tdvp)
1279 			cache_purge(fdvp);
1280 	}
1281 
1282 	if (ltdvp != NULLVP)
1283 		VOP_UNLOCK(ltdvp, LK_RELEASE);
1284 	if (tdvp != rtdvp)
1285 		vrele(tdvp);
1286 	if (ltvp != NULLVP)
1287 		VOP_UNLOCK(ltvp, LK_RELEASE);
1288 	if (tvp != rtvp && tvp != NULLVP) {
1289 		if (rtvp == NULLVP)
1290 			vput(tvp);
1291 		else
1292 			vrele(tvp);
1293 	}
1294 	if (fdvp != rfdvp)
1295 		vrele(fdvp);
1296 	if (fvp != rfvp)
1297 		vrele(fvp);
1298 
1299 	UNIONFS_INTERNAL_DEBUG("unionfs_rename: leave (%d)\n", error);
1300 
1301 	return (error);
1302 
1303 unionfs_rename_abort:
1304 	vput(tdvp);
1305 	if (tdvp != rtdvp)
1306 		vrele(rtdvp);
1307 	if (tvp != NULLVP) {
1308 		if (tdvp != tvp)
1309 			vput(tvp);
1310 		else
1311 			vrele(tvp);
1312 	}
1313 	if (tvp != rtvp && rtvp != NULLVP)
1314 		vrele(rtvp);
1315 	if (fdvp != rfdvp)
1316 		vrele(rfdvp);
1317 	if (fvp != rfvp)
1318 		vrele(rfvp);
1319 	vrele(fdvp);
1320 	vrele(fvp);
1321 
1322 	UNIONFS_INTERNAL_DEBUG("unionfs_rename: leave (%d)\n", error);
1323 
1324 	return (error);
1325 }
1326 
1327 static int
1328 unionfs_mkdir(struct vop_mkdir_args *ap)
1329 {
1330 	int		error;
1331 	int		lkflags;
1332 	struct unionfs_node *dunp;
1333 	struct componentname *cnp;
1334 	struct thread  *td;
1335 	struct vnode   *udvp;
1336 	struct vnode   *uvp;
1337 	struct vattr	va;
1338 
1339 	UNIONFS_INTERNAL_DEBUG("unionfs_mkdir: enter\n");
1340 
1341 	KASSERT_UNIONFS_VNODE(ap->a_dvp);
1342 
1343 	error = EROFS;
1344 	dunp = VTOUNIONFS(ap->a_dvp);
1345 	cnp = ap->a_cnp;
1346 	lkflags = cnp->cn_lkflags;
1347 	td = curthread;
1348 	udvp = dunp->un_uppervp;
1349 
1350 	if (udvp != NULLVP) {
1351 		/* check opaque */
1352 		if (!(cnp->cn_flags & ISWHITEOUT)) {
1353 			error = VOP_GETATTR(udvp, &va, cnp->cn_cred);
1354 			if (error != 0)
1355 				return (error);
1356 			if (va.va_flags & OPAQUE)
1357 				cnp->cn_flags |= ISWHITEOUT;
1358 		}
1359 
1360 		if ((error = VOP_MKDIR(udvp, &uvp, cnp, ap->a_vap)) == 0) {
1361 			VOP_UNLOCK(uvp, LK_RELEASE);
1362 			cnp->cn_lkflags = LK_EXCLUSIVE;
1363 			error = unionfs_nodeget(ap->a_dvp->v_mount, uvp, NULLVP,
1364 			    ap->a_dvp, ap->a_vpp, cnp, td);
1365 			cnp->cn_lkflags = lkflags;
1366 			vrele(uvp);
1367 		}
1368 	}
1369 
1370 	UNIONFS_INTERNAL_DEBUG("unionfs_mkdir: leave (%d)\n", error);
1371 
1372 	return (error);
1373 }
1374 
1375 static int
1376 unionfs_rmdir(struct vop_rmdir_args *ap)
1377 {
1378 	int		error;
1379 	struct unionfs_node *dunp;
1380 	struct unionfs_node *unp;
1381 	struct unionfs_mount *ump;
1382 	struct componentname *cnp;
1383 	struct thread  *td;
1384 	struct vnode   *udvp;
1385 	struct vnode   *uvp;
1386 	struct vnode   *lvp;
1387 
1388 	UNIONFS_INTERNAL_DEBUG("unionfs_rmdir: enter\n");
1389 
1390 	KASSERT_UNIONFS_VNODE(ap->a_dvp);
1391 	KASSERT_UNIONFS_VNODE(ap->a_vp);
1392 
1393 	error = 0;
1394 	dunp = VTOUNIONFS(ap->a_dvp);
1395 	unp = VTOUNIONFS(ap->a_vp);
1396 	cnp = ap->a_cnp;
1397 	td = curthread;
1398 	udvp = dunp->un_uppervp;
1399 	uvp = unp->un_uppervp;
1400 	lvp = unp->un_lowervp;
1401 
1402 	if (udvp == NULLVP)
1403 		return (EROFS);
1404 
1405 	if (udvp == uvp)
1406 		return (EOPNOTSUPP);
1407 
1408 	if (uvp != NULLVP) {
1409 		if (lvp != NULLVP) {
1410 			error = unionfs_check_rmdir(ap->a_vp, cnp->cn_cred, td);
1411 			if (error != 0)
1412 				return (error);
1413 		}
1414 		ump = MOUNTTOUNIONFSMOUNT(ap->a_vp->v_mount);
1415 		if (ump->um_whitemode == UNIONFS_WHITE_ALWAYS || lvp != NULLVP)
1416 			cnp->cn_flags |= DOWHITEOUT;
1417 		error = unionfs_relookup_for_delete(ap->a_dvp, cnp, td);
1418 		if (!error)
1419 			error = VOP_RMDIR(udvp, uvp, cnp);
1420 	}
1421 	else if (lvp != NULLVP)
1422 		error = unionfs_mkwhiteout(udvp, cnp, td, unp->un_path);
1423 
1424 	if (error == 0) {
1425 		cache_purge(ap->a_dvp);
1426 		cache_purge(ap->a_vp);
1427 	}
1428 
1429 	UNIONFS_INTERNAL_DEBUG("unionfs_rmdir: leave (%d)\n", error);
1430 
1431 	return (error);
1432 }
1433 
1434 static int
1435 unionfs_symlink(struct vop_symlink_args *ap)
1436 {
1437 	int		error;
1438 	int		lkflags;
1439 	struct unionfs_node *dunp;
1440 	struct componentname *cnp;
1441 	struct thread  *td;
1442 	struct vnode   *udvp;
1443 	struct vnode   *uvp;
1444 
1445 	UNIONFS_INTERNAL_DEBUG("unionfs_symlink: enter\n");
1446 
1447 	KASSERT_UNIONFS_VNODE(ap->a_dvp);
1448 
1449 	error = EROFS;
1450 	dunp = VTOUNIONFS(ap->a_dvp);
1451 	cnp = ap->a_cnp;
1452 	lkflags = cnp->cn_lkflags;
1453 	td = curthread;
1454 	udvp = dunp->un_uppervp;
1455 
1456 	if (udvp != NULLVP) {
1457 		error = VOP_SYMLINK(udvp, &uvp, cnp, ap->a_vap, ap->a_target);
1458 		if (error == 0) {
1459 			VOP_UNLOCK(uvp, LK_RELEASE);
1460 			cnp->cn_lkflags = LK_EXCLUSIVE;
1461 			error = unionfs_nodeget(ap->a_dvp->v_mount, uvp, NULLVP,
1462 			    ap->a_dvp, ap->a_vpp, cnp, td);
1463 			cnp->cn_lkflags = lkflags;
1464 			vrele(uvp);
1465 		}
1466 	}
1467 
1468 	UNIONFS_INTERNAL_DEBUG("unionfs_symlink: leave (%d)\n", error);
1469 
1470 	return (error);
1471 }
1472 
1473 static int
1474 unionfs_readdir(struct vop_readdir_args *ap)
1475 {
1476 	int		error;
1477 	int		eofflag;
1478 	int		locked;
1479 	int		uio_offset_bk;
1480 	struct unionfs_node *unp;
1481 	struct unionfs_node_status *unsp;
1482 	struct uio     *uio;
1483 	struct vnode   *vp;
1484 	struct vnode   *uvp;
1485 	struct vnode   *lvp;
1486 	struct thread  *td;
1487 	struct vattr    va;
1488 
1489 	int		ncookies_bk;
1490 	u_long         *cookies_bk;
1491 
1492 	UNIONFS_INTERNAL_DEBUG("unionfs_readdir: enter\n");
1493 
1494 	KASSERT_UNIONFS_VNODE(ap->a_vp);
1495 
1496 	error = 0;
1497 	eofflag = 0;
1498 	locked = 0;
1499 	uio_offset_bk = 0;
1500 	uio = ap->a_uio;
1501 	uvp = NULLVP;
1502 	lvp = NULLVP;
1503 	td = uio->uio_td;
1504 	ncookies_bk = 0;
1505 	cookies_bk = NULL;
1506 
1507 	vp = ap->a_vp;
1508 	if (vp->v_type != VDIR)
1509 		return (ENOTDIR);
1510 
1511 	/* check the open count. unionfs needs to open before readdir. */
1512 	if (VOP_ISLOCKED(vp) != LK_EXCLUSIVE) {
1513 		if (vn_lock(vp, LK_UPGRADE) != 0)
1514 			vn_lock(vp, LK_EXCLUSIVE | LK_RETRY);
1515 		locked = 1;
1516 	}
1517 	unp = VTOUNIONFS(vp);
1518 	if (unp == NULL)
1519 		error = EBADF;
1520 	else {
1521 		uvp = unp->un_uppervp;
1522 		lvp = unp->un_lowervp;
1523 		unionfs_get_node_status(unp, td, &unsp);
1524 		if ((uvp != NULLVP && unsp->uns_upper_opencnt <= 0) ||
1525 			(lvp != NULLVP && unsp->uns_lower_opencnt <= 0)) {
1526 			unionfs_tryrem_node_status(unp, unsp);
1527 			error = EBADF;
1528 		}
1529 	}
1530 	if (locked)
1531 		vn_lock(vp, LK_DOWNGRADE | LK_RETRY);
1532 	if (error != 0)
1533 		goto unionfs_readdir_exit;
1534 
1535 	/* check opaque */
1536 	if (uvp != NULLVP && lvp != NULLVP) {
1537 		if ((error = VOP_GETATTR(uvp, &va, ap->a_cred)) != 0)
1538 			goto unionfs_readdir_exit;
1539 		if (va.va_flags & OPAQUE)
1540 			lvp = NULLVP;
1541 	}
1542 
1543 	/* upper only */
1544 	if (uvp != NULLVP && lvp == NULLVP) {
1545 		error = VOP_READDIR(uvp, uio, ap->a_cred, ap->a_eofflag,
1546 		    ap->a_ncookies, ap->a_cookies);
1547 		unsp->uns_readdir_status = 0;
1548 
1549 		goto unionfs_readdir_exit;
1550 	}
1551 
1552 	/* lower only */
1553 	if (uvp == NULLVP && lvp != NULLVP) {
1554 		error = VOP_READDIR(lvp, uio, ap->a_cred, ap->a_eofflag,
1555 		    ap->a_ncookies, ap->a_cookies);
1556 		unsp->uns_readdir_status = 2;
1557 
1558 		goto unionfs_readdir_exit;
1559 	}
1560 
1561 	/*
1562 	 * readdir upper and lower
1563 	 */
1564 	KASSERT(uvp != NULLVP, ("unionfs_readdir: null upper vp"));
1565 	KASSERT(lvp != NULLVP, ("unionfs_readdir: null lower vp"));
1566 	if (uio->uio_offset == 0)
1567 		unsp->uns_readdir_status = 0;
1568 
1569 	if (unsp->uns_readdir_status == 0) {
1570 		/* read upper */
1571 		error = VOP_READDIR(uvp, uio, ap->a_cred, &eofflag,
1572 				    ap->a_ncookies, ap->a_cookies);
1573 
1574 		if (error != 0 || eofflag == 0)
1575 			goto unionfs_readdir_exit;
1576 		unsp->uns_readdir_status = 1;
1577 
1578 		/*
1579 		 * UFS(and other FS) needs size of uio_resid larger than
1580 		 * DIRBLKSIZ.
1581 		 * size of DIRBLKSIZ equals DEV_BSIZE.
1582 		 * (see: ufs/ufs/ufs_vnops.c ufs_readdir func , ufs/ufs/dir.h)
1583 		 */
1584 		if (uio->uio_resid <= (uio->uio_resid & (DEV_BSIZE -1)))
1585 			goto unionfs_readdir_exit;
1586 
1587 		/*
1588 		 * Backup cookies.
1589 		 * It prepares to readdir in lower.
1590 		 */
1591 		if (ap->a_ncookies != NULL) {
1592 			ncookies_bk = *(ap->a_ncookies);
1593 			*(ap->a_ncookies) = 0;
1594 		}
1595 		if (ap->a_cookies != NULL) {
1596 			cookies_bk = *(ap->a_cookies);
1597 			*(ap->a_cookies) = NULL;
1598 		}
1599 	}
1600 
1601 	/* initialize for readdir in lower */
1602 	if (unsp->uns_readdir_status == 1) {
1603 		unsp->uns_readdir_status = 2;
1604 		/*
1605 		 * Backup uio_offset. See the comment after the
1606 		 * VOP_READDIR call on the lower layer.
1607 		 */
1608 		uio_offset_bk = uio->uio_offset;
1609 		uio->uio_offset = 0;
1610 	}
1611 
1612 	if (lvp == NULLVP) {
1613 		error = EBADF;
1614 		goto unionfs_readdir_exit;
1615 	}
1616 	/* read lower */
1617 	error = VOP_READDIR(lvp, uio, ap->a_cred, ap->a_eofflag,
1618 			    ap->a_ncookies, ap->a_cookies);
1619 
1620 	/*
1621 	 * We can't return an uio_offset of 0: this would trigger an
1622 	 * infinite loop, because the next call to unionfs_readdir would
1623 	 * always restart with the upper layer (uio_offset == 0) and
1624 	 * always return some data.
1625 	 *
1626 	 * This happens when the lower layer root directory is removed.
1627 	 * (A root directory deleting of unionfs should not be permitted.
1628 	 *  But current VFS can not do it.)
1629 	 */
1630 	if (uio->uio_offset == 0)
1631 		uio->uio_offset = uio_offset_bk;
1632 
1633 	if (cookies_bk != NULL) {
1634 		/* merge cookies */
1635 		int		size;
1636 		u_long         *newcookies, *pos;
1637 
1638 		size = *(ap->a_ncookies) + ncookies_bk;
1639 		newcookies = (u_long *) malloc(size * sizeof(u_long),
1640 		    M_TEMP, M_WAITOK);
1641 		pos = newcookies;
1642 
1643 		memcpy(pos, cookies_bk, ncookies_bk * sizeof(u_long));
1644 		pos += ncookies_bk;
1645 		memcpy(pos, *(ap->a_cookies), *(ap->a_ncookies) * sizeof(u_long));
1646 		free(cookies_bk, M_TEMP);
1647 		free(*(ap->a_cookies), M_TEMP);
1648 		*(ap->a_ncookies) = size;
1649 		*(ap->a_cookies) = newcookies;
1650 	}
1651 
1652 unionfs_readdir_exit:
1653 	if (error != 0 && ap->a_eofflag != NULL)
1654 		*(ap->a_eofflag) = 1;
1655 
1656 	UNIONFS_INTERNAL_DEBUG("unionfs_readdir: leave (%d)\n", error);
1657 
1658 	return (error);
1659 }
1660 
1661 static int
1662 unionfs_readlink(struct vop_readlink_args *ap)
1663 {
1664 	int error;
1665 	struct unionfs_node *unp;
1666 	struct vnode   *vp;
1667 
1668 	UNIONFS_INTERNAL_DEBUG("unionfs_readlink: enter\n");
1669 
1670 	KASSERT_UNIONFS_VNODE(ap->a_vp);
1671 
1672 	unp = VTOUNIONFS(ap->a_vp);
1673 	vp = (unp->un_uppervp != NULLVP ? unp->un_uppervp : unp->un_lowervp);
1674 
1675 	error = VOP_READLINK(vp, ap->a_uio, ap->a_cred);
1676 
1677 	UNIONFS_INTERNAL_DEBUG("unionfs_readlink: leave (%d)\n", error);
1678 
1679 	return (error);
1680 }
1681 
1682 static int
1683 unionfs_getwritemount(struct vop_getwritemount_args *ap)
1684 {
1685 	int		error;
1686 	struct vnode   *uvp;
1687 	struct vnode   *vp;
1688 
1689 	UNIONFS_INTERNAL_DEBUG("unionfs_getwritemount: enter\n");
1690 
1691 	error = 0;
1692 	vp = ap->a_vp;
1693 
1694 	if (vp == NULLVP || (vp->v_mount->mnt_flag & MNT_RDONLY))
1695 		return (EACCES);
1696 
1697 	KASSERT_UNIONFS_VNODE(vp);
1698 
1699 	uvp = UNIONFSVPTOUPPERVP(vp);
1700 	if (uvp == NULLVP && VREG == vp->v_type)
1701 		uvp = UNIONFSVPTOUPPERVP(VTOUNIONFS(vp)->un_dvp);
1702 
1703 	if (uvp != NULLVP)
1704 		error = VOP_GETWRITEMOUNT(uvp, ap->a_mpp);
1705 	else {
1706 		VI_LOCK(vp);
1707 		if (vp->v_iflag & VI_FREE)
1708 			error = EOPNOTSUPP;
1709 		else
1710 			error = EACCES;
1711 		VI_UNLOCK(vp);
1712 	}
1713 
1714 	UNIONFS_INTERNAL_DEBUG("unionfs_getwritemount: leave (%d)\n", error);
1715 
1716 	return (error);
1717 }
1718 
1719 static int
1720 unionfs_inactive(struct vop_inactive_args *ap)
1721 {
1722 	ap->a_vp->v_object = NULL;
1723 	vrecycle(ap->a_vp);
1724 	return (0);
1725 }
1726 
1727 static int
1728 unionfs_reclaim(struct vop_reclaim_args *ap)
1729 {
1730 	/* UNIONFS_INTERNAL_DEBUG("unionfs_reclaim: enter\n"); */
1731 
1732 	unionfs_noderem(ap->a_vp, ap->a_td);
1733 
1734 	/* UNIONFS_INTERNAL_DEBUG("unionfs_reclaim: leave\n"); */
1735 
1736 	return (0);
1737 }
1738 
1739 static int
1740 unionfs_print(struct vop_print_args *ap)
1741 {
1742 	struct unionfs_node *unp;
1743 	/* struct unionfs_node_status *unsp; */
1744 
1745 	unp = VTOUNIONFS(ap->a_vp);
1746 	/* unionfs_get_node_status(unp, curthread, &unsp); */
1747 
1748 	printf("unionfs_vp=%p, uppervp=%p, lowervp=%p\n",
1749 	    ap->a_vp, unp->un_uppervp, unp->un_lowervp);
1750 	/*
1751 	printf("unionfs opencnt: uppervp=%d, lowervp=%d\n",
1752 	    unsp->uns_upper_opencnt, unsp->uns_lower_opencnt);
1753 	*/
1754 
1755 	if (unp->un_uppervp != NULLVP)
1756 		vprint("unionfs: upper", unp->un_uppervp);
1757 	if (unp->un_lowervp != NULLVP)
1758 		vprint("unionfs: lower", unp->un_lowervp);
1759 
1760 	return (0);
1761 }
1762 
1763 static int
1764 unionfs_islocked(struct vop_islocked_args *ap)
1765 {
1766 	struct unionfs_node *unp;
1767 
1768 	KASSERT_UNIONFS_VNODE(ap->a_vp);
1769 
1770 	unp = VTOUNIONFS(ap->a_vp);
1771 	if (unp == NULL)
1772 		return (vop_stdislocked(ap));
1773 
1774 	if (unp->un_uppervp != NULLVP)
1775 		return (VOP_ISLOCKED(unp->un_uppervp));
1776 	if (unp->un_lowervp != NULLVP)
1777 		return (VOP_ISLOCKED(unp->un_lowervp));
1778 	return (vop_stdislocked(ap));
1779 }
1780 
1781 static int
1782 unionfs_get_llt_revlock(struct vnode *vp, int flags)
1783 {
1784 	int revlock;
1785 
1786 	revlock = 0;
1787 
1788 	switch (flags & LK_TYPE_MASK) {
1789 	case LK_SHARED:
1790 		if (VOP_ISLOCKED(vp) == LK_EXCLUSIVE)
1791 			revlock = LK_UPGRADE;
1792 		else
1793 			revlock = LK_RELEASE;
1794 		break;
1795 	case LK_EXCLUSIVE:
1796 	case LK_UPGRADE:
1797 		revlock = LK_RELEASE;
1798 		break;
1799 	case LK_DOWNGRADE:
1800 		revlock = LK_UPGRADE;
1801 		break;
1802 	default:
1803 		break;
1804 	}
1805 
1806 	return (revlock);
1807 }
1808 
1809 /*
1810  * The state of an acquired lock is adjusted similarly to
1811  * the time of error generating.
1812  * flags: LK_RELEASE or LK_UPGRADE
1813  */
1814 static void
1815 unionfs_revlock(struct vnode *vp, int flags)
1816 {
1817 	if (flags & LK_RELEASE)
1818 		VOP_UNLOCK(vp, flags);
1819 	else {
1820 		/* UPGRADE */
1821 		if (vn_lock(vp, flags) != 0)
1822 			vn_lock(vp, LK_EXCLUSIVE | LK_RETRY);
1823 	}
1824 }
1825 
1826 static int
1827 unionfs_lock(struct vop_lock1_args *ap)
1828 {
1829 	int		error;
1830 	int		flags;
1831 	int		revlock;
1832 	int		interlock;
1833 	int		uhold;
1834 	struct mount   *mp;
1835 	struct unionfs_mount *ump;
1836 	struct unionfs_node *unp;
1837 	struct vnode   *vp;
1838 	struct vnode   *uvp;
1839 	struct vnode   *lvp;
1840 
1841 	KASSERT_UNIONFS_VNODE(ap->a_vp);
1842 
1843 	error = 0;
1844 	interlock = 1;
1845 	uhold = 0;
1846 	flags = ap->a_flags;
1847 	vp = ap->a_vp;
1848 
1849 	if (LK_RELEASE == (flags & LK_TYPE_MASK) || !(flags & LK_TYPE_MASK))
1850 		return (VOP_UNLOCK(vp, flags | LK_RELEASE));
1851 
1852 	if ((flags & LK_INTERLOCK) == 0)
1853 		VI_LOCK(vp);
1854 
1855 	mp = vp->v_mount;
1856 	if (mp == NULL)
1857 		goto unionfs_lock_null_vnode;
1858 
1859 	ump = MOUNTTOUNIONFSMOUNT(mp);
1860 	unp = VTOUNIONFS(vp);
1861 	if (ump == NULL || unp == NULL)
1862 		goto unionfs_lock_null_vnode;
1863 	lvp = unp->un_lowervp;
1864 	uvp = unp->un_uppervp;
1865 
1866 	if ((revlock = unionfs_get_llt_revlock(vp, flags)) == 0)
1867 		panic("unknown lock type: 0x%x", flags & LK_TYPE_MASK);
1868 
1869 	if ((vp->v_iflag & VI_OWEINACT) != 0)
1870 		flags |= LK_NOWAIT;
1871 
1872 	/*
1873 	 * Sometimes, lower or upper is already exclusive locked.
1874 	 * (ex. vfs_domount: mounted vnode is already locked.)
1875 	 */
1876 	if ((flags & LK_TYPE_MASK) == LK_EXCLUSIVE &&
1877 	    vp == ump->um_rootvp)
1878 		flags |= LK_CANRECURSE;
1879 
1880 	if (lvp != NULLVP) {
1881 		if (uvp != NULLVP && flags & LK_UPGRADE) {
1882 			/* Share Lock is once released and a deadlock is avoided.  */
1883 			VI_LOCK_FLAGS(uvp, MTX_DUPOK);
1884 			vholdl(uvp);
1885 			uhold = 1;
1886 			VI_UNLOCK(vp);
1887 			VOP_UNLOCK(uvp, LK_RELEASE | LK_INTERLOCK);
1888 			VI_LOCK(vp);
1889 			unp = VTOUNIONFS(vp);
1890 			if (unp == NULL) {
1891 				/* vnode is released. */
1892 				VI_UNLOCK(vp);
1893 				VOP_UNLOCK(lvp, LK_RELEASE);
1894 				vdrop(uvp);
1895 				return (EBUSY);
1896 			}
1897 		}
1898 		VI_LOCK_FLAGS(lvp, MTX_DUPOK);
1899 		flags |= LK_INTERLOCK;
1900 		vholdl(lvp);
1901 
1902 		VI_UNLOCK(vp);
1903 		ap->a_flags &= ~LK_INTERLOCK;
1904 
1905 		error = VOP_LOCK(lvp, flags);
1906 
1907 		VI_LOCK(vp);
1908 		unp = VTOUNIONFS(vp);
1909 		if (unp == NULL) {
1910 			/* vnode is released. */
1911 			VI_UNLOCK(vp);
1912 			if (error == 0)
1913 				VOP_UNLOCK(lvp, LK_RELEASE);
1914 			vdrop(lvp);
1915 			if (uhold != 0)
1916 				vdrop(uvp);
1917 			return (vop_stdlock(ap));
1918 		}
1919 	}
1920 
1921 	if (error == 0 && uvp != NULLVP) {
1922 		if (uhold && flags & LK_UPGRADE) {
1923 			flags &= ~LK_TYPE_MASK;
1924 			flags |= LK_EXCLUSIVE;
1925 		}
1926 		VI_LOCK_FLAGS(uvp, MTX_DUPOK);
1927 		flags |= LK_INTERLOCK;
1928 		if (uhold == 0) {
1929 			vholdl(uvp);
1930 			uhold = 1;
1931 		}
1932 
1933 		VI_UNLOCK(vp);
1934 		ap->a_flags &= ~LK_INTERLOCK;
1935 
1936 		error = VOP_LOCK(uvp, flags);
1937 
1938 		VI_LOCK(vp);
1939 		unp = VTOUNIONFS(vp);
1940 		if (unp == NULL) {
1941 			/* vnode is released. */
1942 			VI_UNLOCK(vp);
1943 			if (error == 0)
1944 				VOP_UNLOCK(uvp, LK_RELEASE);
1945 			vdrop(uvp);
1946 			if (lvp != NULLVP) {
1947 				VOP_UNLOCK(lvp, LK_RELEASE);
1948 				vdrop(lvp);
1949 			}
1950 			return (vop_stdlock(ap));
1951 		}
1952 		if (error != 0 && lvp != NULLVP) {
1953 			/* rollback */
1954 			VI_UNLOCK(vp);
1955 			unionfs_revlock(lvp, revlock);
1956 			interlock = 0;
1957 		}
1958 	}
1959 
1960 	if (interlock)
1961 		VI_UNLOCK(vp);
1962 	if (lvp != NULLVP)
1963 		vdrop(lvp);
1964 	if (uhold != 0)
1965 		vdrop(uvp);
1966 
1967 	return (error);
1968 
1969 unionfs_lock_null_vnode:
1970 	ap->a_flags |= LK_INTERLOCK;
1971 	return (vop_stdlock(ap));
1972 }
1973 
1974 static int
1975 unionfs_unlock(struct vop_unlock_args *ap)
1976 {
1977 	int		error;
1978 	int		flags;
1979 	int		mtxlkflag;
1980 	int		uhold;
1981 	struct vnode   *vp;
1982 	struct vnode   *lvp;
1983 	struct vnode   *uvp;
1984 	struct unionfs_node *unp;
1985 
1986 	KASSERT_UNIONFS_VNODE(ap->a_vp);
1987 
1988 	error = 0;
1989 	mtxlkflag = 0;
1990 	uhold = 0;
1991 	flags = ap->a_flags | LK_RELEASE;
1992 	vp = ap->a_vp;
1993 
1994 	if ((flags & LK_INTERLOCK) != 0)
1995 		mtxlkflag = 1;
1996 	else if (mtx_owned(VI_MTX(vp)) == 0) {
1997 		VI_LOCK(vp);
1998 		mtxlkflag = 2;
1999 	}
2000 
2001 	unp = VTOUNIONFS(vp);
2002 	if (unp == NULL)
2003 		goto unionfs_unlock_null_vnode;
2004 	lvp = unp->un_lowervp;
2005 	uvp = unp->un_uppervp;
2006 
2007 	if (lvp != NULLVP) {
2008 		VI_LOCK_FLAGS(lvp, MTX_DUPOK);
2009 		flags |= LK_INTERLOCK;
2010 		vholdl(lvp);
2011 
2012 		VI_UNLOCK(vp);
2013 		ap->a_flags &= ~LK_INTERLOCK;
2014 
2015 		error = VOP_UNLOCK(lvp, flags);
2016 
2017 		VI_LOCK(vp);
2018 	}
2019 
2020 	if (error == 0 && uvp != NULLVP) {
2021 		VI_LOCK_FLAGS(uvp, MTX_DUPOK);
2022 		flags |= LK_INTERLOCK;
2023 		vholdl(uvp);
2024 		uhold = 1;
2025 
2026 		VI_UNLOCK(vp);
2027 		ap->a_flags &= ~LK_INTERLOCK;
2028 
2029 		error = VOP_UNLOCK(uvp, flags);
2030 
2031 		VI_LOCK(vp);
2032 	}
2033 
2034 	VI_UNLOCK(vp);
2035 	if (lvp != NULLVP)
2036 		vdrop(lvp);
2037 	if (uhold != 0)
2038 		vdrop(uvp);
2039 	if (mtxlkflag == 0)
2040 		VI_LOCK(vp);
2041 
2042 	return error;
2043 
2044 unionfs_unlock_null_vnode:
2045 	if (mtxlkflag == 2)
2046 		VI_UNLOCK(vp);
2047 	return (vop_stdunlock(ap));
2048 }
2049 
2050 static int
2051 unionfs_pathconf(struct vop_pathconf_args *ap)
2052 {
2053 	struct unionfs_node *unp;
2054 	struct vnode   *vp;
2055 
2056 	KASSERT_UNIONFS_VNODE(ap->a_vp);
2057 
2058 	unp = VTOUNIONFS(ap->a_vp);
2059 	vp = (unp->un_uppervp != NULLVP ? unp->un_uppervp : unp->un_lowervp);
2060 
2061 	return (VOP_PATHCONF(vp, ap->a_name, ap->a_retval));
2062 }
2063 
2064 static int
2065 unionfs_advlock(struct vop_advlock_args *ap)
2066 {
2067 	int error;
2068 	struct unionfs_node *unp;
2069 	struct unionfs_node_status *unsp;
2070 	struct vnode   *vp;
2071 	struct vnode   *uvp;
2072 	struct thread  *td;
2073 
2074 	UNIONFS_INTERNAL_DEBUG("unionfs_advlock: enter\n");
2075 
2076 	KASSERT_UNIONFS_VNODE(ap->a_vp);
2077 
2078 	vp = ap->a_vp;
2079 	td = curthread;
2080 
2081 	vn_lock(vp, LK_EXCLUSIVE | LK_RETRY);
2082 
2083 	unp = VTOUNIONFS(ap->a_vp);
2084 	uvp = unp->un_uppervp;
2085 
2086 	if (uvp == NULLVP) {
2087 		error = unionfs_copyfile(unp, 1, td->td_ucred, td);
2088 		if (error != 0)
2089 			goto unionfs_advlock_abort;
2090 		uvp = unp->un_uppervp;
2091 
2092 		unionfs_get_node_status(unp, td, &unsp);
2093 		if (unsp->uns_lower_opencnt > 0) {
2094 			/* try reopen the vnode */
2095 			error = VOP_OPEN(uvp, unsp->uns_lower_openmode,
2096 				td->td_ucred, td, NULL);
2097 			if (error)
2098 				goto unionfs_advlock_abort;
2099 			unsp->uns_upper_opencnt++;
2100 			VOP_CLOSE(unp->un_lowervp, unsp->uns_lower_openmode, td->td_ucred, td);
2101 			unsp->uns_lower_opencnt--;
2102 		} else
2103 			unionfs_tryrem_node_status(unp, unsp);
2104 	}
2105 
2106 	VOP_UNLOCK(vp, LK_RELEASE);
2107 
2108 	error = VOP_ADVLOCK(uvp, ap->a_id, ap->a_op, ap->a_fl, ap->a_flags);
2109 
2110 	UNIONFS_INTERNAL_DEBUG("unionfs_advlock: leave (%d)\n", error);
2111 
2112 	return error;
2113 
2114 unionfs_advlock_abort:
2115 	VOP_UNLOCK(vp, LK_RELEASE);
2116 
2117 	UNIONFS_INTERNAL_DEBUG("unionfs_advlock: leave (%d)\n", error);
2118 
2119 	return error;
2120 }
2121 
2122 static int
2123 unionfs_strategy(struct vop_strategy_args *ap)
2124 {
2125 	struct unionfs_node *unp;
2126 	struct vnode   *vp;
2127 
2128 	KASSERT_UNIONFS_VNODE(ap->a_vp);
2129 
2130 	unp = VTOUNIONFS(ap->a_vp);
2131 	vp = (unp->un_uppervp != NULLVP ? unp->un_uppervp : unp->un_lowervp);
2132 
2133 #ifdef DIAGNOSTIC
2134 	if (vp == NULLVP)
2135 		panic("unionfs_strategy: nullvp");
2136 
2137 	if (ap->a_bp->b_iocmd == BIO_WRITE && vp == unp->un_lowervp)
2138 		panic("unionfs_strategy: writing to lowervp");
2139 #endif
2140 
2141 	return (VOP_STRATEGY(vp, ap->a_bp));
2142 }
2143 
2144 static int
2145 unionfs_getacl(struct vop_getacl_args *ap)
2146 {
2147 	int		error;
2148 	struct unionfs_node *unp;
2149 	struct vnode   *vp;
2150 
2151 	KASSERT_UNIONFS_VNODE(ap->a_vp);
2152 
2153 	unp = VTOUNIONFS(ap->a_vp);
2154 	vp = (unp->un_uppervp != NULLVP ? unp->un_uppervp : unp->un_lowervp);
2155 
2156 	UNIONFS_INTERNAL_DEBUG("unionfs_getacl: enter\n");
2157 
2158 	error = VOP_GETACL(vp, ap->a_type, ap->a_aclp, ap->a_cred, ap->a_td);
2159 
2160 	UNIONFS_INTERNAL_DEBUG("unionfs_getacl: leave (%d)\n", error);
2161 
2162 	return (error);
2163 }
2164 
2165 static int
2166 unionfs_setacl(struct vop_setacl_args *ap)
2167 {
2168 	int		error;
2169 	struct unionfs_node *unp;
2170 	struct vnode   *uvp;
2171 	struct vnode   *lvp;
2172 	struct thread  *td;
2173 
2174 	UNIONFS_INTERNAL_DEBUG("unionfs_setacl: enter\n");
2175 
2176 	KASSERT_UNIONFS_VNODE(ap->a_vp);
2177 
2178 	error = EROFS;
2179 	unp = VTOUNIONFS(ap->a_vp);
2180 	uvp = unp->un_uppervp;
2181 	lvp = unp->un_lowervp;
2182 	td = ap->a_td;
2183 
2184 	if (ap->a_vp->v_mount->mnt_flag & MNT_RDONLY)
2185 		return (EROFS);
2186 
2187 	if (uvp == NULLVP && lvp->v_type == VREG) {
2188 		if ((error = unionfs_copyfile(unp, 1, ap->a_cred, td)) != 0)
2189 			return (error);
2190 		uvp = unp->un_uppervp;
2191 	}
2192 
2193 	if (uvp != NULLVP)
2194 		error = VOP_SETACL(uvp, ap->a_type, ap->a_aclp, ap->a_cred, td);
2195 
2196 	UNIONFS_INTERNAL_DEBUG("unionfs_setacl: leave (%d)\n", error);
2197 
2198 	return (error);
2199 }
2200 
2201 static int
2202 unionfs_aclcheck(struct vop_aclcheck_args *ap)
2203 {
2204 	int		error;
2205 	struct unionfs_node *unp;
2206 	struct vnode   *vp;
2207 
2208 	UNIONFS_INTERNAL_DEBUG("unionfs_aclcheck: enter\n");
2209 
2210 	KASSERT_UNIONFS_VNODE(ap->a_vp);
2211 
2212 	unp = VTOUNIONFS(ap->a_vp);
2213 	vp = (unp->un_uppervp != NULLVP ? unp->un_uppervp : unp->un_lowervp);
2214 
2215 	error = VOP_ACLCHECK(vp, ap->a_type, ap->a_aclp, ap->a_cred, ap->a_td);
2216 
2217 	UNIONFS_INTERNAL_DEBUG("unionfs_aclcheck: leave (%d)\n", error);
2218 
2219 	return (error);
2220 }
2221 
2222 static int
2223 unionfs_openextattr(struct vop_openextattr_args *ap)
2224 {
2225 	int		error;
2226 	struct unionfs_node *unp;
2227 	struct vnode   *vp;
2228 	struct vnode   *tvp;
2229 
2230 	KASSERT_UNIONFS_VNODE(ap->a_vp);
2231 
2232 	vp = ap->a_vp;
2233 	unp = VTOUNIONFS(vp);
2234 	tvp = (unp->un_uppervp != NULLVP ? unp->un_uppervp : unp->un_lowervp);
2235 
2236 	if ((tvp == unp->un_uppervp && (unp->un_flag & UNIONFS_OPENEXTU)) ||
2237 	    (tvp == unp->un_lowervp && (unp->un_flag & UNIONFS_OPENEXTL)))
2238 		return (EBUSY);
2239 
2240 	error = VOP_OPENEXTATTR(tvp, ap->a_cred, ap->a_td);
2241 
2242 	if (error == 0) {
2243 		if (vn_lock(vp, LK_UPGRADE) != 0)
2244 			vn_lock(vp, LK_EXCLUSIVE | LK_RETRY);
2245 		if (tvp == unp->un_uppervp)
2246 			unp->un_flag |= UNIONFS_OPENEXTU;
2247 		else
2248 			unp->un_flag |= UNIONFS_OPENEXTL;
2249 		vn_lock(vp, LK_DOWNGRADE | LK_RETRY);
2250 	}
2251 
2252 	return (error);
2253 }
2254 
2255 static int
2256 unionfs_closeextattr(struct vop_closeextattr_args *ap)
2257 {
2258 	int		error;
2259 	struct unionfs_node *unp;
2260 	struct vnode   *vp;
2261 	struct vnode   *tvp;
2262 
2263 	KASSERT_UNIONFS_VNODE(ap->a_vp);
2264 
2265 	vp = ap->a_vp;
2266 	unp = VTOUNIONFS(vp);
2267 	tvp = NULLVP;
2268 
2269 	if (unp->un_flag & UNIONFS_OPENEXTU)
2270 		tvp = unp->un_uppervp;
2271 	else if (unp->un_flag & UNIONFS_OPENEXTL)
2272 		tvp = unp->un_lowervp;
2273 
2274 	if (tvp == NULLVP)
2275 		return (EOPNOTSUPP);
2276 
2277 	error = VOP_CLOSEEXTATTR(tvp, ap->a_commit, ap->a_cred, ap->a_td);
2278 
2279 	if (error == 0) {
2280 		if (vn_lock(vp, LK_UPGRADE) != 0)
2281 			vn_lock(vp, LK_EXCLUSIVE | LK_RETRY);
2282 		if (tvp == unp->un_uppervp)
2283 			unp->un_flag &= ~UNIONFS_OPENEXTU;
2284 		else
2285 			unp->un_flag &= ~UNIONFS_OPENEXTL;
2286 		vn_lock(vp, LK_DOWNGRADE | LK_RETRY);
2287 	}
2288 
2289 	return (error);
2290 }
2291 
2292 static int
2293 unionfs_getextattr(struct vop_getextattr_args *ap)
2294 {
2295 	struct unionfs_node *unp;
2296 	struct vnode   *vp;
2297 
2298 	KASSERT_UNIONFS_VNODE(ap->a_vp);
2299 
2300 	unp = VTOUNIONFS(ap->a_vp);
2301 	vp = NULLVP;
2302 
2303 	if (unp->un_flag & UNIONFS_OPENEXTU)
2304 		vp = unp->un_uppervp;
2305 	else if (unp->un_flag & UNIONFS_OPENEXTL)
2306 		vp = unp->un_lowervp;
2307 
2308 	if (vp == NULLVP)
2309 		return (EOPNOTSUPP);
2310 
2311 	return (VOP_GETEXTATTR(vp, ap->a_attrnamespace, ap->a_name,
2312 	    ap->a_uio, ap->a_size, ap->a_cred, ap->a_td));
2313 }
2314 
2315 static int
2316 unionfs_setextattr(struct vop_setextattr_args *ap)
2317 {
2318 	int		error;
2319 	struct unionfs_node *unp;
2320 	struct vnode   *uvp;
2321 	struct vnode   *lvp;
2322 	struct vnode   *ovp;
2323 	struct ucred   *cred;
2324 	struct thread  *td;
2325 
2326 	KASSERT_UNIONFS_VNODE(ap->a_vp);
2327 
2328 	error = EROFS;
2329 	unp = VTOUNIONFS(ap->a_vp);
2330 	uvp = unp->un_uppervp;
2331 	lvp = unp->un_lowervp;
2332 	ovp = NULLVP;
2333 	cred = ap->a_cred;
2334 	td = ap->a_td;
2335 
2336 	UNIONFS_INTERNAL_DEBUG("unionfs_setextattr: enter (un_flag=%x)\n", unp->un_flag);
2337 
2338 	if (ap->a_vp->v_mount->mnt_flag & MNT_RDONLY)
2339 		return (EROFS);
2340 
2341 	if (unp->un_flag & UNIONFS_OPENEXTU)
2342 		ovp = unp->un_uppervp;
2343 	else if (unp->un_flag & UNIONFS_OPENEXTL)
2344 		ovp = unp->un_lowervp;
2345 
2346 	if (ovp == NULLVP)
2347 		return (EOPNOTSUPP);
2348 
2349 	if (ovp == lvp && lvp->v_type == VREG) {
2350 		VOP_CLOSEEXTATTR(lvp, 0, cred, td);
2351 		if (uvp == NULLVP &&
2352 		    (error = unionfs_copyfile(unp, 1, cred, td)) != 0) {
2353 unionfs_setextattr_reopen:
2354 			if ((unp->un_flag & UNIONFS_OPENEXTL) &&
2355 			    VOP_OPENEXTATTR(lvp, cred, td)) {
2356 #ifdef DIAGNOSTIC
2357 				panic("unionfs: VOP_OPENEXTATTR failed");
2358 #endif
2359 				unp->un_flag &= ~UNIONFS_OPENEXTL;
2360 			}
2361 			goto unionfs_setextattr_abort;
2362 		}
2363 		uvp = unp->un_uppervp;
2364 		if ((error = VOP_OPENEXTATTR(uvp, cred, td)) != 0)
2365 			goto unionfs_setextattr_reopen;
2366 		unp->un_flag &= ~UNIONFS_OPENEXTL;
2367 		unp->un_flag |= UNIONFS_OPENEXTU;
2368 		ovp = uvp;
2369 	}
2370 
2371 	if (ovp == uvp)
2372 		error = VOP_SETEXTATTR(ovp, ap->a_attrnamespace, ap->a_name,
2373 		    ap->a_uio, cred, td);
2374 
2375 unionfs_setextattr_abort:
2376 	UNIONFS_INTERNAL_DEBUG("unionfs_setextattr: leave (%d)\n", error);
2377 
2378 	return (error);
2379 }
2380 
2381 static int
2382 unionfs_listextattr(struct vop_listextattr_args *ap)
2383 {
2384 	struct unionfs_node *unp;
2385 	struct vnode   *vp;
2386 
2387 	KASSERT_UNIONFS_VNODE(ap->a_vp);
2388 
2389 	unp = VTOUNIONFS(ap->a_vp);
2390 	vp = NULLVP;
2391 
2392 	if (unp->un_flag & UNIONFS_OPENEXTU)
2393 		vp = unp->un_uppervp;
2394 	else if (unp->un_flag & UNIONFS_OPENEXTL)
2395 		vp = unp->un_lowervp;
2396 
2397 	if (vp == NULLVP)
2398 		return (EOPNOTSUPP);
2399 
2400 	return (VOP_LISTEXTATTR(vp, ap->a_attrnamespace, ap->a_uio,
2401 	    ap->a_size, ap->a_cred, ap->a_td));
2402 }
2403 
2404 static int
2405 unionfs_deleteextattr(struct vop_deleteextattr_args *ap)
2406 {
2407 	int		error;
2408 	struct unionfs_node *unp;
2409 	struct vnode   *uvp;
2410 	struct vnode   *lvp;
2411 	struct vnode   *ovp;
2412 	struct ucred   *cred;
2413 	struct thread  *td;
2414 
2415 	KASSERT_UNIONFS_VNODE(ap->a_vp);
2416 
2417 	error = EROFS;
2418 	unp = VTOUNIONFS(ap->a_vp);
2419 	uvp = unp->un_uppervp;
2420 	lvp = unp->un_lowervp;
2421 	ovp = NULLVP;
2422 	cred = ap->a_cred;
2423 	td = ap->a_td;
2424 
2425 	UNIONFS_INTERNAL_DEBUG("unionfs_deleteextattr: enter (un_flag=%x)\n", unp->un_flag);
2426 
2427 	if (ap->a_vp->v_mount->mnt_flag & MNT_RDONLY)
2428 		return (EROFS);
2429 
2430 	if (unp->un_flag & UNIONFS_OPENEXTU)
2431 		ovp = unp->un_uppervp;
2432 	else if (unp->un_flag & UNIONFS_OPENEXTL)
2433 		ovp = unp->un_lowervp;
2434 
2435 	if (ovp == NULLVP)
2436 		return (EOPNOTSUPP);
2437 
2438 	if (ovp == lvp && lvp->v_type == VREG) {
2439 		VOP_CLOSEEXTATTR(lvp, 0, cred, td);
2440 		if (uvp == NULLVP &&
2441 		    (error = unionfs_copyfile(unp, 1, cred, td)) != 0) {
2442 unionfs_deleteextattr_reopen:
2443 			if ((unp->un_flag & UNIONFS_OPENEXTL) &&
2444 			    VOP_OPENEXTATTR(lvp, cred, td)) {
2445 #ifdef DIAGNOSTIC
2446 				panic("unionfs: VOP_OPENEXTATTR failed");
2447 #endif
2448 				unp->un_flag &= ~UNIONFS_OPENEXTL;
2449 			}
2450 			goto unionfs_deleteextattr_abort;
2451 		}
2452 		uvp = unp->un_uppervp;
2453 		if ((error = VOP_OPENEXTATTR(uvp, cred, td)) != 0)
2454 			goto unionfs_deleteextattr_reopen;
2455 		unp->un_flag &= ~UNIONFS_OPENEXTL;
2456 		unp->un_flag |= UNIONFS_OPENEXTU;
2457 		ovp = uvp;
2458 	}
2459 
2460 	if (ovp == uvp)
2461 		error = VOP_DELETEEXTATTR(ovp, ap->a_attrnamespace, ap->a_name,
2462 		    ap->a_cred, ap->a_td);
2463 
2464 unionfs_deleteextattr_abort:
2465 	UNIONFS_INTERNAL_DEBUG("unionfs_deleteextattr: leave (%d)\n", error);
2466 
2467 	return (error);
2468 }
2469 
2470 static int
2471 unionfs_setlabel(struct vop_setlabel_args *ap)
2472 {
2473 	int		error;
2474 	struct unionfs_node *unp;
2475 	struct vnode   *uvp;
2476 	struct vnode   *lvp;
2477 	struct thread  *td;
2478 
2479 	UNIONFS_INTERNAL_DEBUG("unionfs_setlabel: enter\n");
2480 
2481 	KASSERT_UNIONFS_VNODE(ap->a_vp);
2482 
2483 	error = EROFS;
2484 	unp = VTOUNIONFS(ap->a_vp);
2485 	uvp = unp->un_uppervp;
2486 	lvp = unp->un_lowervp;
2487 	td = ap->a_td;
2488 
2489 	if (ap->a_vp->v_mount->mnt_flag & MNT_RDONLY)
2490 		return (EROFS);
2491 
2492 	if (uvp == NULLVP && lvp->v_type == VREG) {
2493 		if ((error = unionfs_copyfile(unp, 1, ap->a_cred, td)) != 0)
2494 			return (error);
2495 		uvp = unp->un_uppervp;
2496 	}
2497 
2498 	if (uvp != NULLVP)
2499 		error = VOP_SETLABEL(uvp, ap->a_label, ap->a_cred, td);
2500 
2501 	UNIONFS_INTERNAL_DEBUG("unionfs_setlabel: leave (%d)\n", error);
2502 
2503 	return (error);
2504 }
2505 
2506 static int
2507 unionfs_vptofh(struct vop_vptofh_args *ap)
2508 {
2509 	return (EOPNOTSUPP);
2510 }
2511 
2512 struct vop_vector unionfs_vnodeops = {
2513 	.vop_default =		&default_vnodeops,
2514 
2515 	.vop_access =		unionfs_access,
2516 	.vop_aclcheck =		unionfs_aclcheck,
2517 	.vop_advlock =		unionfs_advlock,
2518 	.vop_bmap =		VOP_EOPNOTSUPP,
2519 	.vop_cachedlookup =	unionfs_lookup,
2520 	.vop_close =		unionfs_close,
2521 	.vop_closeextattr =	unionfs_closeextattr,
2522 	.vop_create =		unionfs_create,
2523 	.vop_deleteextattr =	unionfs_deleteextattr,
2524 	.vop_fsync =		unionfs_fsync,
2525 	.vop_getacl =		unionfs_getacl,
2526 	.vop_getattr =		unionfs_getattr,
2527 	.vop_getextattr =	unionfs_getextattr,
2528 	.vop_getwritemount =	unionfs_getwritemount,
2529 	.vop_inactive =		unionfs_inactive,
2530 	.vop_islocked =		unionfs_islocked,
2531 	.vop_ioctl =		unionfs_ioctl,
2532 	.vop_link =		unionfs_link,
2533 	.vop_listextattr =	unionfs_listextattr,
2534 	.vop_lock1 =		unionfs_lock,
2535 	.vop_lookup =		vfs_cache_lookup,
2536 	.vop_mkdir =		unionfs_mkdir,
2537 	.vop_mknod =		unionfs_mknod,
2538 	.vop_open =		unionfs_open,
2539 	.vop_openextattr =	unionfs_openextattr,
2540 	.vop_pathconf =		unionfs_pathconf,
2541 	.vop_poll =		unionfs_poll,
2542 	.vop_print =		unionfs_print,
2543 	.vop_read =		unionfs_read,
2544 	.vop_readdir =		unionfs_readdir,
2545 	.vop_readlink =		unionfs_readlink,
2546 	.vop_reclaim =		unionfs_reclaim,
2547 	.vop_remove =		unionfs_remove,
2548 	.vop_rename =		unionfs_rename,
2549 	.vop_rmdir =		unionfs_rmdir,
2550 	.vop_setacl =		unionfs_setacl,
2551 	.vop_setattr =		unionfs_setattr,
2552 	.vop_setextattr =	unionfs_setextattr,
2553 	.vop_setlabel =		unionfs_setlabel,
2554 	.vop_strategy =		unionfs_strategy,
2555 	.vop_symlink =		unionfs_symlink,
2556 	.vop_unlock =		unionfs_unlock,
2557 	.vop_whiteout =		unionfs_whiteout,
2558 	.vop_write =		unionfs_write,
2559 	.vop_vptofh =		unionfs_vptofh,
2560 };
2561