[net-next-2.6.git] / mm / page_isolation.c

/*
 * linux/mm/page_isolation.c
 */

#include <stddef.h>
#include <linux/mm.h>
#include <linux/page-isolation.h>
#include <linux/pageblock-flags.h>
#include "internal.h"

static inline struct page *
__first_valid_page(unsigned long pfn, unsigned long nr_pages)
{
	int i;
	for (i = 0; i < nr_pages; i++)
		if (pfn_valid_within(pfn + i))
			break;
	if (unlikely(i == nr_pages))
		return NULL;
	return pfn_to_page(pfn + i);
}

/*
 * start_isolate_page_range() -- make page-allocation-type of range of pages
 * to be MIGRATE_ISOLATE.
 * @start_pfn: The lower PFN of the range to be isolated.
 * @end_pfn: The upper PFN of the range to be isolated.
 *
 * Making page-allocation-type to be MIGRATE_ISOLATE means free pages in
 * the range will never be allocated. Any free pages and pages freed in the
 * future will not be allocated again.
 *
 * start_pfn/end_pfn must be aligned to pageblock_order.
 * Returns 0 on success and -EBUSY if any part of range cannot be isolated.
 */
int
start_isolate_page_range(unsigned long start_pfn, unsigned long end_pfn)
{
	unsigned long pfn;
	unsigned long undo_pfn;
	struct page *page;

	BUG_ON((start_pfn) & (pageblock_nr_pages - 1));
	BUG_ON((end_pfn) & (pageblock_nr_pages - 1));

	for (pfn = start_pfn;
	     pfn < end_pfn;
	     pfn += pageblock_nr_pages) {
		page = __first_valid_page(pfn, pageblock_nr_pages);
		if (page && set_migratetype_isolate(page)) {
			undo_pfn = pfn;
			goto undo;
		}
	}
	return 0;
undo:
	for (pfn = start_pfn;
	     pfn <= undo_pfn;
	     pfn += pageblock_nr_pages)
		unset_migratetype_isolate(pfn_to_page(pfn));

	return -EBUSY;
}

/*
 * Make isolated pages available again.
 */
int
undo_isolate_page_range(unsigned long start_pfn, unsigned long end_pfn)
{
	unsigned long pfn;
	struct page *page;
	BUG_ON((start_pfn) & (pageblock_nr_pages - 1));
	BUG_ON((end_pfn) & (pageblock_nr_pages - 1));
	for (pfn = start_pfn;
	     pfn < end_pfn;
	     pfn += pageblock_nr_pages) {
		page = __first_valid_page(pfn, pageblock_nr_pages);
		if (!page || get_pageblock_flags(page) != MIGRATE_ISOLATE)
			continue;
		unset_migratetype_isolate(page);
	}
	return 0;
}
/*
 * Test all pages in the range is free(means isolated) or not.
 * all pages in [start_pfn...end_pfn) must be in the same zone.
 * zone->lock must be held before call this.
 *
 * Returns 0 if all pages in the range is isolated.
 */
static int
__test_page_isolated_in_pageblock(unsigned long pfn, unsigned long end_pfn)
{
	struct page *page;

	while (pfn < end_pfn) {
		if (!pfn_valid_within(pfn)) {
			pfn++;
			continue;
		}
		page = pfn_to_page(pfn);
		if (PageBuddy(page))
			pfn += 1 << page_order(page);
		else if (page_count(page) == 0 &&
				page_private(page) == MIGRATE_ISOLATE)
			pfn += 1;
		else
			break;
	}
	if (pfn < end_pfn)
		return 0;
	return 1;
}

int test_pages_isolated(unsigned long start_pfn, unsigned long end_pfn)
{
	unsigned long pfn;
	struct page *page;

	pfn = start_pfn;
	/*
	 * Note: pageblock_nr_page != MAX_ORDER. Then, chunks of free page
	 * is not aligned to pageblock_nr_pages.
	 * Then we just check pagetype fist.
	 */
	for (pfn = start_pfn; pfn < end_pfn; pfn += pageblock_nr_pages) {
		page = __first_valid_page(pfn, pageblock_nr_pages);
		if (page && get_pageblock_flags(page) != MIGRATE_ISOLATE)
			break;
	}
	if (pfn < end_pfn)
		return -EBUSY;
	/* Check all pages are free or Marked as ISOLATED */
	if (__test_page_isolated_in_pageblock(start_pfn, end_pfn))
		return 0;
	return -EBUSY;
}
Commit	Line	Data
a5d76b54 KH	1	/*
	2	* linux/mm/page_isolation.c
	3	*/
	4
	5	#include <stddef.h>
	6	#include <linux/mm.h>
	7	#include <linux/page-isolation.h>
	8	#include <linux/pageblock-flags.h>
	9	#include "internal.h"
	10
	11	static inline struct page *
	12	__first_valid_page(unsigned long pfn, unsigned long nr_pages)
	13	{
	14	int i;
	15	for (i = 0; i < nr_pages; i++)
	16	if (pfn_valid_within(pfn + i))
	17	break;
	18	if (unlikely(i == nr_pages))
	19	return NULL;
	20	return pfn_to_page(pfn + i);
	21	}
	22
	23	/*
	24	* start_isolate_page_range() -- make page-allocation-type of range of pages
	25	* to be MIGRATE_ISOLATE.
	26	* @start_pfn: The lower PFN of the range to be isolated.
	27	* @end_pfn: The upper PFN of the range to be isolated.
	28	*
	29	* Making page-allocation-type to be MIGRATE_ISOLATE means free pages in
	30	* the range will never be allocated. Any free pages and pages freed in the
	31	* future will not be allocated again.
	32	*
	33	* start_pfn/end_pfn must be aligned to pageblock_order.
	34	* Returns 0 on success and -EBUSY if any part of range cannot be isolated.
	35	*/
	36	int
	37	start_isolate_page_range(unsigned long start_pfn, unsigned long end_pfn)
	38	{
	39	unsigned long pfn;
	40	unsigned long undo_pfn;
	41	struct page *page;
	42
	43	BUG_ON((start_pfn) & (pageblock_nr_pages - 1));
	44	BUG_ON((end_pfn) & (pageblock_nr_pages - 1));
	45
	46	for (pfn = start_pfn;
	47	pfn < end_pfn;
	48	pfn += pageblock_nr_pages) {
	49	page = __first_valid_page(pfn, pageblock_nr_pages);
	50	if (page && set_migratetype_isolate(page)) {
	51	undo_pfn = pfn;
	52	goto undo;
	53	}
	54	}
	55	return 0;
	56	undo:
	57	for (pfn = start_pfn;
	58	pfn <= undo_pfn;
	59	pfn += pageblock_nr_pages)
	60	unset_migratetype_isolate(pfn_to_page(pfn));
	61
	62	return -EBUSY;
	63	}
	64
65	/*
66	* Make isolated pages available again.
67	*/
68	int
69	undo_isolate_page_range(unsigned long start_pfn, unsigned long end_pfn)
70	{
71	unsigned long pfn;
72	struct page *page;
73	BUG_ON((start_pfn) & (pageblock_nr_pages - 1));
74	BUG_ON((end_pfn) & (pageblock_nr_pages - 1));
75	for (pfn = start_pfn;
76	pfn < end_pfn;
77	pfn += pageblock_nr_pages) {
78	page = __first_valid_page(pfn, pageblock_nr_pages);
79	if (!page \|\| get_pageblock_flags(page) != MIGRATE_ISOLATE)
80	continue;
81	unset_migratetype_isolate(page);
82	}
83	return 0;
84	}
85	/*
86	* Test all pages in the range is free(means isolated) or not.
87	* all pages in [start_pfn...end_pfn) must be in the same zone.
88	* zone->lock must be held before call this.
89	*
90	* Returns 0 if all pages in the range is isolated.
91	*/
92	static int
93	__test_page_isolated_in_pageblock(unsigned long pfn, unsigned long end_pfn)
94	{
95	struct page *page;
96
97	while (pfn < end_pfn) {
98	if (!pfn_valid_within(pfn)) {
99	pfn++;
100	continue;
101	}
102	page = pfn_to_page(pfn);
103	if (PageBuddy(page))
104	pfn += 1 << page_order(page);
105	else if (page_count(page) == 0 &&
106	page_private(page) == MIGRATE_ISOLATE)
107	pfn += 1;
108	else
109	break;
110	}
111	if (pfn < end_pfn)
112	return 0;
113	return 1;
114	}
115
116	int test_pages_isolated(unsigned long start_pfn, unsigned long end_pfn)
117	{
118	unsigned long pfn;
119	struct page *page;
120
121	pfn = start_pfn;
122	/*
123	* Note: pageblock_nr_page != MAX_ORDER. Then, chunks of free page
124	* is not aligned to pageblock_nr_pages.
125	* Then we just check pagetype fist.
126	*/
127	for (pfn = start_pfn; pfn < end_pfn; pfn += pageblock_nr_pages) {
128	page = __first_valid_page(pfn, pageblock_nr_pages);
129	if (page && get_pageblock_flags(page) != MIGRATE_ISOLATE)
130	break;
131	}
132	if (pfn < end_pfn)
133	return -EBUSY;
134	/* Check all pages are free or Marked as ISOLATED */
135	if (__test_page_isolated_in_pageblock(start_pfn, end_pfn))
136	return 0;
137	return -EBUSY;
138	}