ion_page_pool.c revision 38c003b113ceab37f80d020999d3ec2cbf784da3 
1/*
2 * drivers/staging/android/ion/ion_mem_pool.c
3 *
4 * Copyright (C) 2011 Google, Inc.
5 *
6 * This software is licensed under the terms of the GNU General Public
7 * License version 2, as published by the Free Software Foundation, and
8 * may be copied, distributed, and modified under those terms.
9 *
10 * This program is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13 * GNU General Public License for more details.
14 *
15 */
16
17#include <linux/debugfs.h>
18#include <linux/dma-mapping.h>
19#include <linux/err.h>
20#include <linux/fs.h>
21#include <linux/list.h>
22#include <linux/module.h>
23#include <linux/slab.h>
24#include "ion_priv.h"
25
26static void *ion_page_pool_alloc_pages(struct ion_page_pool *pool)
27{
28	struct page *page = alloc_pages(pool->gfp_mask, pool->order);
29
30	if (!page)
31		return NULL;
32	ion_pages_sync_for_device(NULL, page, PAGE_SIZE << pool->order,
33						DMA_BIDIRECTIONAL);
34	return page;
35}
36
37static void ion_page_pool_free_pages(struct ion_page_pool *pool,
38				     struct page *page)
39{
40	__free_pages(page, pool->order);
41}
42
43static int ion_page_pool_add(struct ion_page_pool *pool, struct page *page)
44{
45	mutex_lock(&pool->mutex);
46	if (PageHighMem(page)) {
47		list_add_tail(&page->lru, &pool->high_items);
48		pool->high_count++;
49	} else {
50		list_add_tail(&page->lru, &pool->low_items);
51		pool->low_count++;
52	}
53	mutex_unlock(&pool->mutex);
54	return 0;
55}
56
57static struct page *ion_page_pool_remove(struct ion_page_pool *pool, bool high)
58{
59	struct page *page;
60
61	if (high) {
62		BUG_ON(!pool->high_count);
63		page = list_first_entry(&pool->high_items, struct page, lru);
64		pool->high_count--;
65	} else {
66		BUG_ON(!pool->low_count);
67		page = list_first_entry(&pool->low_items, struct page, lru);
68		pool->low_count--;
69	}
70
71	list_del(&page->lru);
72	return page;
73}
74
75struct page *ion_page_pool_alloc(struct ion_page_pool *pool)
76{
77	struct page *page = NULL;
78
79	BUG_ON(!pool);
80
81	mutex_lock(&pool->mutex);
82	if (pool->high_count)
83		page = ion_page_pool_remove(pool, true);
84	else if (pool->low_count)
85		page = ion_page_pool_remove(pool, false);
86	mutex_unlock(&pool->mutex);
87
88	if (!page)
89		page = ion_page_pool_alloc_pages(pool);
90
91	return page;
92}
93
94void ion_page_pool_free(struct ion_page_pool *pool, struct page *page)
95{
96	int ret;
97
98	ret = ion_page_pool_add(pool, page);
99	if (ret)
100		ion_page_pool_free_pages(pool, page);
101}
102
103static int ion_page_pool_total(struct ion_page_pool *pool, bool high)
104{
105	int count = pool->low_count;
106
107	if (high)
108		count += pool->high_count;
109
110	return count << pool->order;
111}
112
113int ion_page_pool_shrink(struct ion_page_pool *pool, gfp_t gfp_mask,
114				int nr_to_scan)
115{
116	int freed;
117	bool high;
118
119	high = !!(gfp_mask & __GFP_HIGHMEM);
120
121	if (nr_to_scan == 0)
122		return ion_page_pool_total(pool, high);
123
124	for (freed = 0; freed < nr_to_scan; freed++) {
125		struct page *page;
126
127		mutex_lock(&pool->mutex);
128		if (pool->low_count) {
129			page = ion_page_pool_remove(pool, false);
130		} else if (high && pool->high_count) {
131			page = ion_page_pool_remove(pool, true);
132		} else {
133			mutex_unlock(&pool->mutex);
134			break;
135		}
136		mutex_unlock(&pool->mutex);
137		ion_page_pool_free_pages(pool, page);
138	}
139
140	return freed;
141}
142
143struct ion_page_pool *ion_page_pool_create(gfp_t gfp_mask, unsigned int order)
144{
145	struct ion_page_pool *pool = kmalloc(sizeof(struct ion_page_pool),
146					     GFP_KERNEL);
147	if (!pool)
148		return NULL;
149	pool->high_count = 0;
150	pool->low_count = 0;
151	INIT_LIST_HEAD(&pool->low_items);
152	INIT_LIST_HEAD(&pool->high_items);
153	pool->gfp_mask = gfp_mask;
154	pool->order = order;
155	mutex_init(&pool->mutex);
156	plist_node_init(&pool->list, order);
157
158	return pool;
159}
160
161void ion_page_pool_destroy(struct ion_page_pool *pool)
162{
163	kfree(pool);
164}
165
166static int __init ion_page_pool_init(void)
167{
168	return 0;
169}
170
171static void __exit ion_page_pool_exit(void)
172{
173}
174
175module_init(ion_page_pool_init);
176module_exit(ion_page_pool_exit);
177