Lines Matching defs:pcp
134 int segpcache_pcp_maxage_sec = 1; /* pcp max age in secs */
135 clock_t segpcache_pcp_maxage_ticks = 0; /* pcp max age in ticks */
173 clock_t p_pcp_maxage; /* max pcp age in ticks */
212 #define IS_PCP_WIRED(pcp) IS_PFLAGS_WIRED((pcp)->p_flags)
216 #define PCP_AGE(pcp) LBOLT_DELTA((pcp)->p_lbolt)
233 #define P_MATCH(pcp, htag0, addr, len) \
234 ((pcp)->p_htag0 == (htag0) && \
235 (pcp)->p_addr == (addr) && \
236 (pcp)->p_len >= (len))
238 #define P_MATCH_PP(pcp, htag0, addr, len, pp) \
239 ((pcp)->p_pp == (pp) && \
240 (pcp)->p_htag0 == (htag0) && \
241 (pcp)->p_addr == (addr) && \
242 (pcp)->p_len >= (len))
274 * be called after the last pcp entry is deleted from its chain. Per bucket
276 * when seg_premove_abuck() removes a bucket after pcp entries are added to
356 * seg_pinsert() can't sneak in and add pcp entries to this
396 * which we just deleted the last pcp entry must be still on one of the
413 * Check if bucket pointed by hp already has a pcp entry that matches request
425 struct seg_pcache *pcp;
431 for (pcp = hp->p_hnext; pcp != (struct seg_pcache *)hp;
432 pcp = pcp->p_hnext) {
433 ASSERT(pcp->p_hashp == hp);
434 if (pcp->p_htag0 == htag0 && pcp->p_addr == addr) {
435 ASSERT(!IS_PCP_WIRED(pcp));
436 if (pcp->p_len < len) {
438 if (pcp->p_active) {
441 plinkp = &pcp->p_plink;
444 pcp->p_hprev->p_hnext = pcp->p_hnext;
445 pcp->p_hnext->p_hprev = pcp->p_hprev;
446 pcp->p_hprev = delcallb_list;
447 delcallb_list = pcp;
466 struct seg_pcache *pcp;
485 for (pcp = hp->p_hnext; pcp != (struct seg_pcache *)hp;
486 pcp = pcp->p_hnext) {
487 ASSERT(pcp->p_hashp == hp);
488 if (P_MATCH(pcp, htag0, addr, len)) {
489 ASSERT(IS_PFLAGS_WIRED(flags) == IS_PCP_WIRED(pcp));
498 if (rw == S_WRITE && pcp->p_wlen < len) {
501 if (pcp->p_active == UINT_MAX) {
504 pcp->p_active++;
505 if (rw == S_WRITE && !pcp->p_write) {
506 pcp->p_write = 1;
509 return (pcp->p_pp);
528 struct seg_pcache *pcp;
566 for (pcp = hp->p_hnext; pcp != (struct seg_pcache *)hp;
567 pcp = pcp->p_hnext) {
568 ASSERT(pcp->p_hashp == hp);
569 if (P_MATCH_PP(pcp, htag0, addr, len, pp)) {
570 ASSERT(IS_PFLAGS_WIRED(flags) == IS_PCP_WIRED(pcp));
571 ASSERT(pcp->p_active);
574 * Don't remove this pcp entry
586 pcp->p_active--;
587 if (pcp->p_active == 0 && (pmtx != NULL ||
593 * disabled or there're other pcp entries that
598 ASSERT(callback == pcp->p_callback);
600 pcache_link_t *plinkp = &pcp->p_plink;
601 ASSERT(!IS_PCP_WIRED(pcp));
609 pcp->p_hprev->p_hnext = pcp->p_hnext;
610 pcp->p_hnext->p_hprev = pcp->p_hprev;
611 if (!IS_PCP_WIRED(pcp) &&
624 len = pcp->p_len;
626 if (rw != S_WRITE && pcp->p_write) {
629 kmem_cache_free(seg_pkmcache, pcp);
633 * We found a matching pcp entry but will not
637 if (!pcp->p_active && !IS_PCP_WIRED(pcp)) {
640 * time of last access to this pcp
645 pcp->p_lbolt = ddi_get_lbolt();
646 pcp->p_ref = 1;
655 P_MATCH(pcp, htag0, addr, len)) {
657 * This is a duplicate pcp entry. This situation may
660 * Now we can free our pcp entry if it becomes
663 if (!pcp->p_active) {
666 * we'll free our own pcp entry soon.
668 pcp->p_lbolt = ddi_get_lbolt();
669 pcp->p_ref = 1;
674 * duplicate. Don't keep our own pcp entry.
804 struct seg_pcache *pcp;
841 pcp = kmem_cache_alloc(seg_pkmcache, KM_SLEEP);
846 pcp->p_htag0 = (void *)seg;
847 pcp->p_flags = flags & 0xffff;
849 pcp->p_htag0 = (void *)amp;
850 pcp->p_flags = (flags & 0xffff) | SEGP_AMP;
852 pcp->p_addr = addr;
853 pcp->p_len = len;
854 pcp->p_wlen = wlen;
855 pcp->p_pp = pp;
856 pcp->p_write = (rw == S_WRITE);
857 pcp->p_callback = callback;
858 pcp->p_active = 1;
860 hp = P_HASHBP(seg, pcp->p_htag0, addr, flags);
884 kmem_cache_free(seg_pkmcache, pcp);
887 pcp->p_plink.p_lnext = pheadp->p_lnext;
888 pcp->p_plink.p_lprev = pheadp;
889 pheadp->p_lnext->p_lprev = &pcp->p_plink;
890 pheadp->p_lnext = &pcp->p_plink;
894 pcp->p_hashp = hp;
895 pcp->p_hnext = hp->p_hnext;
896 pcp->p_hprev = (struct seg_pcache *)hp;
897 hp->p_hnext->p_hprev = pcp;
898 hp->p_hnext = pcp;
900 hp->p_hprev == pcp) {
911 pcp = delcallb_list;
912 delcallb_list = pcp->p_hprev;
913 ASSERT(!IS_PCP_WIRED(pcp) && !pcp->p_active);
914 (void) (*pcp->p_callback)(pcp->p_htag0, pcp->p_addr,
915 pcp->p_len, pcp->p_pp, pcp->p_write ? S_WRITE : S_READ, 0);
916 npages += btop(pcp->p_len);
917 kmem_cache_free(seg_pkmcache, pcp);
940 struct seg_pcache *pcp;
1013 for (pcp = hpw->p_hnext;
1014 pcp != (struct seg_pcache *)hpw;
1015 pcp = pcp->p_hnext) {
1017 ASSERT(IS_PCP_WIRED(pcp));
1018 ASSERT(pcp->p_hashp ==
1021 if (pcp->p_active) {
1024 pcp->p_hprev->p_hnext = pcp->p_hnext;
1025 pcp->p_hnext->p_hprev = pcp->p_hprev;
1026 pcp->p_hprev = delcallb_list;
1027 delcallb_list = pcp;
1058 for (pcp = hp->p_hnext; pcp != (struct seg_pcache *)hp;
1059 pcp = pcp->p_hnext) {
1065 ASSERT(!IS_PCP_WIRED(pcp));
1066 ASSERT(pcp->p_hashp == hp);
1068 if (pcp->p_active) {
1071 if (!force && pcp->p_ref &&
1072 PCP_AGE(pcp) < seg_pmax_pcpage) {
1073 pcp->p_ref = 0;
1076 plinkp = &pcp->p_plink;
1077 htag0 = pcp->p_htag0;
1078 if (pcp->p_flags & SEGP_AMP) {
1094 pcp->p_hprev->p_hnext = pcp->p_hnext;
1095 pcp->p_hnext->p_hprev = pcp->p_hprev;
1097 pcp->p_hprev = delcallb_list;
1098 delcallb_list = pcp;
1099 npgs_purged += btop(pcp->p_len);
1168 pcp = delcallb_list;
1169 delcallb_list = pcp->p_hprev;
1170 ASSERT(!pcp->p_active);
1171 (void) (*pcp->p_callback)(pcp->p_htag0, pcp->p_addr,
1172 pcp->p_len, pcp->p_pp, pcp->p_write ? S_WRITE : S_READ, 1);
1173 npages += btop(pcp->p_len);
1174 if (!IS_PCP_WIRED(pcp)) {
1175 npages_window += btop(pcp->p_len);
1177 kmem_cache_free(seg_pkmcache, pcp);
1197 struct seg_pcache *pcp;
1216 pcp = hp->p_hnext;
1217 while (pcp != (struct seg_pcache *)hp) {
1218 ASSERT(pcp->p_hashp == (struct seg_phash *)hp);
1219 ASSERT(IS_PCP_WIRED(pcp));
1223 if (!pcp->p_active && pcp->p_pp == pp) {
1224 ASSERT(pcp->p_htag0 != NULL);
1225 pcp->p_hprev->p_hnext = pcp->p_hnext;
1226 pcp->p_hnext->p_hprev = pcp->p_hprev;
1227 pcp->p_hprev = delcallb_list;
1228 delcallb_list = pcp;
1230 pcp = pcp->p_hnext;
1240 pcp = delcallb_list;
1241 delcallb_list = pcp->p_hprev;
1242 ASSERT(!pcp->p_active);
1243 done = (*pcp->p_callback)(pcp->p_htag0, pcp->p_addr,
1244 pcp->p_len, pcp->p_pp,
1245 pcp->p_write ? S_WRITE : S_READ, 1);
1246 npages += btop(pcp->p_len);
1247 ASSERT(IS_PCP_WIRED(pcp));
1248 kmem_cache_free(seg_pkmcache, pcp);
1272 struct seg_pcache *pcp;
1291 pcp = hp->p_hnext;
1292 while (pcp != (struct seg_pcache *)hp) {
1293 ASSERT(pcp->p_hashp == hp);
1294 ASSERT(IS_PCP_WIRED(pcp));
1295 if (pcp->p_htag0 == htag0) {
1296 if (pcp->p_active) {
1299 pcp->p_hprev->p_hnext = pcp->p_hnext;
1300 pcp->p_hnext->p_hprev = pcp->p_hprev;
1301 pcp->p_hprev = delcallb_list;
1302 delcallb_list = pcp;
1304 pcp = pcp->p_hnext;
1322 pcp = plink2pcache(plinkp);
1323 ASSERT(!IS_PCP_WIRED(pcp));
1324 ASSERT(pcp->p_htag0 == htag0);
1325 hp = pcp->p_hashp;
1327 if (pcp->p_active) {
1334 pcp->p_hprev->p_hnext = pcp->p_hnext;
1335 pcp->p_hnext->p_hprev = pcp->p_hprev;
1336 pcp->p_hprev = delcallb_list;
1337 delcallb_list = pcp;
1346 pcp = delcallb_list;
1347 delcallb_list = pcp->p_hprev;
1348 ASSERT(!pcp->p_active);
1349 (void) (*pcp->p_callback)(pcp->p_htag0, pcp->p_addr, pcp->p_len,
1350 pcp->p_pp, pcp->p_write ? S_WRITE : S_READ, 0);
1351 npages += btop(pcp->p_len);
1352 kmem_cache_free(seg_pkmcache, pcp);