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