Lines Matching defs:vpage
72 #include <vm/vpage.h>
183 #define vpgtob(n) ((n) * sizeof (struct vpage)) /* For brevity */
209 u_offset_t, struct vpage *, page_t **, uint_t,
225 static int segvn_claim_pages(struct seg *, struct vpage *, u_offset_t,
826 svd->vpage = NULL;
1019 struct vpage *vpage1 = svd1->vpage;
1020 struct vpage *vpage2 = svd2->vpage, *nvpage = NULL;
1079 * If either seg has vpages, create a new merged vpage array.
1082 struct vpage *vp, *evp;
1219 * Now free the old vpage structures.
1226 svd2->vpage = NULL;
1238 svd1->vpage = nvpage;
1264 struct vpage *new_vpage;
1332 if (svd1->vpage != NULL) {
1333 struct vpage *vp, *evp;
1339 bcopy(svd1->vpage, new_vpage, vpgtob(seg_pages(seg1)));
1340 kmem_free(svd1->vpage, vpgtob(seg_pages(seg1)));
1341 svd1->vpage = new_vpage;
1356 ASSERT(svd1->vpage != NULL || svd1->pageswap == 0);
1385 struct vpage *new_vpage;
1448 if (svd2->vpage != NULL) {
1449 struct vpage *vp, *evp;
1459 bcopy(svd2->vpage, new_vpage + seg_pages(seg1),
1461 kmem_free(svd2->vpage, vpgtob(seg_pages(seg2)));
1462 svd2->vpage = new_vpage;
1477 ASSERT(svd2->vpage != NULL || svd2->pageswap == 0);
1523 struct vpage *vpp;
1525 vpp = &svd->vpage[seg_page(seg, addr)];
1717 newsvd->vpage = NULL;
1744 * If necessary, create a vpage structure for the new segment.
1747 if (svd->vpage != NULL) {
1749 struct vpage *ovp = svd->vpage;
1750 struct vpage *nvp;
1752 nvp = newsvd->vpage =
1759 newsvd->vpage = NULL;
1838 struct vpage *vp, *evp;
1842 ASSERT(svd->vpage != NULL);
1844 evp = &svd->vpage[seg_page(seg, seg->s_base + seg->s_size)];
1846 for (vp = svd->vpage; vp < evp; vp++) {
2025 if (svd->vpage != NULL) {
2027 struct vpage *ovpage;
2029 ovpage = svd->vpage; /* keep pointer to vpage */
2032 svd->vpage = kmem_alloc(nbytes, KM_SLEEP);
2033 bcopy(&ovpage[dpages], svd->vpage, nbytes);
2035 /* free up old vpage */
2131 if (svd->vpage != NULL) {
2133 struct vpage *ovpage;
2135 ovpage = svd->vpage; /* keep pointer to vpage */
2138 svd->vpage = kmem_alloc(nbytes, KM_SLEEP);
2139 bcopy(ovpage, svd->vpage, nbytes);
2141 /* free up old vpage */
2265 if (svd->vpage == NULL) {
2266 nsvd->vpage = NULL;
2268 /* need to split vpage into two arrays */
2270 struct vpage *ovpage;
2272 ovpage = svd->vpage; /* keep pointer to vpage */
2276 svd->vpage = kmem_alloc(nbytes, KM_SLEEP);
2278 bcopy(ovpage, svd->vpage, nbytes);
2282 nsvd->vpage = kmem_alloc(nbytes, KM_SLEEP);
2284 bcopy(&ovpage[opages - npages], nsvd->vpage, nbytes);
2286 /* free up old vpage */
2438 * Deallocate the vpage and anon pointers if necessary and possible.
2440 if (svd->vpage != NULL) {
2441 kmem_free(svd->vpage, vpgtob(npages));
2442 svd->vpage = NULL;
2705 struct vpage *vpage, /* pointer to vpage for vp, off */
2760 prot = VPP_PROT(vpage);
2840 * We decide to lock only if vpage is present:
2842 * - "future" segments will have a vpage array (see
2845 * - "past" segments may not have a vpage array,
2847 * mprotect) have occurred. Locking if vpage
2849 * locking if vpage is absent, will not break
2851 * allocating vpage here if it's absent requires
2860 if (AS_ISPGLCK(seg->s_as) && vpage != NULL &&
2862 !VPP_ISPPLOCK(vpage)) {
2868 claim = VPP_PROT(vpage) & PROT_WRITE;
2870 VPP_SETPPLOCK(vpage);
3031 vpage != NULL && VPP_ISPPLOCK(vpage)))) {
3051 * If we have a vpage pointer, see if it indicates that we have
3059 if (vpage != NULL && VPP_ISPPLOCK(vpage))
3841 struct vpage *vpage = (svd->vpage != NULL) ?
3842 &svd->vpage[seg_page(seg, a)] : NULL;
3980 ASSERT(vpage != NULL);
3981 prot = VPP_PROT(vpage);
4169 seg, a, prot, ppa, vpage, segvn_anypgsz,
4504 if (vpage != NULL) {
4505 vpage += pages;
4556 vpage = (svd->vpage != NULL) ?
4557 &svd->vpage[seg_page(seg, a)] : NULL;
4580 vpage = (svd->vpage != NULL) ?
4581 &svd->vpage[seg_page(seg, a)] : NULL;
4647 struct vpage *vpage = (svd->vpage != NULL) ?
4648 &svd->vpage[seg_page(seg, a)] : NULL;
4707 ASSERT(vpage != NULL);
4708 prot = VPP_PROT(vpage);
4732 prot, &vpprot, ppa, &ppa_szc, vpage, rw, brkcow,
4779 if (vpage != NULL)
4780 vpage += pages;
4855 vpage = (svd->vpage != NULL) ?
4856 &svd->vpage[seg_page(seg, a)] : NULL;
4878 vpage = (svd->vpage != NULL) ?
4879 &svd->vpage[seg_page(seg, a)] : NULL;
4929 struct vpage *vpage;
5219 if (svd->vpage == NULL)
5220 vpage = NULL;
5222 vpage = &svd->vpage[page];
5233 struct vpage *vpp;
5242 VPP_ADVICE(vpage) == MADV_SEQUENTIAL)) {
5245 if (vpage != NULL)
5246 vpp = &svd->vpage[fpage];
5252 (!svd->pageadvice || (vpage &&
5485 err = segvn_faultpage(hat, seg, a, off, vpage, plp, vpprot,
5500 if (vpage) {
5501 vpage++;
5502 } else if (svd->vpage) {
5504 vpage = &svd->vpage[++page];
5558 prot = VPP_PROT(&svd->vpage[page]) & vpprot;
5672 struct vpage *cvp, *svp, *evp;
5781 * making writable only a part of the segment then we use its vpage
5807 * Make sure that the vpage array
5813 if (svd->vpage == NULL) {
5818 svp = &svd->vpage[seg_page(seg, addr)];
5819 evp = &svd->vpage[seg_page(seg,
5859 ASSERT(svd->vpage != NULL);
5888 if (addr == seg->s_base && len == seg->s_size && svd->vpage == NULL) {
5902 * A vpage structure exists or else the change does not
5903 * involve the entire segment. Establish a vpage structure
5911 if (svd->vpage == NULL) {
5924 evp = &svd->vpage[seg_page(seg, addr + len)];
5930 for (svp = &svd->vpage[seg_page(seg, addr)]; svp < evp; svp++) {
6008 len = (svp - &svd->vpage[seg_page(seg, addr)]) *
6019 if (svd->vpage == NULL) {
6024 evp = &svd->vpage[seg_page(seg, addr + len)];
6025 for (svp = &svd->vpage[seg_page(seg, addr)]; svp < evp; svp++) {
6329 seg->s_size, szc, svd->prot, svd->vpage,
6364 struct vpage *vpage = svd->vpage;
6422 ASSERT(vpage != NULL || svd->pageprot == 0);
6423 if (vpage != NULL) {
6425 prot = VPP_PROT(vpage);
6426 pageflag = VPP_ISPPLOCK(vpage) ? LOCK_PAGE : 0;
6432 seg, a, prot, vpage, svd->cred)) != 0) {
6455 vpage = (vpage == NULL) ? NULL : vpage + pages;
6468 struct vpage *svp,
6478 struct vpage *evp = svp + pgcnt;
6479 caddr_t addr = ((uintptr_t)(svp - svd->vpage) << PAGESHIFT)
6490 ASSERT(svd->vpage != NULL);
6631 if (svd->vpage != NULL) {
6634 struct vpage *ovpage = svd->vpage;
6636 svd->vpage = kmem_alloc(bytes, KM_SLEEP);
6637 bcopy(ovpage, svd->vpage, bytes);
6638 nsvd->vpage = kmem_alloc(nbytes, KM_SLEEP);
6639 bcopy(ovpage + seg_pages(seg), nsvd->vpage, nbytes);
6864 struct vpage *vp, *evp;
6881 * Have to check down to the vpage level.
6883 evp = &svd->vpage[seg_page(seg, addr + len)];
6884 for (vp = &svd->vpage[seg_page(seg, addr)]; vp < evp; vp++) {
6913 protv[pgno] = VPP_PROT(&svd->vpage[pgno+pgoff]);
6996 else if (svd->pageadvice && svd->vpage) {
6997 struct vpage *bvpp, *evpp;
6999 bvpp = &svd->vpage[page];
7000 evpp = &svd->vpage[page + pd];
7245 struct vpage *vpp;
7308 vpp = svd->vpage;
7333 vpp = &svd->vpage[seg_page(seg, addr)];
7475 struct vpage *vpp;
7498 vpp = (svd->vpage) ? &svd->vpage[p]: NULL;
7597 * if vpage has PROT_WRITE
7603 * p_cowcnt on the newpage *if* the corresponding vpage has PROT_WRITE.
7606 * In this case, vpage may not have PROT_WRITE. So, we need to decrement
7608 * vpage doesn't have PROT_WRITE.
7633 struct vpage *vpp;
7634 struct vpage *evp;
7707 * If we're locking, then we must create a vpage structure if
7709 * is a vpage -- if not, then we could not have locked anything.
7712 if ((vpp = svd->vpage) == NULL) {
7715 if (svd->vpage == NULL) {
7741 evp = &svd->vpage[seg_page(seg, addr + len)];
7750 for (vpp = &svd->vpage[seg_page(seg, addr)]; vpp < evp;
7803 for (vpp = &svd->vpage[seg_page(seg, addr)]; vpp < evp;
8222 * otherwise use appropriate vpage entry.
8336 if (svd->vpage == NULL) {
8342 struct vpage *bvpp, *evpp;
8548 bvpp = &svd->vpage[page];
8549 evpp = &svd->vpage[page + (len >> PAGESHIFT)];
8576 struct vpage *bvpp, *evpp;
8621 if (svd->vpage == NULL) {
8623 if (svd->vpage == NULL) {
8631 bvpp = &svd->vpage[page];
8632 evpp = &svd->vpage[page + (len >> PAGESHIFT)];
8643 * Create a vpage structure for this seg.
8649 struct vpage *vp, *evp;
8655 * If no vpage structure exists, allocate one. Copy the protections
8658 if (svd->vpage == NULL) {
8661 * track the per-page vpage structs needs for this entire
8674 ulong_t mem_needed = seg_pages(seg) * sizeof (struct vpage);
8684 svd->vpage = kmem_zalloc(mem_needed, KM_SLEEP);
8685 evp = &svd->vpage[seg_page(seg, seg->s_base + seg->s_size)];
8686 for (vp = svd->vpage; vp < evp; vp++) {
8964 struct vpage *vp = &svd->vpage[seg_page(seg, lpgaddr)];
8965 struct vpage *evp = &svd->vpage[seg_page(seg, addr)];
9001 struct vpage *vp;
9002 struct vpage *evp;
9004 vp = &svd->vpage[seg_page(seg, addr + len)];
9005 evp = &svd->vpage[seg_page(seg, lpgeaddr)];
9172 struct vpage *vp;
9176 vp = &svd->vpage[seg_page(seg, a)];
9232 struct vpage *vp;
9236 vp = &svd->vpage[seg_page(seg, a)];
9328 struct vpage *vpage;
9334 if (svd->vpage != NULL) {
9335 vpage = &svd->vpage[seg_page(seg, a)];
9337 vpage = NULL;
9344 vpage, &pp, 0, F_INVAL, rw, 1);
9651 struct vpage *vpage;
9658 ASSERT(svd->vpage != NULL);
9660 vpage = &svd->vpage[seg_page(seg, a)];
9661 prot = VPP_PROT(vpage);
9662 vpage++;
9665 if (prot != VPP_PROT(vpage))
9667 vpage++;