Print this page
6149 use NULL capable segop as a shorthand for no-capabilities

Split Close
Expand all
Collapse all
          --- old/usr/src/uts/common/vm/seg_vn.c
          +++ new/usr/src/uts/common/vm/seg_vn.c
↓ open down ↓ 126 lines elided ↑ open up ↑
 127  127  static int      segvn_advise(struct seg *seg, caddr_t addr, size_t len,
 128  128                      uint_t behav);
 129  129  static void     segvn_dump(struct seg *seg);
 130  130  static int      segvn_pagelock(struct seg *seg, caddr_t addr, size_t len,
 131  131                      struct page ***ppp, enum lock_type type, enum seg_rw rw);
 132  132  static int      segvn_setpagesize(struct seg *seg, caddr_t addr, size_t len,
 133  133                      uint_t szc);
 134  134  static int      segvn_getmemid(struct seg *seg, caddr_t addr,
 135  135                      memid_t *memidp);
 136  136  static lgrp_mem_policy_info_t   *segvn_getpolicy(struct seg *, caddr_t);
 137      -static int      segvn_capable(struct seg *seg, segcapability_t capable);
 138  137  static int      segvn_inherit(struct seg *, caddr_t, size_t, uint_t);
 139  138  
 140  139  struct  seg_ops segvn_ops = {
 141  140          .dup            = segvn_dup,
 142  141          .unmap          = segvn_unmap,
 143  142          .free           = segvn_free,
 144  143          .fault          = segvn_fault,
 145  144          .faulta         = segvn_faulta,
 146  145          .setprot        = segvn_setprot,
 147  146          .checkprot      = segvn_checkprot,
↓ open down ↓ 5 lines elided ↑ open up ↑
 153  152          .getprot        = segvn_getprot,
 154  153          .getoffset      = segvn_getoffset,
 155  154          .gettype        = segvn_gettype,
 156  155          .getvp          = segvn_getvp,
 157  156          .advise         = segvn_advise,
 158  157          .dump           = segvn_dump,
 159  158          .pagelock       = segvn_pagelock,
 160  159          .setpagesize    = segvn_setpagesize,
 161  160          .getmemid       = segvn_getmemid,
 162  161          .getpolicy      = segvn_getpolicy,
 163      -        .capable        = segvn_capable,
 164  162          .inherit        = segvn_inherit,
 165  163  };
 166  164  
 167  165  /*
 168  166   * Common zfod structures, provided as a shorthand for others to use.
 169  167   */
 170  168  static segvn_crargs_t zfod_segvn_crargs =
 171  169          SEGVN_ZFOD_ARGS(PROT_ZFOD, PROT_ALL);
 172  170  static segvn_crargs_t kzfod_segvn_crargs =
 173  171          SEGVN_ZFOD_ARGS(PROT_ZFOD & ~PROT_USER,
↓ open down ↓ 9508 lines elided ↑ open up ↑
9682 9680                  }
9683 9681          } else {
9684 9682                  amp = svn_data->amp;
9685 9683                  anon_index = svn_data->anon_index + seg_page(seg, addr);
9686 9684                  vp = svn_data->vp;
9687 9685                  vn_off = svn_data->offset + (uintptr_t)(addr - seg->s_base);
9688 9686                  policy_info = lgrp_shm_policy_get(amp, anon_index, vp, vn_off);
9689 9687          }
9690 9688  
9691 9689          return (policy_info);
9692      -}
9693      -
9694      -/*ARGSUSED*/
9695      -static int
9696      -segvn_capable(struct seg *seg, segcapability_t capability)
9697      -{
9698      -        return (0);
9699 9690  }
9700 9691  
9701 9692  /*
9702 9693   * Bind text vnode segment to an amp. If we bind successfully mappings will be
9703 9694   * established to per vnode mapping per lgroup amp pages instead of to vnode
9704 9695   * pages. There's one amp per vnode text mapping per lgroup. Many processes
9705 9696   * may share the same text replication amp. If a suitable amp doesn't already
9706 9697   * exist in svntr hash table create a new one.  We may fail to bind to amp if
9707 9698   * segment is not eligible for text replication.  Code below first checks for
9708 9699   * these conditions. If binding is successful segment tr_state is set to on
↓ open down ↓ 606 lines elided ↑ open up ↑
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX