isolate_lru_pages

static unsigned long isolate_lru_pages(unsigned longnr_to_scan,
              struct lruvec *lruvec, struct list_head*dst,
              unsignedlong *nr_scanned, struct scan_control *sc,
              isolate_mode_tmode, enum lru_list lru)
{
       struct list_head *src = &lruvec->lists[lru];
       unsignedlong nr_taken = 0;
       unsignedlong scan;
 
       for (scan=0;scan<nr_to_scan&& nr_taken < nr_to_scan &&!list_empty(src); scan++) {
              structpage *page;
               page= lru_to_page(src);
              prefetchw_prev_lru_page(page,src, flags);
               VM_BUG_ON_PAGE(!PageLRU(page),page);
            switch(__isolate_lru_page(page, mode)) {
              case0:
                     nr_taken+= hpage_nr_pages(page);
                     list_move(&page->lru,dst);
                     break;
 
              case-EBUSY:
                     /*else it is being freed elsewhere */
                     list_move(&page->lru,src);
                     continue;
 
              default:
                     BUG();
              }
       }
 
       *nr_scanned = scan;
       trace_mm_vmscan_lru_isolate(sc->order,nr_to_scan, scan, nr_taken, mode, is_file_lru(lru));
       return nr_taken;
}
 
 
 
 
int __isolate_lru_page(struct page *page, isolate_mode_t mode)
{
       intret = -EINVAL;
        /*Only take pages on the LRU. */
       if (!PageLRU(page))
              returnret;
 
       /*Compaction should not handle unevictable pages but CMA can do so */
       if(PageUnevictable(page) && !(mode &ISOLATE_UNEVICTABLE))
              returnret;
        ret= -EBUSY;
        if(mode & (ISOLATE_CLEAN|ISOLATE_ASYNC_MIGRATE)) {
              /*All the caller can do on PageWriteback is block */
              if (PageWriteback(page))
                     returnret;
 
              if (PageDirty(page)) {
                     structaddress_space *mapping;
                      /*ISOLATE_CLEAN means only clean pages */
if (mode & ISOLATE_CLEAN)
                            returnret;
mapping = page_mapping(page);
                     if(mapping && !mapping->a_ops->migratepage)
                            returnret;
              }
       }
 
       if ((mode & ISOLATE_UNMAPPED) && page_mapped(page))
              returnret;
 
       if (likely(get_page_unless_zero(page))) {
              ClearPageLRU(page);
              ret= 0;
       }
 
return ret;
}