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


  56 #include <vm/vpage.h>
  57 
  58 /*
  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


 428 }
 429 
 430 /* ARGSUSED */
 431 static int
 432 segnf_gettype(struct seg *seg, caddr_t addr)
 433 {
 434         ASSERT(seg->s_as && AS_LOCK_HELD(seg->s_as, &seg->s_as->a_lock));
 435 
 436         return (MAP_SHARED);
 437 }
 438 
 439 /* ARGSUSED */
 440 static int
 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 }


  56 #include <vm/vpage.h>
  57 
  58 /*
  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 int      segnf_pagelock(struct seg *seg, caddr_t addr, size_t len,
  77                     struct page ***ppp, enum lock_type type, enum seg_rw rw);
  78 
  79 
  80 struct seg_ops segnf_ops = {
  81         .dup            = segnf_dup,
  82         .unmap          = segnf_unmap,
  83         .free           = segnf_free,
  84         .fault          = (faultcode_t (*)(struct hat *, struct seg *, caddr_t,
  85             size_t, enum fault_type, enum seg_rw))segnf_nomap,
  86         .faulta         = (faultcode_t (*)(struct seg *, caddr_t)) segnf_nomap,
  87         .setprot        = segnf_setprot,
  88         .checkprot      = segnf_checkprot,
  89         .kluster        = (int (*)())segnf_badop,
  90         .sync           = (int (*)(struct seg *, caddr_t, size_t, int, uint_t))
  91                 segnf_nop,
  92         .incore         = (size_t (*)(struct seg *, caddr_t, size_t, char *))
  93                 segnf_nop,
  94         .lockop         = (int (*)(struct seg *, caddr_t, size_t, int, int,
  95             ulong_t *, size_t))segnf_nop,
  96         .getprot        = segnf_getprot,
  97         .getoffset      = segnf_getoffset,
  98         .gettype        = segnf_gettype,
  99         .getvp          = segnf_getvp,
 100         .advise         = (int (*)(struct seg *, caddr_t, size_t, uint_t))
 101                 segnf_nop,

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


 426 }
 427 
 428 /* ARGSUSED */
 429 static int
 430 segnf_gettype(struct seg *seg, caddr_t addr)
 431 {
 432         ASSERT(seg->s_as && AS_LOCK_HELD(seg->s_as, &seg->s_as->a_lock));
 433 
 434         return (MAP_SHARED);
 435 }
 436 
 437 /* ARGSUSED */
 438 static int
 439 segnf_getvp(struct seg *seg, caddr_t addr, struct vnode **vpp)
 440 {
 441         ASSERT(seg->s_as && AS_LOCK_HELD(seg->s_as, &seg->s_as->a_lock));
 442 
 443         *vpp = &nfvp;
 444         return (0);
 445 }








 446 
 447 /*ARGSUSED*/
 448 static int
 449 segnf_pagelock(struct seg *seg, caddr_t addr, size_t len,
 450     struct page ***ppp, enum lock_type type, enum seg_rw rw)
 451 {
 452         return (ENOTSUP);
 453 }