xref: /titanic_44/usr/src/uts/common/fs/fem.c (revision e3e7cd2990d896de7fff76bc91b8cf570470d6ba)
1 /*
2  * CDDL HEADER START
3  *
4  * The contents of this file are subject to the terms of the
5  * Common Development and Distribution License (the "License").
6  * You may not use this file except in compliance with the License.
7  *
8  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9  * or http://www.opensolaris.org/os/licensing.
10  * See the License for the specific language governing permissions
11  * and limitations under the License.
12  *
13  * When distributing Covered Code, include this CDDL HEADER in each
14  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15  * If applicable, add the following below this CDDL HEADER, with the
16  * fields enclosed by brackets "[]" replaced with your own identifying
17  * information: Portions Copyright [yyyy] [name of copyright owner]
18  *
19  * CDDL HEADER END
20  */
21 /*
22  * Copyright 2008 Sun Microsystems, Inc.  All rights reserved.
23  * Use is subject to license terms.
24  */
25 #pragma ident	"%Z%%M%	%I%	%E% SMI"
26 
27 #include <sys/types.h>
28 #include <sys/atomic.h>
29 #include <sys/kmem.h>
30 #include <sys/mutex.h>
31 #include <sys/errno.h>
32 #include <sys/param.h>
33 #include <sys/sysmacros.h>
34 #include <sys/systm.h>
35 #include <sys/cmn_err.h>
36 #include <sys/debug.h>
37 
38 #include <sys/fem.h>
39 #include <sys/vfs.h>
40 #include <sys/vnode.h>
41 #include <sys/vfs_opreg.h>
42 
43 #define	NNODES_DEFAULT	8	/* Default number of nodes in a fem_list */
44 /*
45  * fl_ntob(n) - Fem_list: number of nodes to bytes
46  * Given the number of nodes in a fem_list return the size, in bytes,
47  * of the fem_list structure.
48  */
49 #define	fl_ntob(n)	(sizeof (struct fem_list) + \
50 			((n) - 1) * sizeof (struct fem_node))
51 
52 typedef enum {
53 	FEMTYPE_NULL,	/* Uninitialized */
54 	FEMTYPE_VNODE,
55 	FEMTYPE_VFS,
56 	FEMTYPE_NTYPES
57 } femtype_t;
58 
59 #define	FEM_HEAD(_t) femtype[(_t)].head.fn_op.anon
60 #define	FEM_GUARD(_t) femtype[(_t)].guard
61 
62 static struct fem_type_info {
63 	struct fem_node		head;
64 	struct fem_node		guard;
65 	femop_t			*errf;
66 }	femtype[FEMTYPE_NTYPES];
67 
68 
69 /*
70  * For each type, two tables - the translation offset definition, which
71  * is used by fs_build_vector to layout the operation(s) vector; and the
72  * guard_operation_vector which protects from stack under-run.
73  */
74 
75 int fem_err();
76 int fsem_err();
77 
78 
79 #define	_FEMOPDEF(name, member)  \
80 	{ VOPNAME_##name, offsetof(fem_t, femop_##member), NULL, fem_err }
81 
82 static fs_operation_trans_def_t	fem_opdef[] = {
83 	_FEMOPDEF(OPEN,		open),
84 	_FEMOPDEF(CLOSE,	close),
85 	_FEMOPDEF(READ,		read),
86 	_FEMOPDEF(WRITE,	write),
87 	_FEMOPDEF(IOCTL,	ioctl),
88 	_FEMOPDEF(SETFL,	setfl),
89 	_FEMOPDEF(GETATTR,	getattr),
90 	_FEMOPDEF(SETATTR,	setattr),
91 	_FEMOPDEF(ACCESS,	access),
92 	_FEMOPDEF(LOOKUP,	lookup),
93 	_FEMOPDEF(CREATE,	create),
94 	_FEMOPDEF(REMOVE,	remove),
95 	_FEMOPDEF(LINK,		link),
96 	_FEMOPDEF(RENAME,	rename),
97 	_FEMOPDEF(MKDIR,	mkdir),
98 	_FEMOPDEF(RMDIR,	rmdir),
99 	_FEMOPDEF(READDIR,	readdir),
100 	_FEMOPDEF(SYMLINK,	symlink),
101 	_FEMOPDEF(READLINK,	readlink),
102 	_FEMOPDEF(FSYNC,	fsync),
103 	_FEMOPDEF(INACTIVE,	inactive),
104 	_FEMOPDEF(FID,		fid),
105 	_FEMOPDEF(RWLOCK,	rwlock),
106 	_FEMOPDEF(RWUNLOCK,	rwunlock),
107 	_FEMOPDEF(SEEK,		seek),
108 	_FEMOPDEF(CMP,		cmp),
109 	_FEMOPDEF(FRLOCK,	frlock),
110 	_FEMOPDEF(SPACE,	space),
111 	_FEMOPDEF(REALVP,	realvp),
112 	_FEMOPDEF(GETPAGE,	getpage),
113 	_FEMOPDEF(PUTPAGE,	putpage),
114 	_FEMOPDEF(MAP,		map),
115 	_FEMOPDEF(ADDMAP,	addmap),
116 	_FEMOPDEF(DELMAP,	delmap),
117 	_FEMOPDEF(POLL,		poll),
118 	_FEMOPDEF(DUMP,		dump),
119 	_FEMOPDEF(PATHCONF,	pathconf),
120 	_FEMOPDEF(PAGEIO,	pageio),
121 	_FEMOPDEF(DUMPCTL,	dumpctl),
122 	_FEMOPDEF(DISPOSE,	dispose),
123 	_FEMOPDEF(SETSECATTR,	setsecattr),
124 	_FEMOPDEF(GETSECATTR,	getsecattr),
125 	_FEMOPDEF(SHRLOCK,	shrlock),
126 	_FEMOPDEF(VNEVENT,	vnevent),
127 	{ NULL, 0, NULL, NULL }
128 };
129 
130 
131 #define	_FEMGUARD(name, ignore)  \
132 	{ VOPNAME_##name, (femop_t *)fem_err }
133 
134 static struct fs_operation_def fem_guard_ops[] = {
135 	_FEMGUARD(OPEN,		open),
136 	_FEMGUARD(CLOSE,	close),
137 	_FEMGUARD(READ,		read),
138 	_FEMGUARD(WRITE,	write),
139 	_FEMGUARD(IOCTL,	ioctl),
140 	_FEMGUARD(SETFL,	setfl),
141 	_FEMGUARD(GETATTR,	getattr),
142 	_FEMGUARD(SETATTR,	setattr),
143 	_FEMGUARD(ACCESS,	access),
144 	_FEMGUARD(LOOKUP,	lookup),
145 	_FEMGUARD(CREATE,	create),
146 	_FEMGUARD(REMOVE,	remove),
147 	_FEMGUARD(LINK,		link),
148 	_FEMGUARD(RENAME,	rename),
149 	_FEMGUARD(MKDIR,	mkdir),
150 	_FEMGUARD(RMDIR,	rmdir),
151 	_FEMGUARD(READDIR,	readdir),
152 	_FEMGUARD(SYMLINK,	symlink),
153 	_FEMGUARD(READLINK,	readlink),
154 	_FEMGUARD(FSYNC,	fsync),
155 	_FEMGUARD(INACTIVE,	inactive),
156 	_FEMGUARD(FID,		fid),
157 	_FEMGUARD(RWLOCK,	rwlock),
158 	_FEMGUARD(RWUNLOCK,	rwunlock),
159 	_FEMGUARD(SEEK,		seek),
160 	_FEMGUARD(CMP,		cmp),
161 	_FEMGUARD(FRLOCK,	frlock),
162 	_FEMGUARD(SPACE,	space),
163 	_FEMGUARD(REALVP,	realvp),
164 	_FEMGUARD(GETPAGE,	getpage),
165 	_FEMGUARD(PUTPAGE,	putpage),
166 	_FEMGUARD(MAP,		map),
167 	_FEMGUARD(ADDMAP,	addmap),
168 	_FEMGUARD(DELMAP,	delmap),
169 	_FEMGUARD(POLL,		poll),
170 	_FEMGUARD(DUMP,		dump),
171 	_FEMGUARD(PATHCONF,	pathconf),
172 	_FEMGUARD(PAGEIO,	pageio),
173 	_FEMGUARD(DUMPCTL,	dumpctl),
174 	_FEMGUARD(DISPOSE,	dispose),
175 	_FEMGUARD(SETSECATTR,	setsecattr),
176 	_FEMGUARD(GETSECATTR,	getsecattr),
177 	_FEMGUARD(SHRLOCK,	shrlock),
178 	_FEMGUARD(VNEVENT,	vnevent),
179 	{ NULL, NULL }
180 };
181 
182 
183 #define	_FSEMOPDEF(name, member)  \
184 	{ VFSNAME_##name, offsetof(fsem_t, fsemop_##member), NULL, fsem_err }
185 
186 static fs_operation_trans_def_t fsem_opdef[] = {
187 	_FSEMOPDEF(MOUNT, 	mount),
188 	_FSEMOPDEF(UNMOUNT,	unmount),
189 	_FSEMOPDEF(ROOT,	root),
190 	_FSEMOPDEF(STATVFS,	statvfs),
191 	_FSEMOPDEF(SYNC,	sync),
192 	_FSEMOPDEF(VGET,	vget),
193 	_FSEMOPDEF(MOUNTROOT,	mountroot),
194 	_FSEMOPDEF(FREEVFS,	freevfs),
195 	_FSEMOPDEF(VNSTATE,	vnstate),
196 	{ NULL, 0, NULL, NULL }
197 };
198 
199 #define	_FSEMGUARD(name, ignore)  \
200 	{ VFSNAME_##name, (femop_t *)fsem_err }
201 
202 static struct fs_operation_def fsem_guard_ops[] = {
203 	_FSEMGUARD(MOUNT, 	mount),
204 	_FSEMGUARD(UNMOUNT,	unmount),
205 	_FSEMGUARD(ROOT,	root),
206 	_FSEMGUARD(STATVFS,	statvfs),
207 	_FSEMGUARD(SYNC,	sync),
208 	_FSEMGUARD(VGET,	vget),
209 	_FSEMGUARD(MOUNTROOT,	mountroot),
210 	_FSEMGUARD(FREEVFS,	freevfs),
211 	_FSEMGUARD(VNSTATE,	vnstate),
212 	{ NULL, NULL}
213 };
214 
215 
216 /*
217  * vsop_find, vfsop_find -
218  *
219  * These macros descend the stack until they find either a basic
220  * vnode/vfs operation [ indicated by a null fn_available ] or a
221  * stacked item where this method is non-null [_vsop].
222  *
223  * The DEBUG one is written with a single function which manually applies
224  * the structure offsets.  It can have additional debugging support.
225  */
226 
227 #ifndef DEBUG
228 
229 #define	vsop_find(ap, func, funct, arg0, _vop, _vsop) \
230 for (;;) { \
231 	if ((ap)->fa_fnode->fn_available == NULL) { \
232 		*(func) = (funct (*)())((ap)->fa_fnode->fn_op.vnode->_vop); \
233 		*(arg0) = (void *)(ap)->fa_vnode.vp; \
234 		break;	\
235 	} else if ((*(func) = (funct (*)())((ap)->fa_fnode->fn_op.fem->_vsop))\
236 		    != NULL) { \
237 		*(arg0) = (void *) (ap); \
238 		break;	\
239 	} else { \
240 		(ap)->fa_fnode--; \
241 	} \
242 } \
243 
244 #define	vfsop_find(ap, func, funct, arg0, _vop, _vsop) \
245 for (;;) { \
246 	if ((ap)->fa_fnode->fn_available == NULL) { \
247 		*(func) = (funct (*)())((ap)->fa_fnode->fn_op.vfs->_vop); \
248 		*(arg0) = (void *)(ap)->fa_vnode.vp; \
249 		break; \
250 	} else if ((*(func) = (funct (*)())((ap)->fa_fnode->fn_op.fsem->_vsop))\
251 		    != NULL) { \
252 		*(arg0) = (void *) (ap); \
253 		break; \
254 	} else { \
255 		(ap)->fa_fnode--; \
256 	} \
257 } \
258 
259 #else
260 
261 #define	vsop_find(ap, func, funct, arg0, _vop, _vsop) \
262 	*(arg0) = _op_find((ap), (void **)(func), \
263 			offsetof(vnodeops_t, _vop), offsetof(fem_t, _vsop))
264 
265 #define	vfsop_find(ap, func, funct, arg0, _fop, _fsop) \
266 	*(arg0) = _op_find((ap), (void **)(func), \
267 			offsetof(vfsops_t, _fop), offsetof(fsem_t, _fsop))
268 
269 static void *
270 _op_find(femarg_t *ap, void **fp, int offs0, int offs1)
271 {
272 	void *ptr;
273 	for (;;) {
274 		struct fem_node	*fnod = ap->fa_fnode;
275 		if (fnod->fn_available == NULL) {
276 			*fp = *(void **)((char *)fnod->fn_op.anon + offs0);
277 			ptr = (void *)(ap->fa_vnode.anon);
278 			break;
279 		} else if ((*fp = *(void **)((char *)fnod->fn_op.anon+offs1))
280 		    != NULL) {
281 			ptr = (void *)(ap);
282 			break;
283 		} else {
284 			ap->fa_fnode--;
285 		}
286 	}
287 	return (ptr);
288 }
289 #endif
290 
291 static fem_t *
292 fem_alloc()
293 {
294 	fem_t	*p;
295 
296 	p = (fem_t *)kmem_alloc(sizeof (*p), KM_SLEEP);
297 	return (p);
298 }
299 
300 void
301 fem_free(fem_t *p)
302 {
303 	kmem_free(p, sizeof (*p));
304 }
305 
306 static fsem_t *
307 fsem_alloc()
308 {
309 	fsem_t	*p;
310 
311 	p = (fsem_t *)kmem_alloc(sizeof (*p), KM_SLEEP);
312 	return (p);
313 }
314 
315 void
316 fsem_free(fsem_t *p)
317 {
318 	kmem_free(p, sizeof (*p));
319 }
320 
321 
322 /*
323  * fem_get, fem_release - manage reference counts on the stack.
324  *
325  * The list of monitors can be updated while operations are in
326  * progress on the object.
327  *
328  * The reference count facilitates this by counting the number of
329  * current accessors, and deconstructing the list when it is exhausted.
330  *
331  * fem_lock() is required to:
332  *	look at femh_list
333  *	update what femh_list points to
334  *	update femh_list
335  *	increase femh_list->feml_refc.
336  *
337  * the feml_refc can decrement without holding the lock;
338  * when feml_refc becomes zero, the list is destroyed.
339  *
340  */
341 
342 static struct fem_list *
343 fem_lock(struct fem_head *fp)
344 {
345 	struct fem_list	*sp = NULL;
346 
347 	ASSERT(fp != NULL);
348 	mutex_enter(&fp->femh_lock);
349 	sp = fp->femh_list;
350 	return (sp);
351 }
352 
353 static void
354 fem_unlock(struct fem_head *fp)
355 {
356 	ASSERT(fp != NULL);
357 	mutex_exit(&fp->femh_lock);
358 }
359 
360 /*
361  * Addref can only be called while its head->lock is held.
362  */
363 
364 static void
365 fem_addref(struct fem_list *sp)
366 {
367 	atomic_add_32(&sp->feml_refc, 1);
368 }
369 
370 static uint32_t
371 fem_delref(struct fem_list *sp)
372 {
373 	return (atomic_add_32_nv(&sp->feml_refc, -1));
374 }
375 
376 static struct fem_list *
377 fem_get(struct fem_head *fp)
378 {
379 	struct fem_list *sp = NULL;
380 
381 	if (fp != NULL) {
382 		if ((sp = fem_lock(fp)) != NULL) {
383 			fem_addref(sp);
384 		}
385 		fem_unlock(fp);
386 	}
387 	return (sp);
388 }
389 
390 static void
391 fem_release(struct fem_list *sp)
392 {
393 	int	i;
394 
395 	ASSERT(sp->feml_refc != 0);
396 	if (fem_delref(sp) == 0) {
397 		/*
398 		 * Before freeing the list, we need to release the
399 		 * caller-provided data.
400 		 */
401 		for (i = sp->feml_tos; i > 0; i--) {
402 			struct fem_node *fnp = &sp->feml_nodes[i];
403 
404 			if (fnp->fn_av_rele)
405 				(*(fnp->fn_av_rele))(fnp->fn_available);
406 		}
407 		kmem_free(sp, fl_ntob(sp->feml_ssize));
408 	}
409 }
410 
411 
412 /*
413  * These are the 'head' operations which perform the interposition.
414  *
415  * This set must be 1:1, onto with the (vnodeops, vfsos).
416  *
417  * If there is a desire to globally disable interposition for a particular
418  * method, the corresponding 'head' routine should unearth the base method
419  * and invoke it directly rather than bypassing the function.
420  *
421  * All the functions are virtually the same, save for names, types & args.
422  *  1. get a reference to the monitor stack for this object.
423  *  2. store the top of stack into the femarg structure.
424  *  3. store the basic object (vnode *, vnode **, vfs *) in the femarg struc.
425  *  4. invoke the "top" method for this object.
426  *  5. release the reference to the monitor stack.
427  *
428  */
429 
430 static int
431 vhead_open(vnode_t **vpp, int mode, cred_t *cr, caller_context_t *ct)
432 {
433 	femarg_t	farg;
434 	struct fem_list	*femsp;
435 	int		(*func)();
436 	void		*arg0;
437 	int		errc;
438 
439 	if ((femsp = fem_lock((*vpp)->v_femhead)) == NULL) {
440 		func = (int (*)()) ((*vpp)->v_op->vop_open);
441 		arg0 = (void *)vpp;
442 		fem_unlock((*vpp)->v_femhead);
443 		errc = (*func)(arg0, mode, cr, ct);
444 	} else {
445 		fem_addref(femsp);
446 		fem_unlock((*vpp)->v_femhead);
447 		farg.fa_vnode.vpp = vpp;
448 		farg.fa_fnode = femsp->feml_nodes + femsp->feml_tos;
449 		vsop_find(&farg, &func, int, &arg0, vop_open, femop_open);
450 		errc = (*func)(arg0, mode, cr, ct);
451 		fem_release(femsp);
452 	}
453 	return (errc);
454 }
455 
456 static int
457 vhead_close(vnode_t *vp, int flag, int count, offset_t offset, cred_t *cr,
458 	caller_context_t *ct)
459 {
460 	femarg_t	farg;
461 	struct fem_list	*femsp;
462 	int		(*func)();
463 	void		*arg0;
464 	int		errc;
465 
466 	if ((femsp = fem_lock(vp->v_femhead)) == NULL) {
467 		func = (int (*)()) (vp->v_op->vop_close);
468 		arg0 = vp;
469 		fem_unlock(vp->v_femhead);
470 		errc = (*func)(arg0, flag, count, offset, cr, ct);
471 	} else {
472 		fem_addref(femsp);
473 		fem_unlock(vp->v_femhead);
474 		farg.fa_vnode.vp = vp;
475 		farg.fa_fnode = femsp->feml_nodes + femsp->feml_tos;
476 		vsop_find(&farg, &func, int, &arg0, vop_close, femop_close);
477 		errc = (*func)(arg0, flag, count, offset, cr, ct);
478 		fem_release(femsp);
479 	}
480 	return (errc);
481 }
482 
483 static int
484 vhead_read(vnode_t *vp, uio_t *uiop, int ioflag, cred_t *cr,
485 	caller_context_t *ct)
486 {
487 	femarg_t	farg;
488 	struct fem_list	*femsp;
489 	int		(*func)();
490 	void		*arg0;
491 	int		errc;
492 
493 	if ((femsp = fem_lock(vp->v_femhead)) == NULL) {
494 		func = (int (*)()) (vp->v_op->vop_read);
495 		arg0 = vp;
496 		fem_unlock(vp->v_femhead);
497 		errc = (*func)(arg0, uiop, ioflag, cr, ct);
498 	} else {
499 		fem_addref(femsp);
500 		fem_unlock(vp->v_femhead);
501 		farg.fa_vnode.vp = vp;
502 		farg.fa_fnode = femsp->feml_nodes + femsp->feml_tos;
503 		vsop_find(&farg, &func, int, &arg0, vop_read, femop_read);
504 		errc = (*func)(arg0, uiop, ioflag, cr, ct);
505 		fem_release(femsp);
506 	}
507 	return (errc);
508 }
509 
510 static int
511 vhead_write(vnode_t *vp, uio_t *uiop, int ioflag, cred_t *cr,
512 	caller_context_t *ct)
513 {
514 	femarg_t	farg;
515 	struct fem_list	*femsp;
516 	int		(*func)();
517 	void		*arg0;
518 	int		errc;
519 
520 	if ((femsp = fem_lock(vp->v_femhead)) == NULL) {
521 		func = (int (*)()) (vp->v_op->vop_write);
522 		arg0 = vp;
523 		fem_unlock(vp->v_femhead);
524 		errc = (*func)(arg0, uiop, ioflag, cr, ct);
525 	} else {
526 		fem_addref(femsp);
527 		fem_unlock(vp->v_femhead);
528 		farg.fa_vnode.vp = vp;
529 		farg.fa_fnode = femsp->feml_nodes + femsp->feml_tos;
530 		vsop_find(&farg, &func, int, &arg0, vop_write, femop_write);
531 		errc = (*func)(arg0, uiop, ioflag, cr, ct);
532 		fem_release(femsp);
533 	}
534 	return (errc);
535 }
536 
537 static int
538 vhead_ioctl(vnode_t *vp, int cmd, intptr_t arg, int flag, cred_t *cr,
539 	int *rvalp, caller_context_t *ct)
540 {
541 	femarg_t	farg;
542 	struct fem_list	*femsp;
543 	int		(*func)();
544 	void		*arg0;
545 	int		errc;
546 
547 	if ((femsp = fem_lock(vp->v_femhead)) == NULL) {
548 		func = (int (*)()) (vp->v_op->vop_ioctl);
549 		arg0 = vp;
550 		fem_unlock(vp->v_femhead);
551 		errc = (*func)(arg0, cmd, arg, flag, cr, rvalp, ct);
552 	} else {
553 		fem_addref(femsp);
554 		fem_unlock(vp->v_femhead);
555 		farg.fa_vnode.vp = vp;
556 		farg.fa_fnode = femsp->feml_nodes + femsp->feml_tos;
557 		vsop_find(&farg, &func, int, &arg0, vop_ioctl, femop_ioctl);
558 		errc = (*func)(arg0, cmd, arg, flag, cr, rvalp, ct);
559 		fem_release(femsp);
560 	}
561 	return (errc);
562 }
563 
564 static int
565 vhead_setfl(vnode_t *vp, int oflags, int nflags, cred_t *cr,
566 	caller_context_t *ct)
567 {
568 	femarg_t	farg;
569 	struct fem_list	*femsp;
570 	int		(*func)();
571 	void		*arg0;
572 	int		errc;
573 
574 	if ((femsp = fem_lock(vp->v_femhead)) == NULL) {
575 		func = (int (*)()) (vp->v_op->vop_setfl);
576 		arg0 = vp;
577 		fem_unlock(vp->v_femhead);
578 		errc = (*func)(arg0, oflags, nflags, cr, ct);
579 	} else {
580 		fem_addref(femsp);
581 		fem_unlock(vp->v_femhead);
582 		farg.fa_vnode.vp = vp;
583 		farg.fa_fnode = femsp->feml_nodes + femsp->feml_tos;
584 		vsop_find(&farg, &func, int, &arg0, vop_setfl, femop_setfl);
585 		errc = (*func)(arg0, oflags, nflags, cr, ct);
586 		fem_release(femsp);
587 	}
588 	return (errc);
589 }
590 
591 static int
592 vhead_getattr(vnode_t *vp, vattr_t *vap, int flags, cred_t *cr,
593 	caller_context_t *ct)
594 {
595 	femarg_t	farg;
596 	struct fem_list	*femsp;
597 	int		(*func)();
598 	void		*arg0;
599 	int		errc;
600 
601 	if ((femsp = fem_lock(vp->v_femhead)) == NULL) {
602 		func = (int (*)()) (vp->v_op->vop_getattr);
603 		arg0 = vp;
604 		fem_unlock(vp->v_femhead);
605 		errc = (*func)(arg0, vap, flags, cr, ct);
606 	} else {
607 		fem_addref(femsp);
608 		fem_unlock(vp->v_femhead);
609 		farg.fa_vnode.vp = vp;
610 		farg.fa_fnode = femsp->feml_nodes + femsp->feml_tos;
611 		vsop_find(&farg, &func, int, &arg0, vop_getattr,
612 		    femop_getattr);
613 		errc = (*func)(arg0, vap, flags, cr, ct);
614 		fem_release(femsp);
615 	}
616 	return (errc);
617 }
618 
619 static int
620 vhead_setattr(vnode_t *vp, vattr_t *vap, int flags, cred_t *cr,
621 	caller_context_t *ct)
622 {
623 	femarg_t	farg;
624 	struct fem_list	*femsp;
625 	int		(*func)();
626 	void		*arg0;
627 	int		errc;
628 
629 	if ((femsp = fem_lock(vp->v_femhead)) == NULL) {
630 		func = (int (*)()) (vp->v_op->vop_setattr);
631 		arg0 = vp;
632 		fem_unlock(vp->v_femhead);
633 		errc = (*func)(arg0, vap, flags, cr, ct);
634 	} else {
635 		fem_addref(femsp);
636 		fem_unlock(vp->v_femhead);
637 		farg.fa_vnode.vp = vp;
638 		farg.fa_fnode = femsp->feml_nodes + femsp->feml_tos;
639 		vsop_find(&farg, &func, int, &arg0, vop_setattr,
640 		    femop_setattr);
641 		errc = (*func)(arg0, vap, flags, cr, ct);
642 		fem_release(femsp);
643 	}
644 	return (errc);
645 }
646 
647 static int
648 vhead_access(vnode_t *vp, int mode, int flags, cred_t *cr,
649 	caller_context_t *ct)
650 {
651 	femarg_t	farg;
652 	struct fem_list	*femsp;
653 	int		(*func)();
654 	void		*arg0;
655 	int		errc;
656 
657 	if ((femsp = fem_lock(vp->v_femhead)) == NULL) {
658 		func = (int (*)()) (vp->v_op->vop_access);
659 		arg0 = vp;
660 		fem_unlock(vp->v_femhead);
661 		errc = (*func)(arg0, mode, flags, cr, ct);
662 	} else {
663 		fem_addref(femsp);
664 		fem_unlock(vp->v_femhead);
665 		farg.fa_vnode.vp = vp;
666 		farg.fa_fnode = femsp->feml_nodes + femsp->feml_tos;
667 		vsop_find(&farg, &func, int, &arg0, vop_access,
668 		    femop_access);
669 		errc = (*func)(arg0, mode, flags, cr, ct);
670 		fem_release(femsp);
671 	}
672 	return (errc);
673 }
674 
675 static int
676 vhead_lookup(vnode_t *dvp, char *nm, vnode_t **vpp, pathname_t *pnp,
677 	int flags, vnode_t *rdir, cred_t *cr, caller_context_t *ct,
678 	int *direntflags, pathname_t *realpnp)
679 {
680 	femarg_t	farg;
681 	struct fem_list	*femsp;
682 	int		(*func)();
683 	void		*arg0;
684 	int		errc;
685 
686 	if ((femsp = fem_lock(dvp->v_femhead)) == NULL) {
687 		func = (int (*)()) (dvp->v_op->vop_lookup);
688 		arg0 = dvp;
689 		fem_unlock(dvp->v_femhead);
690 		errc = (*func)(arg0, nm, vpp, pnp, flags, rdir, cr, ct,
691 		    direntflags, realpnp);
692 	} else {
693 		fem_addref(femsp);
694 		fem_unlock(dvp->v_femhead);
695 		farg.fa_vnode.vp = dvp;
696 		farg.fa_fnode = femsp->feml_nodes + femsp->feml_tos;
697 		vsop_find(&farg, &func, int, &arg0, vop_lookup,
698 		    femop_lookup);
699 		errc = (*func)(arg0, nm, vpp, pnp, flags, rdir, cr, ct,
700 		    direntflags, realpnp);
701 		fem_release(femsp);
702 	}
703 	return (errc);
704 }
705 
706 static int
707 vhead_create(vnode_t *dvp, char *name, vattr_t *vap, vcexcl_t excl,
708 	int mode, vnode_t **vpp, cred_t *cr, int flag, caller_context_t *ct,
709 	vsecattr_t *vsecp)
710 {
711 	femarg_t	farg;
712 	struct fem_list	*femsp;
713 	int		(*func)();
714 	void		*arg0;
715 	int		errc;
716 
717 	if ((femsp = fem_lock(dvp->v_femhead)) == NULL) {
718 		func = (int (*)()) (dvp->v_op->vop_create);
719 		arg0 = dvp;
720 		fem_unlock(dvp->v_femhead);
721 		errc = (*func)(arg0, name, vap, excl, mode, vpp, cr, flag,
722 		    ct, vsecp);
723 	} else {
724 		fem_addref(femsp);
725 		fem_unlock(dvp->v_femhead);
726 		farg.fa_vnode.vp = dvp;
727 		farg.fa_fnode = femsp->feml_nodes + femsp->feml_tos;
728 		vsop_find(&farg, &func, int, &arg0, vop_create,
729 		    femop_create);
730 		errc = (*func)(arg0, name, vap, excl, mode, vpp, cr, flag,
731 		    ct, vsecp);
732 		fem_release(femsp);
733 	}
734 	return (errc);
735 }
736 
737 static int
738 vhead_remove(vnode_t *dvp, char *nm, cred_t *cr, caller_context_t *ct,
739 	int flags)
740 {
741 	femarg_t	farg;
742 	struct fem_list	*femsp;
743 	int		(*func)();
744 	void		*arg0;
745 	int		errc;
746 
747 	if ((femsp = fem_lock(dvp->v_femhead)) == NULL) {
748 		func = (int (*)()) (dvp->v_op->vop_remove);
749 		arg0 = dvp;
750 		fem_unlock(dvp->v_femhead);
751 		errc = (*func)(arg0, nm, cr, ct, flags);
752 	} else {
753 		fem_addref(femsp);
754 		fem_unlock(dvp->v_femhead);
755 		farg.fa_vnode.vp = dvp;
756 		farg.fa_fnode = femsp->feml_nodes + femsp->feml_tos;
757 		vsop_find(&farg, &func, int, &arg0, vop_remove,
758 		    femop_remove);
759 		errc = (*func)(arg0, nm, cr, ct, flags);
760 		fem_release(femsp);
761 	}
762 	return (errc);
763 }
764 
765 static int
766 vhead_link(vnode_t *tdvp, vnode_t *svp, char *tnm, cred_t *cr,
767 	caller_context_t *ct, int flags)
768 {
769 	femarg_t	farg;
770 	struct fem_list	*femsp;
771 	int		(*func)();
772 	void		*arg0;
773 	int		errc;
774 
775 	if ((femsp = fem_lock(tdvp->v_femhead)) == NULL) {
776 		func = (int (*)()) (tdvp->v_op->vop_link);
777 		arg0 = tdvp;
778 		fem_unlock(tdvp->v_femhead);
779 		errc = (*func)(arg0, svp, tnm, cr, ct, flags);
780 	} else {
781 		fem_addref(femsp);
782 		fem_unlock(tdvp->v_femhead);
783 		farg.fa_vnode.vp = tdvp;
784 		farg.fa_fnode = femsp->feml_nodes + femsp->feml_tos;
785 		vsop_find(&farg, &func, int, &arg0, vop_link, femop_link);
786 		errc = (*func)(arg0, svp, tnm, cr, ct, flags);
787 		fem_release(femsp);
788 	}
789 	return (errc);
790 }
791 
792 static int
793 vhead_rename(vnode_t *sdvp, char *snm, vnode_t *tdvp, char *tnm,
794 	cred_t *cr, caller_context_t *ct, int flags)
795 {
796 	femarg_t	farg;
797 	struct fem_list	*femsp;
798 	int		(*func)();
799 	void		*arg0;
800 	int		errc;
801 
802 	if ((femsp = fem_lock(sdvp->v_femhead)) == NULL) {
803 		func = (int (*)()) (sdvp->v_op->vop_rename);
804 		arg0 = sdvp;
805 		fem_unlock(sdvp->v_femhead);
806 		errc = (*func)(arg0, snm, tdvp, tnm, cr, ct, flags);
807 	} else {
808 		fem_addref(femsp);
809 		fem_unlock(sdvp->v_femhead);
810 		farg.fa_vnode.vp = sdvp;
811 		farg.fa_fnode = femsp->feml_nodes + femsp->feml_tos;
812 		vsop_find(&farg, &func, int, &arg0, vop_rename,
813 		    femop_rename);
814 		errc = (*func)(arg0, snm, tdvp, tnm, cr, ct, flags);
815 		fem_release(femsp);
816 	}
817 	return (errc);
818 }
819 
820 static int
821 vhead_mkdir(vnode_t *dvp, char *dirname, vattr_t *vap, vnode_t **vpp,
822 	cred_t *cr, caller_context_t *ct, int flags, vsecattr_t *vsecp)
823 {
824 	femarg_t	farg;
825 	struct fem_list	*femsp;
826 	int		(*func)();
827 	void		*arg0;
828 	int		errc;
829 
830 	if ((femsp = fem_lock(dvp->v_femhead)) == NULL) {
831 		func = (int (*)()) (dvp->v_op->vop_mkdir);
832 		arg0 = dvp;
833 		fem_unlock(dvp->v_femhead);
834 		errc = (*func)(arg0, dirname, vap, vpp, cr, ct, flags, vsecp);
835 	} else {
836 		fem_addref(femsp);
837 		fem_unlock(dvp->v_femhead);
838 		farg.fa_vnode.vp = dvp;
839 		farg.fa_fnode = femsp->feml_nodes + femsp->feml_tos;
840 		vsop_find(&farg, &func, int, &arg0, vop_mkdir, femop_mkdir);
841 		errc = (*func)(arg0, dirname, vap, vpp, cr, ct, flags, vsecp);
842 		fem_release(femsp);
843 	}
844 	return (errc);
845 }
846 
847 static int
848 vhead_rmdir(vnode_t *dvp, char *nm, vnode_t *cdir, cred_t *cr,
849 	caller_context_t *ct, int flags)
850 {
851 	femarg_t	farg;
852 	struct fem_list	*femsp;
853 	int		(*func)();
854 	void		*arg0;
855 	int		errc;
856 
857 	if ((femsp = fem_lock(dvp->v_femhead)) == NULL) {
858 		func = (int (*)()) (dvp->v_op->vop_rmdir);
859 		arg0 = dvp;
860 		fem_unlock(dvp->v_femhead);
861 		errc = (*func)(arg0, nm, cdir, cr, ct, flags);
862 	} else {
863 		fem_addref(femsp);
864 		fem_unlock(dvp->v_femhead);
865 		farg.fa_vnode.vp = dvp;
866 		farg.fa_fnode = femsp->feml_nodes + femsp->feml_tos;
867 		vsop_find(&farg, &func, int, &arg0, vop_rmdir, femop_rmdir);
868 		errc = (*func)(arg0, nm, cdir, cr, ct, flags);
869 		fem_release(femsp);
870 	}
871 	return (errc);
872 }
873 
874 static int
875 vhead_readdir(vnode_t *vp, uio_t *uiop, cred_t *cr, int *eofp,
876 	caller_context_t *ct, int flags)
877 {
878 	femarg_t	farg;
879 	struct fem_list	*femsp;
880 	int		(*func)();
881 	void		*arg0;
882 	int		errc;
883 
884 	if ((femsp = fem_lock(vp->v_femhead)) == NULL) {
885 		func = (int (*)()) (vp->v_op->vop_readdir);
886 		arg0 = vp;
887 		fem_unlock(vp->v_femhead);
888 		errc = (*func)(arg0, uiop, cr, eofp, ct, flags);
889 	} else {
890 		fem_addref(femsp);
891 		fem_unlock(vp->v_femhead);
892 		farg.fa_vnode.vp = vp;
893 		farg.fa_fnode = femsp->feml_nodes + femsp->feml_tos;
894 		vsop_find(&farg, &func, int, &arg0, vop_readdir,
895 		    femop_readdir);
896 		errc = (*func)(arg0, uiop, cr, eofp, ct, flags);
897 		fem_release(femsp);
898 	}
899 	return (errc);
900 }
901 
902 static int
903 vhead_symlink(vnode_t *dvp, char *linkname, vattr_t *vap, char *target,
904 	cred_t *cr, caller_context_t *ct, int flags)
905 {
906 	femarg_t	farg;
907 	struct fem_list	*femsp;
908 	int		(*func)();
909 	void		*arg0;
910 	int		errc;
911 
912 	if ((femsp = fem_lock(dvp->v_femhead)) == NULL) {
913 		func = (int (*)()) (dvp->v_op->vop_symlink);
914 		arg0 = dvp;
915 		fem_unlock(dvp->v_femhead);
916 		errc = (*func)(arg0, linkname, vap, target, cr, ct, flags);
917 	} else {
918 		fem_addref(femsp);
919 		fem_unlock(dvp->v_femhead);
920 		farg.fa_vnode.vp = dvp;
921 		farg.fa_fnode = femsp->feml_nodes + femsp->feml_tos;
922 		vsop_find(&farg, &func, int, &arg0, vop_symlink,
923 		    femop_symlink);
924 		errc = (*func)(arg0, linkname, vap, target, cr, ct, flags);
925 		fem_release(femsp);
926 	}
927 	return (errc);
928 }
929 
930 static int
931 vhead_readlink(vnode_t *vp, uio_t *uiop, cred_t *cr, caller_context_t *ct)
932 {
933 	femarg_t	farg;
934 	struct fem_list	*femsp;
935 	int		(*func)();
936 	void		*arg0;
937 	int		errc;
938 
939 	if ((femsp = fem_lock(vp->v_femhead)) == NULL) {
940 		func = (int (*)()) (vp->v_op->vop_readlink);
941 		arg0 = vp;
942 		fem_unlock(vp->v_femhead);
943 		errc = (*func)(arg0, uiop, cr, ct);
944 	} else {
945 		fem_addref(femsp);
946 		fem_unlock(vp->v_femhead);
947 		farg.fa_vnode.vp = vp;
948 		farg.fa_fnode = femsp->feml_nodes + femsp->feml_tos;
949 		vsop_find(&farg, &func, int, &arg0, vop_readlink,
950 		    femop_readlink);
951 		errc = (*func)(arg0, uiop, cr, ct);
952 		fem_release(femsp);
953 	}
954 	return (errc);
955 }
956 
957 static int
958 vhead_fsync(vnode_t *vp, int syncflag, cred_t *cr, caller_context_t *ct)
959 {
960 	femarg_t	farg;
961 	struct fem_list	*femsp;
962 	int		(*func)();
963 	void		*arg0;
964 	int		errc;
965 
966 	if ((femsp = fem_lock(vp->v_femhead)) == NULL) {
967 		func = (int (*)()) (vp->v_op->vop_fsync);
968 		arg0 = vp;
969 		fem_unlock(vp->v_femhead);
970 		errc = (*func)(arg0, syncflag, cr, ct);
971 	} else {
972 		fem_addref(femsp);
973 		fem_unlock(vp->v_femhead);
974 		farg.fa_vnode.vp = vp;
975 		farg.fa_fnode = femsp->feml_nodes + femsp->feml_tos;
976 		vsop_find(&farg, &func, int, &arg0, vop_fsync, femop_fsync);
977 		errc = (*func)(arg0, syncflag, cr, ct);
978 		fem_release(femsp);
979 	}
980 	return (errc);
981 }
982 
983 static void
984 vhead_inactive(vnode_t *vp, cred_t *cr, caller_context_t *ct)
985 {
986 	femarg_t	farg;
987 	struct fem_list	*femsp;
988 	void		(*func)();
989 	void		*arg0;
990 
991 	if ((femsp = fem_lock(vp->v_femhead)) == NULL) {
992 		func = (void (*)()) (vp->v_op->vop_inactive);
993 		arg0 = vp;
994 		fem_unlock(vp->v_femhead);
995 		(*func)(arg0, cr, ct);
996 	} else {
997 		fem_addref(femsp);
998 		fem_unlock(vp->v_femhead);
999 		farg.fa_vnode.vp = vp;
1000 		farg.fa_fnode = femsp->feml_nodes + femsp->feml_tos;
1001 		vsop_find(&farg, &func, void, &arg0, vop_inactive,
1002 		    femop_inactive);
1003 		(*func)(arg0, cr, ct);
1004 		fem_release(femsp);
1005 	}
1006 }
1007 
1008 static int
1009 vhead_fid(vnode_t *vp, fid_t *fidp, caller_context_t *ct)
1010 {
1011 	femarg_t	farg;
1012 	struct fem_list	*femsp;
1013 	int		(*func)();
1014 	void		*arg0;
1015 	int		errc;
1016 
1017 	if ((femsp = fem_lock(vp->v_femhead)) == NULL) {
1018 		func = (int (*)()) (vp->v_op->vop_fid);
1019 		arg0 = vp;
1020 		fem_unlock(vp->v_femhead);
1021 		errc = (*func)(arg0, fidp, ct);
1022 	} else {
1023 		fem_addref(femsp);
1024 		fem_unlock(vp->v_femhead);
1025 		farg.fa_vnode.vp = vp;
1026 		farg.fa_fnode = femsp->feml_nodes + femsp->feml_tos;
1027 		vsop_find(&farg, &func, int, &arg0, vop_fid, femop_fid);
1028 		errc = (*func)(arg0, fidp, ct);
1029 		fem_release(femsp);
1030 	}
1031 	return (errc);
1032 }
1033 
1034 static int
1035 vhead_rwlock(vnode_t *vp, int write_lock, caller_context_t *ct)
1036 {
1037 	femarg_t	farg;
1038 	struct fem_list	*femsp;
1039 	int		(*func)();
1040 	void		*arg0;
1041 	int		errc;
1042 
1043 	if ((femsp = fem_lock(vp->v_femhead)) == NULL) {
1044 		func = (int (*)()) (vp->v_op->vop_rwlock);
1045 		arg0 = vp;
1046 		fem_unlock(vp->v_femhead);
1047 		errc = (*func)(arg0, write_lock, ct);
1048 	} else {
1049 		fem_addref(femsp);
1050 		fem_unlock(vp->v_femhead);
1051 		farg.fa_vnode.vp = vp;
1052 		farg.fa_fnode = femsp->feml_nodes + femsp->feml_tos;
1053 		vsop_find(&farg, &func, int, &arg0, vop_rwlock,
1054 		    femop_rwlock);
1055 		errc = (*func)(arg0, write_lock, ct);
1056 		fem_release(femsp);
1057 	}
1058 	return (errc);
1059 }
1060 
1061 static void
1062 vhead_rwunlock(vnode_t *vp, int write_lock, caller_context_t *ct)
1063 {
1064 	femarg_t	farg;
1065 	struct fem_list	*femsp;
1066 	void		(*func)();
1067 	void		*arg0;
1068 
1069 	if ((femsp = fem_lock(vp->v_femhead)) == NULL) {
1070 		func = (void (*)()) (vp->v_op->vop_rwunlock);
1071 		arg0 = vp;
1072 		fem_unlock(vp->v_femhead);
1073 		(*func)(arg0, write_lock, ct);
1074 	} else {
1075 		fem_addref(femsp);
1076 		fem_unlock(vp->v_femhead);
1077 		farg.fa_vnode.vp = vp;
1078 		farg.fa_fnode = femsp->feml_nodes + femsp->feml_tos;
1079 		vsop_find(&farg, &func, void, &arg0, vop_rwunlock,
1080 		    femop_rwunlock);
1081 		(*func)(arg0, write_lock, ct);
1082 		fem_release(femsp);
1083 	}
1084 }
1085 
1086 static int
1087 vhead_seek(vnode_t *vp, offset_t ooff, offset_t *noffp, caller_context_t *ct)
1088 {
1089 	femarg_t	farg;
1090 	struct fem_list	*femsp;
1091 	int		(*func)();
1092 	void		*arg0;
1093 	int		errc;
1094 
1095 	if ((femsp = fem_lock(vp->v_femhead)) == NULL) {
1096 		func = (int (*)()) (vp->v_op->vop_seek);
1097 		arg0 = vp;
1098 		fem_unlock(vp->v_femhead);
1099 		errc = (*func)(arg0, ooff, noffp, ct);
1100 	} else {
1101 		fem_addref(femsp);
1102 		fem_unlock(vp->v_femhead);
1103 		farg.fa_vnode.vp = vp;
1104 		farg.fa_fnode = femsp->feml_nodes + femsp->feml_tos;
1105 		vsop_find(&farg, &func, int, &arg0, vop_seek, femop_seek);
1106 		errc = (*func)(arg0, ooff, noffp, ct);
1107 		fem_release(femsp);
1108 	}
1109 	return (errc);
1110 }
1111 
1112 static int
1113 vhead_cmp(vnode_t *vp1, vnode_t *vp2, caller_context_t *ct)
1114 {
1115 	femarg_t	farg;
1116 	struct fem_list	*femsp;
1117 	int		(*func)();
1118 	void		*arg0;
1119 	int		errc;
1120 
1121 	if ((femsp = fem_lock(vp1->v_femhead)) == NULL) {
1122 		func = (int (*)()) (vp1->v_op->vop_cmp);
1123 		arg0 = vp1;
1124 		fem_unlock(vp1->v_femhead);
1125 		errc = (*func)(arg0, vp2, ct);
1126 	} else {
1127 		fem_addref(femsp);
1128 		fem_unlock(vp1->v_femhead);
1129 		farg.fa_vnode.vp = vp1;
1130 		farg.fa_fnode = femsp->feml_nodes + femsp->feml_tos;
1131 		vsop_find(&farg, &func, int, &arg0, vop_cmp, femop_cmp);
1132 		errc = (*func)(arg0, vp2, ct);
1133 		fem_release(femsp);
1134 	}
1135 	return (errc);
1136 }
1137 
1138 static int
1139 vhead_frlock(vnode_t *vp, int cmd, struct flock64 *bfp, int flag,
1140 	offset_t offset, struct flk_callback *flk_cbp, cred_t *cr,
1141 	caller_context_t *ct)
1142 {
1143 	femarg_t	farg;
1144 	struct fem_list	*femsp;
1145 	int		(*func)();
1146 	void		*arg0;
1147 	int		errc;
1148 
1149 	if ((femsp = fem_lock(vp->v_femhead)) == NULL) {
1150 		func = (int (*)()) (vp->v_op->vop_frlock);
1151 		arg0 = vp;
1152 		fem_unlock(vp->v_femhead);
1153 		errc = (*func)(arg0, cmd, bfp, flag, offset, flk_cbp, cr, ct);
1154 	} else {
1155 		fem_addref(femsp);
1156 		fem_unlock(vp->v_femhead);
1157 		farg.fa_vnode.vp = vp;
1158 		farg.fa_fnode = femsp->feml_nodes + femsp->feml_tos;
1159 		vsop_find(&farg, &func, int, &arg0, vop_frlock,
1160 		    femop_frlock);
1161 		errc = (*func)(arg0, cmd, bfp, flag, offset, flk_cbp, cr, ct);
1162 		fem_release(femsp);
1163 	}
1164 	return (errc);
1165 }
1166 
1167 static int
1168 vhead_space(vnode_t *vp, int cmd, struct flock64 *bfp, int flag,
1169 	offset_t offset, cred_t *cr, caller_context_t *ct)
1170 {
1171 	femarg_t	farg;
1172 	struct fem_list	*femsp;
1173 	int		(*func)();
1174 	void		*arg0;
1175 	int		errc;
1176 
1177 	if ((femsp = fem_lock(vp->v_femhead)) == NULL) {
1178 		func = (int (*)()) (vp->v_op->vop_space);
1179 		arg0 = vp;
1180 		fem_unlock(vp->v_femhead);
1181 		errc = (*func)(arg0, cmd, bfp, flag, offset, cr, ct);
1182 	} else {
1183 		fem_addref(femsp);
1184 		fem_unlock(vp->v_femhead);
1185 		farg.fa_vnode.vp = vp;
1186 		farg.fa_fnode = femsp->feml_nodes + femsp->feml_tos;
1187 		vsop_find(&farg, &func, int, &arg0, vop_space, femop_space);
1188 		errc = (*func)(arg0, cmd, bfp, flag, offset, cr, ct);
1189 		fem_release(femsp);
1190 	}
1191 	return (errc);
1192 }
1193 
1194 static int
1195 vhead_realvp(vnode_t *vp, vnode_t **vpp, caller_context_t *ct)
1196 {
1197 	femarg_t	farg;
1198 	struct fem_list	*femsp;
1199 	int		(*func)();
1200 	void		*arg0;
1201 	int		errc;
1202 
1203 	if ((femsp = fem_lock(vp->v_femhead)) == NULL) {
1204 		func = (int (*)()) (vp->v_op->vop_realvp);
1205 		arg0 = vp;
1206 		fem_unlock(vp->v_femhead);
1207 		errc = (*func)(arg0, vpp, ct);
1208 	} else {
1209 		fem_addref(femsp);
1210 		fem_unlock(vp->v_femhead);
1211 		farg.fa_vnode.vp = vp;
1212 		farg.fa_fnode = femsp->feml_nodes + femsp->feml_tos;
1213 		vsop_find(&farg, &func, int, &arg0, vop_realvp,
1214 		    femop_realvp);
1215 		errc = (*func)(arg0, vpp, ct);
1216 		fem_release(femsp);
1217 	}
1218 	return (errc);
1219 }
1220 
1221 static int
1222 vhead_getpage(vnode_t *vp, offset_t off, size_t len, uint_t *protp,
1223 	struct page **plarr, size_t plsz, struct seg *seg, caddr_t addr,
1224 	enum seg_rw rw, cred_t *cr, caller_context_t *ct)
1225 {
1226 	femarg_t	farg;
1227 	struct fem_list	*femsp;
1228 	int		(*func)();
1229 	void		*arg0;
1230 	int		errc;
1231 
1232 	if ((femsp = fem_lock(vp->v_femhead)) == NULL) {
1233 		func = (int (*)()) (vp->v_op->vop_getpage);
1234 		arg0 = vp;
1235 		fem_unlock(vp->v_femhead);
1236 		errc = (*func)(arg0, off, len, protp, plarr, plsz, seg,
1237 		    addr, rw, cr, ct);
1238 	} else {
1239 		fem_addref(femsp);
1240 		fem_unlock(vp->v_femhead);
1241 		farg.fa_vnode.vp = vp;
1242 		farg.fa_fnode = femsp->feml_nodes + femsp->feml_tos;
1243 		vsop_find(&farg, &func, int, &arg0, vop_getpage,
1244 		    femop_getpage);
1245 		errc = (*func)(arg0, off, len, protp, plarr, plsz, seg,
1246 		    addr, rw, cr, ct);
1247 		fem_release(femsp);
1248 	}
1249 	return (errc);
1250 }
1251 
1252 static int
1253 vhead_putpage(vnode_t *vp, offset_t off, size_t len, int flags, cred_t *cr,
1254 	caller_context_t *ct)
1255 {
1256 	femarg_t	farg;
1257 	struct fem_list	*femsp;
1258 	int		(*func)();
1259 	void		*arg0;
1260 	int		errc;
1261 
1262 	if ((femsp = fem_lock(vp->v_femhead)) == NULL) {
1263 		func = (int (*)()) (vp->v_op->vop_putpage);
1264 		arg0 = vp;
1265 		fem_unlock(vp->v_femhead);
1266 		errc = (*func)(arg0, off, len, flags, cr, ct);
1267 	} else {
1268 		fem_addref(femsp);
1269 		fem_unlock(vp->v_femhead);
1270 		farg.fa_vnode.vp = vp;
1271 		farg.fa_fnode = femsp->feml_nodes + femsp->feml_tos;
1272 		vsop_find(&farg, &func, int, &arg0, vop_putpage,
1273 		    femop_putpage);
1274 		errc = (*func)(arg0, off, len, flags, cr, ct);
1275 		fem_release(femsp);
1276 	}
1277 	return (errc);
1278 }
1279 
1280 static int
1281 vhead_map(vnode_t *vp, offset_t off, struct as *as, caddr_t *addrp,
1282 	size_t len, uchar_t prot, uchar_t maxprot, uint_t flags,
1283 	cred_t *cr, caller_context_t *ct)
1284 {
1285 	femarg_t	farg;
1286 	struct fem_list	*femsp;
1287 	int		(*func)();
1288 	void		*arg0;
1289 	int		errc;
1290 
1291 	if ((femsp = fem_lock(vp->v_femhead)) == NULL) {
1292 		func = (int (*)()) (vp->v_op->vop_map);
1293 		arg0 = vp;
1294 		fem_unlock(vp->v_femhead);
1295 		errc = (*func)(arg0, off, as, addrp, len, prot, maxprot,
1296 		    flags, cr, ct);
1297 	} else {
1298 		fem_addref(femsp);
1299 		fem_unlock(vp->v_femhead);
1300 		farg.fa_vnode.vp = vp;
1301 		farg.fa_fnode = femsp->feml_nodes + femsp->feml_tos;
1302 		vsop_find(&farg, &func, int, &arg0, vop_map, femop_map);
1303 		errc = (*func)(arg0, off, as, addrp, len, prot, maxprot,
1304 		    flags, cr, ct);
1305 		fem_release(femsp);
1306 	}
1307 	return (errc);
1308 }
1309 
1310 static int
1311 vhead_addmap(vnode_t *vp, offset_t off, struct as *as, caddr_t addr,
1312 	size_t len, uchar_t prot, uchar_t maxprot, uint_t flags,
1313 	cred_t *cr, caller_context_t *ct)
1314 {
1315 	femarg_t	farg;
1316 	struct fem_list	*femsp;
1317 	int		(*func)();
1318 	void		*arg0;
1319 	int		errc;
1320 
1321 	if ((femsp = fem_lock(vp->v_femhead)) == NULL) {
1322 		func = (int (*)()) (vp->v_op->vop_addmap);
1323 		arg0 = vp;
1324 		fem_unlock(vp->v_femhead);
1325 		errc = (*func)(arg0, off, as, addr, len, prot, maxprot,
1326 		    flags, cr, ct);
1327 	} else {
1328 		fem_addref(femsp);
1329 		fem_unlock(vp->v_femhead);
1330 		farg.fa_vnode.vp = vp;
1331 		farg.fa_fnode = femsp->feml_nodes + femsp->feml_tos;
1332 		vsop_find(&farg, &func, int, &arg0, vop_addmap,
1333 		    femop_addmap);
1334 		errc = (*func)(arg0, off, as, addr, len, prot, maxprot,
1335 		    flags, cr, ct);
1336 		fem_release(femsp);
1337 	}
1338 	return (errc);
1339 }
1340 
1341 static int
1342 vhead_delmap(vnode_t *vp, offset_t off, struct as *as, caddr_t addr,
1343 	size_t len, uint_t prot, uint_t maxprot, uint_t flags, cred_t *cr,
1344 	caller_context_t *ct)
1345 {
1346 	femarg_t	farg;
1347 	struct fem_list	*femsp;
1348 	int		(*func)();
1349 	void		*arg0;
1350 	int		errc;
1351 
1352 	if ((femsp = fem_lock(vp->v_femhead)) == NULL) {
1353 		func = (int (*)()) (vp->v_op->vop_delmap);
1354 		arg0 = vp;
1355 		fem_unlock(vp->v_femhead);
1356 		errc = (*func)(arg0, off, as, addr, len, prot, maxprot,
1357 		    flags, cr, ct);
1358 	} else {
1359 		fem_addref(femsp);
1360 		fem_unlock(vp->v_femhead);
1361 		farg.fa_vnode.vp = vp;
1362 		farg.fa_fnode = femsp->feml_nodes + femsp->feml_tos;
1363 		vsop_find(&farg, &func, int, &arg0, vop_delmap,
1364 		    femop_delmap);
1365 		errc = (*func)(arg0, off, as, addr, len, prot, maxprot,
1366 		    flags, cr, ct);
1367 		fem_release(femsp);
1368 	}
1369 	return (errc);
1370 }
1371 
1372 static int
1373 vhead_poll(vnode_t *vp, short events, int anyyet, short *reventsp,
1374 	struct pollhead **phpp, caller_context_t *ct)
1375 {
1376 	femarg_t	farg;
1377 	struct fem_list	*femsp;
1378 	int		(*func)();
1379 	void		*arg0;
1380 	int		errc;
1381 
1382 	if ((femsp = fem_lock(vp->v_femhead)) == NULL) {
1383 		func = (int (*)()) (vp->v_op->vop_poll);
1384 		arg0 = vp;
1385 		fem_unlock(vp->v_femhead);
1386 		errc = (*func)(arg0, events, anyyet, reventsp, phpp, ct);
1387 	} else {
1388 		fem_addref(femsp);
1389 		fem_unlock(vp->v_femhead);
1390 		farg.fa_vnode.vp = vp;
1391 		farg.fa_fnode = femsp->feml_nodes + femsp->feml_tos;
1392 		vsop_find(&farg, &func, int, &arg0, vop_poll, femop_poll);
1393 		errc = (*func)(arg0, events, anyyet, reventsp, phpp, ct);
1394 		fem_release(femsp);
1395 	}
1396 	return (errc);
1397 }
1398 
1399 static int
1400 vhead_dump(vnode_t *vp, caddr_t addr, offset_t lbdn, offset_t dblks,
1401     caller_context_t *ct)
1402 {
1403 	femarg_t	farg;
1404 	struct fem_list	*femsp;
1405 	int		(*func)();
1406 	void		*arg0;
1407 	int		errc;
1408 
1409 	if ((femsp = fem_lock(vp->v_femhead)) == NULL) {
1410 		func = (int (*)()) (vp->v_op->vop_dump);
1411 		arg0 = vp;
1412 		fem_unlock(vp->v_femhead);
1413 		errc = (*func)(arg0, addr, lbdn, dblks, ct);
1414 	} else {
1415 		fem_addref(femsp);
1416 		fem_unlock(vp->v_femhead);
1417 		farg.fa_vnode.vp = vp;
1418 		farg.fa_fnode = femsp->feml_nodes + femsp->feml_tos;
1419 		vsop_find(&farg, &func, int, &arg0, vop_dump, femop_dump);
1420 		errc = (*func)(arg0, addr, lbdn, dblks, ct);
1421 		fem_release(femsp);
1422 	}
1423 	return (errc);
1424 }
1425 
1426 static int
1427 vhead_pathconf(vnode_t *vp, int cmd, ulong_t *valp, cred_t *cr,
1428 	caller_context_t *ct)
1429 {
1430 	femarg_t	farg;
1431 	struct fem_list	*femsp;
1432 	int		(*func)();
1433 	void		*arg0;
1434 	int		errc;
1435 
1436 	if ((femsp = fem_lock(vp->v_femhead)) == NULL) {
1437 		func = (int (*)()) (vp->v_op->vop_pathconf);
1438 		arg0 = vp;
1439 		fem_unlock(vp->v_femhead);
1440 		errc = (*func)(arg0, cmd, valp, cr, ct);
1441 	} else {
1442 		fem_addref(femsp);
1443 		fem_unlock(vp->v_femhead);
1444 		farg.fa_vnode.vp = vp;
1445 		farg.fa_fnode = femsp->feml_nodes + femsp->feml_tos;
1446 		vsop_find(&farg, &func, int, &arg0, vop_pathconf,
1447 		    femop_pathconf);
1448 		errc = (*func)(arg0, cmd, valp, cr, ct);
1449 		fem_release(femsp);
1450 	}
1451 	return (errc);
1452 }
1453 
1454 static int
1455 vhead_pageio(vnode_t *vp, struct page *pp, u_offset_t io_off,
1456 	size_t io_len, int flags, cred_t *cr, caller_context_t *ct)
1457 {
1458 	femarg_t	farg;
1459 	struct fem_list	*femsp;
1460 	int		(*func)();
1461 	void		*arg0;
1462 	int		errc;
1463 
1464 	if ((femsp = fem_lock(vp->v_femhead)) == NULL) {
1465 		func = (int (*)()) (vp->v_op->vop_pageio);
1466 		arg0 = vp;
1467 		fem_unlock(vp->v_femhead);
1468 		errc = (*func)(arg0, pp, io_off, io_len, flags, cr, ct);
1469 	} else {
1470 		fem_addref(femsp);
1471 		fem_unlock(vp->v_femhead);
1472 		farg.fa_vnode.vp = vp;
1473 		farg.fa_fnode = femsp->feml_nodes + femsp->feml_tos;
1474 		vsop_find(&farg, &func, int, &arg0, vop_pageio,
1475 		    femop_pageio);
1476 		errc = (*func)(arg0, pp, io_off, io_len, flags, cr, ct);
1477 		fem_release(femsp);
1478 	}
1479 	return (errc);
1480 }
1481 
1482 static int
1483 vhead_dumpctl(vnode_t *vp, int action, offset_t *blkp, caller_context_t *ct)
1484 {
1485 	femarg_t	farg;
1486 	struct fem_list	*femsp;
1487 	int		(*func)();
1488 	void		*arg0;
1489 	int		errc;
1490 
1491 	if ((femsp = fem_lock(vp->v_femhead)) == NULL) {
1492 		func = (int (*)()) (vp->v_op->vop_dumpctl);
1493 		arg0 = vp;
1494 		fem_unlock(vp->v_femhead);
1495 		errc = (*func)(arg0, action, blkp, ct);
1496 	} else {
1497 		fem_addref(femsp);
1498 		fem_unlock(vp->v_femhead);
1499 		farg.fa_vnode.vp = vp;
1500 		farg.fa_fnode = femsp->feml_nodes + femsp->feml_tos;
1501 		vsop_find(&farg, &func, int, &arg0, vop_dumpctl,
1502 		    femop_dumpctl);
1503 		errc = (*func)(arg0, action, blkp, ct);
1504 		fem_release(femsp);
1505 	}
1506 	return (errc);
1507 }
1508 
1509 static void
1510 vhead_dispose(vnode_t *vp, struct page *pp, int flag, int dn, cred_t *cr,
1511 	caller_context_t *ct)
1512 {
1513 	femarg_t	farg;
1514 	struct fem_list	*femsp;
1515 	void		(*func)();
1516 	void		*arg0;
1517 
1518 	if ((femsp = fem_lock(vp->v_femhead)) == NULL) {
1519 		func = (void (*)()) (vp->v_op->vop_dispose);
1520 		arg0 = vp;
1521 		fem_unlock(vp->v_femhead);
1522 		(*func)(arg0, pp, flag, dn, cr, ct);
1523 	} else {
1524 		fem_addref(femsp);
1525 		fem_unlock(vp->v_femhead);
1526 		farg.fa_vnode.vp = vp;
1527 		farg.fa_fnode = femsp->feml_nodes + femsp->feml_tos;
1528 		vsop_find(&farg, &func, void, &arg0, vop_dispose,
1529 		    femop_dispose);
1530 		(*func)(arg0, pp, flag, dn, cr, ct);
1531 		fem_release(femsp);
1532 	}
1533 }
1534 
1535 static int
1536 vhead_setsecattr(vnode_t *vp, vsecattr_t *vsap, int flag, cred_t *cr,
1537 	caller_context_t *ct)
1538 {
1539 	femarg_t	farg;
1540 	struct fem_list	*femsp;
1541 	int		(*func)();
1542 	void		*arg0;
1543 	int		errc;
1544 
1545 	if ((femsp = fem_lock(vp->v_femhead)) == NULL) {
1546 		func = (int (*)()) (vp->v_op->vop_setsecattr);
1547 		arg0 = vp;
1548 		fem_unlock(vp->v_femhead);
1549 		errc = (*func)(arg0, vsap, flag, cr, ct);
1550 	} else {
1551 		fem_addref(femsp);
1552 		fem_unlock(vp->v_femhead);
1553 		farg.fa_vnode.vp = vp;
1554 		farg.fa_fnode = femsp->feml_nodes + femsp->feml_tos;
1555 		vsop_find(&farg, &func, int, &arg0, vop_setsecattr,
1556 		    femop_setsecattr);
1557 		errc = (*func)(arg0, vsap, flag, cr, ct);
1558 		fem_release(femsp);
1559 	}
1560 	return (errc);
1561 }
1562 
1563 static int
1564 vhead_getsecattr(vnode_t *vp, vsecattr_t *vsap, int flag, cred_t *cr,
1565 	caller_context_t *ct)
1566 {
1567 	femarg_t	farg;
1568 	struct fem_list	*femsp;
1569 	int		(*func)();
1570 	void		*arg0;
1571 	int		errc;
1572 
1573 	if ((femsp = fem_lock(vp->v_femhead)) == NULL) {
1574 		func = (int (*)()) (vp->v_op->vop_getsecattr);
1575 		arg0 = vp;
1576 		fem_unlock(vp->v_femhead);
1577 		errc = (*func)(arg0, vsap, flag, cr, ct);
1578 	} else {
1579 		fem_addref(femsp);
1580 		fem_unlock(vp->v_femhead);
1581 		farg.fa_vnode.vp = vp;
1582 		farg.fa_fnode = femsp->feml_nodes + femsp->feml_tos;
1583 		vsop_find(&farg, &func, int, &arg0, vop_getsecattr,
1584 		    femop_getsecattr);
1585 		errc = (*func)(arg0, vsap, flag, cr, ct);
1586 		fem_release(femsp);
1587 	}
1588 	return (errc);
1589 }
1590 
1591 static int
1592 vhead_shrlock(vnode_t *vp, int cmd, struct shrlock *shr, int flag,
1593 	cred_t *cr, caller_context_t *ct)
1594 {
1595 	femarg_t	farg;
1596 	struct fem_list	*femsp;
1597 	int		(*func)();
1598 	void		*arg0;
1599 	int		errc;
1600 
1601 	if ((femsp = fem_lock(vp->v_femhead)) == NULL) {
1602 		func = (int (*)()) (vp->v_op->vop_shrlock);
1603 		arg0 = vp;
1604 		fem_unlock(vp->v_femhead);
1605 		errc = (*func)(arg0, cmd, shr, flag, cr, ct);
1606 	} else {
1607 		fem_addref(femsp);
1608 		fem_unlock(vp->v_femhead);
1609 		farg.fa_vnode.vp = vp;
1610 		farg.fa_fnode = femsp->feml_nodes + femsp->feml_tos;
1611 		vsop_find(&farg, &func, int, &arg0, vop_shrlock,
1612 		    femop_shrlock);
1613 		errc = (*func)(arg0, cmd, shr, flag, cr, ct);
1614 		fem_release(femsp);
1615 	}
1616 	return (errc);
1617 }
1618 
1619 static int
1620 vhead_vnevent(vnode_t *vp, vnevent_t vnevent, vnode_t *dvp, char *cname,
1621     caller_context_t *ct)
1622 {
1623 	femarg_t	farg;
1624 	struct fem_list	*femsp;
1625 	int		(*func)();
1626 	void		*arg0;
1627 	int		errc;
1628 
1629 	if ((femsp = fem_lock(vp->v_femhead)) == NULL) {
1630 		func = (int (*)()) (vp->v_op->vop_vnevent);
1631 		arg0 = vp;
1632 		fem_unlock(vp->v_femhead);
1633 		errc = (*func)(arg0, vnevent, dvp, cname, ct);
1634 	} else {
1635 		fem_addref(femsp);
1636 		fem_unlock(vp->v_femhead);
1637 		farg.fa_vnode.vp = vp;
1638 		farg.fa_fnode = femsp->feml_nodes + femsp->feml_tos;
1639 		vsop_find(&farg, &func, int, &arg0, vop_vnevent,
1640 		    femop_vnevent);
1641 		errc = (*func)(arg0, vnevent, dvp, cname, ct);
1642 		fem_release(femsp);
1643 	}
1644 	return (errc);
1645 }
1646 
1647 static int
1648 fshead_mount(vfs_t *vfsp, vnode_t *mvp, struct mounta *uap, cred_t *cr)
1649 {
1650 	fsemarg_t	farg;
1651 	struct fem_list	*femsp;
1652 	int		(*func)();
1653 	void		*arg0;
1654 	int		errc;
1655 
1656 	ASSERT(vfsp->vfs_implp);
1657 
1658 	if ((femsp = fem_lock(vfsp->vfs_femhead)) == NULL) {
1659 		func = (int (*)()) vfsp->vfs_op->vfs_mount;
1660 		fem_unlock(vfsp->vfs_femhead);
1661 		errc = (*func)(vfsp, mvp, uap, cr);
1662 	} else {
1663 		fem_addref(femsp);
1664 		fem_unlock(vfsp->vfs_femhead);
1665 		farg.fa_vnode.vfsp = vfsp;
1666 		farg.fa_fnode = femsp->feml_nodes + femsp->feml_tos;
1667 		vfsop_find(&farg, &func, int, &arg0, vfs_mount,
1668 		    fsemop_mount);
1669 		errc = (*func)(arg0, mvp, uap, cr);
1670 		fem_release(femsp);
1671 	}
1672 	return (errc);
1673 }
1674 
1675 static int
1676 fshead_unmount(vfs_t *vfsp, int flag, cred_t *cr)
1677 {
1678 	fsemarg_t	farg;
1679 	struct fem_list	*femsp;
1680 	int		(*func)();
1681 	void		*arg0;
1682 	int		errc;
1683 
1684 	ASSERT(vfsp->vfs_implp);
1685 
1686 	if ((femsp = fem_lock(vfsp->vfs_femhead)) == NULL) {
1687 		func = (int (*)()) vfsp->vfs_op->vfs_unmount;
1688 		fem_unlock(vfsp->vfs_femhead);
1689 		errc = (*func)(vfsp, flag, cr);
1690 	} else {
1691 		fem_addref(femsp);
1692 		fem_unlock(vfsp->vfs_femhead);
1693 		farg.fa_vnode.vfsp = vfsp;
1694 		farg.fa_fnode = femsp->feml_nodes + femsp->feml_tos;
1695 		vfsop_find(&farg, &func, int, &arg0, vfs_unmount,
1696 		    fsemop_unmount);
1697 		errc = (*func)(arg0, flag, cr);
1698 		fem_release(femsp);
1699 	}
1700 	return (errc);
1701 }
1702 
1703 static int
1704 fshead_root(vfs_t *vfsp, vnode_t **vpp)
1705 {
1706 	fsemarg_t	farg;
1707 	struct fem_list	*femsp;
1708 	int		(*func)();
1709 	void		*arg0;
1710 	int		errc;
1711 
1712 	ASSERT(vfsp->vfs_implp);
1713 
1714 	if ((femsp = fem_lock(vfsp->vfs_femhead)) == NULL) {
1715 		func = (int (*)()) vfsp->vfs_op->vfs_root;
1716 		fem_unlock(vfsp->vfs_femhead);
1717 		errc = (*func)(vfsp, vpp);
1718 	} else {
1719 		fem_addref(femsp);
1720 		fem_unlock(vfsp->vfs_femhead);
1721 		farg.fa_vnode.vfsp = vfsp;
1722 		farg.fa_fnode = femsp->feml_nodes + femsp->feml_tos;
1723 		vfsop_find(&farg, &func, int, &arg0, vfs_root, fsemop_root);
1724 		errc = (*func)(arg0, vpp);
1725 		fem_release(femsp);
1726 	}
1727 	return (errc);
1728 }
1729 
1730 static int
1731 fshead_statvfs(vfs_t *vfsp, statvfs64_t *sp)
1732 {
1733 	fsemarg_t	farg;
1734 	struct fem_list	*femsp;
1735 	int		(*func)();
1736 	void		*arg0;
1737 	int		errc;
1738 
1739 	ASSERT(vfsp->vfs_implp);
1740 
1741 	if ((femsp = fem_lock(vfsp->vfs_femhead)) == NULL) {
1742 		func = (int (*)()) vfsp->vfs_op->vfs_statvfs;
1743 		fem_unlock(vfsp->vfs_femhead);
1744 		errc = (*func)(vfsp, sp);
1745 	} else {
1746 		fem_addref(femsp);
1747 		fem_unlock(vfsp->vfs_femhead);
1748 		farg.fa_vnode.vfsp = vfsp;
1749 		farg.fa_fnode = femsp->feml_nodes + femsp->feml_tos;
1750 		vfsop_find(&farg, &func, int, &arg0, vfs_statvfs,
1751 		    fsemop_statvfs);
1752 		errc = (*func)(arg0, sp);
1753 		fem_release(femsp);
1754 	}
1755 	return (errc);
1756 }
1757 
1758 static int
1759 fshead_sync(vfs_t *vfsp, short flag, cred_t *cr)
1760 {
1761 	fsemarg_t	farg;
1762 	struct fem_list	*femsp;
1763 	int		(*func)();
1764 	void		*arg0;
1765 	int		errc;
1766 
1767 	ASSERT(vfsp->vfs_implp);
1768 
1769 	if ((femsp = fem_lock(vfsp->vfs_femhead)) == NULL) {
1770 		func = (int (*)()) vfsp->vfs_op->vfs_sync;
1771 		fem_unlock(vfsp->vfs_femhead);
1772 		errc = (*func)(vfsp, flag, cr);
1773 	} else {
1774 		fem_addref(femsp);
1775 		fem_unlock(vfsp->vfs_femhead);
1776 		farg.fa_vnode.vfsp = vfsp;
1777 		farg.fa_fnode = femsp->feml_nodes + femsp->feml_tos;
1778 		vfsop_find(&farg, &func, int, &arg0, vfs_sync, fsemop_sync);
1779 		errc = (*func)(arg0, flag, cr);
1780 		fem_release(femsp);
1781 	}
1782 	return (errc);
1783 }
1784 
1785 static int
1786 fshead_vget(vfs_t *vfsp, vnode_t **vpp, fid_t *fidp)
1787 {
1788 	fsemarg_t	farg;
1789 	struct fem_list	*femsp;
1790 	int		(*func)();
1791 	void		*arg0;
1792 	int		errc;
1793 
1794 	ASSERT(vfsp->vfs_implp);
1795 
1796 	if ((femsp = fem_lock(vfsp->vfs_femhead)) == NULL) {
1797 		func = (int (*)()) vfsp->vfs_op->vfs_vget;
1798 		fem_unlock(vfsp->vfs_femhead);
1799 		errc = (*func)(vfsp, vpp, fidp);
1800 	} else {
1801 		fem_addref(femsp);
1802 		fem_unlock(vfsp->vfs_femhead);
1803 		farg.fa_vnode.vfsp = vfsp;
1804 		farg.fa_fnode = femsp->feml_nodes + femsp->feml_tos;
1805 		vfsop_find(&farg, &func, int, &arg0, vfs_vget, fsemop_vget);
1806 		errc = (*func)(arg0, vpp, fidp);
1807 		fem_release(femsp);
1808 	}
1809 	return (errc);
1810 }
1811 
1812 static int
1813 fshead_mountroot(vfs_t *vfsp, enum whymountroot reason)
1814 {
1815 	fsemarg_t	farg;
1816 	struct fem_list	*femsp;
1817 	int		(*func)();
1818 	void		*arg0;
1819 	int		errc;
1820 
1821 	ASSERT(vfsp->vfs_implp);
1822 
1823 	if ((femsp = fem_lock(vfsp->vfs_femhead)) == NULL) {
1824 		func = (int (*)()) vfsp->vfs_op->vfs_mountroot;
1825 		fem_unlock(vfsp->vfs_femhead);
1826 		errc = (*func)(vfsp, reason);
1827 	} else {
1828 		fem_addref(femsp);
1829 		fem_unlock(vfsp->vfs_femhead);
1830 		farg.fa_vnode.vfsp = vfsp;
1831 		farg.fa_fnode = femsp->feml_nodes + femsp->feml_tos;
1832 		vfsop_find(&farg, &func, int, &arg0, vfs_mountroot,
1833 		    fsemop_mountroot);
1834 		errc = (*func)(arg0, reason);
1835 		fem_release(femsp);
1836 	}
1837 	return (errc);
1838 }
1839 
1840 static void
1841 fshead_freevfs(vfs_t *vfsp)
1842 {
1843 	fsemarg_t	farg;
1844 	struct fem_list	*femsp;
1845 	void		(*func)();
1846 	void		*arg0;
1847 
1848 	ASSERT(vfsp->vfs_implp);
1849 
1850 	if ((femsp = fem_lock(vfsp->vfs_femhead)) == NULL) {
1851 		func = (void (*)()) vfsp->vfs_op->vfs_freevfs;
1852 		fem_unlock(vfsp->vfs_femhead);
1853 		(*func)(vfsp);
1854 	} else {
1855 		fem_addref(femsp);
1856 		fem_unlock(vfsp->vfs_femhead);
1857 		farg.fa_vnode.vfsp = vfsp;
1858 		farg.fa_fnode = femsp->feml_nodes + femsp->feml_tos;
1859 		vfsop_find(&farg, &func, void, &arg0, vfs_freevfs,
1860 		    fsemop_freevfs);
1861 		(*func)(arg0);
1862 		fem_release(femsp);
1863 	}
1864 }
1865 
1866 static int
1867 fshead_vnstate(vfs_t *vfsp, vnode_t *vp, vntrans_t nstate)
1868 {
1869 	fsemarg_t	farg;
1870 	struct fem_list	*femsp;
1871 	int		(*func)();
1872 	void		*arg0;
1873 	int		errc;
1874 
1875 	ASSERT(vfsp->vfs_implp);
1876 
1877 	if ((femsp = fem_lock(vfsp->vfs_femhead)) == NULL) {
1878 		func = (int (*)()) vfsp->vfs_op->vfs_vnstate;
1879 		fem_unlock(vfsp->vfs_femhead);
1880 		errc = (*func)(vfsp, vp, nstate);
1881 	} else {
1882 		fem_addref(femsp);
1883 		fem_unlock(vfsp->vfs_femhead);
1884 		farg.fa_vnode.vfsp = vfsp;
1885 		farg.fa_fnode = femsp->feml_nodes + femsp->feml_tos;
1886 		vfsop_find(&farg, &func, int, &arg0, vfs_vnstate,
1887 		    fsemop_vnstate);
1888 		errc = (*func)(arg0, vp, nstate);
1889 		fem_release(femsp);
1890 	}
1891 	return (errc);
1892 }
1893 
1894 
1895 /*
1896  * specification table for the vhead vnode operations.
1897  * It is an error for any operations to be missing.
1898  */
1899 
1900 static struct fs_operation_def fhead_vn_spec[] = {
1901 	{ VOPNAME_OPEN, (femop_t *)vhead_open },
1902 	{ VOPNAME_CLOSE, (femop_t *)vhead_close },
1903 	{ VOPNAME_READ, (femop_t *)vhead_read },
1904 	{ VOPNAME_WRITE, (femop_t *)vhead_write },
1905 	{ VOPNAME_IOCTL, (femop_t *)vhead_ioctl },
1906 	{ VOPNAME_SETFL, (femop_t *)vhead_setfl },
1907 	{ VOPNAME_GETATTR, (femop_t *)vhead_getattr },
1908 	{ VOPNAME_SETATTR, (femop_t *)vhead_setattr },
1909 	{ VOPNAME_ACCESS, (femop_t *)vhead_access },
1910 	{ VOPNAME_LOOKUP, (femop_t *)vhead_lookup },
1911 	{ VOPNAME_CREATE, (femop_t *)vhead_create },
1912 	{ VOPNAME_REMOVE, (femop_t *)vhead_remove },
1913 	{ VOPNAME_LINK, (femop_t *)vhead_link },
1914 	{ VOPNAME_RENAME, (femop_t *)vhead_rename },
1915 	{ VOPNAME_MKDIR, (femop_t *)vhead_mkdir },
1916 	{ VOPNAME_RMDIR, (femop_t *)vhead_rmdir },
1917 	{ VOPNAME_READDIR, (femop_t *)vhead_readdir },
1918 	{ VOPNAME_SYMLINK, (femop_t *)vhead_symlink },
1919 	{ VOPNAME_READLINK, (femop_t *)vhead_readlink },
1920 	{ VOPNAME_FSYNC, (femop_t *)vhead_fsync },
1921 	{ VOPNAME_INACTIVE, (femop_t *)vhead_inactive },
1922 	{ VOPNAME_FID, (femop_t *)vhead_fid },
1923 	{ VOPNAME_RWLOCK, (femop_t *)vhead_rwlock },
1924 	{ VOPNAME_RWUNLOCK, (femop_t *)vhead_rwunlock },
1925 	{ VOPNAME_SEEK, (femop_t *)vhead_seek },
1926 	{ VOPNAME_CMP, (femop_t *)vhead_cmp },
1927 	{ VOPNAME_FRLOCK, (femop_t *)vhead_frlock },
1928 	{ VOPNAME_SPACE, (femop_t *)vhead_space },
1929 	{ VOPNAME_REALVP, (femop_t *)vhead_realvp },
1930 	{ VOPNAME_GETPAGE, (femop_t *)vhead_getpage },
1931 	{ VOPNAME_PUTPAGE, (femop_t *)vhead_putpage },
1932 	{ VOPNAME_MAP, (femop_t *)vhead_map },
1933 	{ VOPNAME_ADDMAP, (femop_t *)vhead_addmap },
1934 	{ VOPNAME_DELMAP, (femop_t *)vhead_delmap },
1935 	{ VOPNAME_POLL, (femop_t *)vhead_poll },
1936 	{ VOPNAME_DUMP, (femop_t *)vhead_dump },
1937 	{ VOPNAME_PATHCONF, (femop_t *)vhead_pathconf },
1938 	{ VOPNAME_PAGEIO, (femop_t *)vhead_pageio },
1939 	{ VOPNAME_DUMPCTL, (femop_t *)vhead_dumpctl },
1940 	{ VOPNAME_DISPOSE, (femop_t *)vhead_dispose },
1941 	{ VOPNAME_SETSECATTR, (femop_t *)vhead_setsecattr },
1942 	{ VOPNAME_GETSECATTR, (femop_t *)vhead_getsecattr },
1943 	{ VOPNAME_SHRLOCK, (femop_t *)vhead_shrlock },
1944 	{ VOPNAME_VNEVENT, (femop_t *)vhead_vnevent },
1945 	{	NULL,	NULL	}
1946 };
1947 
1948 /*
1949  * specification table for the vfshead vnode operations.
1950  * It is an error for any operations to be missing.
1951  */
1952 
1953 static struct fs_operation_def fshead_vfs_spec[]  = {
1954 	{ VFSNAME_MOUNT, (femop_t *)fshead_mount },
1955 	{ VFSNAME_UNMOUNT, (femop_t *)fshead_unmount },
1956 	{ VFSNAME_ROOT, (femop_t *)fshead_root },
1957 	{ VFSNAME_STATVFS, (femop_t *)fshead_statvfs },
1958 	{ VFSNAME_SYNC, (femop_t *)fshead_sync },
1959 	{ VFSNAME_VGET, (femop_t *)fshead_vget },
1960 	{ VFSNAME_MOUNTROOT, (femop_t *)fshead_mountroot },
1961 	{ VFSNAME_FREEVFS, (femop_t *)fshead_freevfs },
1962 	{ VFSNAME_VNSTATE, (femop_t *)fshead_vnstate },
1963 	{	NULL,	NULL	}
1964 };
1965 
1966 /*
1967  * This set of routines transfer control to the next stacked monitor.
1968  *
1969  * Each routine is identical except for naming, types and arguments.
1970  *
1971  * The basic steps are:
1972  * 1.  Decrease the stack pointer by one.
1973  * 2.  If the current item is a base operation (vnode, vfs), goto 5.
1974  * 3.  If the current item does not have a corresponding operation, goto 1
1975  * 4.  Return by invoking the current item with the argument handle.
1976  * 5.  Return by invoking the base operation with the base object.
1977  *
1978  * for each classification, there needs to be at least one "next" operation
1979  * for each "head"operation.
1980  *
1981  */
1982 
1983 int
1984 vnext_open(femarg_t *vf, int mode, cred_t *cr, caller_context_t *ct)
1985 {
1986 	int (*func)() = NULL;
1987 	void *arg0 = NULL;
1988 
1989 	ASSERT(vf != NULL);
1990 	vf->fa_fnode--;
1991 	vsop_find(vf, &func, int, &arg0, vop_open, femop_open);
1992 	ASSERT(func != NULL);
1993 	ASSERT(arg0 != NULL);
1994 	return ((*func)(arg0, mode, cr, ct));
1995 }
1996 
1997 int
1998 vnext_close(femarg_t *vf, int flag, int count, offset_t offset, cred_t *cr,
1999 	caller_context_t *ct)
2000 {
2001 	int (*func)() = NULL;
2002 	void *arg0 = NULL;
2003 
2004 	ASSERT(vf != NULL);
2005 	vf->fa_fnode--;
2006 	vsop_find(vf, &func, int, &arg0, vop_close, femop_close);
2007 	ASSERT(func != NULL);
2008 	ASSERT(arg0 != NULL);
2009 	return ((*func)(arg0, flag, count, offset, cr, ct));
2010 }
2011 
2012 int
2013 vnext_read(femarg_t *vf, uio_t *uiop, int ioflag, cred_t *cr,
2014 	caller_context_t *ct)
2015 {
2016 	int (*func)() = NULL;
2017 	void *arg0 = NULL;
2018 
2019 	ASSERT(vf != NULL);
2020 	vf->fa_fnode--;
2021 	vsop_find(vf, &func, int, &arg0, vop_read, femop_read);
2022 	ASSERT(func != NULL);
2023 	ASSERT(arg0 != NULL);
2024 	return ((*func)(arg0, uiop, ioflag, cr, ct));
2025 }
2026 
2027 int
2028 vnext_write(femarg_t *vf, uio_t *uiop, int ioflag, cred_t *cr,
2029 	caller_context_t *ct)
2030 {
2031 	int (*func)() = NULL;
2032 	void *arg0 = NULL;
2033 
2034 	ASSERT(vf != NULL);
2035 	vf->fa_fnode--;
2036 	vsop_find(vf, &func, int, &arg0, vop_write, femop_write);
2037 	ASSERT(func != NULL);
2038 	ASSERT(arg0 != NULL);
2039 	return ((*func)(arg0, uiop, ioflag, cr, ct));
2040 }
2041 
2042 int
2043 vnext_ioctl(femarg_t *vf, int cmd, intptr_t arg, int flag, cred_t *cr,
2044 	int *rvalp, caller_context_t *ct)
2045 {
2046 	int (*func)() = NULL;
2047 	void *arg0 = NULL;
2048 
2049 	ASSERT(vf != NULL);
2050 	vf->fa_fnode--;
2051 	vsop_find(vf, &func, int, &arg0, vop_ioctl, femop_ioctl);
2052 	ASSERT(func != NULL);
2053 	ASSERT(arg0 != NULL);
2054 	return ((*func)(arg0, cmd, arg, flag, cr, rvalp, ct));
2055 }
2056 
2057 int
2058 vnext_setfl(femarg_t *vf, int oflags, int nflags, cred_t *cr,
2059 	caller_context_t *ct)
2060 {
2061 	int (*func)() = NULL;
2062 	void *arg0 = NULL;
2063 
2064 	ASSERT(vf != NULL);
2065 	vf->fa_fnode--;
2066 	vsop_find(vf, &func, int, &arg0, vop_setfl, femop_setfl);
2067 	ASSERT(func != NULL);
2068 	ASSERT(arg0 != NULL);
2069 	return ((*func)(arg0, oflags, nflags, cr, ct));
2070 }
2071 
2072 int
2073 vnext_getattr(femarg_t *vf, vattr_t *vap, int flags, cred_t *cr,
2074 	caller_context_t *ct)
2075 {
2076 	int (*func)() = NULL;
2077 	void *arg0 = NULL;
2078 
2079 	ASSERT(vf != NULL);
2080 	vf->fa_fnode--;
2081 	vsop_find(vf, &func, int, &arg0, vop_getattr, femop_getattr);
2082 	ASSERT(func != NULL);
2083 	ASSERT(arg0 != NULL);
2084 	return ((*func)(arg0, vap, flags, cr, ct));
2085 }
2086 
2087 int
2088 vnext_setattr(femarg_t *vf, vattr_t *vap, int flags, cred_t *cr,
2089 	caller_context_t *ct)
2090 {
2091 	int (*func)() = NULL;
2092 	void *arg0 = NULL;
2093 
2094 	ASSERT(vf != NULL);
2095 	vf->fa_fnode--;
2096 	vsop_find(vf, &func, int, &arg0, vop_setattr, femop_setattr);
2097 	ASSERT(func != NULL);
2098 	ASSERT(arg0 != NULL);
2099 	return ((*func)(arg0, vap, flags, cr, ct));
2100 }
2101 
2102 int
2103 vnext_access(femarg_t *vf, int mode, int flags, cred_t *cr,
2104 	caller_context_t *ct)
2105 {
2106 	int (*func)() = NULL;
2107 	void *arg0 = NULL;
2108 
2109 	ASSERT(vf != NULL);
2110 	vf->fa_fnode--;
2111 	vsop_find(vf, &func, int, &arg0, vop_access, femop_access);
2112 	ASSERT(func != NULL);
2113 	ASSERT(arg0 != NULL);
2114 	return ((*func)(arg0, mode, flags, cr, ct));
2115 }
2116 
2117 int
2118 vnext_lookup(femarg_t *vf, char *nm, vnode_t **vpp, pathname_t *pnp,
2119 	int flags, vnode_t *rdir, cred_t *cr, caller_context_t *ct,
2120 	int *direntflags, pathname_t *realpnp)
2121 {
2122 	int (*func)() = NULL;
2123 	void *arg0 = NULL;
2124 
2125 	ASSERT(vf != NULL);
2126 	vf->fa_fnode--;
2127 	vsop_find(vf, &func, int, &arg0, vop_lookup, femop_lookup);
2128 	ASSERT(func != NULL);
2129 	ASSERT(arg0 != NULL);
2130 	return ((*func)(arg0, nm, vpp, pnp, flags, rdir, cr, ct,
2131 	    direntflags, realpnp));
2132 }
2133 
2134 int
2135 vnext_create(femarg_t *vf, char *name, vattr_t *vap, vcexcl_t excl,
2136 	int mode, vnode_t **vpp, cred_t *cr, int flag, caller_context_t *ct,
2137 	vsecattr_t *vsecp)
2138 {
2139 	int (*func)() = NULL;
2140 	void *arg0 = NULL;
2141 
2142 	ASSERT(vf != NULL);
2143 	vf->fa_fnode--;
2144 	vsop_find(vf, &func, int, &arg0, vop_create, femop_create);
2145 	ASSERT(func != NULL);
2146 	ASSERT(arg0 != NULL);
2147 	return ((*func)(arg0, name, vap, excl, mode, vpp, cr, flag, ct, vsecp));
2148 }
2149 
2150 int
2151 vnext_remove(femarg_t *vf, char *nm, cred_t *cr, caller_context_t *ct,
2152 	int flags)
2153 {
2154 	int (*func)() = NULL;
2155 	void *arg0 = NULL;
2156 
2157 	ASSERT(vf != NULL);
2158 	vf->fa_fnode--;
2159 	vsop_find(vf, &func, int, &arg0, vop_remove, femop_remove);
2160 	ASSERT(func != NULL);
2161 	ASSERT(arg0 != NULL);
2162 	return ((*func)(arg0, nm, cr, ct, flags));
2163 }
2164 
2165 int
2166 vnext_link(femarg_t *vf, vnode_t *svp, char *tnm, cred_t *cr,
2167 	caller_context_t *ct, int flags)
2168 {
2169 	int (*func)() = NULL;
2170 	void *arg0 = NULL;
2171 
2172 	ASSERT(vf != NULL);
2173 	vf->fa_fnode--;
2174 	vsop_find(vf, &func, int, &arg0, vop_link, femop_link);
2175 	ASSERT(func != NULL);
2176 	ASSERT(arg0 != NULL);
2177 	return ((*func)(arg0, svp, tnm, cr, ct, flags));
2178 }
2179 
2180 int
2181 vnext_rename(femarg_t *vf, char *snm, vnode_t *tdvp, char *tnm, cred_t *cr,
2182 	caller_context_t *ct, int flags)
2183 {
2184 	int (*func)() = NULL;
2185 	void *arg0 = NULL;
2186 
2187 	ASSERT(vf != NULL);
2188 	vf->fa_fnode--;
2189 	vsop_find(vf, &func, int, &arg0, vop_rename, femop_rename);
2190 	ASSERT(func != NULL);
2191 	ASSERT(arg0 != NULL);
2192 	return ((*func)(arg0, snm, tdvp, tnm, cr, ct, flags));
2193 }
2194 
2195 int
2196 vnext_mkdir(femarg_t *vf, char *dirname, vattr_t *vap, vnode_t **vpp,
2197 	cred_t *cr, caller_context_t *ct, int flags, vsecattr_t *vsecp)
2198 {
2199 	int (*func)() = NULL;
2200 	void *arg0 = NULL;
2201 
2202 	ASSERT(vf != NULL);
2203 	vf->fa_fnode--;
2204 	vsop_find(vf, &func, int, &arg0, vop_mkdir, femop_mkdir);
2205 	ASSERT(func != NULL);
2206 	ASSERT(arg0 != NULL);
2207 	return ((*func)(arg0, dirname, vap, vpp, cr, ct, flags, vsecp));
2208 }
2209 
2210 int
2211 vnext_rmdir(femarg_t *vf, char *nm, vnode_t *cdir, cred_t *cr,
2212 	caller_context_t *ct, int flags)
2213 {
2214 	int (*func)() = NULL;
2215 	void *arg0 = NULL;
2216 
2217 	ASSERT(vf != NULL);
2218 	vf->fa_fnode--;
2219 	vsop_find(vf, &func, int, &arg0, vop_rmdir, femop_rmdir);
2220 	ASSERT(func != NULL);
2221 	ASSERT(arg0 != NULL);
2222 	return ((*func)(arg0, nm, cdir, cr, ct, flags));
2223 }
2224 
2225 int
2226 vnext_readdir(femarg_t *vf, uio_t *uiop, cred_t *cr, int *eofp,
2227 	caller_context_t *ct, int flags)
2228 {
2229 	int (*func)() = NULL;
2230 	void *arg0 = NULL;
2231 
2232 	ASSERT(vf != NULL);
2233 	vf->fa_fnode--;
2234 	vsop_find(vf, &func, int, &arg0, vop_readdir, femop_readdir);
2235 	ASSERT(func != NULL);
2236 	ASSERT(arg0 != NULL);
2237 	return ((*func)(arg0, uiop, cr, eofp, ct, flags));
2238 }
2239 
2240 int
2241 vnext_symlink(femarg_t *vf, char *linkname, vattr_t *vap, char *target,
2242 	cred_t *cr, caller_context_t *ct, int flags)
2243 {
2244 	int (*func)() = NULL;
2245 	void *arg0 = NULL;
2246 
2247 	ASSERT(vf != NULL);
2248 	vf->fa_fnode--;
2249 	vsop_find(vf, &func, int, &arg0, vop_symlink, femop_symlink);
2250 	ASSERT(func != NULL);
2251 	ASSERT(arg0 != NULL);
2252 	return ((*func)(arg0, linkname, vap, target, cr, ct, flags));
2253 }
2254 
2255 int
2256 vnext_readlink(femarg_t *vf, uio_t *uiop, cred_t *cr, caller_context_t *ct)
2257 {
2258 	int (*func)() = NULL;
2259 	void *arg0 = NULL;
2260 
2261 	ASSERT(vf != NULL);
2262 	vf->fa_fnode--;
2263 	vsop_find(vf, &func, int, &arg0, vop_readlink, femop_readlink);
2264 	ASSERT(func != NULL);
2265 	ASSERT(arg0 != NULL);
2266 	return ((*func)(arg0, uiop, cr, ct));
2267 }
2268 
2269 int
2270 vnext_fsync(femarg_t *vf, int syncflag, cred_t *cr, caller_context_t *ct)
2271 {
2272 	int (*func)() = NULL;
2273 	void *arg0 = NULL;
2274 
2275 	ASSERT(vf != NULL);
2276 	vf->fa_fnode--;
2277 	vsop_find(vf, &func, int, &arg0, vop_fsync, femop_fsync);
2278 	ASSERT(func != NULL);
2279 	ASSERT(arg0 != NULL);
2280 	return ((*func)(arg0, syncflag, cr, ct));
2281 }
2282 
2283 void
2284 vnext_inactive(femarg_t *vf, cred_t *cr, caller_context_t *ct)
2285 {
2286 	void (*func)() = NULL;
2287 	void *arg0 = NULL;
2288 
2289 	ASSERT(vf != NULL);
2290 	vf->fa_fnode--;
2291 	vsop_find(vf, &func, void, &arg0, vop_inactive, femop_inactive);
2292 	ASSERT(func != NULL);
2293 	ASSERT(arg0 != NULL);
2294 	(*func)(arg0, cr, ct);
2295 }
2296 
2297 int
2298 vnext_fid(femarg_t *vf, fid_t *fidp, caller_context_t *ct)
2299 {
2300 	int (*func)() = NULL;
2301 	void *arg0 = NULL;
2302 
2303 	ASSERT(vf != NULL);
2304 	vf->fa_fnode--;
2305 	vsop_find(vf, &func, int, &arg0, vop_fid, femop_fid);
2306 	ASSERT(func != NULL);
2307 	ASSERT(arg0 != NULL);
2308 	return ((*func)(arg0, fidp, ct));
2309 }
2310 
2311 int
2312 vnext_rwlock(femarg_t *vf, int write_lock, caller_context_t *ct)
2313 {
2314 	int (*func)() = NULL;
2315 	void *arg0 = NULL;
2316 
2317 	ASSERT(vf != NULL);
2318 	vf->fa_fnode--;
2319 	vsop_find(vf, &func, int, &arg0, vop_rwlock, femop_rwlock);
2320 	ASSERT(func != NULL);
2321 	ASSERT(arg0 != NULL);
2322 	return ((*func)(arg0, write_lock, ct));
2323 }
2324 
2325 void
2326 vnext_rwunlock(femarg_t *vf, int write_lock, caller_context_t *ct)
2327 {
2328 	void (*func)() = NULL;
2329 	void *arg0 = NULL;
2330 
2331 	ASSERT(vf != NULL);
2332 	vf->fa_fnode--;
2333 	vsop_find(vf, &func, void, &arg0, vop_rwunlock, femop_rwunlock);
2334 	ASSERT(func != NULL);
2335 	ASSERT(arg0 != NULL);
2336 	(*func)(arg0, write_lock, ct);
2337 }
2338 
2339 int
2340 vnext_seek(femarg_t *vf, offset_t ooff, offset_t *noffp, caller_context_t *ct)
2341 {
2342 	int (*func)() = NULL;
2343 	void *arg0 = NULL;
2344 
2345 	ASSERT(vf != NULL);
2346 	vf->fa_fnode--;
2347 	vsop_find(vf, &func, int, &arg0, vop_seek, femop_seek);
2348 	ASSERT(func != NULL);
2349 	ASSERT(arg0 != NULL);
2350 	return ((*func)(arg0, ooff, noffp, ct));
2351 }
2352 
2353 int
2354 vnext_cmp(femarg_t *vf, vnode_t *vp2, caller_context_t *ct)
2355 {
2356 	int (*func)() = NULL;
2357 	void *arg0 = NULL;
2358 
2359 	ASSERT(vf != NULL);
2360 	vf->fa_fnode--;
2361 	vsop_find(vf, &func, int, &arg0, vop_cmp, femop_cmp);
2362 	ASSERT(func != NULL);
2363 	ASSERT(arg0 != NULL);
2364 	return ((*func)(arg0, vp2, ct));
2365 }
2366 
2367 int
2368 vnext_frlock(femarg_t *vf, int cmd, struct flock64 *bfp, int flag,
2369 	offset_t offset, struct flk_callback *flk_cbp, cred_t *cr,
2370 	caller_context_t *ct)
2371 {
2372 	int (*func)() = NULL;
2373 	void *arg0 = NULL;
2374 
2375 	ASSERT(vf != NULL);
2376 	vf->fa_fnode--;
2377 	vsop_find(vf, &func, int, &arg0, vop_frlock, femop_frlock);
2378 	ASSERT(func != NULL);
2379 	ASSERT(arg0 != NULL);
2380 	return ((*func)(arg0, cmd, bfp, flag, offset, flk_cbp, cr, ct));
2381 }
2382 
2383 int
2384 vnext_space(femarg_t *vf, int cmd, struct flock64 *bfp, int flag,
2385 	offset_t offset, cred_t *cr, caller_context_t *ct)
2386 {
2387 	int (*func)() = NULL;
2388 	void *arg0 = NULL;
2389 
2390 	ASSERT(vf != NULL);
2391 	vf->fa_fnode--;
2392 	vsop_find(vf, &func, int, &arg0, vop_space, femop_space);
2393 	ASSERT(func != NULL);
2394 	ASSERT(arg0 != NULL);
2395 	return ((*func)(arg0, cmd, bfp, flag, offset, cr, ct));
2396 }
2397 
2398 int
2399 vnext_realvp(femarg_t *vf, vnode_t **vpp, caller_context_t *ct)
2400 {
2401 	int (*func)() = NULL;
2402 	void *arg0 = NULL;
2403 
2404 	ASSERT(vf != NULL);
2405 	vf->fa_fnode--;
2406 	vsop_find(vf, &func, int, &arg0, vop_realvp, femop_realvp);
2407 	ASSERT(func != NULL);
2408 	ASSERT(arg0 != NULL);
2409 	return ((*func)(arg0, vpp, ct));
2410 }
2411 
2412 int
2413 vnext_getpage(femarg_t *vf, offset_t off, size_t len, uint_t *protp,
2414 	struct page **plarr, size_t plsz, struct seg *seg, caddr_t addr,
2415 	enum seg_rw rw, cred_t *cr, caller_context_t *ct)
2416 {
2417 	int (*func)() = NULL;
2418 	void *arg0 = NULL;
2419 
2420 	ASSERT(vf != NULL);
2421 	vf->fa_fnode--;
2422 	vsop_find(vf, &func, int, &arg0, vop_getpage, femop_getpage);
2423 	ASSERT(func != NULL);
2424 	ASSERT(arg0 != NULL);
2425 	return ((*func)(arg0, off, len, protp, plarr, plsz, seg, addr, rw,
2426 	    cr, ct));
2427 }
2428 
2429 int
2430 vnext_putpage(femarg_t *vf, offset_t off, size_t len, int flags,
2431 	cred_t *cr, caller_context_t *ct)
2432 {
2433 	int (*func)() = NULL;
2434 	void *arg0 = NULL;
2435 
2436 	ASSERT(vf != NULL);
2437 	vf->fa_fnode--;
2438 	vsop_find(vf, &func, int, &arg0, vop_putpage, femop_putpage);
2439 	ASSERT(func != NULL);
2440 	ASSERT(arg0 != NULL);
2441 	return ((*func)(arg0, off, len, flags, cr, ct));
2442 }
2443 
2444 int
2445 vnext_map(femarg_t *vf, offset_t off, struct as *as, caddr_t *addrp,
2446 	size_t len, uchar_t prot, uchar_t maxprot, uint_t flags,
2447 	cred_t *cr, caller_context_t *ct)
2448 {
2449 	int (*func)() = NULL;
2450 	void *arg0 = NULL;
2451 
2452 	ASSERT(vf != NULL);
2453 	vf->fa_fnode--;
2454 	vsop_find(vf, &func, int, &arg0, vop_map, femop_map);
2455 	ASSERT(func != NULL);
2456 	ASSERT(arg0 != NULL);
2457 	return ((*func)(arg0, off, as, addrp, len, prot, maxprot, flags,
2458 	    cr, ct));
2459 }
2460 
2461 int
2462 vnext_addmap(femarg_t *vf, offset_t off, struct as *as, caddr_t addr,
2463 	size_t len, uchar_t prot, uchar_t maxprot, uint_t flags,
2464 	cred_t *cr, caller_context_t *ct)
2465 {
2466 	int (*func)() = NULL;
2467 	void *arg0 = NULL;
2468 
2469 	ASSERT(vf != NULL);
2470 	vf->fa_fnode--;
2471 	vsop_find(vf, &func, int, &arg0, vop_addmap, femop_addmap);
2472 	ASSERT(func != NULL);
2473 	ASSERT(arg0 != NULL);
2474 	return ((*func)(arg0, off, as, addr, len, prot, maxprot, flags,
2475 	    cr, ct));
2476 }
2477 
2478 int
2479 vnext_delmap(femarg_t *vf, offset_t off, struct as *as, caddr_t addr,
2480 	size_t len, uint_t prot, uint_t maxprot, uint_t flags,
2481 	cred_t *cr, caller_context_t *ct)
2482 {
2483 	int (*func)() = NULL;
2484 	void *arg0 = NULL;
2485 
2486 	ASSERT(vf != NULL);
2487 	vf->fa_fnode--;
2488 	vsop_find(vf, &func, int, &arg0, vop_delmap, femop_delmap);
2489 	ASSERT(func != NULL);
2490 	ASSERT(arg0 != NULL);
2491 	return ((*func)(arg0, off, as, addr, len, prot, maxprot, flags,
2492 	    cr, ct));
2493 }
2494 
2495 int
2496 vnext_poll(femarg_t *vf, short events, int anyyet, short *reventsp,
2497 	struct pollhead **phpp, caller_context_t *ct)
2498 {
2499 	int (*func)() = NULL;
2500 	void *arg0 = NULL;
2501 
2502 	ASSERT(vf != NULL);
2503 	vf->fa_fnode--;
2504 	vsop_find(vf, &func, int, &arg0, vop_poll, femop_poll);
2505 	ASSERT(func != NULL);
2506 	ASSERT(arg0 != NULL);
2507 	return ((*func)(arg0, events, anyyet, reventsp, phpp, ct));
2508 }
2509 
2510 int
2511 vnext_dump(femarg_t *vf, caddr_t addr, offset_t lbdn, offset_t dblks,
2512 	caller_context_t *ct)
2513 {
2514 	int (*func)() = NULL;
2515 	void *arg0 = NULL;
2516 
2517 	ASSERT(vf != NULL);
2518 	vf->fa_fnode--;
2519 	vsop_find(vf, &func, int, &arg0, vop_dump, femop_dump);
2520 	ASSERT(func != NULL);
2521 	ASSERT(arg0 != NULL);
2522 	return ((*func)(arg0, addr, lbdn, dblks, ct));
2523 }
2524 
2525 int
2526 vnext_pathconf(femarg_t *vf, int cmd, ulong_t *valp, cred_t *cr,
2527 	caller_context_t *ct)
2528 {
2529 	int (*func)() = NULL;
2530 	void *arg0 = NULL;
2531 
2532 	ASSERT(vf != NULL);
2533 	vf->fa_fnode--;
2534 	vsop_find(vf, &func, int, &arg0, vop_pathconf, femop_pathconf);
2535 	ASSERT(func != NULL);
2536 	ASSERT(arg0 != NULL);
2537 	return ((*func)(arg0, cmd, valp, cr, ct));
2538 }
2539 
2540 int
2541 vnext_pageio(femarg_t *vf, struct page *pp, u_offset_t io_off,
2542 	size_t io_len, int flags, cred_t *cr, caller_context_t *ct)
2543 {
2544 	int (*func)() = NULL;
2545 	void *arg0 = NULL;
2546 
2547 	ASSERT(vf != NULL);
2548 	vf->fa_fnode--;
2549 	vsop_find(vf, &func, int, &arg0, vop_pageio, femop_pageio);
2550 	ASSERT(func != NULL);
2551 	ASSERT(arg0 != NULL);
2552 	return ((*func)(arg0, pp, io_off, io_len, flags, cr, ct));
2553 }
2554 
2555 int
2556 vnext_dumpctl(femarg_t *vf, int action, offset_t *blkp, caller_context_t *ct)
2557 {
2558 	int (*func)() = NULL;
2559 	void *arg0 = NULL;
2560 
2561 	ASSERT(vf != NULL);
2562 	vf->fa_fnode--;
2563 	vsop_find(vf, &func, int, &arg0, vop_dumpctl, femop_dumpctl);
2564 	ASSERT(func != NULL);
2565 	ASSERT(arg0 != NULL);
2566 	return ((*func)(arg0, action, blkp, ct));
2567 }
2568 
2569 void
2570 vnext_dispose(femarg_t *vf, struct page *pp, int flag, int dn, cred_t *cr,
2571 	caller_context_t *ct)
2572 {
2573 	void (*func)() = NULL;
2574 	void *arg0 = NULL;
2575 
2576 	ASSERT(vf != NULL);
2577 	vf->fa_fnode--;
2578 	vsop_find(vf, &func, void, &arg0, vop_dispose, femop_dispose);
2579 	ASSERT(func != NULL);
2580 	ASSERT(arg0 != NULL);
2581 	(*func)(arg0, pp, flag, dn, cr, ct);
2582 }
2583 
2584 int
2585 vnext_setsecattr(femarg_t *vf, vsecattr_t *vsap, int flag, cred_t *cr,
2586 	caller_context_t *ct)
2587 {
2588 	int (*func)() = NULL;
2589 	void *arg0 = NULL;
2590 
2591 	ASSERT(vf != NULL);
2592 	vf->fa_fnode--;
2593 	vsop_find(vf, &func, int, &arg0, vop_setsecattr, femop_setsecattr);
2594 	ASSERT(func != NULL);
2595 	ASSERT(arg0 != NULL);
2596 	return ((*func)(arg0, vsap, flag, cr, ct));
2597 }
2598 
2599 int
2600 vnext_getsecattr(femarg_t *vf, vsecattr_t *vsap, int flag, cred_t *cr,
2601 	caller_context_t *ct)
2602 {
2603 	int (*func)() = NULL;
2604 	void *arg0 = NULL;
2605 
2606 	ASSERT(vf != NULL);
2607 	vf->fa_fnode--;
2608 	vsop_find(vf, &func, int, &arg0, vop_getsecattr, femop_getsecattr);
2609 	ASSERT(func != NULL);
2610 	ASSERT(arg0 != NULL);
2611 	return ((*func)(arg0, vsap, flag, cr, ct));
2612 }
2613 
2614 int
2615 vnext_shrlock(femarg_t *vf, int cmd, struct shrlock *shr, int flag,
2616 	cred_t *cr, caller_context_t *ct)
2617 {
2618 	int (*func)() = NULL;
2619 	void *arg0 = NULL;
2620 
2621 	ASSERT(vf != NULL);
2622 	vf->fa_fnode--;
2623 	vsop_find(vf, &func, int, &arg0, vop_shrlock, femop_shrlock);
2624 	ASSERT(func != NULL);
2625 	ASSERT(arg0 != NULL);
2626 	return ((*func)(arg0, cmd, shr, flag, cr, ct));
2627 }
2628 
2629 int
2630 vnext_vnevent(femarg_t *vf, vnevent_t vnevent, vnode_t *dvp, char *cname,
2631     caller_context_t *ct)
2632 {
2633 	int (*func)() = NULL;
2634 	void *arg0 = NULL;
2635 
2636 	ASSERT(vf != NULL);
2637 	vf->fa_fnode--;
2638 	vsop_find(vf, &func, int, &arg0, vop_vnevent, femop_vnevent);
2639 	ASSERT(func != NULL);
2640 	ASSERT(arg0 != NULL);
2641 	return ((*func)(arg0, vnevent, dvp, cname, ct));
2642 }
2643 
2644 int
2645 vfsnext_mount(fsemarg_t *vf, vnode_t *mvp, struct mounta *uap, cred_t *cr)
2646 {
2647 	int (*func)() = NULL;
2648 	void *arg0 = NULL;
2649 
2650 	ASSERT(vf != NULL);
2651 	vf->fa_fnode--;
2652 	vfsop_find(vf, &func, int, &arg0, vfs_mount, fsemop_mount);
2653 	ASSERT(func != NULL);
2654 	ASSERT(arg0 != NULL);
2655 	return ((*func)(arg0, mvp, uap, cr));
2656 }
2657 
2658 int
2659 vfsnext_unmount(fsemarg_t *vf, int flag, cred_t *cr)
2660 {
2661 	int (*func)() = NULL;
2662 	void *arg0 = NULL;
2663 
2664 	ASSERT(vf != NULL);
2665 	vf->fa_fnode--;
2666 	vfsop_find(vf, &func, int, &arg0, vfs_unmount, fsemop_unmount);
2667 	ASSERT(func != NULL);
2668 	ASSERT(arg0 != NULL);
2669 	return ((*func)(arg0, flag, cr));
2670 }
2671 
2672 int
2673 vfsnext_root(fsemarg_t *vf, vnode_t **vpp)
2674 {
2675 	int (*func)() = NULL;
2676 	void *arg0 = NULL;
2677 
2678 	ASSERT(vf != NULL);
2679 	vf->fa_fnode--;
2680 	vfsop_find(vf, &func, int, &arg0, vfs_root, fsemop_root);
2681 	ASSERT(func != NULL);
2682 	ASSERT(arg0 != NULL);
2683 	return ((*func)(arg0, vpp));
2684 }
2685 
2686 int
2687 vfsnext_statvfs(fsemarg_t *vf, statvfs64_t *sp)
2688 {
2689 	int (*func)() = NULL;
2690 	void *arg0 = NULL;
2691 
2692 	ASSERT(vf != NULL);
2693 	vf->fa_fnode--;
2694 	vfsop_find(vf, &func, int, &arg0, vfs_statvfs, fsemop_statvfs);
2695 	ASSERT(func != NULL);
2696 	ASSERT(arg0 != NULL);
2697 	return ((*func)(arg0, sp));
2698 }
2699 
2700 int
2701 vfsnext_sync(fsemarg_t *vf, short flag, cred_t *cr)
2702 {
2703 	int (*func)() = NULL;
2704 	void *arg0 = NULL;
2705 
2706 	ASSERT(vf != NULL);
2707 	vf->fa_fnode--;
2708 	vfsop_find(vf, &func, int, &arg0, vfs_sync, fsemop_sync);
2709 	ASSERT(func != NULL);
2710 	ASSERT(arg0 != NULL);
2711 	return ((*func)(arg0, flag, cr));
2712 }
2713 
2714 int
2715 vfsnext_vget(fsemarg_t *vf, vnode_t **vpp, fid_t *fidp)
2716 {
2717 	int (*func)() = NULL;
2718 	void *arg0 = NULL;
2719 
2720 	ASSERT(vf != NULL);
2721 	vf->fa_fnode--;
2722 	vfsop_find(vf, &func, int, &arg0, vfs_vget, fsemop_vget);
2723 	ASSERT(func != NULL);
2724 	ASSERT(arg0 != NULL);
2725 	return ((*func)(arg0, vpp, fidp));
2726 }
2727 
2728 int
2729 vfsnext_mountroot(fsemarg_t *vf, enum whymountroot reason)
2730 {
2731 	int (*func)() = NULL;
2732 	void *arg0 = NULL;
2733 
2734 	ASSERT(vf != NULL);
2735 	vf->fa_fnode--;
2736 	vfsop_find(vf, &func, int, &arg0, vfs_mountroot, fsemop_mountroot);
2737 	ASSERT(func != NULL);
2738 	ASSERT(arg0 != NULL);
2739 	return ((*func)(arg0, reason));
2740 }
2741 
2742 void
2743 vfsnext_freevfs(fsemarg_t *vf)
2744 {
2745 	void (*func)() = NULL;
2746 	void *arg0 = NULL;
2747 
2748 	ASSERT(vf != NULL);
2749 	vf->fa_fnode--;
2750 	vfsop_find(vf, &func, void, &arg0, vfs_freevfs, fsemop_freevfs);
2751 	ASSERT(func != NULL);
2752 	ASSERT(arg0 != NULL);
2753 	(*func)(arg0);
2754 }
2755 
2756 int
2757 vfsnext_vnstate(fsemarg_t *vf, vnode_t *vp, vntrans_t nstate)
2758 {
2759 	int (*func)() = NULL;
2760 	void *arg0 = NULL;
2761 
2762 	ASSERT(vf != NULL);
2763 	vf->fa_fnode--;
2764 	vfsop_find(vf, &func, int, &arg0, vfs_vnstate, fsemop_vnstate);
2765 	ASSERT(func != NULL);
2766 	ASSERT(arg0 != NULL);
2767 	return ((*func)(arg0, vp, nstate));
2768 }
2769 
2770 
2771 /*
2772  * Create a new fem_head and associate with the vnode.
2773  * To keep the unaugmented vnode access path lock free, we spin
2774  * update this - create a new one, then try and install it. If
2775  * we fail to install, release the old one and pretend we succeeded.
2776  */
2777 
2778 static struct fem_head *
2779 new_femhead(struct fem_head **hp)
2780 {
2781 	struct fem_head	*head;
2782 
2783 	head = kmem_alloc(sizeof (*head), KM_SLEEP);
2784 	mutex_init(&head->femh_lock, NULL, MUTEX_DEFAULT, NULL);
2785 	head->femh_list = NULL;
2786 	if (casptr(hp, NULL, head) != NULL) {
2787 		kmem_free(head, sizeof (*head));
2788 		head = *hp;
2789 	}
2790 	return (head);
2791 }
2792 
2793 /*
2794  * Create a fem_list.  The fem_list that gets returned is in a
2795  * very rudimentary state and MUST NOT be used until it's initialized
2796  * (usually by femlist_construct() or fem_dup_list()).  The refcount
2797  * and size is set properly and top-of-stack is set to the "guard" node
2798  * just to be consistent.
2799  *
2800  * If anyone were to accidentally trying to run on this fem_list before
2801  * it's initialized then the system would likely panic trying to defererence
2802  * the (NULL) fn_op pointer.
2803  *
2804  */
2805 static struct fem_list *
2806 femlist_create(int numnodes)
2807 {
2808 	struct fem_list	*sp;
2809 
2810 	sp = kmem_alloc(fl_ntob(numnodes), KM_SLEEP);
2811 	sp->feml_refc  = 1;
2812 	sp->feml_ssize = numnodes;
2813 	sp->feml_nodes[0] = FEM_GUARD(FEMTYPE_NULL);
2814 	sp->feml_tos = 0;
2815 	return (sp);
2816 }
2817 
2818 /*
2819  * Construct a new femlist.
2820  * The list is constructed with the appropriate type of guard to
2821  * anchor it, and inserts the original ops.
2822  */
2823 
2824 static struct fem_list *
2825 femlist_construct(void *baseops, int type, int numnodes)
2826 {
2827 	struct fem_list	*sp;
2828 
2829 	sp = femlist_create(numnodes);
2830 	sp->feml_nodes[0] = FEM_GUARD(type);
2831 	sp->feml_nodes[1].fn_op.anon = baseops;
2832 	sp->feml_nodes[1].fn_available = NULL;
2833 	sp->feml_nodes[1].fn_av_hold = NULL;
2834 	sp->feml_nodes[1].fn_av_rele = NULL;
2835 	sp->feml_tos = 1;
2836 	return (sp);
2837 }
2838 
2839 /*
2840  * Duplicate a list.  Copy the original list to the clone.
2841  *
2842  * NOTE: The caller must have the fem_head for the lists locked.
2843  * Assuming the appropriate lock is held and the caller has done the
2844  * math right, the clone list should be big enough to old the original.
2845  */
2846 
2847 static void
2848 fem_dup_list(struct fem_list *orig, struct fem_list *clone)
2849 {
2850 	int		i;
2851 
2852 	ASSERT(clone->feml_ssize >= orig->feml_ssize);
2853 
2854 	bcopy(orig->feml_nodes, clone->feml_nodes,
2855 	    sizeof (orig->feml_nodes[0]) * orig->feml_ssize);
2856 	clone->feml_tos = orig->feml_tos;
2857 	/*
2858 	 * Now that we've copied the old list (orig) to the new list (clone),
2859 	 * we need to walk the new list and put another hold on fn_available.
2860 	 */
2861 	for (i = clone->feml_tos; i > 0; i--) {
2862 		struct fem_node *fnp = &clone->feml_nodes[i];
2863 
2864 		if (fnp->fn_av_hold)
2865 			(*(fnp->fn_av_hold))(fnp->fn_available);
2866 	}
2867 }
2868 
2869 
2870 static int
2871 fem_push_node(
2872 	struct fem_head **hp,
2873 	void **baseops,
2874 	int type,
2875 	struct fem_node *nnode,
2876 	femhow_t how)
2877 {
2878 	struct fem_head	*hd;
2879 	struct fem_list	*list;
2880 	void		*oldops;
2881 	int		retry;
2882 	int		error = 0;
2883 	int		i;
2884 
2885 	/* Validate the node */
2886 	if ((nnode->fn_op.anon == NULL) || (nnode->fn_available == NULL)) {
2887 		return (EINVAL);
2888 	}
2889 
2890 	if ((hd = *hp) == NULL) { /* construct a proto-list */
2891 		hd = new_femhead(hp);
2892 	}
2893 	/*
2894 	 * RULE: once a femhead has been pushed onto a object, it cannot be
2895 	 * removed until the object is destroyed.  It can be deactivated by
2896 	 * placing the original 'object operations' onto the object, which
2897 	 * will ignore the femhead.
2898 	 * The loop will exist when the femh_list has space to push a monitor
2899 	 * onto it.
2900 	 */
2901 	do {
2902 		retry = 1;
2903 		list = fem_lock(hd);
2904 		oldops = *baseops;
2905 
2906 		if (list != NULL) {
2907 			if (list->feml_tos+1 < list->feml_ssize) {
2908 				retry = 0;
2909 			} else {
2910 				struct fem_list	*olist = list;
2911 
2912 				fem_addref(olist);
2913 				fem_unlock(hd);
2914 				list = femlist_create(olist->feml_ssize * 2);
2915 				(void) fem_lock(hd);
2916 				if (hd->femh_list == olist) {
2917 					if (list->feml_ssize <=
2918 					    olist->feml_ssize) {
2919 						/*
2920 						 * We have a new list, but it
2921 						 * is too small to hold the
2922 						 * original contents plus the
2923 						 * one to push.  Release the
2924 						 * new list and start over.
2925 						 */
2926 						fem_release(list);
2927 						fem_unlock(hd);
2928 					} else {
2929 						/*
2930 						 * Life is good:  Our new list
2931 						 * is big enough to hold the
2932 						 * original list (olist) + 1.
2933 						 */
2934 						fem_dup_list(olist, list);
2935 						/* orphan this list */
2936 						hd->femh_list = list;
2937 						(void) fem_delref(olist);
2938 						retry = 0;
2939 					}
2940 				} else {
2941 					/* concurrent update, retry */
2942 					fem_release(list);
2943 					fem_unlock(hd);
2944 				}
2945 				/* remove the reference we added above */
2946 				fem_release(olist);
2947 			}
2948 		} else {
2949 			fem_unlock(hd);
2950 			list = femlist_construct(oldops, type, NNODES_DEFAULT);
2951 			(void) fem_lock(hd);
2952 			if (hd->femh_list != NULL || *baseops != oldops) {
2953 				/* concurrent update, retry */
2954 				fem_release(list);
2955 				fem_unlock(hd);
2956 			} else {
2957 				hd->femh_list = list;
2958 				*baseops = FEM_HEAD(type);
2959 				retry = 0;
2960 			}
2961 		}
2962 	} while (retry);
2963 
2964 	ASSERT(mutex_owner(&hd->femh_lock) == curthread);
2965 	ASSERT(list->feml_tos+1 < list->feml_ssize);
2966 
2967 	/*
2968 	 * The presence of "how" will modify the behavior of how/if
2969 	 * nodes are pushed.  If it's FORCE, then we can skip
2970 	 * all the checks and push it on.
2971 	 */
2972 	if (how != FORCE) {
2973 		/* Start at the top and work our way down */
2974 		for (i = list->feml_tos; i > 0; i--) {
2975 			void *fn_av = list->feml_nodes[i].fn_available;
2976 			void *fn_op = list->feml_nodes[i].fn_op.anon;
2977 
2978 			/*
2979 			 * OPARGUNIQ means that this node should not
2980 			 * be pushed on if a node with the same op/avail
2981 			 * combination exists.  This situation returns
2982 			 * EBUSY.
2983 			 *
2984 			 * OPUNIQ means that this node should not be
2985 			 * pushed on if a node with the same op exists.
2986 			 * This situation also returns EBUSY.
2987 			 */
2988 			switch (how) {
2989 
2990 			case OPUNIQ:
2991 				if (fn_op == nnode->fn_op.anon) {
2992 					error = EBUSY;
2993 				}
2994 				break;
2995 
2996 			case OPARGUNIQ:
2997 				if ((fn_op == nnode->fn_op.anon) &&
2998 				    (fn_av == nnode->fn_available)) {
2999 					error = EBUSY;
3000 				}
3001 				break;
3002 
3003 			default:
3004 				error = EINVAL;	/* Unexpected value */
3005 				break;
3006 			}
3007 
3008 			if (error)
3009 				break;
3010 		}
3011 	}
3012 
3013 	if (error == 0) {
3014 		/*
3015 		 * If no errors, slap the node on the list.
3016 		 * Note: The following is a structure copy.
3017 		 */
3018 		list->feml_nodes[++(list->feml_tos)] = *nnode;
3019 	}
3020 
3021 	fem_unlock(hd);
3022 	return (error);
3023 }
3024 
3025 /*
3026  * Remove a node by copying the list above it down a notch.
3027  * If the list is busy, replace it with an idle one and work
3028  * upon it.
3029  * A node matches if the opset matches and the datap matches or is
3030  * null.
3031  */
3032 
3033 static int
3034 remove_node(struct fem_list *sp, void **baseops, void *opset, void *datap)
3035 {
3036 	int	i;
3037 	struct fem_node	*fn;
3038 
3039 	for (i = sp->feml_tos; i > 0; i--) {
3040 		fn = sp->feml_nodes+i;
3041 		if (fn->fn_op.anon == opset &&
3042 		    (fn->fn_available == datap || datap == NULL)) {
3043 			break;
3044 		}
3045 	}
3046 	if (i == 0) {
3047 		return (EINVAL);
3048 	}
3049 
3050 	/*
3051 	 * At this point we have a node in-hand (*fn) that we are about
3052 	 * to remove by overwriting it and adjusting the stack.  This is
3053 	 * our last chance to do anything with this node so we do the
3054 	 * release on the arg.
3055 	 */
3056 	if (fn->fn_av_rele)
3057 		(*(fn->fn_av_rele))(fn->fn_available);
3058 
3059 	while (i++ < sp->feml_tos) {
3060 		sp->feml_nodes[i-1] = sp->feml_nodes[i];
3061 	}
3062 	if (--(sp->feml_tos) == 1) { /* Empty, restore ops */
3063 		*baseops = sp->feml_nodes[1].fn_op.anon;
3064 	}
3065 	return (0);
3066 }
3067 
3068 static int
3069 fem_remove_node(struct fem_head *fh, void **baseops, void *opset, void *datap)
3070 {
3071 	struct fem_list *sp;
3072 	int		error = 0;
3073 	int		retry;
3074 
3075 	if (fh == NULL) {
3076 		return (EINVAL);
3077 	}
3078 
3079 	do {
3080 		retry = 0;
3081 		if ((sp = fem_lock(fh)) == NULL) {
3082 			fem_unlock(fh);
3083 			error = EINVAL;
3084 		} else if (sp->feml_refc == 1) {
3085 			error = remove_node(sp, baseops, opset, datap);
3086 			if (sp->feml_tos == 1) {
3087 				/*
3088 				 * The top-of-stack was decremented by
3089 				 * remove_node().  If it got down to 1,
3090 				 * then the base ops were replaced and we
3091 				 * call fem_release() which will free the
3092 				 * fem_list.
3093 				 */
3094 				fem_release(sp);
3095 				fh->femh_list = NULL;
3096 				/* XXX - Do we need a membar_producer() call? */
3097 			}
3098 			fem_unlock(fh);
3099 		} else {
3100 			/* busy - install a new one without this monitor */
3101 			struct fem_list *nsp;	/* New fem_list being cloned */
3102 
3103 			fem_addref(sp);
3104 			fem_unlock(fh);
3105 			nsp = femlist_create(sp->feml_ssize);
3106 			if (fem_lock(fh) == sp) {
3107 				/*
3108 				 * We popped out of the lock, created a
3109 				 * list, then relocked.  If we're in here
3110 				 * then the fem_head points to the same list
3111 				 * it started with.
3112 				 */
3113 				fem_dup_list(sp, nsp);
3114 				error = remove_node(nsp, baseops, opset, datap);
3115 				if (error != 0) {
3116 					fem_release(nsp);
3117 				} else if (nsp->feml_tos == 1) {
3118 					/* New list now empty, tear it down */
3119 					fem_release(nsp);
3120 					fh->femh_list = NULL;
3121 				} else {
3122 					fh->femh_list = nsp;
3123 				}
3124 				(void) fem_delref(sp);
3125 			} else {
3126 				/* List changed while locked, try again... */
3127 				fem_release(nsp);
3128 				retry = 1;
3129 			}
3130 			/*
3131 			 * If error is set, then we tried to remove a node
3132 			 * from the list, but failed.  This means that we
3133 			 * will still be using this list so don't release it.
3134 			 */
3135 			if (error == 0)
3136 				fem_release(sp);
3137 			fem_unlock(fh);
3138 		}
3139 	} while (retry);
3140 	return (error);
3141 }
3142 
3143 
3144 /*
3145  * perform operation on each element until one returns non zero
3146  */
3147 static int
3148 fem_walk_list(
3149 	struct fem_list *sp,
3150 	int (*f)(struct fem_node *, void *, void *),
3151 	void *mon,
3152 	void *arg)
3153 {
3154 	int	i;
3155 
3156 	ASSERT(sp != NULL);
3157 	for (i = sp->feml_tos; i > 0; i--) {
3158 		if ((*f)(sp->feml_nodes+i, mon, arg) != 0) {
3159 			break;
3160 		}
3161 	}
3162 	return (i);
3163 }
3164 
3165 /*
3166  * companion comparison functions.
3167  */
3168 static int
3169 fem_compare_mon(struct fem_node *n, void *mon, void *arg)
3170 {
3171 	return ((n->fn_op.anon == mon) && (n->fn_available == arg));
3172 }
3173 
3174 /*
3175  * VNODE interposition.
3176  */
3177 
3178 int
3179 fem_create(char *name, const struct fs_operation_def *templ,
3180     fem_t **actual)
3181 {
3182 	int	unused_ops = 0;
3183 	int	e;
3184 	fem_t	*newf;
3185 
3186 	newf = fem_alloc();
3187 	newf->name = name;
3188 	newf->templ = templ;
3189 
3190 	e =  fs_build_vector(newf, &unused_ops, fem_opdef, templ);
3191 	if (e != 0) {
3192 #ifdef DEBUG
3193 		cmn_err(CE_WARN, "fem_create: error %d building vector", e);
3194 #endif
3195 		fem_free(newf);
3196 	} else {
3197 		*actual = newf;
3198 	}
3199 	return (e);
3200 }
3201 
3202 int
3203 fem_install(
3204 	vnode_t *vp,		/* Vnode on which monitor is being installed */
3205 	fem_t *mon,		/* Monitor operations being installed */
3206 	void *arg,		/* Opaque data used by monitor */
3207 	femhow_t how,		/* Installation control */
3208 	void (*arg_hold)(void *),	/* Hold routine for "arg" */
3209 	void (*arg_rele)(void *))	/* Release routine for "arg" */
3210 {
3211 	int	error;
3212 	struct fem_node	nnode;
3213 
3214 	nnode.fn_available = arg;
3215 	nnode.fn_op.fem = mon;
3216 	nnode.fn_av_hold = arg_hold;
3217 	nnode.fn_av_rele = arg_rele;
3218 	/*
3219 	 * If we have a non-NULL hold function, do the hold right away.
3220 	 * The release is done in remove_node().
3221 	 */
3222 	if (arg_hold)
3223 		(*arg_hold)(arg);
3224 
3225 	error = fem_push_node(&vp->v_femhead, (void **)&vp->v_op, FEMTYPE_VNODE,
3226 	    &nnode, how);
3227 
3228 	/* If there was an error then the monitor wasn't pushed */
3229 	if (error && arg_rele)
3230 		(*arg_rele)(arg);
3231 
3232 	return (error);
3233 }
3234 
3235 int
3236 fem_is_installed(vnode_t *v, fem_t *mon, void *arg)
3237 {
3238 	int	e;
3239 	struct fem_list	*fl;
3240 
3241 	fl = fem_get(v->v_femhead);
3242 	if (fl != NULL) {
3243 		e = fem_walk_list(fl, fem_compare_mon, (void *)mon, arg);
3244 		fem_release(fl);
3245 		return (e);
3246 	}
3247 	return (0);
3248 }
3249 
3250 int
3251 fem_uninstall(vnode_t *v, fem_t *mon, void *arg)
3252 {
3253 	int	e;
3254 	e = fem_remove_node(v->v_femhead, (void **)&v->v_op,
3255 	    (void *)mon, arg);
3256 	return (e);
3257 }
3258 
3259 void
3260 fem_setvnops(vnode_t *v, vnodeops_t *newops)
3261 {
3262 	vnodeops_t	*r;
3263 
3264 	ASSERT(v != NULL);
3265 	ASSERT(newops != NULL);
3266 
3267 	do {
3268 		r = v->v_op;
3269 		membar_consumer();
3270 		if (v->v_femhead != NULL) {
3271 			struct fem_list	*fl;
3272 			if ((fl = fem_lock(v->v_femhead)) != NULL) {
3273 				fl->feml_nodes[1].fn_op.vnode = newops;
3274 				fem_unlock(v->v_femhead);
3275 				return;
3276 			}
3277 			fem_unlock(v->v_femhead);
3278 		}
3279 	} while (casptr(&v->v_op, r, newops) != r);
3280 }
3281 
3282 vnodeops_t *
3283 fem_getvnops(vnode_t *v)
3284 {
3285 	vnodeops_t	*r;
3286 
3287 	ASSERT(v != NULL);
3288 
3289 	r = v->v_op;
3290 	membar_consumer();
3291 	if (v->v_femhead != NULL) {
3292 		struct fem_list	*fl;
3293 		if ((fl = fem_lock(v->v_femhead)) != NULL) {
3294 			r = fl->feml_nodes[1].fn_op.vnode;
3295 		}
3296 		fem_unlock(v->v_femhead);
3297 	}
3298 	return (r);
3299 }
3300 
3301 
3302 /*
3303  * VFS interposition
3304  */
3305 int
3306 fsem_create(char *name, const struct fs_operation_def *templ,
3307     fsem_t **actual)
3308 {
3309 	int	unused_ops = 0;
3310 	int	e;
3311 	fsem_t	*newv;
3312 
3313 	newv = fsem_alloc();
3314 	newv->name = (const char *)name;
3315 	newv->templ = templ;
3316 
3317 	e = fs_build_vector(newv, &unused_ops, fsem_opdef, templ);
3318 	if (e != 0) {
3319 #ifdef DEBUG
3320 		cmn_err(CE_WARN, "fsem_create: error %d building vector", e);
3321 #endif
3322 		fsem_free(newv);
3323 	} else {
3324 		*actual = newv;
3325 	}
3326 	return (e);
3327 }
3328 
3329 /*
3330  * These need to be re-written, but there should be more common bits.
3331  */
3332 
3333 int
3334 fsem_is_installed(struct vfs *v, fsem_t *mon, void *arg)
3335 {
3336 	struct fem_list	*fl;
3337 
3338 	if (v->vfs_implp == NULL)
3339 		return (0);
3340 
3341 	fl = fem_get(v->vfs_femhead);
3342 	if (fl != NULL) {
3343 		int	e;
3344 		e = fem_walk_list(fl, fem_compare_mon, (void *)mon, arg);
3345 		fem_release(fl);
3346 		return (e);
3347 	}
3348 	return (0);
3349 }
3350 
3351 int
3352 fsem_install(
3353 	struct vfs *vfsp,	/* VFS on which monitor is being installed */
3354 	fsem_t *mon,		/* Monitor operations being installed */
3355 	void *arg,		/* Opaque data used by monitor */
3356 	femhow_t how,		/* Installation control */
3357 	void (*arg_hold)(void *),	/* Hold routine for "arg" */
3358 	void (*arg_rele)(void *))	/* Release routine for "arg" */
3359 {
3360 	int	error;
3361 	struct fem_node	nnode;
3362 
3363 	/* If this vfs hasn't been properly initialized, fail the install */
3364 	if (vfsp->vfs_implp == NULL)
3365 		return (EINVAL);
3366 
3367 	nnode.fn_available = arg;
3368 	nnode.fn_op.fsem = mon;
3369 	nnode.fn_av_hold = arg_hold;
3370 	nnode.fn_av_rele = arg_rele;
3371 	/*
3372 	 * If we have a non-NULL hold function, do the hold right away.
3373 	 * The release is done in remove_node().
3374 	 */
3375 	if (arg_hold)
3376 		(*arg_hold)(arg);
3377 
3378 	error = fem_push_node(&vfsp->vfs_femhead, (void **)&vfsp->vfs_op,
3379 	    FEMTYPE_VFS, &nnode, how);
3380 
3381 	/* If there was an error then the monitor wasn't pushed */
3382 	if (error && arg_rele)
3383 		(*arg_rele)(arg);
3384 
3385 	return (error);
3386 }
3387 
3388 int
3389 fsem_uninstall(struct vfs *v, fsem_t *mon, void *arg)
3390 {
3391 	int	e;
3392 
3393 	if (v->vfs_implp == NULL)
3394 		return (EINVAL);
3395 
3396 	e = fem_remove_node(v->vfs_femhead, (void **)&v->vfs_op,
3397 	    (void *)mon, arg);
3398 	return (e);
3399 }
3400 
3401 void
3402 fsem_setvfsops(vfs_t *v, vfsops_t *newops)
3403 {
3404 	vfsops_t	*r;
3405 
3406 	ASSERT(v != NULL);
3407 	ASSERT(newops != NULL);
3408 	ASSERT(v->vfs_implp);
3409 
3410 	do {
3411 		r = v->vfs_op;
3412 		membar_consumer();
3413 		if (v->vfs_femhead != NULL) {
3414 			struct fem_list	*fl;
3415 			if ((fl = fem_lock(v->vfs_femhead)) != NULL) {
3416 				fl->feml_nodes[1].fn_op.vfs = newops;
3417 				fem_unlock(v->vfs_femhead);
3418 				return;
3419 			}
3420 			fem_unlock(v->vfs_femhead);
3421 		}
3422 	} while (casptr(&v->vfs_op, r, newops) != r);
3423 }
3424 
3425 vfsops_t *
3426 fsem_getvfsops(vfs_t *v)
3427 {
3428 	vfsops_t	*r;
3429 
3430 	ASSERT(v != NULL);
3431 	ASSERT(v->vfs_implp);
3432 
3433 	r = v->vfs_op;
3434 	membar_consumer();
3435 	if (v->vfs_femhead != NULL) {
3436 		struct fem_list	*fl;
3437 		if ((fl = fem_lock(v->vfs_femhead)) != NULL) {
3438 			r = fl->feml_nodes[1].fn_op.vfs;
3439 		}
3440 		fem_unlock(v->vfs_femhead);
3441 	}
3442 	return (r);
3443 }
3444 
3445 /*
3446  * Setup FEM.
3447  */
3448 void
3449 fem_init()
3450 {
3451 	struct fem_type_info   *fi;
3452 
3453 	/*
3454 	 * This femtype is only used for fem_list creation so we only
3455 	 * need the "guard" to be initialized so that feml_tos has
3456 	 * some rudimentary meaning.  A fem_list must not be used until
3457 	 * it has been initialized (either via femlist_construct() or
3458 	 * fem_dup_list()).  Anything that tries to use this fem_list
3459 	 * before it's actually initialized would panic the system as
3460 	 * soon as "fn_op" (NULL) is dereferenced.
3461 	 */
3462 	fi = femtype + FEMTYPE_NULL;
3463 	fi->errf = fem_err;
3464 	fi->guard.fn_available = (void *)&fi->guard;
3465 	fi->guard.fn_av_hold = NULL;
3466 	fi->guard.fn_av_rele = NULL;
3467 	fi->guard.fn_op.anon = NULL;
3468 
3469 	fi = femtype + FEMTYPE_VNODE;
3470 	fi->errf = fem_err;
3471 	fi->head.fn_available = NULL;
3472 	fi->head.fn_av_hold = NULL;
3473 	fi->head.fn_av_rele = NULL;
3474 	(void) vn_make_ops("fem-head", fhead_vn_spec, &fi->head.fn_op.vnode);
3475 	fi->guard.fn_available = (void *)&fi->guard;
3476 	fi->guard.fn_av_hold = NULL;
3477 	fi->guard.fn_av_rele = NULL;
3478 	(void) fem_create("fem-guard", fem_guard_ops, &fi->guard.fn_op.fem);
3479 
3480 	fi = femtype + FEMTYPE_VFS;
3481 	fi->errf = fsem_err;
3482 	fi->head.fn_available = NULL;
3483 	fi->head.fn_av_hold = NULL;
3484 	fi->head.fn_av_rele = NULL;
3485 	(void) vfs_makefsops(fshead_vfs_spec, &fi->head.fn_op.vfs);
3486 
3487 	fi->guard.fn_available = (void *)&fi->guard;
3488 	fi->guard.fn_av_hold = NULL;
3489 	fi->guard.fn_av_rele = NULL;
3490 	(void) fsem_create("fem-guard", fsem_guard_ops, &fi->guard.fn_op.fsem);
3491 }
3492 
3493 
3494 int
3495 fem_err()
3496 {
3497 	cmn_err(CE_PANIC, "fem/vnode operations corrupt");
3498 	return (0);
3499 }
3500 
3501 int
3502 fsem_err()
3503 {
3504 	cmn_err(CE_PANIC, "fem/vfs operations corrupt");
3505 	return (0);
3506 }
3507