Print this page
use NULL dump segop as a shorthand for no-op
Instead of forcing every segment driver to implement a dummy function that
does nothing, handle NULL dump segop function pointer as a no-op shorthand.


  85  * . Set by default for platforms that don't support kpm large pages or
  86  *   where large pages cannot be used for other reasons (e.g. there are
  87  *   only few full associative TLB entries available for large pages).
  88  *
  89  * segmap_kpm -- separate on/off switch for segmap using segkpm:
  90  * . Set by default.
  91  * . Will be disabled when kpm_enable is zero.
  92  * . Will be disabled when MAXBSIZE != PAGESIZE.
  93  * . Can be disabled via /etc/system.
  94  *
  95  */
  96 int kpm_enable = 1;
  97 int kpm_smallpages = 0;
  98 int segmap_kpm = 1;
  99 
 100 /*
 101  * Private seg op routines.
 102  */
 103 faultcode_t segkpm_fault(struct hat *hat, struct seg *seg, caddr_t addr,
 104                         size_t len, enum fault_type type, enum seg_rw rw);
 105 static void     segkpm_dump(struct seg *);
 106 static int      segkpm_pagelock(struct seg *seg, caddr_t addr, size_t len,
 107                         struct page ***page, enum lock_type type,
 108                         enum seg_rw rw);
 109 
 110 static const struct seg_ops segkpm_ops = {
 111         .fault          = segkpm_fault,
 112         .dump           = segkpm_dump,
 113         .pagelock       = segkpm_pagelock,
 114 //#ifndef SEGKPM_SUPPORT
 115 #if 0
 116 #error FIXME: define nop
 117         .dup            = nop,
 118         .unmap          = nop,
 119         .free           = nop,
 120         .faulta         = nop,
 121         .setprot        = nop,
 122         .checkprot      = nop,
 123         .kluster        = nop,
 124         .sync           = nop,
 125         .incore         = nop,
 126         .lockop         = nop,
 127         .getprot        = nop,
 128         .getoffset      = nop,
 129         .gettype        = nop,
 130         .getvp          = nop,
 131         .advise         = nop,
 132         .getpolicy      = nop,


 300 
 301 /* ARGSUSED */
 302 caddr_t segkpm_create_va(u_offset_t off)
 303 {
 304         return (NULL);
 305 }
 306 
 307 /* ARGSUSED */
 308 void segkpm_mapout_validkpme(struct kpme *kpme)
 309 {
 310 }
 311 
 312 #endif  /* SEGKPM_SUPPORT */
 313 
 314 /* ARGSUSED */
 315 static int
 316 segkpm_pagelock(struct seg *seg, caddr_t addr, size_t len,
 317         struct page ***page, enum lock_type type, enum seg_rw rw)
 318 {
 319         return (ENOTSUP);
 320 }
 321 
 322 /*
 323  * segkpm pages are not dumped, so we just return
 324  */
 325 /*ARGSUSED*/
 326 static void
 327 segkpm_dump(struct seg *seg)
 328 {
 329 }


  85  * . Set by default for platforms that don't support kpm large pages or
  86  *   where large pages cannot be used for other reasons (e.g. there are
  87  *   only few full associative TLB entries available for large pages).
  88  *
  89  * segmap_kpm -- separate on/off switch for segmap using segkpm:
  90  * . Set by default.
  91  * . Will be disabled when kpm_enable is zero.
  92  * . Will be disabled when MAXBSIZE != PAGESIZE.
  93  * . Can be disabled via /etc/system.
  94  *
  95  */
  96 int kpm_enable = 1;
  97 int kpm_smallpages = 0;
  98 int segmap_kpm = 1;
  99 
 100 /*
 101  * Private seg op routines.
 102  */
 103 faultcode_t segkpm_fault(struct hat *hat, struct seg *seg, caddr_t addr,
 104                         size_t len, enum fault_type type, enum seg_rw rw);

 105 static int      segkpm_pagelock(struct seg *seg, caddr_t addr, size_t len,
 106                         struct page ***page, enum lock_type type,
 107                         enum seg_rw rw);
 108 
 109 static const struct seg_ops segkpm_ops = {
 110         .fault          = segkpm_fault,

 111         .pagelock       = segkpm_pagelock,
 112 //#ifndef SEGKPM_SUPPORT
 113 #if 0
 114 #error FIXME: define nop
 115         .dup            = nop,
 116         .unmap          = nop,
 117         .free           = nop,
 118         .faulta         = nop,
 119         .setprot        = nop,
 120         .checkprot      = nop,
 121         .kluster        = nop,
 122         .sync           = nop,
 123         .incore         = nop,
 124         .lockop         = nop,
 125         .getprot        = nop,
 126         .getoffset      = nop,
 127         .gettype        = nop,
 128         .getvp          = nop,
 129         .advise         = nop,
 130         .getpolicy      = nop,


 298 
 299 /* ARGSUSED */
 300 caddr_t segkpm_create_va(u_offset_t off)
 301 {
 302         return (NULL);
 303 }
 304 
 305 /* ARGSUSED */
 306 void segkpm_mapout_validkpme(struct kpme *kpme)
 307 {
 308 }
 309 
 310 #endif  /* SEGKPM_SUPPORT */
 311 
 312 /* ARGSUSED */
 313 static int
 314 segkpm_pagelock(struct seg *seg, caddr_t addr, size_t len,
 315         struct page ***page, enum lock_type type, enum seg_rw rw)
 316 {
 317         return (ENOTSUP);









 318 }