Print this page
[mq]: core-v2


 993         int iolock)
 994 {
 995         int     i = 0;
 996         pfn_t   pfn = *pfnp;
 997         page_t  *pp;
 998         page_t  *plist = NULL;
 999 
1000         /*
1001          * fail if pfn + minctg crosses a segment boundary.
1002          * Adjust for next starting pfn to begin at segment boundary.
1003          */
1004 
1005         if (((*pfnp + minctg - 1) & pfnseg) < (*pfnp & pfnseg)) {
1006                 *pfnp = roundup(*pfnp, pfnseg + 1);
1007                 return (NULL);
1008         }
1009 
1010         do {
1011 retry:
1012                 pp = page_numtopp_nolock(pfn + i);
1013                 if ((pp == NULL) || IS_DUMP_PAGE(pp) ||
1014                     (page_trylock(pp, SE_EXCL) == 0)) {
1015                         (*pfnp)++;
1016                         break;
1017                 }
1018                 if (page_pptonum(pp) != pfn + i) {
1019                         page_unlock(pp);
1020                         goto retry;
1021                 }
1022 
1023                 if (!(PP_ISFREE(pp))) {
1024                         page_unlock(pp);
1025                         (*pfnp)++;
1026                         break;
1027                 }
1028 
1029                 if (!PP_ISAGED(pp)) {
1030                         page_list_sub(pp, PG_CACHE_LIST);
1031                         page_hashout(pp, (kmutex_t *)NULL);
1032                 } else {
1033                         page_list_sub(pp, PG_FREE_LIST);
1034                 }


3096         bin = origbin;
3097 
3098         /*
3099          * check up to page_colors + 1 bins - origbin may be checked twice
3100          * because of BIN_STEP skip
3101          */
3102         do {
3103                 plw_initialized = 0;
3104 
3105                 for (plw.plw_count = 0;
3106                     plw.plw_count < page_colors; plw.plw_count++) {
3107 
3108                         if (PAGE_FREELISTS(mnode, szc, bin, mtype) == NULL)
3109                                 goto nextfreebin;
3110 
3111                         pcm = PC_BIN_MUTEX(mnode, bin, PG_FREE_LIST);
3112                         mutex_enter(pcm);
3113                         pp = PAGE_FREELISTS(mnode, szc, bin, mtype);
3114                         first_pp = pp;
3115                         while (pp != NULL) {
3116                                 if (IS_DUMP_PAGE(pp) || page_trylock(pp,
3117                                     SE_EXCL) == 0) {
3118                                         pp = pp->p_next;
3119                                         if (pp == first_pp) {
3120                                                 pp = NULL;
3121                                         }
3122                                         continue;
3123                                 }
3124 
3125                                 ASSERT(PP_ISFREE(pp));
3126                                 ASSERT(PP_ISAGED(pp));
3127                                 ASSERT(pp->p_vnode == NULL);
3128                                 ASSERT(pp->p_hash == NULL);
3129                                 ASSERT(pp->p_offset == (u_offset_t)-1);
3130                                 ASSERT(pp->p_szc == szc);
3131                                 ASSERT(PFN_2_MEM_NODE(pp->p_pagenum) == mnode);
3132                                 /* check if page within DMA attributes */
3133                                 pgaddr = pa_to_ma(pfn_to_pa(pp->p_pagenum));
3134                                 if ((pgaddr >= dma_attr->dma_attr_addr_lo) &&
3135                                     (pgaddr + MMU_PAGESIZE - 1 <=
3136                                     dma_attr->dma_attr_addr_hi)) {
3137                                         break;


3191         } while (mtype >= 0);
3192 
3193         /* failed to find a page in the freelist; try it in the cachelist */
3194 
3195         /* reset mtype start for cachelist search */
3196         mtype = mtypestart;
3197         ASSERT(mtype >= 0);
3198 
3199         /* start with the bin of matching color */
3200         bin = origbin;
3201 
3202         do {
3203                 for (i = 0; i <= page_colors; i++) {
3204                         if (PAGE_CACHELISTS(mnode, bin, mtype) == NULL)
3205                                 goto nextcachebin;
3206                         pcm = PC_BIN_MUTEX(mnode, bin, PG_CACHE_LIST);
3207                         mutex_enter(pcm);
3208                         pp = PAGE_CACHELISTS(mnode, bin, mtype);
3209                         first_pp = pp;
3210                         while (pp != NULL) {
3211                                 if (IS_DUMP_PAGE(pp) || page_trylock(pp,
3212                                     SE_EXCL) == 0) {
3213                                         pp = pp->p_next;
3214                                         if (pp == first_pp)
3215                                                 pp = NULL;
3216                                         continue;
3217                                 }
3218                                 ASSERT(pp->p_vnode);
3219                                 ASSERT(PP_ISAGED(pp) == 0);
3220                                 ASSERT(pp->p_szc == 0);
3221                                 ASSERT(PFN_2_MEM_NODE(pp->p_pagenum) == mnode);
3222 
3223                                 /* check if page within DMA attributes */
3224 
3225                                 pgaddr = pa_to_ma(pfn_to_pa(pp->p_pagenum));
3226                                 if ((pgaddr >= dma_attr->dma_attr_addr_lo) &&
3227                                     (pgaddr + MMU_PAGESIZE - 1 <=
3228                                     dma_attr->dma_attr_addr_hi)) {
3229                                         break;
3230                                 }
3231 
3232                                 /* continue looking */




 993         int iolock)
 994 {
 995         int     i = 0;
 996         pfn_t   pfn = *pfnp;
 997         page_t  *pp;
 998         page_t  *plist = NULL;
 999 
1000         /*
1001          * fail if pfn + minctg crosses a segment boundary.
1002          * Adjust for next starting pfn to begin at segment boundary.
1003          */
1004 
1005         if (((*pfnp + minctg - 1) & pfnseg) < (*pfnp & pfnseg)) {
1006                 *pfnp = roundup(*pfnp, pfnseg + 1);
1007                 return (NULL);
1008         }
1009 
1010         do {
1011 retry:
1012                 pp = page_numtopp_nolock(pfn + i);
1013                 if ((pp == NULL) || (page_trylock(pp, SE_EXCL) == 0)) {

1014                         (*pfnp)++;
1015                         break;
1016                 }
1017                 if (page_pptonum(pp) != pfn + i) {
1018                         page_unlock(pp);
1019                         goto retry;
1020                 }
1021 
1022                 if (!(PP_ISFREE(pp))) {
1023                         page_unlock(pp);
1024                         (*pfnp)++;
1025                         break;
1026                 }
1027 
1028                 if (!PP_ISAGED(pp)) {
1029                         page_list_sub(pp, PG_CACHE_LIST);
1030                         page_hashout(pp, (kmutex_t *)NULL);
1031                 } else {
1032                         page_list_sub(pp, PG_FREE_LIST);
1033                 }


3095         bin = origbin;
3096 
3097         /*
3098          * check up to page_colors + 1 bins - origbin may be checked twice
3099          * because of BIN_STEP skip
3100          */
3101         do {
3102                 plw_initialized = 0;
3103 
3104                 for (plw.plw_count = 0;
3105                     plw.plw_count < page_colors; plw.plw_count++) {
3106 
3107                         if (PAGE_FREELISTS(mnode, szc, bin, mtype) == NULL)
3108                                 goto nextfreebin;
3109 
3110                         pcm = PC_BIN_MUTEX(mnode, bin, PG_FREE_LIST);
3111                         mutex_enter(pcm);
3112                         pp = PAGE_FREELISTS(mnode, szc, bin, mtype);
3113                         first_pp = pp;
3114                         while (pp != NULL) {
3115                                 if (page_trylock(pp, SE_EXCL) == 0) {

3116                                         pp = pp->p_next;
3117                                         if (pp == first_pp) {
3118                                                 pp = NULL;
3119                                         }
3120                                         continue;
3121                                 }
3122 
3123                                 ASSERT(PP_ISFREE(pp));
3124                                 ASSERT(PP_ISAGED(pp));
3125                                 ASSERT(pp->p_vnode == NULL);
3126                                 ASSERT(pp->p_hash == NULL);
3127                                 ASSERT(pp->p_offset == (u_offset_t)-1);
3128                                 ASSERT(pp->p_szc == szc);
3129                                 ASSERT(PFN_2_MEM_NODE(pp->p_pagenum) == mnode);
3130                                 /* check if page within DMA attributes */
3131                                 pgaddr = pa_to_ma(pfn_to_pa(pp->p_pagenum));
3132                                 if ((pgaddr >= dma_attr->dma_attr_addr_lo) &&
3133                                     (pgaddr + MMU_PAGESIZE - 1 <=
3134                                     dma_attr->dma_attr_addr_hi)) {
3135                                         break;


3189         } while (mtype >= 0);
3190 
3191         /* failed to find a page in the freelist; try it in the cachelist */
3192 
3193         /* reset mtype start for cachelist search */
3194         mtype = mtypestart;
3195         ASSERT(mtype >= 0);
3196 
3197         /* start with the bin of matching color */
3198         bin = origbin;
3199 
3200         do {
3201                 for (i = 0; i <= page_colors; i++) {
3202                         if (PAGE_CACHELISTS(mnode, bin, mtype) == NULL)
3203                                 goto nextcachebin;
3204                         pcm = PC_BIN_MUTEX(mnode, bin, PG_CACHE_LIST);
3205                         mutex_enter(pcm);
3206                         pp = PAGE_CACHELISTS(mnode, bin, mtype);
3207                         first_pp = pp;
3208                         while (pp != NULL) {
3209                                 if (page_trylock(pp, SE_EXCL) == 0) {

3210                                         pp = pp->p_next;
3211                                         if (pp == first_pp)
3212                                                 pp = NULL;
3213                                         continue;
3214                                 }
3215                                 ASSERT(pp->p_vnode);
3216                                 ASSERT(PP_ISAGED(pp) == 0);
3217                                 ASSERT(pp->p_szc == 0);
3218                                 ASSERT(PFN_2_MEM_NODE(pp->p_pagenum) == mnode);
3219 
3220                                 /* check if page within DMA attributes */
3221 
3222                                 pgaddr = pa_to_ma(pfn_to_pa(pp->p_pagenum));
3223                                 if ((pgaddr >= dma_attr->dma_attr_addr_lo) &&
3224                                     (pgaddr + MMU_PAGESIZE - 1 <=
3225                                     dma_attr->dma_attr_addr_hi)) {
3226                                         break;
3227                                 }
3228 
3229                                 /* continue looking */