Print this page
6151 use NULL setpagesize segop as a shorthand for ENOTSUP


  59  * Private seg op routines.
  60  */
  61 static int      segnf_dup(struct seg *seg, struct seg *newseg);
  62 static int      segnf_unmap(struct seg *seg, caddr_t addr, size_t len);
  63 static void     segnf_free(struct seg *seg);
  64 static faultcode_t segnf_nomap(void);
  65 static int      segnf_setprot(struct seg *seg, caddr_t addr,
  66                     size_t len, uint_t prot);
  67 static int      segnf_checkprot(struct seg *seg, caddr_t addr,
  68                     size_t len, uint_t prot);
  69 static void     segnf_badop(void);
  70 static int      segnf_nop(void);
  71 static int      segnf_getprot(struct seg *seg, caddr_t addr,
  72                     size_t len, uint_t *protv);
  73 static u_offset_t segnf_getoffset(struct seg *seg, caddr_t addr);
  74 static int      segnf_gettype(struct seg *seg, caddr_t addr);
  75 static int      segnf_getvp(struct seg *seg, caddr_t addr, struct vnode **vpp);
  76 static void     segnf_dump(struct seg *seg);
  77 static int      segnf_pagelock(struct seg *seg, caddr_t addr, size_t len,
  78                     struct page ***ppp, enum lock_type type, enum seg_rw rw);
  79 static int      segnf_setpagesize(struct seg *seg, caddr_t addr, size_t len,
  80                     uint_t szc);
  81 
  82 
  83 struct seg_ops segnf_ops = {
  84         .dup            = segnf_dup,
  85         .unmap          = segnf_unmap,
  86         .free           = segnf_free,
  87         .fault          = (faultcode_t (*)(struct hat *, struct seg *, caddr_t,
  88             size_t, enum fault_type, enum seg_rw))segnf_nomap,
  89         .faulta         = (faultcode_t (*)(struct seg *, caddr_t)) segnf_nomap,
  90         .setprot        = segnf_setprot,
  91         .checkprot      = segnf_checkprot,
  92         .kluster        = (int (*)())segnf_badop,
  93         .sync           = (int (*)(struct seg *, caddr_t, size_t, int, uint_t))
  94                 segnf_nop,
  95         .incore         = (size_t (*)(struct seg *, caddr_t, size_t, char *))
  96                 segnf_nop,
  97         .lockop         = (int (*)(struct seg *, caddr_t, size_t, int, int,
  98             ulong_t *, size_t))segnf_nop,
  99         .getprot        = segnf_getprot,
 100         .getoffset      = segnf_getoffset,
 101         .gettype        = segnf_gettype,
 102         .getvp          = segnf_getvp,
 103         .advise         = (int (*)(struct seg *, caddr_t, size_t, uint_t))
 104                 segnf_nop,
 105         .dump           = segnf_dump,
 106         .pagelock       = segnf_pagelock,
 107         .setpagesize    = segnf_setpagesize,
 108 };
 109 
 110 /*
 111  * vnode and page for the page of zeros we use for the nf mappings.
 112  */
 113 static kmutex_t segnf_lock;
 114 static struct vnode nfvp;
 115 static struct page **nfpp;
 116 
 117 #define addr_to_vcolor(addr)                                            \
 118         (shm_alignment) ?                                               \
 119         ((int)(((uintptr_t)(addr) & (shm_alignment - 1)) >> PAGESHIFT)) : 0
 120 
 121 /*
 122  * We try to limit the number of Non-fault segments created.
 123  * Non fault segments are created to optimize sparc V9 code which uses
 124  * the sparc nonfaulting load ASI (ASI_PRIMARY_NOFAULT).
 125  *
 126  * There are several reasons why creating too many non-fault segments
 127  * could cause problems.


 444 segnf_getvp(struct seg *seg, caddr_t addr, struct vnode **vpp)
 445 {
 446         ASSERT(seg->s_as && AS_LOCK_HELD(seg->s_as, &seg->s_as->a_lock));
 447 
 448         *vpp = &nfvp;
 449         return (0);
 450 }
 451 
 452 /*
 453  * segnf pages are not dumped, so we just return
 454  */
 455 /* ARGSUSED */
 456 static void
 457 segnf_dump(struct seg *seg)
 458 {}
 459 
 460 /*ARGSUSED*/
 461 static int
 462 segnf_pagelock(struct seg *seg, caddr_t addr, size_t len,
 463     struct page ***ppp, enum lock_type type, enum seg_rw rw)
 464 {
 465         return (ENOTSUP);
 466 }
 467 
 468 /*ARGSUSED*/
 469 static int
 470 segnf_setpagesize(struct seg *seg, caddr_t addr, size_t len,
 471     uint_t szc)
 472 {
 473         return (ENOTSUP);
 474 }


  59  * Private seg op routines.
  60  */
  61 static int      segnf_dup(struct seg *seg, struct seg *newseg);
  62 static int      segnf_unmap(struct seg *seg, caddr_t addr, size_t len);
  63 static void     segnf_free(struct seg *seg);
  64 static faultcode_t segnf_nomap(void);
  65 static int      segnf_setprot(struct seg *seg, caddr_t addr,
  66                     size_t len, uint_t prot);
  67 static int      segnf_checkprot(struct seg *seg, caddr_t addr,
  68                     size_t len, uint_t prot);
  69 static void     segnf_badop(void);
  70 static int      segnf_nop(void);
  71 static int      segnf_getprot(struct seg *seg, caddr_t addr,
  72                     size_t len, uint_t *protv);
  73 static u_offset_t segnf_getoffset(struct seg *seg, caddr_t addr);
  74 static int      segnf_gettype(struct seg *seg, caddr_t addr);
  75 static int      segnf_getvp(struct seg *seg, caddr_t addr, struct vnode **vpp);
  76 static void     segnf_dump(struct seg *seg);
  77 static int      segnf_pagelock(struct seg *seg, caddr_t addr, size_t len,
  78                     struct page ***ppp, enum lock_type type, enum seg_rw rw);


  79 
  80 
  81 struct seg_ops segnf_ops = {
  82         .dup            = segnf_dup,
  83         .unmap          = segnf_unmap,
  84         .free           = segnf_free,
  85         .fault          = (faultcode_t (*)(struct hat *, struct seg *, caddr_t,
  86             size_t, enum fault_type, enum seg_rw))segnf_nomap,
  87         .faulta         = (faultcode_t (*)(struct seg *, caddr_t)) segnf_nomap,
  88         .setprot        = segnf_setprot,
  89         .checkprot      = segnf_checkprot,
  90         .kluster        = (int (*)())segnf_badop,
  91         .sync           = (int (*)(struct seg *, caddr_t, size_t, int, uint_t))
  92                 segnf_nop,
  93         .incore         = (size_t (*)(struct seg *, caddr_t, size_t, char *))
  94                 segnf_nop,
  95         .lockop         = (int (*)(struct seg *, caddr_t, size_t, int, int,
  96             ulong_t *, size_t))segnf_nop,
  97         .getprot        = segnf_getprot,
  98         .getoffset      = segnf_getoffset,
  99         .gettype        = segnf_gettype,
 100         .getvp          = segnf_getvp,
 101         .advise         = (int (*)(struct seg *, caddr_t, size_t, uint_t))
 102                 segnf_nop,
 103         .dump           = segnf_dump,
 104         .pagelock       = segnf_pagelock,

 105 };
 106 
 107 /*
 108  * vnode and page for the page of zeros we use for the nf mappings.
 109  */
 110 static kmutex_t segnf_lock;
 111 static struct vnode nfvp;
 112 static struct page **nfpp;
 113 
 114 #define addr_to_vcolor(addr)                                            \
 115         (shm_alignment) ?                                               \
 116         ((int)(((uintptr_t)(addr) & (shm_alignment - 1)) >> PAGESHIFT)) : 0
 117 
 118 /*
 119  * We try to limit the number of Non-fault segments created.
 120  * Non fault segments are created to optimize sparc V9 code which uses
 121  * the sparc nonfaulting load ASI (ASI_PRIMARY_NOFAULT).
 122  *
 123  * There are several reasons why creating too many non-fault segments
 124  * could cause problems.


 441 segnf_getvp(struct seg *seg, caddr_t addr, struct vnode **vpp)
 442 {
 443         ASSERT(seg->s_as && AS_LOCK_HELD(seg->s_as, &seg->s_as->a_lock));
 444 
 445         *vpp = &nfvp;
 446         return (0);
 447 }
 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 
 457 /*ARGSUSED*/
 458 static int
 459 segnf_pagelock(struct seg *seg, caddr_t addr, size_t len,
 460     struct page ***ppp, enum lock_type type, enum seg_rw rw)








 461 {
 462         return (ENOTSUP);
 463 }