Print this page
[mq]: core-v2


2965                         ASSERT(PP_ISAGED(pp));
2966                         ASSERT(pp->p_vnode == NULL);
2967                         ASSERT(pp->p_hash == NULL);
2968                         ASSERT(pp->p_offset == (u_offset_t)-1);
2969                         ASSERT(pp->p_szc == szc);
2970                         ASSERT(PFN_2_MEM_NODE(pp->p_pagenum) == mnode);
2971 
2972                         /*
2973                          * Walk down the hash chain.
2974                          * 8k pages are linked on p_next
2975                          * and p_prev fields. Large pages
2976                          * are a contiguous group of
2977                          * constituent pages linked together
2978                          * on their p_next and p_prev fields.
2979                          * The large pages are linked together
2980                          * on the hash chain using p_vpnext
2981                          * p_vpprev of the base constituent
2982                          * page of each large page.
2983                          */
2984                         first_pp = pp;
2985                         while (IS_DUMP_PAGE(pp) || !page_trylock_cons(pp,
2986                             SE_EXCL)) {
2987                                 if (szc == 0) {
2988                                         pp = pp->p_next;
2989                                 } else {
2990                                         pp = pp->p_vpnext;
2991                                 }
2992 
2993                                 ASSERT(PP_ISFREE(pp));
2994                                 ASSERT(PP_ISAGED(pp));
2995                                 ASSERT(pp->p_vnode == NULL);
2996                                 ASSERT(pp->p_hash == NULL);
2997                                 ASSERT(pp->p_offset == (u_offset_t)-1);
2998                                 ASSERT(pp->p_szc == szc);
2999                                 ASSERT(PFN_2_MEM_NODE(pp->p_pagenum) == mnode);
3000 
3001                                 if (pp == first_pp)
3002                                         goto bin_empty_0;
3003                         }
3004 
3005                         ASSERT(pp != NULL);
3006                         ASSERT(mtype == PP_2_MTYPE(pp));


4008          */
4009 
4010         for (plw.plw_count = 0;
4011             plw.plw_count < plw.plw_ceq_dif; plw.plw_count++) {
4012                 sbin = bin;
4013                 do {
4014 
4015                         if (!PAGE_CACHELISTS(mnode, bin, mtype))
4016                                 goto bin_empty_1;
4017                         pcm = PC_BIN_MUTEX(mnode, bin, PG_CACHE_LIST);
4018                         mutex_enter(pcm);
4019                         pp = PAGE_CACHELISTS(mnode, bin, mtype);
4020                         if (pp == NULL)
4021                                 goto bin_empty_0;
4022 
4023                         first_pp = pp;
4024                         ASSERT(pp->p_vnode);
4025                         ASSERT(PP_ISAGED(pp) == 0);
4026                         ASSERT(pp->p_szc == 0);
4027                         ASSERT(PFN_2_MEM_NODE(pp->p_pagenum) == mnode);
4028                         while (IS_DUMP_PAGE(pp) || !page_trylock(pp, SE_EXCL)) {
4029                                 pp = pp->p_next;
4030                                 ASSERT(pp->p_szc == 0);
4031                                 if (pp == first_pp) {
4032                                         /*
4033                                          * We have searched the complete list!
4034                                          * And all of them (might only be one)
4035                                          * are locked. This can happen since
4036                                          * these pages can also be found via
4037                                          * the hash list. When found via the
4038                                          * hash list, they are locked first,
4039                                          * then removed. We give up to let the
4040                                          * other thread run.
4041                                          */
4042                                         pp = NULL;
4043                                         break;
4044                                 }
4045                                 ASSERT(pp->p_vnode);
4046                                 ASSERT(PP_ISFREE(pp));
4047                                 ASSERT(PP_ISAGED(pp) == 0);
4048                                 ASSERT(PFN_2_MEM_NODE(pp->p_pagenum) ==




2965                         ASSERT(PP_ISAGED(pp));
2966                         ASSERT(pp->p_vnode == NULL);
2967                         ASSERT(pp->p_hash == NULL);
2968                         ASSERT(pp->p_offset == (u_offset_t)-1);
2969                         ASSERT(pp->p_szc == szc);
2970                         ASSERT(PFN_2_MEM_NODE(pp->p_pagenum) == mnode);
2971 
2972                         /*
2973                          * Walk down the hash chain.
2974                          * 8k pages are linked on p_next
2975                          * and p_prev fields. Large pages
2976                          * are a contiguous group of
2977                          * constituent pages linked together
2978                          * on their p_next and p_prev fields.
2979                          * The large pages are linked together
2980                          * on the hash chain using p_vpnext
2981                          * p_vpprev of the base constituent
2982                          * page of each large page.
2983                          */
2984                         first_pp = pp;
2985                         while (!page_trylock_cons(pp, SE_EXCL)) {

2986                                 if (szc == 0) {
2987                                         pp = pp->p_next;
2988                                 } else {
2989                                         pp = pp->p_vpnext;
2990                                 }
2991 
2992                                 ASSERT(PP_ISFREE(pp));
2993                                 ASSERT(PP_ISAGED(pp));
2994                                 ASSERT(pp->p_vnode == NULL);
2995                                 ASSERT(pp->p_hash == NULL);
2996                                 ASSERT(pp->p_offset == (u_offset_t)-1);
2997                                 ASSERT(pp->p_szc == szc);
2998                                 ASSERT(PFN_2_MEM_NODE(pp->p_pagenum) == mnode);
2999 
3000                                 if (pp == first_pp)
3001                                         goto bin_empty_0;
3002                         }
3003 
3004                         ASSERT(pp != NULL);
3005                         ASSERT(mtype == PP_2_MTYPE(pp));


4007          */
4008 
4009         for (plw.plw_count = 0;
4010             plw.plw_count < plw.plw_ceq_dif; plw.plw_count++) {
4011                 sbin = bin;
4012                 do {
4013 
4014                         if (!PAGE_CACHELISTS(mnode, bin, mtype))
4015                                 goto bin_empty_1;
4016                         pcm = PC_BIN_MUTEX(mnode, bin, PG_CACHE_LIST);
4017                         mutex_enter(pcm);
4018                         pp = PAGE_CACHELISTS(mnode, bin, mtype);
4019                         if (pp == NULL)
4020                                 goto bin_empty_0;
4021 
4022                         first_pp = pp;
4023                         ASSERT(pp->p_vnode);
4024                         ASSERT(PP_ISAGED(pp) == 0);
4025                         ASSERT(pp->p_szc == 0);
4026                         ASSERT(PFN_2_MEM_NODE(pp->p_pagenum) == mnode);
4027                         while (!page_trylock(pp, SE_EXCL)) {
4028                                 pp = pp->p_next;
4029                                 ASSERT(pp->p_szc == 0);
4030                                 if (pp == first_pp) {
4031                                         /*
4032                                          * We have searched the complete list!
4033                                          * And all of them (might only be one)
4034                                          * are locked. This can happen since
4035                                          * these pages can also be found via
4036                                          * the hash list. When found via the
4037                                          * hash list, they are locked first,
4038                                          * then removed. We give up to let the
4039                                          * other thread run.
4040                                          */
4041                                         pp = NULL;
4042                                         break;
4043                                 }
4044                                 ASSERT(pp->p_vnode);
4045                                 ASSERT(PP_ISFREE(pp));
4046                                 ASSERT(PP_ISAGED(pp) == 0);
4047                                 ASSERT(PFN_2_MEM_NODE(pp->p_pagenum) ==