ion_system_heap.c revision 895ae8765726df407264dc661674e4e04eaf8664
1/* 2 * drivers/staging/android/ion/ion_system_heap.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 <asm/page.h> 18#include <linux/dma-mapping.h> 19#include <linux/err.h> 20#include <linux/highmem.h> 21#include <linux/mm.h> 22#include <linux/scatterlist.h> 23#include <linux/seq_file.h> 24#include <linux/slab.h> 25#include <linux/vmalloc.h> 26#include "ion.h" 27#include "ion_priv.h" 28 29static gfp_t high_order_gfp_flags = (GFP_HIGHUSER | __GFP_ZERO | __GFP_NOWARN | 30 __GFP_NORETRY) & ~__GFP_WAIT; 31static gfp_t low_order_gfp_flags = (GFP_HIGHUSER | __GFP_ZERO | __GFP_NOWARN); 32static const unsigned int orders[] = {8, 4, 0}; 33static const int num_orders = ARRAY_SIZE(orders); 34static int order_to_index(unsigned int order) 35{ 36 int i; 37 38 for (i = 0; i < num_orders; i++) 39 if (order == orders[i]) 40 return i; 41 BUG(); 42 return -1; 43} 44 45static inline unsigned int order_to_size(int order) 46{ 47 return PAGE_SIZE << order; 48} 49 50struct ion_system_heap { 51 struct ion_heap heap; 52 struct ion_page_pool *pools[0]; 53}; 54 55static struct page *alloc_buffer_page(struct ion_system_heap *heap, 56 struct ion_buffer *buffer, 57 unsigned long order) 58{ 59 bool cached = ion_buffer_cached(buffer); 60 struct ion_page_pool *pool = heap->pools[order_to_index(order)]; 61 struct page *page; 62 63 if (!cached) { 64 page = ion_page_pool_alloc(pool); 65 } else { 66 gfp_t gfp_flags = low_order_gfp_flags; 67 68 if (order > 4) 69 gfp_flags = high_order_gfp_flags; 70 page = alloc_pages(gfp_flags | __GFP_COMP, order); 71 if (!page) 72 return NULL; 73 ion_pages_sync_for_device(NULL, page, PAGE_SIZE << order, 74 DMA_BIDIRECTIONAL); 75 } 76 77 return page; 78} 79 80static void free_buffer_page(struct ion_system_heap *heap, 81 struct ion_buffer *buffer, struct page *page) 82{ 83 unsigned int order = compound_order(page); 84 bool cached = ion_buffer_cached(buffer); 85 86 if (!cached && !(buffer->private_flags & ION_PRIV_FLAG_SHRINKER_FREE)) { 87 struct ion_page_pool *pool = heap->pools[order_to_index(order)]; 88 89 ion_page_pool_free(pool, page); 90 } else { 91 __free_pages(page, order); 92 } 93} 94 95 96static struct page *alloc_largest_available(struct ion_system_heap *heap, 97 struct ion_buffer *buffer, 98 unsigned long size, 99 unsigned int max_order) 100{ 101 struct page *page; 102 int i; 103 104 for (i = 0; i < num_orders; i++) { 105 if (size < order_to_size(orders[i])) 106 continue; 107 if (max_order < orders[i]) 108 continue; 109 110 page = alloc_buffer_page(heap, buffer, orders[i]); 111 if (!page) 112 continue; 113 114 return page; 115 } 116 117 return NULL; 118} 119 120static int ion_system_heap_allocate(struct ion_heap *heap, 121 struct ion_buffer *buffer, 122 unsigned long size, unsigned long align, 123 unsigned long flags) 124{ 125 struct ion_system_heap *sys_heap = container_of(heap, 126 struct ion_system_heap, 127 heap); 128 struct sg_table *table; 129 struct scatterlist *sg; 130 struct list_head pages; 131 struct page *page, *tmp_page; 132 int i = 0; 133 unsigned long size_remaining = PAGE_ALIGN(size); 134 unsigned int max_order = orders[0]; 135 136 if (align > PAGE_SIZE) 137 return -EINVAL; 138 139 if (size / PAGE_SIZE > totalram_pages / 2) 140 return -ENOMEM; 141 142 INIT_LIST_HEAD(&pages); 143 while (size_remaining > 0) { 144 page = alloc_largest_available(sys_heap, buffer, size_remaining, 145 max_order); 146 if (!page) 147 goto free_pages; 148 list_add_tail(&page->lru, &pages); 149 size_remaining -= PAGE_SIZE << compound_order(page); 150 max_order = compound_order(page); 151 i++; 152 } 153 table = kmalloc(sizeof(struct sg_table), GFP_KERNEL); 154 if (!table) 155 goto free_pages; 156 157 if (sg_alloc_table(table, i, GFP_KERNEL)) 158 goto free_table; 159 160 sg = table->sgl; 161 list_for_each_entry_safe(page, tmp_page, &pages, lru) { 162 sg_set_page(sg, page, PAGE_SIZE << compound_order(page), 0); 163 sg = sg_next(sg); 164 list_del(&page->lru); 165 } 166 167 buffer->priv_virt = table; 168 return 0; 169 170free_table: 171 kfree(table); 172free_pages: 173 list_for_each_entry_safe(page, tmp_page, &pages, lru) 174 free_buffer_page(sys_heap, buffer, page); 175 return -ENOMEM; 176} 177 178static void ion_system_heap_free(struct ion_buffer *buffer) 179{ 180 struct ion_system_heap *sys_heap = container_of(buffer->heap, 181 struct ion_system_heap, 182 heap); 183 struct sg_table *table = buffer->sg_table; 184 bool cached = ion_buffer_cached(buffer); 185 struct scatterlist *sg; 186 int i; 187 188 /* uncached pages come from the page pools, zero them before returning 189 for security purposes (other allocations are zerod at alloc time */ 190 if (!cached && !(buffer->private_flags & ION_PRIV_FLAG_SHRINKER_FREE)) 191 ion_heap_buffer_zero(buffer); 192 193 for_each_sg(table->sgl, sg, table->nents, i) 194 free_buffer_page(sys_heap, buffer, sg_page(sg)); 195 sg_free_table(table); 196 kfree(table); 197} 198 199static struct sg_table *ion_system_heap_map_dma(struct ion_heap *heap, 200 struct ion_buffer *buffer) 201{ 202 return buffer->priv_virt; 203} 204 205static void ion_system_heap_unmap_dma(struct ion_heap *heap, 206 struct ion_buffer *buffer) 207{ 208 return; 209} 210 211static int ion_system_heap_shrink(struct ion_heap *heap, gfp_t gfp_mask, 212 int nr_to_scan) 213{ 214 struct ion_system_heap *sys_heap; 215 int nr_total = 0; 216 int i; 217 218 sys_heap = container_of(heap, struct ion_system_heap, heap); 219 220 for (i = 0; i < num_orders; i++) { 221 struct ion_page_pool *pool = sys_heap->pools[i]; 222 223 nr_total += ion_page_pool_shrink(pool, gfp_mask, nr_to_scan); 224 } 225 226 return nr_total; 227} 228 229static struct ion_heap_ops system_heap_ops = { 230 .allocate = ion_system_heap_allocate, 231 .free = ion_system_heap_free, 232 .map_dma = ion_system_heap_map_dma, 233 .unmap_dma = ion_system_heap_unmap_dma, 234 .map_kernel = ion_heap_map_kernel, 235 .unmap_kernel = ion_heap_unmap_kernel, 236 .map_user = ion_heap_map_user, 237 .shrink = ion_system_heap_shrink, 238}; 239 240static int ion_system_heap_debug_show(struct ion_heap *heap, struct seq_file *s, 241 void *unused) 242{ 243 244 struct ion_system_heap *sys_heap = container_of(heap, 245 struct ion_system_heap, 246 heap); 247 int i; 248 249 for (i = 0; i < num_orders; i++) { 250 struct ion_page_pool *pool = sys_heap->pools[i]; 251 252 seq_printf(s, "%d order %u highmem pages in pool = %lu total\n", 253 pool->high_count, pool->order, 254 (PAGE_SIZE << pool->order) * pool->high_count); 255 seq_printf(s, "%d order %u lowmem pages in pool = %lu total\n", 256 pool->low_count, pool->order, 257 (PAGE_SIZE << pool->order) * pool->low_count); 258 } 259 return 0; 260} 261 262struct ion_heap *ion_system_heap_create(struct ion_platform_heap *unused) 263{ 264 struct ion_system_heap *heap; 265 int i; 266 267 heap = kzalloc(sizeof(struct ion_system_heap) + 268 sizeof(struct ion_page_pool *) * num_orders, 269 GFP_KERNEL); 270 if (!heap) 271 return ERR_PTR(-ENOMEM); 272 heap->heap.ops = &system_heap_ops; 273 heap->heap.type = ION_HEAP_TYPE_SYSTEM; 274 heap->heap.flags = ION_HEAP_FLAG_DEFER_FREE; 275 276 for (i = 0; i < num_orders; i++) { 277 struct ion_page_pool *pool; 278 gfp_t gfp_flags = low_order_gfp_flags; 279 280 if (orders[i] > 4) 281 gfp_flags = high_order_gfp_flags; 282 pool = ion_page_pool_create(gfp_flags, orders[i]); 283 if (!pool) 284 goto destroy_pools; 285 heap->pools[i] = pool; 286 } 287 288 heap->heap.debug_show = ion_system_heap_debug_show; 289 return &heap->heap; 290 291destroy_pools: 292 while (i--) 293 ion_page_pool_destroy(heap->pools[i]); 294 kfree(heap); 295 return ERR_PTR(-ENOMEM); 296} 297 298void ion_system_heap_destroy(struct ion_heap *heap) 299{ 300 struct ion_system_heap *sys_heap = container_of(heap, 301 struct ion_system_heap, 302 heap); 303 int i; 304 305 for (i = 0; i < num_orders; i++) 306 ion_page_pool_destroy(sys_heap->pools[i]); 307 kfree(sys_heap); 308} 309 310static int ion_system_contig_heap_allocate(struct ion_heap *heap, 311 struct ion_buffer *buffer, 312 unsigned long len, 313 unsigned long align, 314 unsigned long flags) 315{ 316 int order = get_order(len); 317 struct page *page; 318 struct sg_table *table; 319 unsigned long i; 320 int ret; 321 322 if (align > (PAGE_SIZE << order)) 323 return -EINVAL; 324 325 page = alloc_pages(low_order_gfp_flags, order); 326 if (!page) 327 return -ENOMEM; 328 329 split_page(page, order); 330 331 len = PAGE_ALIGN(len); 332 for (i = len >> PAGE_SHIFT; i < (1 << order); i++) 333 __free_page(page + i); 334 335 table = kmalloc(sizeof(struct sg_table), GFP_KERNEL); 336 if (!table) { 337 ret = -ENOMEM; 338 goto free_pages; 339 } 340 341 ret = sg_alloc_table(table, 1, GFP_KERNEL); 342 if (ret) 343 goto free_table; 344 345 sg_set_page(table->sgl, page, len, 0); 346 347 buffer->priv_virt = table; 348 349 ion_pages_sync_for_device(NULL, page, len, DMA_BIDIRECTIONAL); 350 351 return 0; 352 353free_table: 354 kfree(table); 355free_pages: 356 for (i = 0; i < len >> PAGE_SHIFT; i++) 357 __free_page(page + i); 358 359 return ret; 360} 361 362static void ion_system_contig_heap_free(struct ion_buffer *buffer) 363{ 364 struct sg_table *table = buffer->priv_virt; 365 struct page *page = sg_page(table->sgl); 366 unsigned long pages = PAGE_ALIGN(buffer->size) >> PAGE_SHIFT; 367 unsigned long i; 368 369 for (i = 0; i < pages; i++) 370 __free_page(page + i); 371 sg_free_table(table); 372 kfree(table); 373} 374 375static int ion_system_contig_heap_phys(struct ion_heap *heap, 376 struct ion_buffer *buffer, 377 ion_phys_addr_t *addr, size_t *len) 378{ 379 struct sg_table *table = buffer->priv_virt; 380 struct page *page = sg_page(table->sgl); 381 *addr = page_to_phys(page); 382 *len = buffer->size; 383 return 0; 384} 385 386static struct sg_table *ion_system_contig_heap_map_dma(struct ion_heap *heap, 387 struct ion_buffer *buffer) 388{ 389 return buffer->priv_virt; 390} 391 392static void ion_system_contig_heap_unmap_dma(struct ion_heap *heap, 393 struct ion_buffer *buffer) 394{ 395} 396 397static struct ion_heap_ops kmalloc_ops = { 398 .allocate = ion_system_contig_heap_allocate, 399 .free = ion_system_contig_heap_free, 400 .phys = ion_system_contig_heap_phys, 401 .map_dma = ion_system_contig_heap_map_dma, 402 .unmap_dma = ion_system_contig_heap_unmap_dma, 403 .map_kernel = ion_heap_map_kernel, 404 .unmap_kernel = ion_heap_unmap_kernel, 405 .map_user = ion_heap_map_user, 406}; 407 408struct ion_heap *ion_system_contig_heap_create(struct ion_platform_heap *unused) 409{ 410 struct ion_heap *heap; 411 412 heap = kzalloc(sizeof(struct ion_heap), GFP_KERNEL); 413 if (!heap) 414 return ERR_PTR(-ENOMEM); 415 heap->ops = &kmalloc_ops; 416 heap->type = ION_HEAP_TYPE_SYSTEM_CONTIG; 417 return heap; 418} 419 420void ion_system_contig_heap_destroy(struct ion_heap *heap) 421{ 422 kfree(heap); 423} 424