自学教程：C++ update_page_reclaim_stat函数代码示例

/* used by __split_huge_page_refcount() */void lru_add_page_tail(struct zone* zone,		       struct page *page, struct page *page_tail){	int active;	enum lru_list lru;	const int file = 0;	struct list_head *head;	VM_BUG_ON(!PageHead(page));	VM_BUG_ON(PageCompound(page_tail));	VM_BUG_ON(PageLRU(page_tail));	VM_BUG_ON(NR_CPUS != 1 && !spin_is_locked(&zone->lru_lock));	SetPageLRU(page_tail);	if (page_evictable(page_tail, NULL)) {		if (PageActive(page)) {			SetPageActive(page_tail);			active = 1;			lru = LRU_ACTIVE_ANON;		} else {			active = 0;			lru = LRU_INACTIVE_ANON;		}		update_page_reclaim_stat(zone, page_tail, file, active);		if (likely(PageLRU(page)))			head = page->lru.prev;		else			head = &zone->lru[lru].list;		__add_page_to_lru_list(zone, page_tail, lru, head);	} else {		SetPageUnevictable(page_tail);		add_page_to_lru_list(zone, page_tail, LRU_UNEVICTABLE);	}}

static void __pagevec_lru_add_fn(struct page *page, struct lruvec *lruvec,				 void *arg){	enum lru_list lru;	int was_unevictable = TestClearPageUnevictable(page);	VM_BUG_ON_PAGE(PageLRU(page), page);	SetPageLRU(page);	/*	 * Page becomes evictable in two ways:	 * 1) Within LRU lock [munlock_vma_pages() and __munlock_pagevec()].	 * 2) Before acquiring LRU lock to put the page to correct LRU and then	 *   a) do PageLRU check with lock [check_move_unevictable_pages]	 *   b) do PageLRU check before lock [clear_page_mlock]	 *	 * (1) & (2a) are ok as LRU lock will serialize them. For (2b), we need	 * following strict ordering:	 *	 * #0: __pagevec_lru_add_fn		#1: clear_page_mlock	 *	 * SetPageLRU()				TestClearPageMlocked()	 * smp_mb() // explicit ordering	// above provides strict	 *					// ordering	 * PageMlocked()			PageLRU()	 *	 *	 * if '#1' does not observe setting of PG_lru by '#0' and fails	 * isolation, the explicit barrier will make sure that page_evictable	 * check will put the page in correct LRU. Without smp_mb(), SetPageLRU	 * can be reordered after PageMlocked check and can make '#1' to fail	 * the isolation of the page whose Mlocked bit is cleared (#0 is also	 * looking at the same page) and the evictable page will be stranded	 * in an unevictable LRU.	 */	smp_mb();	if (page_evictable(page)) {		lru = page_lru(page);		update_page_reclaim_stat(lruvec, page_is_file_cache(page),					 PageActive(page));		if (was_unevictable)			count_vm_event(UNEVICTABLE_PGRESCUED);	} else {		lru = LRU_UNEVICTABLE;		ClearPageActive(page);		SetPageUnevictable(page);		if (!was_unevictable)			count_vm_event(UNEVICTABLE_PGCULLED);	}	add_page_to_lru_list(page, lruvec, lru);	trace_mm_lru_insertion(page, lru);}

/* used by __split_huge_page_refcount() */void lru_add_page_tail(struct page *page, struct page *page_tail,		       struct lruvec *lruvec, struct list_head *list){	int uninitialized_var(active);	enum lru_list lru;	const int file = 0;	VM_BUG_ON(!PageHead(page));	VM_BUG_ON(PageCompound(page_tail));	VM_BUG_ON(PageLRU(page_tail));	VM_BUG_ON(NR_CPUS != 1 &&		  !spin_is_locked(&lruvec_zone(lruvec)->lru_lock));	if (!list)		SetPageLRU(page_tail);	if (page_evictable(page_tail)) {		if (PageActive(page)) {			SetPageActive(page_tail);			active = 1;			lru = LRU_ACTIVE_ANON;		} else {			active = 0;			lru = LRU_INACTIVE_ANON;		}	} else {		SetPageUnevictable(page_tail);		lru = LRU_UNEVICTABLE;	}	if (likely(PageLRU(page)))		list_add_tail(&page_tail->lru, &page->lru);	else if (list) {		/* page reclaim is reclaiming a huge page */		get_page(page_tail);		list_add_tail(&page_tail->lru, list);	} else {		struct list_head *list_head;		/*		 * Head page has not yet been counted, as an hpage,		 * so we must account for each subpage individually.		 *		 * Use the standard add function to put page_tail on the list,		 * but then correct its position so they all end up in order.		 */		add_page_to_lru_list(page_tail, lruvec, lru);		list_head = page_tail->lru.prev;		list_move_tail(&page_tail->lru, list_head);	}	if (!PageUnevictable(page))		update_page_reclaim_stat(lruvec, file, active);}

static void __pagevec_lru_add_fn(struct page *page, struct lruvec *lruvec,				 void *arg){	int file = page_is_file_cache(page);	int active = PageActive(page);	enum lru_list lru = page_lru(page);	VM_BUG_ON(PageLRU(page));	SetPageLRU(page);	add_page_to_lru_list(page, lruvec, lru);	update_page_reclaim_stat(lruvec, file, active);}

static void __pagevec_lru_add_fn(struct page *page, struct lruvec *lruvec,				 void *arg){	int file = page_is_file_cache(page);	int active = PageActive(page);	enum lru_list lru = page_lru(page);	VM_BUG_ON_PAGE(PageLRU(page), page);	SetPageLRU(page);	add_page_to_lru_list(page, lruvec, lru);	update_page_reclaim_stat(lruvec, file, active);	trace_mm_lru_insertion(page, page_to_pfn(page), lru, trace_pagemap_flags(page));}

static void __activate_page(struct page *page, struct lruvec *lruvec,			    void *arg){	if (PageLRU(page) && !PageActive(page) && !PageUnevictable(page)) {		int file = page_is_file_cache(page);		int lru = page_lru_base_type(page);		del_page_from_lru_list(page, lruvec, lru);		SetPageActive(page);		lru += LRU_ACTIVE;		add_page_to_lru_list(page, lruvec, lru);		__count_vm_event(PGACTIVATE);		update_page_reclaim_stat(lruvec, file, 1);	}}

static void lru_deactivate_fn(struct page *page, struct lruvec *lruvec,			    void *arg){	if (PageLRU(page) && PageActive(page) && !PageUnevictable(page)) {		int file = page_is_file_cache(page);		int lru = page_lru_base_type(page);		del_page_from_lru_list(page, lruvec, lru + LRU_ACTIVE);		ClearPageActive(page);		ClearPageReferenced(page);		add_page_to_lru_list(page, lruvec, lru);		__count_vm_event(PGDEACTIVATE);		update_page_reclaim_stat(lruvec, file, 0);	}}

/* * If the page can not be invalidated, it is moved to the * inactive list to speed up its reclaim.  It is moved to the * head of the list, rather than the tail, to give the flusher * threads some time to write it out, as this is much more * effective than the single-page writeout from reclaim. * * If the page isn't page_mapped and dirty/writeback, the page * could reclaim asap using PG_reclaim. * * 1. active, mapped page -> none * 2. active, dirty/writeback page -> inactive, head, PG_reclaim * 3. inactive, mapped page -> none * 4. inactive, dirty/writeback page -> inactive, head, PG_reclaim * 5. inactive, clean -> inactive, tail * 6. Others -> none * * In 4, why it moves inactive's head, the VM expects the page would * be write it out by flusher threads as this is much more effective * than the single-page writeout from reclaim. */static void lru_deactivate_fn(struct page *page, void *arg){	int lru, file;	bool active;	struct zone *zone = page_zone(page);	if (!PageLRU(page))		return;	if (PageUnevictable(page))		return;	/* Some processes are using the page */	if (page_mapped(page))		return;	active = PageActive(page);	file = page_is_file_cache(page);	lru = page_lru_base_type(page);	del_page_from_lru_list(zone, page, lru + active);	ClearPageActive(page);	ClearPageReferenced(page);	add_page_to_lru_list(zone, page, lru);	if (PageWriteback(page) || PageDirty(page)) {		/*		 * PG_reclaim could be raced with end_page_writeback		 * It can make readahead confusing.  But race window		 * is _really_ small and  it's non-critical problem.		 */		SetPageReclaim(page);	} else {		struct lruvec *lruvec;		/*		 * The page's writeback ends up during pagevec		 * We moves tha page into tail of inactive.		 */		lruvec = mem_cgroup_lru_move_lists(zone, page, lru, lru);		list_move_tail(&page->lru, &lruvec->lists[lru]);		__count_vm_event(PGROTATED);	}	if (active)		__count_vm_event(PGDEACTIVATE);	update_page_reclaim_stat(zone, page, file, 0);}

static void __pagevec_lru_add_fn(struct page *page, struct lruvec *lruvec,				 void *arg){	enum lru_list lru = (enum lru_list)arg;	int file = is_file_lru(lru);	int active = is_active_lru(lru);	VM_BUG_ON(PageActive(page));	VM_BUG_ON(PageUnevictable(page));	VM_BUG_ON(PageLRU(page));	SetPageLRU(page);	if (active)		SetPageActive(page);	add_page_to_lru_list(page, lruvec, lru);	update_page_reclaim_stat(lruvec, file, active);}

/* used by __split_huge_page_refcount() */void lru_add_page_tail(struct zone* zone,		       struct page *page, struct page *page_tail){	int active;	enum lru_list lru;	const int file = 0;	VM_BUG_ON(!PageHead(page));	VM_BUG_ON(PageCompound(page_tail));	VM_BUG_ON(PageLRU(page_tail));	VM_BUG_ON(!spin_is_locked(&zone->lru_lock));	SetPageLRU(page_tail);	if (page_evictable(page_tail, NULL)) {		if (PageActive(page)) {			SetPageActive(page_tail);			active = 1;			lru = LRU_ACTIVE_ANON;		} else {			active = 0;			lru = LRU_INACTIVE_ANON;		}		update_page_reclaim_stat(zone, page_tail, file, active);	} else {		SetPageUnevictable(page_tail);		lru = LRU_UNEVICTABLE;	}	if (likely(PageLRU(page)))		list_add_tail(&page_tail->lru, &page->lru);	else {		struct list_head *list_head;		/*		 * Head page has not yet been counted, as an hpage,		 * so we must account for each subpage individually.		 *		 * Use the standard add function to put page_tail on the list,		 * but then correct its position so they all end up in order.		 */		add_page_to_lru_list(zone, page_tail, lru);		list_head = page_tail->lru.prev;		list_move_tail(&page_tail->lru, list_head);	}}

/* * added by qijiwen. * put the page on the lru directly */void add_page_to_lru_list_cma(struct page *page, enum lru_list lru){	struct zone *zone = page_zone(page);	int file = is_file_lru(lru);	int active = is_active_lru(lru);	unsigned long flags = 0;	VM_BUG_ON(PageActive(page));	VM_BUG_ON(PageUnevictable(page));	VM_BUG_ON(PageLRU(page));	spin_lock_irqsave(&zone->lru_lock, flags);	SetPageLRU(page);	if (active)		SetPageActive(page);	update_page_reclaim_stat(zone, page, file, active);	add_page_to_lru_list(zone, page, lru);	spin_unlock_irqrestore(&zone->lru_lock, flags);}

/* used by __split_huge_page_refcount() */void lru_add_page_tail(struct page *page, struct page *page_tail,		       struct lruvec *lruvec, struct list_head *list){	const int file = 0;	VM_BUG_ON_PAGE(!PageHead(page), page);	VM_BUG_ON_PAGE(PageCompound(page_tail), page);	VM_BUG_ON_PAGE(PageLRU(page_tail), page);	VM_BUG_ON(NR_CPUS != 1 &&		  !spin_is_locked(&lruvec_pgdat(lruvec)->lru_lock));	if (!list)		SetPageLRU(page_tail);	if (likely(PageLRU(page)))		list_add_tail(&page_tail->lru, &page->lru);	else if (list) {		/* page reclaim is reclaiming a huge page */		get_page(page_tail);		list_add_tail(&page_tail->lru, list);	} else {		struct list_head *list_head;		/*		 * Head page has not yet been counted, as an hpage,		 * so we must account for each subpage individually.		 *		 * Use the standard add function to put page_tail on the list,		 * but then correct its position so they all end up in order.		 */		add_page_to_lru_list(page_tail, lruvec, page_lru(page_tail));		list_head = page_tail->lru.prev;		list_move_tail(&page_tail->lru, list_head);	}	if (!PageUnevictable(page))		update_page_reclaim_stat(lruvec, file, PageActive(page_tail));}

static void lru_lazyfree_fn(struct page *page, struct lruvec *lruvec,			    void *arg){	if (PageLRU(page) && PageAnon(page) && PageSwapBacked(page) &&	    !PageSwapCache(page) && !PageUnevictable(page)) {		bool active = PageActive(page);		del_page_from_lru_list(page, lruvec,				       LRU_INACTIVE_ANON + active);		ClearPageActive(page);		ClearPageReferenced(page);		/*		 * lazyfree pages are clean anonymous pages. They have		 * SwapBacked flag cleared to distinguish normal anonymous		 * pages		 */		ClearPageSwapBacked(page);		add_page_to_lru_list(page, lruvec, LRU_INACTIVE_FILE);		__count_vm_events(PGLAZYFREE, hpage_nr_pages(page));		count_memcg_page_event(page, PGLAZYFREE);		update_page_reclaim_stat(lruvec, 1, 0);	}}