Print this page
6152 use NULL dump segop as a shorthand for no-op

Split Close
Expand all
Collapse all
          --- old/usr/src/uts/sparc/v9/vm/seg_nf.c
          +++ new/usr/src/uts/sparc/v9/vm/seg_nf.c
↓ open down ↓ 65 lines elided ↑ open up ↑
  66   66                      size_t len, uint_t prot);
  67   67  static int      segnf_checkprot(struct seg *seg, caddr_t addr,
  68   68                      size_t len, uint_t prot);
  69   69  static void     segnf_badop(void);
  70   70  static int      segnf_nop(void);
  71   71  static int      segnf_getprot(struct seg *seg, caddr_t addr,
  72   72                      size_t len, uint_t *protv);
  73   73  static u_offset_t segnf_getoffset(struct seg *seg, caddr_t addr);
  74   74  static int      segnf_gettype(struct seg *seg, caddr_t addr);
  75   75  static int      segnf_getvp(struct seg *seg, caddr_t addr, struct vnode **vpp);
  76      -static void     segnf_dump(struct seg *seg);
  77   76  static int      segnf_pagelock(struct seg *seg, caddr_t addr, size_t len,
  78   77                      struct page ***ppp, enum lock_type type, enum seg_rw rw);
  79   78  
  80   79  
  81   80  struct seg_ops segnf_ops = {
  82   81          .dup            = segnf_dup,
  83   82          .unmap          = segnf_unmap,
  84   83          .free           = segnf_free,
  85   84          .fault          = (faultcode_t (*)(struct hat *, struct seg *, caddr_t,
  86   85              size_t, enum fault_type, enum seg_rw))segnf_nomap,
↓ open down ↓ 6 lines elided ↑ open up ↑
  93   92          .incore         = (size_t (*)(struct seg *, caddr_t, size_t, char *))
  94   93                  segnf_nop,
  95   94          .lockop         = (int (*)(struct seg *, caddr_t, size_t, int, int,
  96   95              ulong_t *, size_t))segnf_nop,
  97   96          .getprot        = segnf_getprot,
  98   97          .getoffset      = segnf_getoffset,
  99   98          .gettype        = segnf_gettype,
 100   99          .getvp          = segnf_getvp,
 101  100          .advise         = (int (*)(struct seg *, caddr_t, size_t, uint_t))
 102  101                  segnf_nop,
 103      -        .dump           = segnf_dump,
 104  102          .pagelock       = segnf_pagelock,
 105  103  };
 106  104  
 107  105  /*
 108  106   * vnode and page for the page of zeros we use for the nf mappings.
 109  107   */
 110  108  static kmutex_t segnf_lock;
 111  109  static struct vnode nfvp;
 112  110  static struct page **nfpp;
 113  111  
↓ open down ↓ 324 lines elided ↑ open up ↑
 438  436  
 439  437  /* ARGSUSED */
 440  438  static int
 441  439  segnf_getvp(struct seg *seg, caddr_t addr, struct vnode **vpp)
 442  440  {
 443  441          ASSERT(seg->s_as && AS_LOCK_HELD(seg->s_as, &seg->s_as->a_lock));
 444  442  
 445  443          *vpp = &nfvp;
 446  444          return (0);
 447  445  }
 448      -
 449      -/*
 450      - * segnf pages are not dumped, so we just return
 451      - */
 452      -/* ARGSUSED */
 453      -static void
 454      -segnf_dump(struct seg *seg)
 455      -{}
 456  446  
 457  447  /*ARGSUSED*/
 458  448  static int
 459  449  segnf_pagelock(struct seg *seg, caddr_t addr, size_t len,
 460  450      struct page ***ppp, enum lock_type type, enum seg_rw rw)
 461  451  {
 462  452          return (ENOTSUP);
 463  453  }
    
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX