--- old/usr/src/uts/common/vm/seg_dev.c	2015-11-24 09:34:38.446274790 -0500
+++ new/usr/src/uts/common/vm/seg_dev.c	2015-11-24 09:34:38.451852770 -0500
@@ -192,30 +192,29 @@
  *	"static" you'll need to fix rootnex_map_fault.
  */
 struct seg_ops segdev_ops = {
-	segdev_dup,
-	segdev_unmap,
-	segdev_free,
-	segdev_fault,
-	segdev_faulta,
-	segdev_setprot,
-	segdev_checkprot,
-	(int (*)())segdev_badop,	/* kluster */
-	(size_t (*)(struct seg *))NULL,	/* swapout */
-	segdev_sync,			/* sync */
-	segdev_incore,
-	segdev_lockop,			/* lockop */
-	segdev_getprot,
-	segdev_getoffset,
-	segdev_gettype,
-	segdev_getvp,
-	segdev_advise,
-	segdev_dump,
-	segdev_pagelock,
-	segdev_setpagesize,
-	segdev_getmemid,
-	segdev_getpolicy,
-	segdev_capable,
-	seg_inherit_notsup
+	.dup		= segdev_dup,
+	.unmap		= segdev_unmap,
+	.free		= segdev_free,
+	.fault		= segdev_fault,
+	.faulta		= segdev_faulta,
+	.setprot	= segdev_setprot,
+	.checkprot	= segdev_checkprot,
+	.kluster	= (int (*)())segdev_badop,
+	.sync		= segdev_sync,
+	.incore		= segdev_incore,
+	.lockop		= segdev_lockop,
+	.getprot	= segdev_getprot,
+	.getoffset	= segdev_getoffset,
+	.gettype	= segdev_gettype,
+	.getvp		= segdev_getvp,
+	.advise		= segdev_advise,
+	.dump		= segdev_dump,
+	.pagelock	= segdev_pagelock,
+	.setpagesize	= segdev_setpagesize,
+	.getmemid	= segdev_getmemid,
+	.getpolicy	= segdev_getpolicy,
+	.capable	= segdev_capable,
+	.inherit	= seg_inherit_notsup,
 };
 
 /*
--- old/usr/src/uts/common/vm/seg_kmem.c	2015-11-24 09:34:38.660092365 -0500
+++ new/usr/src/uts/common/vm/seg_kmem.c	2015-11-24 09:34:38.663836124 -0500
@@ -774,30 +774,30 @@
 }
 
 static struct seg_ops segkmem_ops = {
-	SEGKMEM_BADOP(int),		/* dup */
-	SEGKMEM_BADOP(int),		/* unmap */
-	SEGKMEM_BADOP(void),		/* free */
-	segkmem_fault,
-	SEGKMEM_BADOP(faultcode_t),	/* faulta */
-	segkmem_setprot,
-	segkmem_checkprot,
-	segkmem_kluster,
-	SEGKMEM_BADOP(size_t),		/* swapout */
-	SEGKMEM_BADOP(int),		/* sync */
-	SEGKMEM_BADOP(size_t),		/* incore */
-	SEGKMEM_BADOP(int),		/* lockop */
-	SEGKMEM_BADOP(int),		/* getprot */
-	SEGKMEM_BADOP(u_offset_t),	/* getoffset */
-	SEGKMEM_BADOP(int),		/* gettype */
-	SEGKMEM_BADOP(int),		/* getvp */
-	SEGKMEM_BADOP(int),		/* advise */
-	segkmem_dump,
-	segkmem_pagelock,
-	SEGKMEM_BADOP(int),		/* setpgsz */
-	segkmem_getmemid,
-	segkmem_getpolicy,		/* getpolicy */
-	segkmem_capable,		/* capable */
-	seg_inherit_notsup		/* inherit */
+	.dup		= SEGKMEM_BADOP(int),
+	.unmap		= SEGKMEM_BADOP(int),
+	.free		= SEGKMEM_BADOP(void),
+	.fault		= segkmem_fault,
+	.faulta		= SEGKMEM_BADOP(faultcode_t),
+	.setprot	= segkmem_setprot,
+	.checkprot	= segkmem_checkprot,
+	.kluster	= segkmem_kluster,
+	.swapout	= SEGKMEM_BADOP(size_t),
+	.sync		= SEGKMEM_BADOP(int),
+	.incore		= SEGKMEM_BADOP(size_t),
+	.lockop		= SEGKMEM_BADOP(int),
+	.getprot	= SEGKMEM_BADOP(int),
+	.getoffset	= SEGKMEM_BADOP(u_offset_t),
+	.gettype	= SEGKMEM_BADOP(int),
+	.getvp		= SEGKMEM_BADOP(int),
+	.advise		= SEGKMEM_BADOP(int),
+	.dump		= segkmem_dump,
+	.pagelock	= segkmem_pagelock,
+	.setpagesize	= SEGKMEM_BADOP(int),
+	.getmemid	= segkmem_getmemid,
+	.getpolicy	= segkmem_getpolicy,
+	.capable	= segkmem_capable,
+	.inherit	= seg_inherit_notsup,
 };
 
 int
--- old/usr/src/uts/common/vm/seg_kp.c	2015-11-24 09:34:38.803212724 -0500
+++ new/usr/src/uts/common/vm/seg_kp.c	2015-11-24 09:34:38.806927279 -0500
@@ -146,30 +146,30 @@
 pgcnt_t anon_segkp_pages_resv;		/* anon reserved by seg_kp */
 
 static struct	seg_ops segkp_ops = {
-	SEGKP_BADOP(int),		/* dup */
-	SEGKP_BADOP(int),		/* unmap */
-	SEGKP_BADOP(void),		/* free */
-	segkp_fault,
-	SEGKP_BADOP(faultcode_t),	/* faulta */
-	SEGKP_BADOP(int),		/* setprot */
-	segkp_checkprot,
-	segkp_kluster,
-	SEGKP_BADOP(size_t),		/* swapout */
-	SEGKP_BADOP(int),		/* sync */
-	SEGKP_BADOP(size_t),		/* incore */
-	SEGKP_BADOP(int),		/* lockop */
-	SEGKP_BADOP(int),		/* getprot */
-	SEGKP_BADOP(u_offset_t),		/* getoffset */
-	SEGKP_BADOP(int),		/* gettype */
-	SEGKP_BADOP(int),		/* getvp */
-	SEGKP_BADOP(int),		/* advise */
-	segkp_dump,			/* dump */
-	segkp_pagelock,			/* pagelock */
-	SEGKP_BADOP(int),		/* setpgsz */
-	segkp_getmemid,			/* getmemid */
-	segkp_getpolicy,		/* getpolicy */
-	segkp_capable,			/* capable */
-	seg_inherit_notsup		/* inherit */
+	.dup		= SEGKP_BADOP(int),
+	.unmap		= SEGKP_BADOP(int),
+	.free		= SEGKP_BADOP(void),
+	.fault		= segkp_fault,
+	.faulta		= SEGKP_BADOP(faultcode_t),
+	.setprot	= SEGKP_BADOP(int),
+	.checkprot	= segkp_checkprot,
+	.kluster	= segkp_kluster,
+	.swapout	= SEGKP_BADOP(size_t),
+	.sync		= SEGKP_BADOP(int),
+	.incore		= SEGKP_BADOP(size_t),
+	.lockop		= SEGKP_BADOP(int),
+	.getprot	= SEGKP_BADOP(int),
+	.getoffset	= SEGKP_BADOP(u_offset_t),
+	.gettype	= SEGKP_BADOP(int),
+	.getvp		= SEGKP_BADOP(int),
+	.advise		= SEGKP_BADOP(int),
+	.dump		= segkp_dump,
+	.pagelock	= segkp_pagelock,
+	.setpagesize	= SEGKP_BADOP(int),
+	.getmemid	= segkp_getmemid,
+	.getpolicy	= segkp_getpolicy,
+	.capable	= segkp_capable,
+	.inherit	= seg_inherit_notsup,
 };
 
 
--- old/usr/src/uts/common/vm/seg_kpm.c	2015-11-24 09:34:38.949454442 -0500
+++ new/usr/src/uts/common/vm/seg_kpm.c	2015-11-24 09:34:38.959300597 -0500
@@ -111,30 +111,30 @@
 #define	SEGKPM_NOTSUP	(int(*)())segkpm_notsup
 
 static struct seg_ops segkpm_ops = {
-	SEGKPM_BADOP(int),	/* dup */
-	SEGKPM_BADOP(int),	/* unmap */
-	SEGKPM_BADOP(void),	/* free */
-	segkpm_fault,
-	SEGKPM_BADOP(int),	/* faulta */
-	SEGKPM_BADOP(int),	/* setprot */
-	SEGKPM_BADOP(int),	/* checkprot */
-	SEGKPM_BADOP(int),	/* kluster */
-	SEGKPM_BADOP(size_t),	/* swapout */
-	SEGKPM_BADOP(int),	/* sync */
-	SEGKPM_BADOP(size_t),	/* incore */
-	SEGKPM_BADOP(int),	/* lockop */
-	SEGKPM_BADOP(int),	/* getprot */
-	SEGKPM_BADOP(u_offset_t), /* getoffset */
-	SEGKPM_BADOP(int),	/* gettype */
-	SEGKPM_BADOP(int),	/* getvp */
-	SEGKPM_BADOP(int),	/* advise */
-	segkpm_dump,		/* dump */
-	SEGKPM_NOTSUP,		/* pagelock */
-	SEGKPM_BADOP(int),	/* setpgsz */
-	SEGKPM_BADOP(int),	/* getmemid */
-	SEGKPM_BADOP(lgrp_mem_policy_info_t *),	/* getpolicy */
-	segkpm_capable,		/* capable */
-	seg_inherit_notsup	/* inherit */
+	.dup		= SEGKPM_BADOP(int),
+	.unmap		= SEGKPM_BADOP(int),
+	.free		= SEGKPM_BADOP(void),
+	.fault		= segkpm_fault,
+	.faulta		= SEGKPM_BADOP(int),
+	.setprot	= SEGKPM_BADOP(int),
+	.checkprot	= SEGKPM_BADOP(int),
+	.kluster	= SEGKPM_BADOP(int),
+	.swapout	= SEGKPM_BADOP(size_t),
+	.sync		= SEGKPM_BADOP(int),
+	.incore		= SEGKPM_BADOP(size_t),
+	.lockop		= SEGKPM_BADOP(int),
+	.getprot	= SEGKPM_BADOP(int),
+	.getoffset	= SEGKPM_BADOP(u_offset_t),
+	.gettype	= SEGKPM_BADOP(int),
+	.getvp		= SEGKPM_BADOP(int),
+	.advise		= SEGKPM_BADOP(int),
+	.dump		= segkpm_dump,
+	.pagelock	= SEGKPM_NOTSUP,
+	.setpagesize	= SEGKPM_BADOP(int),
+	.getmemid	= SEGKPM_BADOP(int),
+	.getpolicy	= SEGKPM_BADOP(lgrp_mem_policy_info_t *),
+	.capable	= segkpm_capable,
+	.inherit	= seg_inherit_notsup,
 };
 
 /*
--- old/usr/src/uts/common/vm/seg_map.c	2015-11-24 09:34:39.108805497 -0500
+++ new/usr/src/uts/common/vm/seg_map.c	2015-11-24 09:34:39.112607159 -0500
@@ -101,30 +101,30 @@
 #define	SEGMAP_BADOP(t)	(t(*)())segmap_badop
 
 static struct seg_ops segmap_ops = {
-	SEGMAP_BADOP(int),	/* dup */
-	SEGMAP_BADOP(int),	/* unmap */
-	segmap_free,
-	segmap_fault,
-	segmap_faulta,
-	SEGMAP_BADOP(int),	/* setprot */
-	segmap_checkprot,
-	segmap_kluster,
-	SEGMAP_BADOP(size_t),	/* swapout */
-	SEGMAP_BADOP(int),	/* sync */
-	SEGMAP_BADOP(size_t),	/* incore */
-	SEGMAP_BADOP(int),	/* lockop */
-	segmap_getprot,
-	segmap_getoffset,
-	segmap_gettype,
-	segmap_getvp,
-	SEGMAP_BADOP(int),	/* advise */
-	segmap_dump,
-	segmap_pagelock,	/* pagelock */
-	SEGMAP_BADOP(int),	/* setpgsz */
-	segmap_getmemid,	/* getmemid */
-	segmap_getpolicy,	/* getpolicy */
-	segmap_capable,		/* capable */
-	seg_inherit_notsup	/* inherit */
+	.dup		= SEGMAP_BADOP(int),
+	.unmap		= SEGMAP_BADOP(int),
+	.free		= segmap_free,
+	.fault		= segmap_fault,
+	.faulta		= segmap_faulta,
+	.setprot	= SEGMAP_BADOP(int),
+	.checkprot	= segmap_checkprot,
+	.kluster	= segmap_kluster,
+	.swapout	= SEGMAP_BADOP(size_t),
+	.sync		= SEGMAP_BADOP(int),
+	.incore		= SEGMAP_BADOP(size_t),
+	.lockop		= SEGMAP_BADOP(int),
+	.getprot	= segmap_getprot,
+	.getoffset	= segmap_getoffset,
+	.gettype	= segmap_gettype,
+	.getvp		= segmap_getvp,
+	.advise		= SEGMAP_BADOP(int),
+	.dump		= segmap_dump,
+	.pagelock	= segmap_pagelock,
+	.setpagesize	= SEGMAP_BADOP(int),
+	.getmemid	= segmap_getmemid,
+	.getpolicy	= segmap_getpolicy,
+	.capable	= segmap_capable,
+	.inherit	= seg_inherit_notsup,
 };
 
 /*
--- old/usr/src/uts/common/vm/seg_spt.c	2015-11-24 09:34:39.278452600 -0500
+++ new/usr/src/uts/common/vm/seg_spt.c	2015-11-24 09:34:39.282076607 -0500
@@ -86,30 +86,30 @@
 #define	SEGSPT_BADOP(t)	(t(*)())segspt_badop
 
 struct seg_ops segspt_ops = {
-	SEGSPT_BADOP(int),		/* dup */
-	segspt_unmap,
-	segspt_free,
-	SEGSPT_BADOP(int),		/* fault */
-	SEGSPT_BADOP(faultcode_t),	/* faulta */
-	SEGSPT_BADOP(int),		/* setprot */
-	SEGSPT_BADOP(int),		/* checkprot */
-	SEGSPT_BADOP(int),		/* kluster */
-	SEGSPT_BADOP(size_t),		/* swapout */
-	SEGSPT_BADOP(int),		/* sync */
-	SEGSPT_BADOP(size_t),		/* incore */
-	SEGSPT_BADOP(int),		/* lockop */
-	SEGSPT_BADOP(int),		/* getprot */
-	SEGSPT_BADOP(u_offset_t), 	/* getoffset */
-	SEGSPT_BADOP(int),		/* gettype */
-	SEGSPT_BADOP(int),		/* getvp */
-	SEGSPT_BADOP(int),		/* advise */
-	SEGSPT_BADOP(void),		/* dump */
-	SEGSPT_BADOP(int),		/* pagelock */
-	SEGSPT_BADOP(int),		/* setpgsz */
-	SEGSPT_BADOP(int),		/* getmemid */
-	segspt_getpolicy,		/* getpolicy */
-	SEGSPT_BADOP(int),		/* capable */
-	seg_inherit_notsup		/* inherit */
+	.dup		= SEGSPT_BADOP(int),
+	.unmap		= segspt_unmap,
+	.free		= segspt_free,
+	.fault		= SEGSPT_BADOP(int),
+	.faulta		= SEGSPT_BADOP(faultcode_t),
+	.setprot	= SEGSPT_BADOP(int),
+	.checkprot	= SEGSPT_BADOP(int),
+	.kluster	= SEGSPT_BADOP(int),
+	.swapout	= SEGSPT_BADOP(size_t),
+	.sync		= SEGSPT_BADOP(int),
+	.incore		= SEGSPT_BADOP(size_t),
+	.lockop		= SEGSPT_BADOP(int),
+	.getprot	= SEGSPT_BADOP(int),
+	.getoffset	= SEGSPT_BADOP(u_offset_t),
+	.gettype	= SEGSPT_BADOP(int),
+	.getvp		= SEGSPT_BADOP(int),
+	.advise		= SEGSPT_BADOP(int),
+	.dump		= SEGSPT_BADOP(void),
+	.pagelock	= SEGSPT_BADOP(int),
+	.setpagesize	= SEGSPT_BADOP(int),
+	.getmemid	= SEGSPT_BADOP(int),
+	.getpolicy	= segspt_getpolicy,
+	.capable	= SEGSPT_BADOP(int),
+	.inherit	= seg_inherit_notsup,
 };
 
 static int segspt_shmdup(struct seg *seg, struct seg *newseg);
@@ -146,30 +146,30 @@
 static int segspt_shmcapable(struct seg *, segcapability_t);
 
 struct seg_ops segspt_shmops = {
-	segspt_shmdup,
-	segspt_shmunmap,
-	segspt_shmfree,
-	segspt_shmfault,
-	segspt_shmfaulta,
-	segspt_shmsetprot,
-	segspt_shmcheckprot,
-	segspt_shmkluster,
-	segspt_shmswapout,
-	segspt_shmsync,
-	segspt_shmincore,
-	segspt_shmlockop,
-	segspt_shmgetprot,
-	segspt_shmgetoffset,
-	segspt_shmgettype,
-	segspt_shmgetvp,
-	segspt_shmadvise,	/* advise */
-	segspt_shmdump,
-	segspt_shmpagelock,
-	segspt_shmsetpgsz,
-	segspt_shmgetmemid,
-	segspt_shmgetpolicy,
-	segspt_shmcapable,
-	seg_inherit_notsup
+	.dup		= segspt_shmdup,
+	.unmap		= segspt_shmunmap,
+	.free		= segspt_shmfree,
+	.fault		= segspt_shmfault,
+	.faulta		= segspt_shmfaulta,
+	.setprot	= segspt_shmsetprot,
+	.checkprot	= segspt_shmcheckprot,
+	.kluster	= segspt_shmkluster,
+	.swapout	= segspt_shmswapout,
+	.sync		= segspt_shmsync,
+	.incore		= segspt_shmincore,
+	.lockop		= segspt_shmlockop,
+	.getprot	= segspt_shmgetprot,
+	.getoffset	= segspt_shmgetoffset,
+	.gettype	= segspt_shmgettype,
+	.getvp		= segspt_shmgetvp,
+	.advise		= segspt_shmadvise,
+	.dump		= segspt_shmdump,
+	.pagelock	= segspt_shmpagelock,
+	.setpagesize	= segspt_shmsetpgsz,
+	.getmemid	= segspt_shmgetmemid,
+	.getpolicy	= segspt_shmgetpolicy,
+	.capable	= segspt_shmcapable,
+	.inherit	= seg_inherit_notsup,
 };
 
 static void segspt_purge(struct seg *seg);
--- old/usr/src/uts/common/vm/seg_vn.c	2015-11-24 09:34:39.457503644 -0500
+++ new/usr/src/uts/common/vm/seg_vn.c	2015-11-24 09:34:39.461512558 -0500
@@ -138,30 +138,30 @@
 static int	segvn_inherit(struct seg *, caddr_t, size_t, uint_t);
 
 struct	seg_ops segvn_ops = {
-	segvn_dup,
-	segvn_unmap,
-	segvn_free,
-	segvn_fault,
-	segvn_faulta,
-	segvn_setprot,
-	segvn_checkprot,
-	segvn_kluster,
-	segvn_swapout,
-	segvn_sync,
-	segvn_incore,
-	segvn_lockop,
-	segvn_getprot,
-	segvn_getoffset,
-	segvn_gettype,
-	segvn_getvp,
-	segvn_advise,
-	segvn_dump,
-	segvn_pagelock,
-	segvn_setpagesize,
-	segvn_getmemid,
-	segvn_getpolicy,
-	segvn_capable,
-	segvn_inherit
+	.dup		= segvn_dup,
+	.unmap		= segvn_unmap,
+	.free		= segvn_free,
+	.fault		= segvn_fault,
+	.faulta		= segvn_faulta,
+	.setprot	= segvn_setprot,
+	.checkprot	= segvn_checkprot,
+	.kluster	= segvn_kluster,
+	.swapout	= segvn_swapout,
+	.sync		= segvn_sync,
+	.incore		= segvn_incore,
+	.lockop		= segvn_lockop,
+	.getprot	= segvn_getprot,
+	.getoffset	= segvn_getoffset,
+	.gettype	= segvn_gettype,
+	.getvp		= segvn_getvp,
+	.advise		= segvn_advise,
+	.dump		= segvn_dump,
+	.pagelock	= segvn_pagelock,
+	.setpagesize	= segvn_setpagesize,
+	.getmemid	= segvn_getmemid,
+	.getpolicy	= segvn_getpolicy,
+	.capable	= segvn_capable,
+	.inherit	= segvn_inherit,
 };
 
 /*
--- old/usr/src/uts/i86xpv/vm/seg_mf.c	2015-11-24 09:34:39.791101354 -0500
+++ new/usr/src/uts/i86xpv/vm/seg_mf.c	2015-11-24 09:34:39.794791059 -0500
@@ -758,28 +758,27 @@
 }
 
 static struct seg_ops segmf_ops = {
-	segmf_dup,
-	segmf_unmap,
-	segmf_free,
-	segmf_fault,
-	segmf_faulta,
-	segmf_setprot,
-	segmf_checkprot,
-	(int (*)())segmf_kluster,
-	(size_t (*)(struct seg *))NULL,	/* swapout */
-	segmf_sync,
-	segmf_incore,
-	segmf_lockop,
-	segmf_getprot,
-	segmf_getoffset,
-	segmf_gettype,
-	segmf_getvp,
-	segmf_advise,
-	segmf_dump,
-	segmf_pagelock,
-	segmf_setpagesize,
-	segmf_getmemid,
-	segmf_getpolicy,
-	segmf_capable,
-	seg_inherit_notsup
+	.dup		= segmf_dup,
+	.unmap		= segmf_unmap,
+	.free		= segmf_free,
+	.fault		= segmf_fault,
+	.faulta		= segmf_faulta,
+	.setprot	= segmf_setprot,
+	.checkprot	= segmf_checkprot,
+	.kluster	= segmf_kluster,
+	.sync		= segmf_sync,
+	.incore		= segmf_incore,
+	.lockop		= segmf_lockop,
+	.getprot	= segmf_getprot,
+	.getoffset	= segmf_getoffset,
+	.gettype	= segmf_gettype,
+	.getvp		= segmf_getvp,
+	.advise		= segmf_advise,
+	.dump		= segmf_dump,
+	.pagelock	= segmf_pagelock,
+	.setpagesize	= segmf_setpagesize,
+	.getmemid	= segmf_getmemid,
+	.getpolicy	= segmf_getpolicy,
+	.capable	= segmf_capable,
+	.inherit	= seg_inherit_notsup,
 };
--- old/usr/src/uts/sparc/v9/vm/seg_nf.c	2015-11-24 09:34:39.917081518 -0500
+++ new/usr/src/uts/sparc/v9/vm/seg_nf.c	2015-11-24 09:34:39.920785888 -0500
@@ -31,8 +31,6 @@
  * under license from the Regents of the University of California.
  */
 
-#pragma ident	"%Z%%M%	%I%	%E% SMI"
-
 /*
  * VM - segment for non-faulting loads.
  */
@@ -86,35 +84,32 @@
 
 
 struct seg_ops segnf_ops = {
-	segnf_dup,
-	segnf_unmap,
-	segnf_free,
-	(faultcode_t (*)(struct hat *, struct seg *, caddr_t, size_t,
-	    enum fault_type, enum seg_rw))
-		segnf_nomap,		/* fault */
-	(faultcode_t (*)(struct seg *, caddr_t))
-		segnf_nomap,		/* faulta */
-	segnf_setprot,
-	segnf_checkprot,
-	(int (*)())segnf_badop,		/* kluster */
-	(size_t (*)(struct seg *))NULL,	/* swapout */
-	(int (*)(struct seg *, caddr_t, size_t, int, uint_t))
-		segnf_nop,		/* sync */
-	(size_t (*)(struct seg *, caddr_t, size_t, char *))
-		segnf_nop,		/* incore */
-	(int (*)(struct seg *, caddr_t, size_t, int, int, ulong_t *, size_t))
-		segnf_nop,		/* lockop */
-	segnf_getprot,
-	segnf_getoffset,
-	segnf_gettype,
-	segnf_getvp,
-	(int (*)(struct seg *, caddr_t, size_t, uint_t))
-		segnf_nop,		/* advise */
-	segnf_dump,
-	segnf_pagelock,
-	segnf_setpagesize,
-	segnf_getmemid,
-	segnf_getpolicy,
+	.dup		= segnf_dup,
+	.unmap		= segnf_unmap,
+	.free		= segnf_free,
+	.fault		= (faultcode_t (*)(struct hat *, struct seg *, caddr_t,
+	    size_t, enum fault_type, enum seg_rw))segnf_nomap,
+	.faulta		= (faultcode_t (*)(struct seg *, caddr_t)) segnf_nomap,
+	.setprot	= segnf_setprot,
+	.checkprot	= segnf_checkprot,
+	.kluster	= (int (*)())segnf_badop,
+	.sync		= (int (*)(struct seg *, caddr_t, size_t, int, uint_t))
+		segnf_nop,
+	.incore		= (size_t (*)(struct seg *, caddr_t, size_t, char *))
+		segnf_nop,
+	.lockop		= (int (*)(struct seg *, caddr_t, size_t, int, int,
+	    ulong_t *, size_t))segnf_nop,
+	.getprot	= segnf_getprot,
+	.getoffset	= segnf_getoffset,
+	.gettype	= segnf_gettype,
+	.getvp		= segnf_getvp,
+	.advise		= (int (*)(struct seg *, caddr_t, size_t, uint_t))
+		segnf_nop,
+	.dump		= segnf_dump,
+	.pagelock	= segnf_pagelock,
+	.setpagesize	= segnf_setpagesize,
+	.getmemid	= segnf_getmemid,
+	.getpolicy	= segnf_getpolicy,
 };
 
 /*
