Lines Matching defs:amp
336 * replica's are represented by anon maps (amp). There's one amp per text file
337 * region per lgroup. A process chooses the amp for each of its text mappings
340 * mapping share the same amp. amp's are looked up in svntr_hashtab hash table
343 * forcing COW faults from vnode to amp and mapping amp pages instead of vnode
344 * pages. Replication amp is assigned to a segment when it gets its first
346 * rechecks periodically if the process still maps an amp local to the main
347 * thread. If not async thread forces process to remap to an amp in the new
357 * amp pages are used instead of vnode pages as long as segment has a very
363 * (unmap segment's address range and set svd->amp to NULL).
365 * The original file can be changed after amp is inserted into
547 struct anon_map *amp;
565 if (a->amp != NULL && a->vp != NULL) {
582 (a->amp != NULL && a->type == MAP_PRIVATE) ||
604 } else if (a->amp != NULL) {
617 if (!(a->flags & MAP_NORESERVE) && ((a->vp == NULL && a->amp == NULL) ||
692 if (a->amp == NULL && !use_rgn && !trok) {
743 segvn_comb_thrshld || psvd->amp == NULL) &&
847 amp = a->amp;
848 if ((svd->amp = amp) == NULL) {
860 svd->amp = anonmap_alloc(seg->s_size, swresv,
862 svd->amp->a_szc = seg->s_szc;
884 if ((amp->size - a->offset) < seg->s_size) {
895 ANON_LOCK_ENTER(&->a_rwlock, RW_WRITER);
896 amp->refcnt++;
897 if (a->szc > amp->a_szc) {
898 amp->a_szc = a->szc;
900 ANON_LOCK_EXIT(&->a_rwlock);
923 svd->amp = anonmap_alloc(seg->s_size, 0, ANON_SLEEP);
924 svd->amp->a_szc = seg->s_szc;
932 ANON_LOCK_ENTER(&->a_rwlock, RW_WRITER);
939 if ((ap = anon_get_ptr(amp->ahp,
958 ASSERT(anon_get_ptr(amp->ahp,
960 (void) anon_set_ptr(amp->ahp, anon_idx, ap,
973 anon_dup(amp->ahp, anon_num, svd->amp->ahp,
975 ANON_LOCK_EXIT(&->a_rwlock);
988 (void) lgrp_shm_policy_set(mpolicy, svd->amp, svd->anon_index,
993 ASSERT(svd->amp == NULL);
1017 struct anon_map *amp1 = svd1->amp;
1018 struct anon_map *amp2 = svd2->amp;
1061 * segments with non NULL amp.
1147 svd2->amp = NULL;
1210 svd2->amp = NULL; /* needed for seg_free */
1214 svd1->amp = namp;
1293 amp1 = svd1->amp;
1413 amp2 = svd2->amp;
1522 if ((ap = anon_get_ptr(svd->amp->ahp, old_idx)) != NULL) {
1556 (void) anon_set_ptr(newsvd->amp->ahp, new_idx, newap,
1576 struct anon_map *amp;
1628 if ((amp = svd->amp) == NULL || svd->tr_state == SEGVN_TR_ON) {
1635 ASSERT(newsvd->vp != NULL && amp != NULL);
1640 newsvd->amp = NULL;
1649 newsvd->amp = amp;
1650 ANON_LOCK_ENTER(&->a_rwlock, RW_WRITER);
1651 amp->refcnt++;
1652 ANON_LOCK_EXIT(&->a_rwlock);
1660 newsvd->amp = anonmap_alloc(newseg->s_size, 0,
1662 newsvd->amp->a_szc = newseg->s_szc;
1729 anon_dup_fill_holes(amp->ahp,
1730 svd->anon_index, newsvd->amp->ahp,
1734 anon_dup(amp->ahp, svd->anon_index,
1735 newsvd->amp->ahp, 0, seg->s_size);
1769 ASSERT(newsvd->amp == NULL);
1860 struct anon_map *amp;
1921 ASSERT(svd->amp == NULL);
1935 ASSERT(svd->amp != NULL);
1937 ASSERT(svd->amp == NULL);
1972 ASSERT(svd->amp == NULL);
1979 ASSERT(svd->amp != NULL);
1982 ASSERT(svd->amp == NULL && svd->tr_state == SEGVN_TR_OFF);
2018 amp = svd->amp;
2019 ASSERT(amp == NULL || amp->a_szc >= seg->s_szc);
2038 if (amp != NULL) {
2039 ANON_LOCK_ENTER(&->a_rwlock, RW_WRITER);
2040 if (amp->refcnt == 1 || svd->type == MAP_PRIVATE) {
2044 * pcache that belong to this amp.
2047 ASSERT(amp->refcnt == 1);
2049 anonmap_purge(amp);
2054 if (amp->a_szc == seg->s_szc) {
2056 anon_free_pages(amp->ahp,
2060 anon_free(amp->ahp,
2066 ASSERT(amp->a_szc > seg->s_szc);
2067 anon_shmap_free_pages(amp,
2079 amp->swresv -= len;
2082 ANON_LOCK_EXIT(&->a_rwlock);
2093 ASSERT(amp);
2096 svd->swresv = ptob(anon_pages(amp->ahp,
2145 if (amp != NULL) {
2146 ANON_LOCK_ENTER(&->a_rwlock, RW_WRITER);
2147 if (amp->refcnt == 1 || svd->type == MAP_PRIVATE) {
2156 * pcache that belong to this amp.
2159 ASSERT(amp->refcnt == 1);
2161 anonmap_purge(amp);
2164 if (amp->a_szc == seg->s_szc) {
2166 anon_free_pages(amp->ahp,
2170 anon_free(amp->ahp, an_idx,
2175 ASSERT(amp->a_szc > seg->s_szc);
2176 anon_shmap_free_pages(amp,
2188 amp->swresv -= len;
2191 ANON_LOCK_EXIT(&->a_rwlock);
2198 ASSERT(amp);
2200 svd->swresv = ptob(anon_pages(amp->ahp,
2290 if (amp == NULL) {
2291 nsvd->amp = NULL;
2300 ANON_LOCK_ENTER(&->a_rwlock, RW_WRITER);
2301 if (amp->refcnt == 1 || svd->type == MAP_PRIVATE) {
2310 * pcache that belong to this amp.
2313 ASSERT(amp->refcnt == 1);
2315 anonmap_purge(amp);
2318 if (amp->a_szc == seg->s_szc) {
2320 anon_free_pages(amp->ahp, an_idx, len,
2323 anon_free(amp->ahp, an_idx,
2328 ASSERT(amp->a_szc > seg->s_szc);
2329 anon_shmap_free_pages(amp, an_idx, len);
2340 amp->swresv -= len;
2346 amp->refcnt++;
2347 nsvd->amp = amp;
2356 (void) anon_copy_ptr(amp->ahp, svd->anon_index, nahp,
2358 (void) anon_copy_ptr(amp->ahp, nsvd->anon_index,
2360 anon_release(amp->ahp, btop(amp->size));
2363 amp->ahp = nahp;
2364 amp->size = seg->s_size;
2365 nsvd->amp = namp;
2367 ANON_LOCK_EXIT(&->a_rwlock);
2371 ASSERT(amp);
2373 svd->swresv = ptob(anon_pages(amp->ahp,
2375 nsvd->swresv = ptob(anon_pages(nsvd->amp->ahp,
2418 struct anon_map *amp;
2444 if ((amp = svd->amp) != NULL) {
2450 ANON_LOCK_ENTER(&->a_rwlock, RW_WRITER);
2451 ASSERT(amp->a_szc >= seg->s_szc);
2452 if (--amp->refcnt == 0) {
2459 anon_free_pages(amp->ahp,
2463 anon_free(amp->ahp, svd->anon_index,
2471 * pcache that belong to this amp.
2474 anonmap_purge(amp);
2481 if (amp->a_szc != 0) {
2482 anon_shmap_free_pages(amp, 0,
2483 amp->size);
2485 anon_free(amp->ahp, 0, amp->size);
2487 if ((len = amp->swresv) != 0) {
2494 svd->amp = NULL;
2495 ANON_LOCK_EXIT(&->a_rwlock);
2496 anonmap_free(amp);
2504 anon_free_pages(amp->ahp, svd->anon_index,
2507 anon_free(amp->ahp, svd->anon_index,
2510 ANON_LOCK_EXIT(&->a_rwlock);
2512 ANON_LOCK_EXIT(&->a_rwlock);
2572 struct anon_map *amp;
2578 if ((amp = svd->amp) != NULL)
2588 if (amp != NULL) {
2589 ANON_LOCK_ENTER(&->a_rwlock, RW_READER);
2590 if ((ap = anon_get_ptr(amp->ahp, anon_index++))
2598 ANON_LOCK_EXIT(&->a_rwlock);
2724 struct anon_map *amp;
2776 if ((amp = svd->amp) != NULL) {
2777 ASSERT(RW_READ_HELD(&->a_rwlock));
2779 anon_array_enter(amp, anon_index, &cookie);
2783 if (svd->vp == NULL && amp != NULL) {
2784 if ((ap = anon_get_ptr(amp->ahp, anon_index)) == NULL) {
2809 (void) anon_set_ptr(amp->ahp, anon_index, ap,
2895 if (amp != NULL) {
2896 if ((ap = anon_get_ptr(amp->ahp, anon_index)) != NULL) {
2959 ASSERT(amp != NULL);
2988 ASSERT(amp == NULL ||
3006 ASSERT(amp != NULL && anon_lock);
3012 if ((ap = anon_get_ptr(amp->ahp, anon_index)) == NULL)
3097 (void) anon_set_ptr(amp->ahp, anon_index, ap, ANON_SLEEP);
3829 struct anon_map *amp = svd->amp;
3868 ASSERT(brkcow == 0 || amp != NULL);
3869 ASSERT(tron == 0 || amp != NULL);
3874 ASSERT(amp == NULL || IS_P2ALIGNED(aindx, maxpages));
3917 VM_STAT_COND_ADD(amp != NULL, segvnvmstats.fltvnpages[3]);
3943 if (IS_P2ALIGNED(a, maxpgsz) && amp != NULL) {
3945 ANON_LOCK_ENTER(&->a_rwlock, RW_READER);
3946 anon_array_enter(amp, aindx, &an_cookie);
3947 if (anon_get_ptr(amp->ahp, aindx) != NULL) {
3949 ASSERT(anon_pages(amp->ahp, aindx,
3952 ANON_LOCK_EXIT(&->a_rwlock);
3969 ASSERT(anon_pages(amp->ahp, aindx,
3973 ANON_LOCK_EXIT(&->a_rwlock);
4108 if (amp != NULL) {
4109 ANON_LOCK_ENTER(&->a_rwlock, RW_READER);
4110 anon_array_enter(amp, aindx, &an_cookie);
4112 if (amp != NULL &&
4113 anon_get_ptr(amp->ahp, aindx) != NULL) {
4117 ASSERT(anon_pages(amp->ahp, taindx,
4123 ANON_LOCK_EXIT(&->a_rwlock);
4155 if (amp != NULL) {
4157 ASSERT(!anon_pages(amp->ahp, taindx, maxpages));
4162 ASSERT(amp != NULL);
4168 ierr = anon_map_privatepages(amp, aindx, szc,
4174 ANON_LOCK_EXIT(&->a_rwlock);
4197 ANON_LOCK_EXIT(&->a_rwlock);
4272 if (amp != NULL) {
4274 ANON_LOCK_EXIT(&->a_rwlock);
4305 if (amp != NULL) {
4307 ANON_LOCK_EXIT(&->a_rwlock);
4344 if (amp != NULL) {
4346 ANON_LOCK_EXIT(&->a_rwlock);
4379 if (amp != NULL) {
4381 ANON_LOCK_EXIT(&->a_rwlock);
4437 if (amp != NULL) {
4439 ANON_LOCK_EXIT(&->a_rwlock);
4456 if (amp != NULL) {
4458 ANON_LOCK_EXIT(&->a_rwlock);
4498 if (amp != NULL) {
4500 ANON_LOCK_EXIT(&->a_rwlock);
4638 struct anon_map *amp = svd->amp;
4661 ASSERT(amp != NULL);
4701 ANON_LOCK_ENTER(&->a_rwlock, RW_READER);
4729 anon_array_enter(amp, aindx, &cookie);
4731 ierr = anon_map_getpages(amp, aindx, szc, seg, a,
4884 ANON_LOCK_EXIT(&->a_rwlock);
4889 ANON_LOCK_EXIT(&->a_rwlock);
4936 struct anon_map *amp;
4944 ASSERT(svd->amp == NULL || svd->rcookie == HAT_INVALID_REGION_COOKIE);
4970 ASSERT(svd->vp != NULL && svd->amp == NULL);
4976 svd->amp != NULL);
4990 ASSERT(svd->vp != NULL && svd->amp != NULL);
4992 ASSERT(svd->amp == NULL &&
4997 ASSERT(svd->amp == NULL && svd->tr_state == SEGVN_TR_OFF);
5037 ASSERT(svd->amp == NULL);
5121 if (svd->amp == NULL && (svd->vp == NULL || brkcow)) {
5131 if (svd->amp == NULL) {
5132 svd->amp = anonmap_alloc(seg->s_size, 0, ANON_SLEEP);
5133 svd->amp->a_szc = seg->s_szc;
5155 amp = svd->amp;
5182 if (amp != NULL) {
5192 ANON_LOCK_ENTER(&->a_rwlock, RW_READER);
5203 anon_array_enter(amp, index, &cookie);
5204 ap = anon_get_ptr(amp->ahp, index);
5207 ANON_LOCK_EXIT(&->a_rwlock);
5212 ANON_LOCK_EXIT(&->a_rwlock);
5247 if (amp != NULL)
5261 if (amp != NULL) {
5262 ANON_LOCK_ENTER(&->a_rwlock,
5264 anon_array_enter(amp, fanon_index,
5266 fap = anon_get_ptr(amp->ahp,
5275 ANON_LOCK_EXIT(&->a_rwlock);
5347 if (amp == NULL)
5351 * Only acquire reader lock to prevent amp->ahp
5355 ANON_LOCK_ENTER(&->a_rwlock, RW_READER);
5356 ap = anon_get_ptr(amp->ahp, anon_index);
5362 dogetpage = non_anon(amp->ahp, anon_index,
5364 ANON_LOCK_EXIT(&->a_rwlock);
5468 * locking scheme with per amp rwlock and a global set of hash
5478 if (amp != NULL)
5479 ANON_LOCK_ENTER(&->a_rwlock, RW_READER);
5488 if (amp != NULL)
5489 ANON_LOCK_EXIT(&->a_rwlock);
5567 if (amp != NULL) {
5569 anon_array_enter(amp, anon_index, &cookie);
5570 ap = anon_get_ptr(amp->ahp, anon_index);
5572 if ((amp == NULL) || (ap == NULL)) {
5586 ASSERT(amp == NULL ||
5595 if (amp != NULL)
5601 if (amp != NULL)
5602 ANON_LOCK_EXIT(&->a_rwlock);
5619 struct anon_map *amp;
5625 if ((amp = svd->amp) != NULL) {
5629 * Reader lock to prevent amp->ahp from being changed.
5633 ANON_LOCK_ENTER(&->a_rwlock, RW_READER);
5634 if ((ap = anon_get_ptr(amp->ahp,
5640 ANON_LOCK_EXIT(&->a_rwlock);
5646 ANON_LOCK_EXIT(&->a_rwlock);
5723 ASSERT(svd->amp == NULL);
5732 ASSERT(svd->amp != NULL);
5734 ASSERT(svd->amp == NULL && svd->tr_state == SEGVN_TR_OFF);
5876 svd->amp == NULL && addr == seg->s_base &&
5898 struct anon_map *amp;
5916 if ((amp = svd->amp) != NULL) {
5920 ANON_LOCK_ENTER(&->a_rwlock, RW_READER);
5933 if (amp != NULL) {
5934 anon_array_enter(amp, anon_idx,
5940 if (amp != NULL) {
5945 if (amp != NULL) {
5950 if (amp != NULL) {
5951 anon_array_enter(amp, anon_idx,
5953 ap = anon_get_ptr(amp->ahp, anon_idx++);
5959 if (amp == NULL || ap == NULL) {
5964 if (amp != NULL)
5990 } else if (amp != NULL)
5996 if (amp != NULL)
5997 ANON_LOCK_EXIT(&->a_rwlock);
6074 struct anon_map *amp = svd->amp;
6104 if (amp != NULL && svd->type == MAP_SHARED) {
6176 ASSERT(svd->amp == NULL);
6184 ASSERT(svd->amp != NULL);
6186 ASSERT(svd->amp == NULL && svd->tr_state == SEGVN_TR_OFF);
6187 amp = NULL;
6279 if (amp != NULL) {
6285 ANON_LOCK_ENTER(&->a_rwlock, RW_WRITER);
6286 ASSERT(amp->refcnt == 1);
6287 nahp = anon_create(btop(amp->size), ANON_NOSLEEP);
6289 ANON_LOCK_EXIT(&->a_rwlock);
6292 if (anon_copy_ptr(amp->ahp, svd->anon_index,
6294 anon_release(nahp, btop(amp->size));
6295 ANON_LOCK_EXIT(&->a_rwlock);
6298 anon_release(amp->ahp, btop(amp->size));
6299 amp->ahp = nahp;
6301 ANON_LOCK_EXIT(&->a_rwlock);
6318 if (amp != NULL) {
6328 amp->ahp, svd->anon_index, svd->vp, svd->offset,
6337 if (amp != NULL) {
6338 ANON_LOCK_ENTER(&->a_rwlock, RW_WRITER);
6340 amp->a_szc = szc;
6341 } else if (szc > amp->a_szc) {
6342 amp->a_szc = szc;
6344 ANON_LOCK_EXIT(&->a_rwlock);
6356 struct anon_map *amp = svd->amp;
6374 if (vp == NULL && amp == NULL) {
6381 ASSERT(svd->amp == NULL);
6387 ASSERT(svd->amp != NULL);
6389 ASSERT(svd->amp == NULL && svd->tr_state == SEGVN_TR_OFF);
6390 amp = NULL;
6406 if (amp == NULL || svd->type == MAP_SHARED) {
6418 ANON_LOCK_ENTER(&->a_rwlock, RW_WRITER);
6421 if ((oldap = anon_get_ptr(amp->ahp, an_idx)) != NULL) {
6429 ASSERT(vp == NULL || anon_pages(amp->ahp,
6431 if ((err = anon_map_demotepages(amp, an_idx,
6450 (void) anon_set_ptr(amp->ahp, an_idx, ap,
6458 amp->a_szc = 0;
6461 ANON_LOCK_EXIT(&->a_rwlock);
6477 struct anon_map *amp = svd->amp;
6487 int anon = (amp != NULL) ? 1 : 0;
6493 ASSERT(amp == NULL || IS_P2ALIGNED(anon_idx, pgcnt));
6503 if (anon_get_ptr(amp->ahp, anon_idx) == NULL) {
6505 ASSERT(!anon_pages(amp->ahp, anon_idx, pgcnt));
6508 anon_pages(amp->ahp, anon_idx, pgcnt) == pgcnt);
6515 ap = anon_get_ptr(amp->ahp, anon_idx);
6642 if (svd->amp != NULL && svd->type == MAP_PRIVATE) {
6643 struct anon_map *oamp = svd->amp, *namp;
6661 nsvd->amp = namp;
6664 } else if (svd->amp != NULL) {
6666 ASSERT(svd->amp == nsvd->amp);
6667 ASSERT(seg->s_szc <= svd->amp->a_szc);
6670 ANON_LOCK_ENTER(&svd->amp->a_rwlock, RW_WRITER);
6671 svd->amp->refcnt++;
6672 ANON_LOCK_EXIT(&svd->amp->a_rwlock);
6687 ASSERT(svd->amp);
6689 svd->swresv = ptob(anon_pages(svd->amp->ahp,
6691 nsvd->swresv = ptob(anon_pages(nsvd->amp->ahp,
6974 struct anon_map *amp;
7012 if ((amp = svd->amp) == NULL)
7017 ANON_LOCK_ENTER(&->a_rwlock, RW_READER);
7019 oap = anon_get_ptr(amp->ahp, page);
7020 ap = anon_get_ptr(amp->ahp, page + pd);
7022 ANON_LOCK_EXIT(&->a_rwlock);
7076 struct anon_map *amp;
7089 if ((amp = svd->amp) != NULL)
7106 if (amp != NULL) {
7107 ANON_LOCK_ENTER(&->a_rwlock, RW_READER);
7108 if (anon_array_try_enter(amp, anon_index + page,
7110 ANON_LOCK_EXIT(&->a_rwlock);
7113 ap = anon_get_ptr(amp->ahp, anon_index + page);
7121 ANON_LOCK_EXIT(&->a_rwlock);
7257 struct anon_map *amp;
7294 } else if (svd->type == MAP_SHARED && svd->amp != NULL &&
7295 svd->amp->a_softlockcnt > 0) {
7297 * Try to purge this amp's entries from pcache. It will
7298 * succeed only if other segments that share the amp have no
7302 if (svd->amp->a_softlockcnt > 0 || svd->softlockcnt > 0) {
7335 } else if (svd->vp && svd->amp == NULL &&
7348 if ((amp = svd->amp) != NULL)
7353 if (amp != NULL) {
7354 ANON_LOCK_ENTER(&->a_rwlock, RW_READER);
7355 anon_array_enter(amp, anon_index, &cookie);
7356 ap = anon_get_ptr(amp->ahp, anon_index++);
7364 ANON_LOCK_EXIT(&->a_rwlock);
7417 } else if (svd->type == MAP_SHARED && amp != NULL) {
7478 struct anon_map *amp; /* XXX - for locknest */
7486 if (svd->amp == NULL && svd->vp == NULL) {
7496 amp = svd->amp;
7503 if (amp != NULL) {
7504 ANON_LOCK_ENTER(&->a_rwlock, RW_READER);
7505 anon_array_enter(amp, svd->anon_index + p, &cookie);
7506 ap = anon_get_ptr(amp->ahp, svd->anon_index + p);
7511 ANON_LOCK_EXIT(&->a_rwlock);
7643 struct anon_map *amp;
7667 if (svd->amp != NULL && svd->amp->a_sp != NULL) {
7670 sp = svd->amp->a_sp;
7699 ASSERT(svd->amp != NULL);
7701 ASSERT(svd->amp == NULL &&
7730 if (op == MC_LOCK && svd->amp == NULL && svd->vp == NULL) {
7732 svd->amp = anonmap_alloc(seg->s_size, 0, ANON_SLEEP);
7733 svd->amp->a_szc = seg->s_szc;
7736 if ((amp = svd->amp) != NULL) {
7764 ANON_LOCK_ENTER(&->a_rwlock, RW_READER);
7766 anon_array_enter(amp, i_idx, &i_cookie);
7767 i_ap = anon_get_ptr(amp->ahp, i_idx);
7783 ANON_LOCK_EXIT(&->a_rwlock);
7809 if (amp != NULL)
7810 ANON_LOCK_ENTER(&->a_rwlock, RW_READER);
7818 amp != NULL &&
7819 ((ap = anon_get_ptr(amp->ahp, anon_index))
7821 anon_array_enter(amp, anon_index, &cookie);
7823 if ((ap = anon_get_ptr(amp->ahp,
7829 ANON_LOCK_EXIT(&->a_rwlock);
7833 ASSERT(anon_get_ptr(amp->ahp,
7835 (void) anon_set_ptr(amp->ahp,
7847 if (amp != NULL) {
7848 anon_array_enter(amp, anon_index, &cookie);
7849 ap = anon_get_ptr(amp->ahp, anon_index);
7856 ANON_LOCK_EXIT(&->a_rwlock);
7864 ANON_LOCK_EXIT(&->a_rwlock);
7895 ANON_LOCK_EXIT(&->a_rwlock);
7974 ANON_LOCK_EXIT(&->a_rwlock);
8069 struct anon_map *amp;
8145 } else if (svd->type == MAP_SHARED && svd->amp != NULL &&
8146 svd->amp->a_softlockcnt > 0) {
8148 * Try to purge this amp's entries from pcache. It
8150 * amp have no outstanding softlock's.
8156 amp = svd->amp;
8161 if (behav == MADV_FREE && (vp != NULL || amp == NULL)) {
8173 if (amp == NULL) {
8187 ANON_LOCK_ENTER(&->a_rwlock, RW_READER);
8188 err = anon_disclaim(amp,
8207 ANON_LOCK_EXIT(&->a_rwlock);
8234 already_set = lgrp_shm_policy_set(policy, amp,
8263 page_mark_migrate(seg, addr, len, amp, svd->anon_index,
8373 already_set = lgrp_shm_policy_set(policy, amp,
8402 page_mark_migrate(seg, addr, len, amp, svd->anon_index,
8414 ASSERT(svd->amp == NULL);
8701 struct anon_map *amp;
8715 if ((amp = svd->amp) != NULL) {
8717 ANON_LOCK_ENTER(&->a_rwlock, RW_READER);
8724 if (amp && (ap = anon_get_ptr(svd->amp->ahp, anon_index++))) {
8752 if (amp != NULL)
8753 ANON_LOCK_EXIT(&->a_rwlock);
8816 struct anon_map *amp;
8867 if ((amp = svd->amp) == NULL) {
8872 panic("segvn_pagelock(L_PAGEUNLOCK): amp == NULL");
9021 * For MAP_SHARED segments we create pcache entries tagged by amp and
9023 * that map this amp. For private segments pcache entries are tagged
9027 pamp = amp;
9295 ANON_LOCK_ENTER(&->a_rwlock, RW_READER);
9296 ASSERT(amp->a_szc >= seg->s_szc);
9297 anpgcnt = page_get_pagecnt(amp->a_szc);
9313 anon_array_enter(amp, anon_index, &cookie);
9316 ap = anon_get_ptr(amp->ahp, anon_index);
9349 anon_array_enter(amp, anon_index, &cookie);
9351 ap = anon_get_ptr(amp->ahp, anon_index);
9379 ANON_LOCK_EXIT(&->a_rwlock);
9433 if (svd->amp == NULL || svd->vp != NULL) {
9446 } else if (svd->softlockcnt == 0 && svd->amp->a_softlockcnt != 0) {
9447 seg_ppurge(seg, svd->amp, 0);
9469 ASSERT(svd->vp == NULL && svd->amp != NULL);
9538 amp_t *amp = (amp_t *)ptag;
9544 ASSERT(amp->a_softlockcnt >= npages);
9569 mutex_enter(&->a_purgemtx);
9570 if (!atomic_add_long_nv((ulong_t *)&->a_softlockcnt, -npages) &&
9571 amp->a_purgewait) {
9572 amp->a_purgewait = 0;
9573 cv_broadcast(&->a_purgecv);
9575 mutex_exit(&->a_purgemtx);
9591 struct anon_map *amp;
9609 if ((amp = svd->amp) != NULL) {
9615 ASSERT(amp != NULL);
9617 ANON_LOCK_ENTER(&->a_rwlock, RW_READER);
9618 anon_array_enter(amp, anon_index, &cookie);
9619 ap = anon_get_ptr(amp->ahp, anon_index);
9626 ANON_LOCK_EXIT(&->a_rwlock);
9629 ASSERT(anon_get_ptr(amp->ahp, anon_index)
9631 (void) anon_set_ptr(amp->ahp, anon_index,
9637 ANON_LOCK_EXIT(&->a_rwlock);
9678 struct anon_map *amp;
9703 amp = svn_data->amp;
9707 policy_info = lgrp_shm_policy_get(amp, anon_index, vp, vn_off);
9721 * Bind text vnode segment to an amp. If we bind successfully mappings will be
9722 * established to per vnode mapping per lgroup amp pages instead of to vnode
9723 * pages. There's one amp per vnode text mapping per lgroup. Many processes
9724 * may share the same text replication amp. If a suitable amp doesn't already
9725 * exist in svntr hash table create a new one. We may fail to bind to amp if
9728 * and svd->amp points to the amp to use. Otherwise tr_state is set to off and
9729 * svd->amp remains as NULL.
9747 struct anon_map *amp;
9756 ASSERT(vp != NULL && svd->amp == NULL);
9828 * replication amp's can be used most of the time.
9948 * If no amp was created yet for lgrp_id create a new one as long as
9951 if ((amp = svntrp->tr_amp[lgrp_id]) == NULL) {
9961 amp = anonmap_alloc(size, size, ANON_NOSLEEP);
9962 if (amp == NULL) {
9967 ASSERT(amp->refcnt == 1);
9968 amp->a_szc = szc;
9969 svntrp->tr_amp[lgrp_id] = amp;
9981 ASSERT(amp->a_szc == szc && amp->size == size && amp->swresv == size);
9982 ASSERT(amp->refcnt >= 1);
9983 svd->amp = amp;
10009 * replication amp. This routine is most typically called when segment is
10035 ASSERT(svd->amp != NULL);
10036 ASSERT(svd->amp->refcnt >= 1);
10053 if (svntrp->tr_amp[lgrp_id] != svd->amp) {
10054 panic("segvn_textunrepl: amp mismatch");
10057 svd->amp = NULL;
10080 struct anon_map *amp = svntrp->tr_amp[i];
10081 if (amp == NULL) {
10084 ASSERT(amp->refcnt == 1);
10085 ASSERT(amp->swresv == size);
10086 ASSERT(amp->size == size);
10087 ASSERT(amp->a_szc == szc);
10088 if (amp->a_szc != 0) {
10089 anon_free_pages(amp->ahp, 0, size, szc);
10091 anon_free(amp->ahp, 0, size);
10096 anon_unresv_zone(amp->swresv, NULL);
10097 amp->refcnt = 0;
10098 anonmap_free(amp);
10218 struct anon_map *amp;
10230 ASSERT(svd->amp != NULL);
10234 ASSERT(svntrp->tr_amp[svd->tr_policy_info.mem_lgrpid] == svd->amp);
10288 amp = anonmap_alloc(size, size, KM_NOSLEEP);
10289 if (amp == NULL) {
10297 ASSERT(amp->refcnt == 1);
10298 amp->a_szc = seg->s_szc;
10299 svntrp->tr_amp[lgrp_id] = amp;
10314 ASSERT(svd->amp != NULL);
10317 ASSERT(svd->amp != svntrp->tr_amp[lgrp_id]);
10320 svd->amp = svntrp->tr_amp[lgrp_id];
10328 ASSERT(svd->amp != NULL && svd->amp == svntrp->tr_amp[lgrp_id]);