no need for bad-op segment op functions
The segment drivers have a number of bad-op functions that simply panic.
Keeping the function pointer NULL will accomplish the same thing in most
cases.  In other cases, keeping the function pointer NULL will result in
proper error code being returned.

*** 101,141 ****
   * Private seg op routines.
   */
  faultcode_t segkpm_fault(struct hat *hat, struct seg *seg, caddr_t addr,
                          size_t len, enum fault_type type, enum seg_rw rw);
  static void     segkpm_dump(struct seg *);
! static void     segkpm_badop(void);
! static int      segkpm_notsup(void);
  static int      segkpm_capable(struct seg *, segcapability_t);
  
- #define SEGKPM_BADOP(t) (t(*)())segkpm_badop
- #define SEGKPM_NOTSUP   (int(*)())segkpm_notsup
- 
  static struct seg_ops segkpm_ops = {
-         .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),
-         .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,
  };
  
  /*
   * kpm_pgsz and kpm_pgshft are set by platform layer.
   */
--- 101,143 ----
   * Private seg op routines.
   */
  faultcode_t segkpm_fault(struct hat *hat, struct seg *seg, caddr_t addr,
                          size_t len, enum fault_type type, enum seg_rw rw);
  static void     segkpm_dump(struct seg *);
! static int      segkpm_pagelock(struct seg *seg, caddr_t addr, size_t len,
!                         struct page ***page, enum lock_type type,
!                         enum seg_rw rw);
  static int      segkpm_capable(struct seg *, segcapability_t);
  
  static struct seg_ops segkpm_ops = {
          .fault          = segkpm_fault,
          .dump           = segkpm_dump,
!         .pagelock       = segkpm_pagelock,
          .capable        = segkpm_capable,
          .inherit        = seg_inherit_notsup,
+ //#ifndef SEGKPM_SUPPORT
+ #if 0
+ #error FIXME: define nop
+         .dup            = nop,
+         .unmap          = nop,
+         .free           = nop,
+         .faulta         = nop,
+         .setprot        = nop,
+         .checkprot      = nop,
+         .kluster        = nop,
+         .sync           = nop,
+         .incore         = nop,
+         .lockop         = nop,
+         .getprot        = nop,
+         .getoffset      = nop,
+         .gettype        = nop,
+         .getvp          = nop,
+         .advise         = nop,
+         .setpagesize    = nop,
+         .getmemid       = nop,
+         .getpolicy      = nop,
+ #endif
  };
  
  /*
   * kpm_pgsz and kpm_pgshft are set by platform layer.
   */
*** 281,335 ****
          vaddr = hat_kpm_page2va(pp, 1);
          hat_kpm_mapout(pp, kpme, vaddr);
          page_unlock(pp);
  }
  
- static void
- segkpm_badop()
- {
-         panic("segkpm_badop");
- }
- 
  #else   /* SEGKPM_SUPPORT */
  
  /* segkpm stubs */
  
  /*ARGSUSED*/
! int segkpm_create(struct seg *seg, void *argsp) { return (0); }
  
  /* ARGSUSED */
  faultcode_t
  segkpm_fault(struct hat *hat, struct seg *seg, caddr_t addr, size_t len,
          enum fault_type type, enum seg_rw rw)
  {
!         return ((faultcode_t)0);
  }
  
  /* ARGSUSED */
! caddr_t segkpm_create_va(u_offset_t off) { return (NULL); }
  
  /* ARGSUSED */
! void segkpm_mapout_validkpme(struct kpme *kpme) {}
! 
! static void
! segkpm_badop() {}
  
  #endif  /* SEGKPM_SUPPORT */
  
  static int
! segkpm_notsup()
  {
          return (ENOTSUP);
  }
  
  /*
   * segkpm pages are not dumped, so we just return
   */
  /*ARGSUSED*/
  static void
  segkpm_dump(struct seg *seg)
! {}
  
  /*
   * We claim to have no special capabilities.
   */
  /*ARGSUSED*/
--- 283,339 ----
          vaddr = hat_kpm_page2va(pp, 1);
          hat_kpm_mapout(pp, kpme, vaddr);
          page_unlock(pp);
  }
  
  #else   /* SEGKPM_SUPPORT */
  
  /* segkpm stubs */
  
  /*ARGSUSED*/
! int segkpm_create(struct seg *seg, void *argsp)
! {
!         return (0);
! }
  
  /* ARGSUSED */
  faultcode_t
  segkpm_fault(struct hat *hat, struct seg *seg, caddr_t addr, size_t len,
          enum fault_type type, enum seg_rw rw)
  {
!         return (0);
  }
  
  /* ARGSUSED */
! caddr_t segkpm_create_va(u_offset_t off)
! {
!         return (NULL);
! }
  
  /* ARGSUSED */
! void segkpm_mapout_validkpme(struct kpme *kpme)
! {
! }
  
  #endif  /* SEGKPM_SUPPORT */
  
+ /* ARGSUSED */
  static int
! segkpm_pagelock(struct seg *seg, caddr_t addr, size_t len,
!         struct page ***page, enum lock_type type, enum seg_rw rw)
  {
          return (ENOTSUP);
  }
  
  /*
   * segkpm pages are not dumped, so we just return
   */
  /*ARGSUSED*/
  static void
  segkpm_dump(struct seg *seg)
! {
! }
  
  /*
   * We claim to have no special capabilities.
   */
  /*ARGSUSED*/