hugetlb: change free_pool_huge_page to remove_pool_huge_page

}

/*

 * helper for free_pool_huge_page() - return the previously saved

 * helper for remove_pool_huge_page() - return the previously saved

 * node ["this node"] from which to free a huge page.  Advance the

 * next node id whether or not we find a free huge page to free so

 * that the next attempt to free addresses the next node.

	}

}

static void update_and_free_pages_bulk(struct hstate *h, struct list_head *list)

{

	struct page *page, *t_page;

	list_for_each_entry_safe(page, t_page, list, lru) {

		update_and_free_page(h, page);

		cond_resched();

	}

}

struct hstate *size_to_hstate(unsigned long size)

{

	struct hstate *h;

}

/*

 * Free huge page from pool from next node to free.

 * Attempt to keep persistent huge pages more or less

 * balanced over allowed nodes.

 * Remove huge page from pool from next node to free.  Attempt to keep

 * persistent huge pages more or less balanced over allowed nodes.

 * This routine only 'removes' the hugetlb page.  The caller must make

 * an additional call to free the page to low level allocators.

 * Called with hugetlb_lock locked.

 */

static int free_pool_huge_page(struct hstate *h, nodemask_t *nodes_allowed,

static struct page *remove_pool_huge_page(struct hstate *h,

						nodemask_t *nodes_allowed,

						 bool acct_surplus)

{

	int nr_nodes, node;

	int ret = 0;

	struct page *page = NULL;

	for_each_node_mask_to_free(h, nr_nodes, node, nodes_allowed) {

		/*

		 */

		if ((!acct_surplus || h->surplus_huge_pages_node[node]) &&

		    !list_empty(&h->hugepage_freelists[node])) {

			struct page *page =

				list_entry(h->hugepage_freelists[node].next,

			page = list_entry(h->hugepage_freelists[node].next,

					  struct page, lru);

			remove_hugetlb_page(h, page, acct_surplus);

			/*

			 * unlock/lock around update_and_free_page is temporary

			 * and will be removed with subsequent patch.

			 */

			spin_unlock(&hugetlb_lock);

			update_and_free_page(h, page);

			spin_lock(&hugetlb_lock);

			ret = 1;

			break;

		}

	}

	return ret;

	return page;

}

/*

 *    to the associated reservation map.

 * 2) Free any unused surplus pages that may have been allocated to satisfy

 *    the reservation.  As many as unused_resv_pages may be freed.

 *

 * Called with hugetlb_lock held.  However, the lock could be dropped (and

 * reacquired) during calls to cond_resched_lock.  Whenever dropping the lock,

 * we must make sure nobody else can claim pages we are in the process of

 * freeing.  Do this by ensuring resv_huge_page always is greater than the

 * number of huge pages we plan to free when dropping the lock.

 */

static void return_unused_surplus_pages(struct hstate *h,

					unsigned long unused_resv_pages)

{

	unsigned long nr_pages;

	struct page *page;

	LIST_HEAD(page_list);

	/* Uncommit the reservation */

	h->resv_huge_pages -= unused_resv_pages;

	/* Cannot return gigantic pages currently */

	if (hstate_is_gigantic(h))

	 * evenly across all nodes with memory. Iterate across these nodes

	 * until we can no longer free unreserved surplus pages. This occurs

	 * when the nodes with surplus pages have no free pages.

	 * free_pool_huge_page() will balance the freed pages across the

	 * remove_pool_huge_page() will balance the freed pages across the

	 * on-line nodes with memory and will handle the hstate accounting.

	 *

	 * Note that we decrement resv_huge_pages as we free the pages.  If

	 * we drop the lock, resv_huge_pages will still be sufficiently large

	 * to cover subsequent pages we may free.

	 */

	while (nr_pages--) {

		h->resv_huge_pages--;

		unused_resv_pages--;

		if (!free_pool_huge_page(h, &node_states[N_MEMORY], 1))

		page = remove_pool_huge_page(h, &node_states[N_MEMORY], 1);

		if (!page)

			goto out;

		cond_resched_lock(&hugetlb_lock);

		list_add(&page->lru, &page_list);

	}

out:

	/* Fully uncommit the reservation */

	h->resv_huge_pages -= unused_resv_pages;

	spin_unlock(&hugetlb_lock);

	update_and_free_pages_bulk(h, &page_list);

	spin_lock(&hugetlb_lock);

}

						nodemask_t *nodes_allowed)

{

	int i;

	struct page *page, *next;

	LIST_HEAD(page_list);

	if (hstate_is_gigantic(h))

	 * Collect pages to be freed on a list, and free after dropping lock

	 */

	for_each_node_mask(i, *nodes_allowed) {

		struct page *page, *next;

		struct list_head *freel = &h->hugepage_freelists[i];

		list_for_each_entry_safe(page, next, freel, lru) {

			if (count >= h->nr_huge_pages)

out:

	spin_unlock(&hugetlb_lock);

	list_for_each_entry_safe(page, next, &page_list, lru) {

		update_and_free_page(h, page);

		cond_resched();

	}

	update_and_free_pages_bulk(h, &page_list);

	spin_lock(&hugetlb_lock);

}

#else

			      nodemask_t *nodes_allowed)

{

	unsigned long min_count, ret;

	struct page *page;

	LIST_HEAD(page_list);

	NODEMASK_ALLOC(nodemask_t, node_alloc_noretry, GFP_KERNEL);

	/*

	min_count = h->resv_huge_pages + h->nr_huge_pages - h->free_huge_pages;

	min_count = max(count, min_count);

	try_to_free_low(h, min_count, nodes_allowed);

	/*

	 * Collect pages to be removed on list without dropping lock

	 */

	while (min_count < persistent_huge_pages(h)) {

		if (!free_pool_huge_page(h, nodes_allowed, 0))

		page = remove_pool_huge_page(h, nodes_allowed, 0);

		if (!page)

			break;

		cond_resched_lock(&hugetlb_lock);

		list_add(&page->lru, &page_list);

	}

	/* free the pages after dropping lock */

	spin_unlock(&hugetlb_lock);

	update_and_free_pages_bulk(h, &page_list);

	spin_lock(&hugetlb_lock);

	while (count < persistent_huge_pages(h)) {

		if (!adjust_pool_surplus(h, nodes_allowed, 1))

			break;