49 #include <sys/archsystm.h>
50 #include <sys/lgrp.h>
51
52 #include <vm/page.h>
53 #include <vm/hat.h>
54 #include <vm/as.h>
55 #include <vm/seg.h>
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 static int segnf_setpagesize(struct seg *seg, caddr_t addr, size_t len,
80 uint_t szc);
81 static int segnf_getmemid(struct seg *seg, caddr_t addr, memid_t *memidp);
82 static lgrp_mem_policy_info_t *segnf_getpolicy(struct seg *seg,
83 caddr_t addr);
84
85
86 struct seg_ops segnf_ops = {
87 .dup = segnf_dup,
88 .unmap = segnf_unmap,
89 .free = segnf_free,
90 .fault = (faultcode_t (*)(struct hat *, struct seg *, caddr_t,
91 size_t, enum fault_type, enum seg_rw))segnf_nomap,
92 .faulta = (faultcode_t (*)(struct seg *, caddr_t)) segnf_nomap,
93 .setprot = segnf_setprot,
94 .checkprot = segnf_checkprot,
95 .kluster = (int (*)())segnf_badop,
96 .sync = (int (*)(struct seg *, caddr_t, size_t, int, uint_t))
97 segnf_nop,
98 .incore = (size_t (*)(struct seg *, caddr_t, size_t, char *))
99 segnf_nop,
100 .lockop = (int (*)(struct seg *, caddr_t, size_t, int, int,
101 ulong_t *, size_t))segnf_nop,
102 .getprot = segnf_getprot,
103 .getoffset = segnf_getoffset,
104 .gettype = segnf_gettype,
105 .getvp = segnf_getvp,
106 .advise = (int (*)(struct seg *, caddr_t, size_t, uint_t))
107 segnf_nop,
108 .dump = segnf_dump,
109 .pagelock = segnf_pagelock,
110 .setpagesize = segnf_setpagesize,
111 .getmemid = segnf_getmemid,
112 .getpolicy = segnf_getpolicy,
113 };
114
115 /*
382 return (FC_NOMAP);
383 }
384
385 /* ARGSUSED */
386 static int
387 segnf_setprot(struct seg *seg, caddr_t addr, size_t len, uint_t prot)
388 {
389 ASSERT(seg->s_as && AS_LOCK_HELD(seg->s_as, &seg->s_as->a_lock));
390 return (EACCES);
391 }
392
393 /* ARGSUSED */
394 static int
395 segnf_checkprot(struct seg *seg, caddr_t addr, size_t len, uint_t prot)
396 {
397 uint_t sprot;
398 ASSERT(seg->s_as && AS_LOCK_HELD(seg->s_as, &seg->s_as->a_lock));
399
400 sprot = seg->s_as == &kas ? PROT_READ : PROT_READ|PROT_USER;
401 return ((prot & sprot) == prot ? 0 : EACCES);
402 }
403
404 static void
405 segnf_badop(void)
406 {
407 panic("segnf_badop");
408 /*NOTREACHED*/
409 }
410
411 static int
412 segnf_nop(void)
413 {
414 return (0);
415 }
416
417 static int
418 segnf_getprot(struct seg *seg, caddr_t addr, size_t len, uint_t *protv)
419 {
420 size_t pgno = seg_page(seg, addr + len) - seg_page(seg, addr) + 1;
421 size_t p;
422 ASSERT(seg->s_as && AS_LOCK_HELD(seg->s_as, &seg->s_as->a_lock));
423
424 for (p = 0; p < pgno; ++p)
425 protv[p] = PROT_READ;
426 return (0);
427 }
428
|
49 #include <sys/archsystm.h>
50 #include <sys/lgrp.h>
51
52 #include <vm/page.h>
53 #include <vm/hat.h>
54 #include <vm/as.h>
55 #include <vm/seg.h>
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 int segnf_nop(void);
70 static int segnf_getprot(struct seg *seg, caddr_t addr,
71 size_t len, uint_t *protv);
72 static u_offset_t segnf_getoffset(struct seg *seg, caddr_t addr);
73 static int segnf_gettype(struct seg *seg, caddr_t addr);
74 static int segnf_getvp(struct seg *seg, caddr_t addr, struct vnode **vpp);
75 static void segnf_dump(struct seg *seg);
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 static int segnf_setpagesize(struct seg *seg, caddr_t addr, size_t len,
79 uint_t szc);
80 static int segnf_getmemid(struct seg *seg, caddr_t addr, memid_t *memidp);
81 static lgrp_mem_policy_info_t *segnf_getpolicy(struct seg *seg,
82 caddr_t addr);
83
84
85 struct seg_ops segnf_ops = {
86 .dup = segnf_dup,
87 .unmap = segnf_unmap,
88 .free = segnf_free,
89 .fault = (faultcode_t (*)(struct hat *, struct seg *, caddr_t,
90 size_t, enum fault_type, enum seg_rw))segnf_nomap,
91 .faulta = (faultcode_t (*)(struct seg *, caddr_t)) segnf_nomap,
92 .setprot = segnf_setprot,
93 .checkprot = segnf_checkprot,
94 .sync = (int (*)(struct seg *, caddr_t, size_t, int, uint_t))
95 segnf_nop,
96 .incore = (size_t (*)(struct seg *, caddr_t, size_t, char *))
97 segnf_nop,
98 .lockop = (int (*)(struct seg *, caddr_t, size_t, int, int,
99 ulong_t *, size_t))segnf_nop,
100 .getprot = segnf_getprot,
101 .getoffset = segnf_getoffset,
102 .gettype = segnf_gettype,
103 .getvp = segnf_getvp,
104 .advise = (int (*)(struct seg *, caddr_t, size_t, uint_t))
105 segnf_nop,
106 .dump = segnf_dump,
107 .pagelock = segnf_pagelock,
108 .setpagesize = segnf_setpagesize,
109 .getmemid = segnf_getmemid,
110 .getpolicy = segnf_getpolicy,
111 };
112
113 /*
380 return (FC_NOMAP);
381 }
382
383 /* ARGSUSED */
384 static int
385 segnf_setprot(struct seg *seg, caddr_t addr, size_t len, uint_t prot)
386 {
387 ASSERT(seg->s_as && AS_LOCK_HELD(seg->s_as, &seg->s_as->a_lock));
388 return (EACCES);
389 }
390
391 /* ARGSUSED */
392 static int
393 segnf_checkprot(struct seg *seg, caddr_t addr, size_t len, uint_t prot)
394 {
395 uint_t sprot;
396 ASSERT(seg->s_as && AS_LOCK_HELD(seg->s_as, &seg->s_as->a_lock));
397
398 sprot = seg->s_as == &kas ? PROT_READ : PROT_READ|PROT_USER;
399 return ((prot & sprot) == prot ? 0 : EACCES);
400 }
401
402 static int
403 segnf_nop(void)
404 {
405 return (0);
406 }
407
408 static int
409 segnf_getprot(struct seg *seg, caddr_t addr, size_t len, uint_t *protv)
410 {
411 size_t pgno = seg_page(seg, addr + len) - seg_page(seg, addr) + 1;
412 size_t p;
413 ASSERT(seg->s_as && AS_LOCK_HELD(seg->s_as, &seg->s_as->a_lock));
414
415 for (p = 0; p < pgno; ++p)
416 protv[p] = PROT_READ;
417 return (0);
418 }
419
|