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 }
|