apfs/linux-apfs
0
0
Fork 0
mirror of https://github.com/linux-apfs/linux-apfs.git synced 2026-05-01 15:00:59 -07:00
Code Issues Packages Projects Releases Wiki Activity

drm: Remove memory debugging infrastructure.

Browse Source 
It hasn't been used in ages, and having the user tell your how much
memory is being freed at free time is a recipe for disaster even if it
was ever used.

Signed-off-by: Eric Anholt <eric@anholt.net>
This commit is contained in:
Eric Anholt
2009-03-24 12:23:04 -07:00
parent 52dc7d32b8
commit 9a298b2acd
41 changed files with 324 additions and 884 deletions
Download Patch File Download Diff File Expand all files Collapse all files
drivers/gpu/drm/drm_agpsupport.c
+6 -6
View File
@@ -203,7 +203,7 @@ int drm_agp_alloc(struct drm_device *dev, struct drm_agp_buffer *request)
if (!dev->agp || !dev->agp->acquired) if (!dev->agp || !dev->agp->acquired)
return -EINVAL; return -EINVAL;
if (!(entry = drm_alloc(sizeof(*entry), DRM_MEM_AGPLISTS))) if (!(entry = kmalloc(sizeof(*entry), GFP_KERNEL)))
return -ENOMEM; return -ENOMEM;
memset(entry, 0, sizeof(*entry)); memset(entry, 0, sizeof(*entry));
@@ -211,7 +211,7 @@ int drm_agp_alloc(struct drm_device *dev, struct drm_agp_buffer *request)
pages = (request->size + PAGE_SIZE - 1) / PAGE_SIZE; pages = (request->size + PAGE_SIZE - 1) / PAGE_SIZE;
type = (u32) request->type; type = (u32) request->type;
if (!(memory = drm_alloc_agp(dev, pages, type))) { if (!(memory = drm_alloc_agp(dev, pages, type))) {
drm_free(entry, sizeof(*entry), DRM_MEM_AGPLISTS); kfree(entry);
return -ENOMEM; return -ENOMEM;
} }
@@ -369,7 +369,7 @@ int drm_agp_free(struct drm_device *dev, struct drm_agp_buffer *request)
list_del(&entry->head); list_del(&entry->head);
drm_free_agp(entry->memory, entry->pages); drm_free_agp(entry->memory, entry->pages);
drm_free(entry, sizeof(*entry), DRM_MEM_AGPLISTS); kfree(entry);
return 0; return 0;
} }
EXPORT_SYMBOL(drm_agp_free); EXPORT_SYMBOL(drm_agp_free);
@@ -397,13 +397,13 @@ struct drm_agp_head *drm_agp_init(struct drm_device *dev)
{ {
struct drm_agp_head *head = NULL; struct drm_agp_head *head = NULL;
if (!(head = drm_alloc(sizeof(*head), DRM_MEM_AGPLISTS))) if (!(head = kmalloc(sizeof(*head), GFP_KERNEL)))
return NULL; return NULL;
memset((void *)head, 0, sizeof(*head)); memset((void *)head, 0, sizeof(*head));
head->bridge = agp_find_bridge(dev->pdev); head->bridge = agp_find_bridge(dev->pdev);
if (!head->bridge) { if (!head->bridge) {
if (!(head->bridge = agp_backend_acquire(dev->pdev))) { if (!(head->bridge = agp_backend_acquire(dev->pdev))) {
drm_free(head, sizeof(*head), DRM_MEM_AGPLISTS); kfree(head);
return NULL; return NULL;
} }
agp_copy_info(head->bridge, &head->agp_info); agp_copy_info(head->bridge, &head->agp_info);
@@ -412,7 +412,7 @@ struct drm_agp_head *drm_agp_init(struct drm_device *dev)
agp_copy_info(head->bridge, &head->agp_info); agp_copy_info(head->bridge, &head->agp_info);
} }
if (head->agp_info.chipset == NOT_SUPPORTED) { if (head->agp_info.chipset == NOT_SUPPORTED) {
drm_free(head, sizeof(*head), DRM_MEM_AGPLISTS); kfree(head);
return NULL; return NULL;
} }
INIT_LIST_HEAD(&head->memory); INIT_LIST_HEAD(&head->memory);
drivers/gpu/drm/drm_auth.c
+2 -2
View File
@@ -79,7 +79,7 @@ static int drm_add_magic(struct drm_master *master, struct drm_file *priv,
struct drm_device *dev = master->minor->dev; struct drm_device *dev = master->minor->dev;
DRM_DEBUG("%d\n", magic); DRM_DEBUG("%d\n", magic);
entry = drm_alloc(sizeof(*entry), DRM_MEM_MAGIC); entry = kmalloc(sizeof(*entry), GFP_KERNEL);
if (!entry) if (!entry)
return -ENOMEM; return -ENOMEM;
memset(entry, 0, sizeof(*entry)); memset(entry, 0, sizeof(*entry));
@@ -120,7 +120,7 @@ static int drm_remove_magic(struct drm_master *master, drm_magic_t magic)
list_del(&pt->head); list_del(&pt->head);
mutex_unlock(&dev->struct_mutex); mutex_unlock(&dev->struct_mutex);
drm_free(pt, sizeof(*pt), DRM_MEM_MAGIC); kfree(pt);
return 0; return 0;
} }
drivers/gpu/drm/drm_bufs.c
+56 -84
View File
@@ -151,7 +151,7 @@ static int drm_addmap_core(struct drm_device * dev, resource_size_t offset,
unsigned long user_token; unsigned long user_token;
int ret; int ret;
map = drm_alloc(sizeof(*map), DRM_MEM_MAPS); map = kmalloc(sizeof(*map), GFP_KERNEL);
if (!map) if (!map)
return -ENOMEM; return -ENOMEM;
@@ -165,7 +165,7 @@ static int drm_addmap_core(struct drm_device * dev, resource_size_t offset,
* when processes fork. * when processes fork.
*/ */
if ((map->flags & _DRM_REMOVABLE) && map->type != _DRM_SHM) { if ((map->flags & _DRM_REMOVABLE) && map->type != _DRM_SHM) {
drm_free(map, sizeof(*map), DRM_MEM_MAPS); kfree(map);
return -EINVAL; return -EINVAL;
} }
DRM_DEBUG("offset = 0x%08llx, size = 0x%08lx, type = %d\n", DRM_DEBUG("offset = 0x%08llx, size = 0x%08lx, type = %d\n",
@@ -179,7 +179,7 @@ static int drm_addmap_core(struct drm_device * dev, resource_size_t offset,
map->size = PAGE_ALIGN(map->size); map->size = PAGE_ALIGN(map->size);
if ((map->offset & (~(resource_size_t)PAGE_MASK)) || (map->size & (~PAGE_MASK))) { if ((map->offset & (~(resource_size_t)PAGE_MASK)) || (map->size & (~PAGE_MASK))) {
drm_free(map, sizeof(*map), DRM_MEM_MAPS); kfree(map);
return -EINVAL; return -EINVAL;
} }
map->mtrr = -1; map->mtrr = -1;
@@ -191,7 +191,7 @@ static int drm_addmap_core(struct drm_device * dev, resource_size_t offset,
#if !defined(__sparc__) && !defined(__alpha__) && !defined(__ia64__) && !defined(__powerpc64__) && !defined(__x86_64__) #if !defined(__sparc__) && !defined(__alpha__) && !defined(__ia64__) && !defined(__powerpc64__) && !defined(__x86_64__)
if (map->offset + (map->size-1) < map->offset || if (map->offset + (map->size-1) < map->offset ||
map->offset < virt_to_phys(high_memory)) { map->offset < virt_to_phys(high_memory)) {
drm_free(map, sizeof(*map), DRM_MEM_MAPS); kfree(map);
return -EINVAL; return -EINVAL;
} }
#endif #endif
@@ -212,7 +212,7 @@ static int drm_addmap_core(struct drm_device * dev, resource_size_t offset,
list->map->size = map->size; list->map->size = map->size;
} }
drm_free(map, sizeof(*map), DRM_MEM_MAPS); kfree(map);
*maplist = list; *maplist = list;
return 0; return 0;
} }
@@ -227,7 +227,7 @@ static int drm_addmap_core(struct drm_device * dev, resource_size_t offset,
if (map->type == _DRM_REGISTERS) { if (map->type == _DRM_REGISTERS) {
map->handle = ioremap(map->offset, map->size); map->handle = ioremap(map->offset, map->size);
if (!map->handle) { if (!map->handle) {
drm_free(map, sizeof(*map), DRM_MEM_MAPS); kfree(map);
return -ENOMEM; return -ENOMEM;
} }
} }
@@ -243,7 +243,7 @@ static int drm_addmap_core(struct drm_device * dev, resource_size_t offset,
list->map->size = map->size; list->map->size = map->size;
} }
drm_free(map, sizeof(*map), DRM_MEM_MAPS); kfree(map);
*maplist = list; *maplist = list;
return 0; return 0;
} }
@@ -251,7 +251,7 @@ static int drm_addmap_core(struct drm_device * dev, resource_size_t offset,
DRM_DEBUG("%lu %d %p\n", DRM_DEBUG("%lu %d %p\n",
map->size, drm_order(map->size), map->handle); map->size, drm_order(map->size), map->handle);
if (!map->handle) { if (!map->handle) {
drm_free(map, sizeof(*map), DRM_MEM_MAPS); kfree(map);
return -ENOMEM; return -ENOMEM;
} }
map->offset = (unsigned long)map->handle; map->offset = (unsigned long)map->handle;
@@ -259,7 +259,7 @@ static int drm_addmap_core(struct drm_device * dev, resource_size_t offset,
/* Prevent a 2nd X Server from creating a 2nd lock */ /* Prevent a 2nd X Server from creating a 2nd lock */
if (dev->primary->master->lock.hw_lock != NULL) { if (dev->primary->master->lock.hw_lock != NULL) {
vfree(map->handle); vfree(map->handle);
drm_free(map, sizeof(*map), DRM_MEM_MAPS); kfree(map);
return -EBUSY; return -EBUSY;
} }
dev->sigdata.lock = dev->primary->master->lock.hw_lock = map->handle; /* Pointer to lock */ dev->sigdata.lock = dev->primary->master->lock.hw_lock = map->handle; /* Pointer to lock */
@@ -270,7 +270,7 @@ static int drm_addmap_core(struct drm_device * dev, resource_size_t offset,
int valid = 0; int valid = 0;
if (!drm_core_has_AGP(dev)) { if (!drm_core_has_AGP(dev)) {
drm_free(map, sizeof(*map), DRM_MEM_MAPS); kfree(map);
return -EINVAL; return -EINVAL;
} }
#ifdef __alpha__ #ifdef __alpha__
@@ -303,7 +303,7 @@ static int drm_addmap_core(struct drm_device * dev, resource_size_t offset,
} }
} }
if (!list_empty(&dev->agp->memory) && !valid) { if (!list_empty(&dev->agp->memory) && !valid) {
drm_free(map, sizeof(*map), DRM_MEM_MAPS); kfree(map);
return -EPERM; return -EPERM;
} }
DRM_DEBUG("AGP offset = 0x%08llx, size = 0x%08lx\n", DRM_DEBUG("AGP offset = 0x%08llx, size = 0x%08lx\n",
@@ -316,7 +316,7 @@ static int drm_addmap_core(struct drm_device * dev, resource_size_t offset,
} }
case _DRM_SCATTER_GATHER: case _DRM_SCATTER_GATHER:
if (!dev->sg) { if (!dev->sg) {
drm_free(map, sizeof(*map), DRM_MEM_MAPS); kfree(map);
return -EINVAL; return -EINVAL;
} }
map->offset += (unsigned long)dev->sg->virtual; map->offset += (unsigned long)dev->sg->virtual;
@@ -328,7 +328,7 @@ static int drm_addmap_core(struct drm_device * dev, resource_size_t offset,
* need to point to a 64bit variable first. */ * need to point to a 64bit variable first. */
dmah = drm_pci_alloc(dev, map->size, map->size, 0xffffffffUL); dmah = drm_pci_alloc(dev, map->size, map->size, 0xffffffffUL);
if (!dmah) { if (!dmah) {
drm_free(map, sizeof(*map), DRM_MEM_MAPS); kfree(map);
return -ENOMEM; return -ENOMEM;
} }
map->handle = dmah->vaddr; map->handle = dmah->vaddr;
@@ -336,15 +336,15 @@ static int drm_addmap_core(struct drm_device * dev, resource_size_t offset,
kfree(dmah); kfree(dmah);
break; break;
default: default:
drm_free(map, sizeof(*map), DRM_MEM_MAPS); kfree(map);
return -EINVAL; return -EINVAL;
} }
list = drm_alloc(sizeof(*list), DRM_MEM_MAPS); list = kmalloc(sizeof(*list), GFP_KERNEL);
if (!list) { if (!list) {
if (map->type == _DRM_REGISTERS) if (map->type == _DRM_REGISTERS)
iounmap(map->handle); iounmap(map->handle);
drm_free(map, sizeof(*map), DRM_MEM_MAPS); kfree(map);
return -EINVAL; return -EINVAL;
} }
memset(list, 0, sizeof(*list)); memset(list, 0, sizeof(*list));
@@ -362,8 +362,8 @@ static int drm_addmap_core(struct drm_device * dev, resource_size_t offset,
if (ret) { if (ret) {
if (map->type == _DRM_REGISTERS) if (map->type == _DRM_REGISTERS)
iounmap(map->handle); iounmap(map->handle);
drm_free(map, sizeof(*map), DRM_MEM_MAPS); kfree(map);
drm_free(list, sizeof(*list), DRM_MEM_MAPS); kfree(list);
mutex_unlock(&dev->struct_mutex); mutex_unlock(&dev->struct_mutex);
return ret; return ret;
} }
@@ -448,7 +448,7 @@ int drm_rmmap_locked(struct drm_device *dev, struct drm_local_map *map)
list_del(&r_list->head); list_del(&r_list->head);
drm_ht_remove_key(&dev->map_hash, drm_ht_remove_key(&dev->map_hash,
r_list->user_token >> PAGE_SHIFT); r_list->user_token >> PAGE_SHIFT);
drm_free(r_list, sizeof(*r_list), DRM_MEM_MAPS); kfree(r_list);
found = 1; found = 1;
break; break;
} }
@@ -491,7 +491,7 @@ int drm_rmmap_locked(struct drm_device *dev, struct drm_local_map *map)
DRM_ERROR("tried to rmmap GEM object\n"); DRM_ERROR("tried to rmmap GEM object\n");
break; break;
} }
drm_free(map, sizeof(*map), DRM_MEM_MAPS); kfree(map);
return 0; return 0;
} }
@@ -582,24 +582,16 @@ static void drm_cleanup_buf_error(struct drm_device * dev,
drm_pci_free(dev, entry->seglist[i]); drm_pci_free(dev, entry->seglist[i]);
} }
} }
drm_free(entry->seglist, kfree(entry->seglist);
entry->seg_count *
sizeof(*entry->seglist), DRM_MEM_SEGS);
entry->seg_count = 0; entry->seg_count = 0;
} }
if (entry->buf_count) { if (entry->buf_count) {
for (i = 0; i < entry->buf_count; i++) { for (i = 0; i < entry->buf_count; i++) {
if (entry->buflist[i].dev_private) { kfree(entry->buflist[i].dev_private);
drm_free(entry->buflist[i].dev_private,
entry->buflist[i].dev_priv_size,
DRM_MEM_BUFS);
} }
} kfree(entry->buflist);
drm_free(entry->buflist,
entry->buf_count *
sizeof(*entry->buflist), DRM_MEM_BUFS);
entry->buf_count = 0; entry->buf_count = 0;
} }
@@ -698,8 +690,7 @@ int drm_addbufs_agp(struct drm_device * dev, struct drm_buf_desc * request)
return -EINVAL; return -EINVAL;
} }
entry->buflist = drm_alloc(count * sizeof(*entry->buflist), entry->buflist = kmalloc(count * sizeof(*entry->buflist), GFP_KERNEL);
DRM_MEM_BUFS);
if (!entry->buflist) { if (!entry->buflist) {
mutex_unlock(&dev->struct_mutex); mutex_unlock(&dev->struct_mutex);
atomic_dec(&dev->buf_alloc); atomic_dec(&dev->buf_alloc);
@@ -729,7 +720,7 @@ int drm_addbufs_agp(struct drm_device * dev, struct drm_buf_desc * request)
buf->file_priv = NULL; buf->file_priv = NULL;
buf->dev_priv_size = dev->driver->dev_priv_size; buf->dev_priv_size = dev->driver->dev_priv_size;
buf->dev_private = drm_alloc(buf->dev_priv_size, DRM_MEM_BUFS); buf->dev_private = kmalloc(buf->dev_priv_size, GFP_KERNEL);
if (!buf->dev_private) { if (!buf->dev_private) {
/* Set count correctly so we free the proper amount. */ /* Set count correctly so we free the proper amount. */
entry->buf_count = count; entry->buf_count = count;
@@ -749,10 +740,9 @@ int drm_addbufs_agp(struct drm_device * dev, struct drm_buf_desc * request)
DRM_DEBUG("byte_count: %d\n", byte_count); DRM_DEBUG("byte_count: %d\n", byte_count);
temp_buflist = drm_realloc(dma->buflist, temp_buflist = krealloc(dma->buflist,
dma->buf_count * sizeof(*dma->buflist), (dma->buf_count + entry->buf_count) *
(dma->buf_count + entry->buf_count) sizeof(*dma->buflist), GFP_KERNEL);
* sizeof(*dma->buflist), DRM_MEM_BUFS);
if (!temp_buflist) { if (!temp_buflist) {
/* Free the entry because it isn't valid */ /* Free the entry because it isn't valid */
drm_cleanup_buf_error(dev, entry); drm_cleanup_buf_error(dev, entry);
@@ -854,8 +844,7 @@ int drm_addbufs_pci(struct drm_device * dev, struct drm_buf_desc * request)
return -EINVAL; return -EINVAL;
} }
entry->buflist = drm_alloc(count * sizeof(*entry->buflist), entry->buflist = kmalloc(count * sizeof(*entry->buflist), GFP_KERNEL);
DRM_MEM_BUFS);
if (!entry->buflist) { if (!entry->buflist) {
mutex_unlock(&dev->struct_mutex); mutex_unlock(&dev->struct_mutex);
atomic_dec(&dev->buf_alloc); atomic_dec(&dev->buf_alloc);
@@ -863,11 +852,9 @@ int drm_addbufs_pci(struct drm_device * dev, struct drm_buf_desc * request)
} }
memset(entry->buflist, 0, count * sizeof(*entry->buflist)); memset(entry->buflist, 0, count * sizeof(*entry->buflist));
entry->seglist = drm_alloc(count * sizeof(*entry->seglist), entry->seglist = kmalloc(count * sizeof(*entry->seglist), GFP_KERNEL);
DRM_MEM_SEGS);
if (!entry->seglist) { if (!entry->seglist) {
drm_free(entry->buflist, kfree(entry->buflist);
count * sizeof(*entry->buflist), DRM_MEM_BUFS);
mutex_unlock(&dev->struct_mutex); mutex_unlock(&dev->struct_mutex);
atomic_dec(&dev->buf_alloc); atomic_dec(&dev->buf_alloc);
return -ENOMEM; return -ENOMEM;
@@ -877,13 +864,11 @@ int drm_addbufs_pci(struct drm_device * dev, struct drm_buf_desc * request)
/* Keep the original pagelist until we know all the allocations /* Keep the original pagelist until we know all the allocations
* have succeeded * have succeeded
*/ */
temp_pagelist = drm_alloc((dma->page_count + (count << page_order)) temp_pagelist = kmalloc((dma->page_count + (count << page_order)) *
* sizeof(*dma->pagelist), DRM_MEM_PAGES); sizeof(*dma->pagelist), GFP_KERNEL);
if (!temp_pagelist) { if (!temp_pagelist) {
drm_free(entry->buflist, kfree(entry->buflist);
count * sizeof(*entry->buflist), DRM_MEM_BUFS); kfree(entry->seglist);
drm_free(entry->seglist,
count * sizeof(*entry->seglist), DRM_MEM_SEGS);
mutex_unlock(&dev->struct_mutex); mutex_unlock(&dev->struct_mutex);
atomic_dec(&dev->buf_alloc); atomic_dec(&dev->buf_alloc);
return -ENOMEM; return -ENOMEM;
@@ -907,9 +892,7 @@ int drm_addbufs_pci(struct drm_device * dev, struct drm_buf_desc * request)
entry->buf_count = count; entry->buf_count = count;
entry->seg_count = count; entry->seg_count = count;
drm_cleanup_buf_error(dev, entry); drm_cleanup_buf_error(dev, entry);
drm_free(temp_pagelist, kfree(temp_pagelist);
(dma->page_count + (count << page_order))
* sizeof(*dma->pagelist), DRM_MEM_PAGES);
mutex_unlock(&dev->struct_mutex); mutex_unlock(&dev->struct_mutex);
atomic_dec(&dev->buf_alloc); atomic_dec(&dev->buf_alloc);
return -ENOMEM; return -ENOMEM;
@@ -940,18 +923,14 @@ int drm_addbufs_pci(struct drm_device * dev, struct drm_buf_desc * request)
buf->file_priv = NULL; buf->file_priv = NULL;
buf->dev_priv_size = dev->driver->dev_priv_size; buf->dev_priv_size = dev->driver->dev_priv_size;
buf->dev_private = drm_alloc(buf->dev_priv_size, buf->dev_private = kmalloc(buf->dev_priv_size,
DRM_MEM_BUFS); GFP_KERNEL);
if (!buf->dev_private) { if (!buf->dev_private) {
/* Set count correctly so we free the proper amount. */ /* Set count correctly so we free the proper amount. */
entry->buf_count = count; entry->buf_count = count;
entry->seg_count = count; entry->seg_count = count;
drm_cleanup_buf_error(dev, entry); drm_cleanup_buf_error(dev, entry);
drm_free(temp_pagelist, kfree(temp_pagelist);
(dma->page_count +
(count << page_order))
* sizeof(*dma->pagelist),
DRM_MEM_PAGES);
mutex_unlock(&dev->struct_mutex); mutex_unlock(&dev->struct_mutex);
atomic_dec(&dev->buf_alloc); atomic_dec(&dev->buf_alloc);
return -ENOMEM; return -ENOMEM;
@@ -964,16 +943,13 @@ int drm_addbufs_pci(struct drm_device * dev, struct drm_buf_desc * request)
byte_count += PAGE_SIZE << page_order; byte_count += PAGE_SIZE << page_order;
} }
temp_buflist = drm_realloc(dma->buflist, temp_buflist = krealloc(dma->buflist,
dma->buf_count * sizeof(*dma->buflist), (dma->buf_count + entry->buf_count) *
(dma->buf_count + entry->buf_count) sizeof(*dma->buflist), GFP_KERNEL);
* sizeof(*dma->buflist), DRM_MEM_BUFS);
if (!temp_buflist) { if (!temp_buflist) {
/* Free the entry because it isn't valid */ /* Free the entry because it isn't valid */
drm_cleanup_buf_error(dev, entry); drm_cleanup_buf_error(dev, entry);
drm_free(temp_pagelist, kfree(temp_pagelist);
(dma->page_count + (count << page_order))
* sizeof(*dma->pagelist), DRM_MEM_PAGES);
mutex_unlock(&dev->struct_mutex); mutex_unlock(&dev->struct_mutex);
atomic_dec(&dev->buf_alloc); atomic_dec(&dev->buf_alloc);
return -ENOMEM; return -ENOMEM;
@@ -988,9 +964,7 @@ int drm_addbufs_pci(struct drm_device * dev, struct drm_buf_desc * request)
* with the new one. * with the new one.
*/ */
if (dma->page_count) { if (dma->page_count) {
drm_free(dma->pagelist, kfree(dma->pagelist);
dma->page_count * sizeof(*dma->pagelist),
DRM_MEM_PAGES);
} }
dma->pagelist = temp_pagelist; dma->pagelist = temp_pagelist;
@@ -1086,8 +1060,8 @@ static int drm_addbufs_sg(struct drm_device * dev, struct drm_buf_desc * request
return -EINVAL; return -EINVAL;
} }
entry->buflist = drm_alloc(count * sizeof(*entry->buflist), entry->buflist = kmalloc(count * sizeof(*entry->buflist),
DRM_MEM_BUFS); GFP_KERNEL);
if (!entry->buflist) { if (!entry->buflist) {
mutex_unlock(&dev->struct_mutex); mutex_unlock(&dev->struct_mutex);
atomic_dec(&dev->buf_alloc); atomic_dec(&dev->buf_alloc);
@@ -1118,7 +1092,7 @@ static int drm_addbufs_sg(struct drm_device * dev, struct drm_buf_desc * request
buf->file_priv = NULL; buf->file_priv = NULL;
buf->dev_priv_size = dev->driver->dev_priv_size; buf->dev_priv_size = dev->driver->dev_priv_size;
buf->dev_private = drm_alloc(buf->dev_priv_size, DRM_MEM_BUFS); buf->dev_private = kmalloc(buf->dev_priv_size, GFP_KERNEL);
if (!buf->dev_private) { if (!buf->dev_private) {
/* Set count correctly so we free the proper amount. */ /* Set count correctly so we free the proper amount. */
entry->buf_count = count; entry->buf_count = count;
@@ -1139,10 +1113,9 @@ static int drm_addbufs_sg(struct drm_device * dev, struct drm_buf_desc * request
DRM_DEBUG("byte_count: %d\n", byte_count); DRM_DEBUG("byte_count: %d\n", byte_count);
temp_buflist = drm_realloc(dma->buflist, temp_buflist = krealloc(dma->buflist,
dma->buf_count * sizeof(*dma->buflist), (dma->buf_count + entry->buf_count) *
(dma->buf_count + entry->buf_count) sizeof(*dma->buflist), GFP_KERNEL);
* sizeof(*dma->buflist), DRM_MEM_BUFS);
if (!temp_buflist) { if (!temp_buflist) {
/* Free the entry because it isn't valid */ /* Free the entry because it isn't valid */
drm_cleanup_buf_error(dev, entry); drm_cleanup_buf_error(dev, entry);
@@ -1248,8 +1221,8 @@ static int drm_addbufs_fb(struct drm_device * dev, struct drm_buf_desc * request
return -EINVAL; return -EINVAL;
} }
entry->buflist = drm_alloc(count * sizeof(*entry->buflist), entry->buflist = kmalloc(count * sizeof(*entry->buflist),
DRM_MEM_BUFS); GFP_KERNEL);
if (!entry->buflist) { if (!entry->buflist) {
mutex_unlock(&dev->struct_mutex); mutex_unlock(&dev->struct_mutex);
atomic_dec(&dev->buf_alloc); atomic_dec(&dev->buf_alloc);
@@ -1279,7 +1252,7 @@ static int drm_addbufs_fb(struct drm_device * dev, struct drm_buf_desc * request
buf->file_priv = NULL; buf->file_priv = NULL;
buf->dev_priv_size = dev->driver->dev_priv_size; buf->dev_priv_size = dev->driver->dev_priv_size;
buf->dev_private = drm_alloc(buf->dev_priv_size, DRM_MEM_BUFS); buf->dev_private = kmalloc(buf->dev_priv_size, GFP_KERNEL);
if (!buf->dev_private) { if (!buf->dev_private) {
/* Set count correctly so we free the proper amount. */ /* Set count correctly so we free the proper amount. */
entry->buf_count = count; entry->buf_count = count;
@@ -1299,10 +1272,9 @@ static int drm_addbufs_fb(struct drm_device * dev, struct drm_buf_desc * request
DRM_DEBUG("byte_count: %d\n", byte_count); DRM_DEBUG("byte_count: %d\n", byte_count);
temp_buflist = drm_realloc(dma->buflist, temp_buflist = krealloc(dma->buflist,
dma->buf_count * sizeof(*dma->buflist), (dma->buf_count + entry->buf_count) *
(dma->buf_count + entry->buf_count) sizeof(*dma->buflist), GFP_KERNEL);
* sizeof(*dma->buflist), DRM_MEM_BUFS);
if (!temp_buflist) { if (!temp_buflist) {
/* Free the entry because it isn't valid */ /* Free the entry because it isn't valid */
drm_cleanup_buf_error(dev, entry); drm_cleanup_buf_error(dev, entry);
drivers/gpu/drm/drm_context.c
+2 -2
View File
@@ -341,7 +341,7 @@ int drm_addctx(struct drm_device *dev, void *data,
} }
} }
ctx_entry = drm_alloc(sizeof(*ctx_entry), DRM_MEM_CTXLIST); ctx_entry = kmalloc(sizeof(*ctx_entry), GFP_KERNEL);
if (!ctx_entry) { if (!ctx_entry) {
DRM_DEBUG("out of memory\n"); DRM_DEBUG("out of memory\n");
return -ENOMEM; return -ENOMEM;
@@ -456,7 +456,7 @@ int drm_rmctx(struct drm_device *dev, void *data,
list_for_each_entry_safe(pos, n, &dev->ctxlist, head) { list_for_each_entry_safe(pos, n, &dev->ctxlist, head) {
if (pos->handle == ctx->handle) { if (pos->handle == ctx->handle) {
list_del(&pos->head); list_del(&pos->head);
drm_free(pos, sizeof(*pos), DRM_MEM_CTXLIST); kfree(pos);
--dev->ctx_count; --dev->ctx_count;
} }
} }
drivers/gpu/drm/drm_debugfs.c
+3 -6
View File
@@ -100,15 +100,13 @@ int drm_debugfs_create_files(struct drm_info_list *files, int count,
(dev->driver->driver_features & features) != features) (dev->driver->driver_features & features) != features)
continue; continue;
tmp = drm_alloc(sizeof(struct drm_info_node), tmp = kmalloc(sizeof(struct drm_info_node), GFP_KERNEL);
_DRM_DRIVER);
ent = debugfs_create_file(files[i].name, S_IFREG | S_IRUGO, ent = debugfs_create_file(files[i].name, S_IFREG | S_IRUGO,
root, tmp, &drm_debugfs_fops); root, tmp, &drm_debugfs_fops);
if (!ent) { if (!ent) {
DRM_ERROR("Cannot create /sys/kernel/debug/dri/%s/%s\n", DRM_ERROR("Cannot create /sys/kernel/debug/dri/%s/%s\n",
name, files[i].name); name, files[i].name);
drm_free(tmp, sizeof(struct drm_info_node), kfree(tmp);
_DRM_DRIVER);
ret = -1; ret = -1;
goto fail; goto fail;
} }
@@ -196,8 +194,7 @@ int drm_debugfs_remove_files(struct drm_info_list *files, int count,
if (tmp->info_ent == &files[i]) { if (tmp->info_ent == &files[i]) {
debugfs_remove(tmp->dent); debugfs_remove(tmp->dent);
list_del(pos); list_del(pos);
drm_free(tmp, sizeof(struct drm_info_node), kfree(tmp);
_DRM_DRIVER);
} }
} }
} }
drivers/gpu/drm/drm_dma.c
+7 -24
View File
@@ -47,7 +47,7 @@ int drm_dma_setup(struct drm_device *dev)
{ {
int i; int i;
dev->dma = drm_alloc(sizeof(*dev->dma), DRM_MEM_DRIVER); dev->dma = kmalloc(sizeof(*dev->dma), GFP_KERNEL);
if (!dev->dma) if (!dev->dma)
return -ENOMEM; return -ENOMEM;
@@ -88,36 +88,19 @@ void drm_dma_takedown(struct drm_device *dev)
drm_pci_free(dev, dma->bufs[i].seglist[j]); drm_pci_free(dev, dma->bufs[i].seglist[j]);
} }
} }
drm_free(dma->bufs[i].seglist, kfree(dma->bufs[i].seglist);
dma->bufs[i].seg_count
* sizeof(*dma->bufs[0].seglist), DRM_MEM_SEGS);
} }
if (dma->bufs[i].buf_count) { if (dma->bufs[i].buf_count) {
for (j = 0; j < dma->bufs[i].buf_count; j++) { for (j = 0; j < dma->bufs[i].buf_count; j++) {
if (dma->bufs[i].buflist[j].dev_private) { kfree(dma->bufs[i].buflist[j].dev_private);
drm_free(dma->bufs[i].buflist[j].
dev_private,
dma->bufs[i].buflist[j].
dev_priv_size, DRM_MEM_BUFS);
} }
} kfree(dma->bufs[i].buflist);
drm_free(dma->bufs[i].buflist,
dma->bufs[i].buf_count *
sizeof(*dma->bufs[0].buflist), DRM_MEM_BUFS);
} }
} }
if (dma->buflist) { kfree(dma->buflist);
drm_free(dma->buflist, kfree(dma->pagelist);
dma->buf_count * sizeof(*dma->buflist), DRM_MEM_BUFS); kfree(dev->dma);
}
if (dma->pagelist) {
drm_free(dma->pagelist,
dma->page_count * sizeof(*dma->pagelist),
DRM_MEM_PAGES);
}
drm_free(dev->dma, sizeof(*dev->dma), DRM_MEM_DRIVER);
dev->dma = NULL; dev->dma = NULL;
} }
drivers/gpu/drm/drm_drawable.c
+11 -14
View File
@@ -85,9 +85,8 @@ int drm_rmdraw(struct drm_device *dev, void *data, struct drm_file *file_priv)
spin_unlock_irqrestore(&dev->drw_lock, irqflags); spin_unlock_irqrestore(&dev->drw_lock, irqflags);
return -EINVAL; return -EINVAL;
} }
drm_free(info->rects, info->num_rects * sizeof(struct drm_clip_rect), kfree(info->rects);
DRM_MEM_BUFS); kfree(info);
drm_free(info, sizeof(struct drm_drawable_info), DRM_MEM_BUFS);
idr_remove(&dev->drw_idr, draw->handle); idr_remove(&dev->drw_idr, draw->handle);
@@ -106,12 +105,12 @@ int drm_update_drawable_info(struct drm_device *dev, void *data, struct drm_file
info = idr_find(&dev->drw_idr, update->handle); info = idr_find(&dev->drw_idr, update->handle);
if (!info) { if (!info) {
info = drm_calloc(1, sizeof(*info), DRM_MEM_BUFS); info = kzalloc(sizeof(*info), GFP_KERNEL);
if (!info) if (!info)
return -ENOMEM; return -ENOMEM;
if (IS_ERR(idr_replace(&dev->drw_idr, info, update->handle))) { if (IS_ERR(idr_replace(&dev->drw_idr, info, update->handle))) {
DRM_ERROR("No such drawable %d\n", update->handle); DRM_ERROR("No such drawable %d\n", update->handle);
drm_free(info, sizeof(*info), DRM_MEM_BUFS); kfree(info);
return -EINVAL; return -EINVAL;
} }
} }
@@ -121,8 +120,9 @@ int drm_update_drawable_info(struct drm_device *dev, void *data, struct drm_file
if (update->num == 0) if (update->num == 0)
rects = NULL; rects = NULL;
else if (update->num != info->num_rects) { else if (update->num != info->num_rects) {
rects = drm_alloc(update->num * sizeof(struct drm_clip_rect), rects = kmalloc(update->num *
DRM_MEM_BUFS); sizeof(struct drm_clip_rect),
GFP_KERNEL);
} else } else
rects = info->rects; rects = info->rects;
@@ -145,8 +145,7 @@ int drm_update_drawable_info(struct drm_device *dev, void *data, struct drm_file
spin_lock_irqsave(&dev->drw_lock, irqflags); spin_lock_irqsave(&dev->drw_lock, irqflags);
if (rects != info->rects) { if (rects != info->rects) {
drm_free(info->rects, info->num_rects * kfree(info->rects);
sizeof(struct drm_clip_rect), DRM_MEM_BUFS);
} }
info->rects = rects; info->rects = rects;
@@ -166,8 +165,7 @@ int drm_update_drawable_info(struct drm_device *dev, void *data, struct drm_file
error: error:
if (rects != info->rects) if (rects != info->rects)
drm_free(rects, update->num * sizeof(struct drm_clip_rect), kfree(rects);
DRM_MEM_BUFS);
return err; return err;
} }
@@ -186,9 +184,8 @@ static int drm_drawable_free(int idr, void *p, void *data)
struct drm_drawable_info *info = p; struct drm_drawable_info *info = p;
if (info) { if (info) {
drm_free(info->rects, info->num_rects * kfree(info->rects);
sizeof(struct drm_clip_rect), DRM_MEM_BUFS); kfree(info);
drm_free(info, sizeof(*info), DRM_MEM_BUFS);
} }
return 0; return 0;
drivers/gpu/drm/drm_drv.c
+4 -12
View File
@@ -189,7 +189,7 @@ int drm_lastclose(struct drm_device * dev)
if (entry->bound) if (entry->bound)
drm_unbind_agp(entry->memory); drm_unbind_agp(entry->memory);
drm_free_agp(entry->memory, entry->pages); drm_free_agp(entry->memory, entry->pages);
drm_free(entry, sizeof(*entry), DRM_MEM_AGPLISTS); kfree(entry);
} }
INIT_LIST_HEAD(&dev->agp->memory); INIT_LIST_HEAD(&dev->agp->memory);
@@ -208,21 +208,15 @@ int drm_lastclose(struct drm_device * dev)
/* Clear vma list (only built for debugging) */ /* Clear vma list (only built for debugging) */
list_for_each_entry_safe(vma, vma_temp, &dev->vmalist, head) { list_for_each_entry_safe(vma, vma_temp, &dev->vmalist, head) {
list_del(&vma->head); list_del(&vma->head);
drm_free(vma, sizeof(*vma), DRM_MEM_VMAS); kfree(vma);
} }
if (drm_core_check_feature(dev, DRIVER_DMA_QUEUE) && dev->queuelist) { if (drm_core_check_feature(dev, DRIVER_DMA_QUEUE) && dev->queuelist) {
for (i = 0; i < dev->queue_count; i++) { for (i = 0; i < dev->queue_count; i++) {
if (dev->queuelist[i]) { kfree(dev->queuelist[i]);
drm_free(dev->queuelist[i],
sizeof(*dev->queuelist[0]),
DRM_MEM_QUEUES);
dev->queuelist[i] = NULL; dev->queuelist[i] = NULL;
} }
} kfree(dev->queuelist);
drm_free(dev->queuelist,
dev->queue_slots * sizeof(*dev->queuelist),
DRM_MEM_QUEUES);
dev->queuelist = NULL; dev->queuelist = NULL;
} }
dev->queue_count = 0; dev->queue_count = 0;
@@ -344,8 +338,6 @@ static int __init drm_core_init(void)
goto err_p3; goto err_p3;
} }
drm_mem_init();
DRM_INFO("Initialized %s %d.%d.%d %s\n", DRM_INFO("Initialized %s %d.%d.%d %s\n",
CORE_NAME, CORE_MAJOR, CORE_MINOR, CORE_PATCHLEVEL, CORE_DATE); CORE_NAME, CORE_MAJOR, CORE_MINOR, CORE_PATCHLEVEL, CORE_DATE);
return 0; return 0;
drivers/gpu/drm/drm_fops.c
+4 -4
View File
@@ -240,7 +240,7 @@ static int drm_open_helper(struct inode *inode, struct file *filp,
DRM_DEBUG("pid = %d, minor = %d\n", task_pid_nr(current), minor_id); DRM_DEBUG("pid = %d, minor = %d\n", task_pid_nr(current), minor_id);
priv = drm_alloc(sizeof(*priv), DRM_MEM_FILES); priv = kmalloc(sizeof(*priv), GFP_KERNEL);
if (!priv) if (!priv)
return -ENOMEM; return -ENOMEM;
@@ -328,7 +328,7 @@ static int drm_open_helper(struct inode *inode, struct file *filp,
return 0; return 0;
out_free: out_free:
drm_free(priv, sizeof(*priv), DRM_MEM_FILES); kfree(priv);
filp->private_data = NULL; filp->private_data = NULL;
return ret; return ret;
} }
@@ -471,7 +471,7 @@ int drm_release(struct inode *inode, struct file *filp)
drm_ctxbitmap_free(dev, pos->handle); drm_ctxbitmap_free(dev, pos->handle);
list_del(&pos->head); list_del(&pos->head);
drm_free(pos, sizeof(*pos), DRM_MEM_CTXLIST); kfree(pos);
--dev->ctx_count; --dev->ctx_count;
} }
} }
@@ -516,7 +516,7 @@ int drm_release(struct inode *inode, struct file *filp)
if (dev->driver->postclose) if (dev->driver->postclose)
dev->driver->postclose(dev, file_priv); dev->driver->postclose(dev, file_priv);
drm_free(file_priv, sizeof(*file_priv), DRM_MEM_FILES); kfree(file_priv);
/* ======================================================== /* ========================================================
* End inline drm_release * End inline drm_release
drivers/gpu/drm/drm_gem.c
+4 -4
View File
@@ -89,7 +89,7 @@ drm_gem_init(struct drm_device *dev)
atomic_set(&dev->gtt_count, 0); atomic_set(&dev->gtt_count, 0);
atomic_set(&dev->gtt_memory, 0); atomic_set(&dev->gtt_memory, 0);
mm = drm_calloc(1, sizeof(struct drm_gem_mm), DRM_MEM_MM); mm = kzalloc(sizeof(struct drm_gem_mm), GFP_KERNEL);
if (!mm) { if (!mm) {
DRM_ERROR("out of memory\n"); DRM_ERROR("out of memory\n");
return -ENOMEM; return -ENOMEM;
@@ -98,14 +98,14 @@ drm_gem_init(struct drm_device *dev)
dev->mm_private = mm; dev->mm_private = mm;
if (drm_ht_create(&mm->offset_hash, 19)) { if (drm_ht_create(&mm->offset_hash, 19)) {
drm_free(mm, sizeof(struct drm_gem_mm), DRM_MEM_MM); kfree(mm);
return -ENOMEM; return -ENOMEM;
} }
if (drm_mm_init(&mm->offset_manager, DRM_FILE_PAGE_OFFSET_START, if (drm_mm_init(&mm->offset_manager, DRM_FILE_PAGE_OFFSET_START,
DRM_FILE_PAGE_OFFSET_SIZE)) { DRM_FILE_PAGE_OFFSET_SIZE)) {
drm_ht_remove(&mm->offset_hash); drm_ht_remove(&mm->offset_hash);
drm_free(mm, sizeof(struct drm_gem_mm), DRM_MEM_MM); kfree(mm);
return -ENOMEM; return -ENOMEM;
} }
@@ -119,7 +119,7 @@ drm_gem_destroy(struct drm_device *dev)
drm_mm_takedown(&mm->offset_manager); drm_mm_takedown(&mm->offset_manager);
drm_ht_remove(&mm->offset_hash); drm_ht_remove(&mm->offset_hash);
drm_free(mm, sizeof(struct drm_gem_mm), DRM_MEM_MM); kfree(mm);
dev->mm_private = NULL; dev->mm_private = NULL;
} }
drivers/gpu/drm/drm_hashtab.c
+2 -4
View File
@@ -46,8 +46,7 @@ int drm_ht_create(struct drm_open_hash *ht, unsigned int order)
ht->table = NULL; ht->table = NULL;
ht->use_vmalloc = ((ht->size * sizeof(*ht->table)) > PAGE_SIZE); ht->use_vmalloc = ((ht->size * sizeof(*ht->table)) > PAGE_SIZE);
if (!ht->use_vmalloc) { if (!ht->use_vmalloc) {
ht->table = drm_calloc(ht->size, sizeof(*ht->table), ht->table = kcalloc(ht->size, sizeof(*ht->table), GFP_KERNEL);
DRM_MEM_HASHTAB);
} }
if (!ht->table) { if (!ht->table) {
ht->use_vmalloc = 1; ht->use_vmalloc = 1;
@@ -200,8 +199,7 @@ void drm_ht_remove(struct drm_open_hash *ht)
if (ht->use_vmalloc) if (ht->use_vmalloc)
vfree(ht->table); vfree(ht->table);
else else
drm_free(ht->table, ht->size * sizeof(*ht->table), kfree(ht->table);
DRM_MEM_HASHTAB);
ht->table = NULL; ht->table = NULL;
} }
} }
drivers/gpu/drm/drm_ioctl.c
+6 -8
View File
@@ -93,7 +93,7 @@ int drm_setunique(struct drm_device *dev, void *data,
master->unique_len = u->unique_len; master->unique_len = u->unique_len;
master->unique_size = u->unique_len + 1; master->unique_size = u->unique_len + 1;
master->unique = drm_alloc(master->unique_size, DRM_MEM_DRIVER); master->unique = kmalloc(master->unique_size, GFP_KERNEL);
if (!master->unique) if (!master->unique)
return -ENOMEM; return -ENOMEM;
if (copy_from_user(master->unique, u->unique, master->unique_len)) if (copy_from_user(master->unique, u->unique, master->unique_len))
@@ -101,9 +101,8 @@ int drm_setunique(struct drm_device *dev, void *data,
master->unique[master->unique_len] = '\0'; master->unique[master->unique_len] = '\0';
dev->devname = dev->devname = kmalloc(strlen(dev->driver->pci_driver.name) +
drm_alloc(strlen(dev->driver->pci_driver.name) + strlen(master->unique) + 2, GFP_KERNEL);
strlen(master->unique) + 2, DRM_MEM_DRIVER);
if (!dev->devname) if (!dev->devname)
return -ENOMEM; return -ENOMEM;
@@ -138,7 +137,7 @@ static int drm_set_busid(struct drm_device *dev, struct drm_file *file_priv)
master->unique_len = 40; master->unique_len = 40;
master->unique_size = master->unique_len; master->unique_size = master->unique_len;
master->unique = drm_alloc(master->unique_size, DRM_MEM_DRIVER); master->unique = kmalloc(master->unique_size, GFP_KERNEL);
if (master->unique == NULL) if (master->unique == NULL)
return -ENOMEM; return -ENOMEM;
@@ -152,9 +151,8 @@ static int drm_set_busid(struct drm_device *dev, struct drm_file *file_priv)
else else
master->unique_len = len; master->unique_len = len;
dev->devname = dev->devname = kmalloc(strlen(dev->driver->pci_driver.name) +
drm_alloc(strlen(dev->driver->pci_driver.name) + master->unique_len + master->unique_len + 2, GFP_KERNEL);
2, DRM_MEM_DRIVER);
if (dev->devname == NULL) if (dev->devname == NULL)
return -ENOMEM; return -ENOMEM;
drivers/gpu/drm/drm_irq.c
+16 -28
View File
@@ -104,21 +104,13 @@ void drm_vblank_cleanup(struct drm_device *dev)
vblank_disable_fn((unsigned long)dev); vblank_disable_fn((unsigned long)dev);
drm_free(dev->vbl_queue, sizeof(*dev->vbl_queue) * dev->num_crtcs, kfree(dev->vbl_queue);
DRM_MEM_DRIVER); kfree(dev->_vblank_count);
drm_free(dev->_vblank_count, sizeof(*dev->_vblank_count) * kfree(dev->vblank_refcount);
dev->num_crtcs, DRM_MEM_DRIVER); kfree(dev->vblank_enabled);
drm_free(dev->vblank_refcount, sizeof(*dev->vblank_refcount) * kfree(dev->last_vblank);
dev->num_crtcs, DRM_MEM_DRIVER); kfree(dev->last_vblank_wait);
drm_free(dev->vblank_enabled, sizeof(*dev->vblank_enabled) * kfree(dev->vblank_inmodeset);
dev->num_crtcs, DRM_MEM_DRIVER);
drm_free(dev->last_vblank, sizeof(*dev->last_vblank) * dev->num_crtcs,
DRM_MEM_DRIVER);
drm_free(dev->last_vblank_wait,
sizeof(*dev->last_vblank_wait) * dev->num_crtcs,
DRM_MEM_DRIVER);
drm_free(dev->vblank_inmodeset, sizeof(*dev->vblank_inmodeset) *
dev->num_crtcs, DRM_MEM_DRIVER);
dev->num_crtcs = 0; dev->num_crtcs = 0;
} }
@@ -132,37 +124,33 @@ int drm_vblank_init(struct drm_device *dev, int num_crtcs)
spin_lock_init(&dev->vbl_lock); spin_lock_init(&dev->vbl_lock);
dev->num_crtcs = num_crtcs; dev->num_crtcs = num_crtcs;
dev->vbl_queue = drm_alloc(sizeof(wait_queue_head_t) * num_crtcs, dev->vbl_queue = kmalloc(sizeof(wait_queue_head_t) * num_crtcs,
DRM_MEM_DRIVER); GFP_KERNEL);
if (!dev->vbl_queue) if (!dev->vbl_queue)
goto err; goto err;
dev->_vblank_count = drm_alloc(sizeof(atomic_t) * num_crtcs, dev->_vblank_count = kmalloc(sizeof(atomic_t) * num_crtcs, GFP_KERNEL);
DRM_MEM_DRIVER);
if (!dev->_vblank_count) if (!dev->_vblank_count)
goto err; goto err;
dev->vblank_refcount = drm_alloc(sizeof(atomic_t) * num_crtcs, dev->vblank_refcount = kmalloc(sizeof(atomic_t) * num_crtcs,
DRM_MEM_DRIVER); GFP_KERNEL);
if (!dev->vblank_refcount) if (!dev->vblank_refcount)
goto err; goto err;
dev->vblank_enabled = drm_calloc(num_crtcs, sizeof(int), dev->vblank_enabled = kcalloc(num_crtcs, sizeof(int), GFP_KERNEL);
DRM_MEM_DRIVER);
if (!dev->vblank_enabled) if (!dev->vblank_enabled)
goto err; goto err;
dev->last_vblank = drm_calloc(num_crtcs, sizeof(u32), DRM_MEM_DRIVER); dev->last_vblank = kcalloc(num_crtcs, sizeof(u32), GFP_KERNEL);
if (!dev->last_vblank) if (!dev->last_vblank)
goto err; goto err;
dev->last_vblank_wait = drm_calloc(num_crtcs, sizeof(u32), dev->last_vblank_wait = kcalloc(num_crtcs, sizeof(u32), GFP_KERNEL);
DRM_MEM_DRIVER);
if (!dev->last_vblank_wait) if (!dev->last_vblank_wait)
goto err; goto err;
dev->vblank_inmodeset = drm_calloc(num_crtcs, sizeof(int), dev->vblank_inmodeset = kcalloc(num_crtcs, sizeof(int), GFP_KERNEL);
DRM_MEM_DRIVER);
if (!dev->vblank_inmodeset) if (!dev->vblank_inmodeset)
goto err; goto err;
drivers/gpu/drm/drm_memory.c
-25
View File
@@ -36,15 +36,6 @@
#include <linux/highmem.h> #include <linux/highmem.h>
#include "drmP.h" #include "drmP.h"
#ifdef DEBUG_MEMORY
#include "drm_memory_debug.h"
#else
/** No-op. */
void drm_mem_init(void)
{
}
/** /**
* Called when "/proc/dri/%dev%/mem" is read. * Called when "/proc/dri/%dev%/mem" is read.
* *
@@ -64,20 +55,6 @@ int drm_mem_info(char *buf, char **start, off_t offset,
return 0; return 0;
} }
/** Wrapper around kmalloc() and kfree() */
void *drm_realloc(void *oldpt, size_t oldsize, size_t size, int area)
{
void *pt;
if (!(pt = kmalloc(size, GFP_KERNEL)))
return NULL;
if (oldpt && oldsize) {
memcpy(pt, oldpt, oldsize);
kfree(oldpt);
}
return pt;
}
#if __OS_HAS_AGP #if __OS_HAS_AGP
static void *agp_remap(unsigned long offset, unsigned long size, static void *agp_remap(unsigned long offset, unsigned long size,
struct drm_device * dev) struct drm_device * dev)
@@ -157,8 +134,6 @@ static inline void *agp_remap(unsigned long offset, unsigned long size,
#endif /* agp */ #endif /* agp */
#endif /* debug_memory */
void drm_core_ioremap(struct drm_local_map *map, struct drm_device *dev) void drm_core_ioremap(struct drm_local_map *map, struct drm_device *dev)
{ {
if (drm_core_has_AGP(dev) && if (drm_core_has_AGP(dev) &&
drivers/gpu/drm/drm_pci.c
+1 -52
View File
@@ -55,17 +55,6 @@ drm_dma_handle_t *drm_pci_alloc(struct drm_device * dev, size_t size, size_t ali
unsigned long addr; unsigned long addr;
size_t sz; size_t sz;
#endif #endif
#ifdef DRM_DEBUG_MEMORY
int area = DRM_MEM_DMA;
spin_lock(&drm_mem_lock);
if ((drm_ram_used >> PAGE_SHIFT)
> (DRM_RAM_PERCENT * drm_ram_available) / 100) {
spin_unlock(&drm_mem_lock);
return 0;
}
spin_unlock(&drm_mem_lock);
#endif
/* pci_alloc_consistent only guarantees alignment to the smallest /* pci_alloc_consistent only guarantees alignment to the smallest
* PAGE_SIZE order which is greater than or equal to the requested size. * PAGE_SIZE order which is greater than or equal to the requested size.
@@ -86,26 +75,10 @@ drm_dma_handle_t *drm_pci_alloc(struct drm_device * dev, size_t size, size_t ali
dmah->size = size; dmah->size = size;
dmah->vaddr = dma_alloc_coherent(&dev->pdev->dev, size, &dmah->busaddr, GFP_KERNEL | __GFP_COMP); dmah->vaddr = dma_alloc_coherent(&dev->pdev->dev, size, &dmah->busaddr, GFP_KERNEL | __GFP_COMP);
#ifdef DRM_DEBUG_MEMORY
if (dmah->vaddr == NULL) {
spin_lock(&drm_mem_lock);
++drm_mem_stats[area].fail_count;
spin_unlock(&drm_mem_lock);
kfree(dmah);
return NULL;
}
spin_lock(&drm_mem_lock);
++drm_mem_stats[area].succeed_count;
drm_mem_stats[area].bytes_allocated += size;
drm_ram_used += size;
spin_unlock(&drm_mem_lock);
#else
if (dmah->vaddr == NULL) { if (dmah->vaddr == NULL) {
kfree(dmah); kfree(dmah);
return NULL; return NULL;
} }
#endif
memset(dmah->vaddr, 0, size); memset(dmah->vaddr, 0, size);
@@ -132,17 +105,8 @@ void __drm_pci_free(struct drm_device * dev, drm_dma_handle_t * dmah)
unsigned long addr; unsigned long addr;
size_t sz; size_t sz;
#endif #endif
#ifdef DRM_DEBUG_MEMORY
int area = DRM_MEM_DMA;
int alloc_count;
int free_count;
#endif
if (!dmah->vaddr) { if (dmah->vaddr) {
#ifdef DRM_DEBUG_MEMORY
DRM_MEM_ERROR(area, "Attempt to free address 0\n");
#endif
} else {
/* XXX - Is virt_to_page() legal for consistent mem? */ /* XXX - Is virt_to_page() legal for consistent mem? */
/* Unreserve */ /* Unreserve */
for (addr = (unsigned long)dmah->vaddr, sz = dmah->size; for (addr = (unsigned long)dmah->vaddr, sz = dmah->size;
@@ -152,21 +116,6 @@ void __drm_pci_free(struct drm_device * dev, drm_dma_handle_t * dmah)
dma_free_coherent(&dev->pdev->dev, dmah->size, dmah->vaddr, dma_free_coherent(&dev->pdev->dev, dmah->size, dmah->vaddr,
dmah->busaddr); dmah->busaddr);
} }
#ifdef DRM_DEBUG_MEMORY
spin_lock(&drm_mem_lock);
free_count = ++drm_mem_stats[area].free_count;
alloc_count = drm_mem_stats[area].succeed_count;
drm_mem_stats[area].bytes_freed += size;
drm_ram_used -= size;
spin_unlock(&drm_mem_lock);
if (free_count > alloc_count) {
DRM_MEM_ERROR(area,
"Excess frees: %d frees, %d allocs\n",
free_count, alloc_count);
}
#endif
} }
/** /**
drivers/gpu/drm/drm_proc.c
+3 -5
View File
@@ -105,13 +105,12 @@ int drm_proc_create_files(struct drm_info_list *files, int count,
(dev->driver->driver_features & features) != features) (dev->driver->driver_features & features) != features)
continue; continue;
tmp = drm_alloc(sizeof(struct drm_info_node), _DRM_DRIVER); tmp = kmalloc(sizeof(struct drm_info_node), GFP_KERNEL);
ent = create_proc_entry(files[i].name, S_IFREG | S_IRUGO, root); ent = create_proc_entry(files[i].name, S_IFREG | S_IRUGO, root);
if (!ent) { if (!ent) {
DRM_ERROR("Cannot create /proc/dri/%s/%s\n", DRM_ERROR("Cannot create /proc/dri/%s/%s\n",
name, files[i].name); name, files[i].name);
drm_free(tmp, sizeof(struct drm_info_node), kfree(tmp);
_DRM_DRIVER);
ret = -1; ret = -1;
goto fail; goto fail;
} }
@@ -192,8 +191,7 @@ int drm_proc_remove_files(struct drm_info_list *files, int count,
remove_proc_entry(files[i].name, remove_proc_entry(files[i].name,
minor->proc_root); minor->proc_root);
list_del(pos); list_del(pos);
drm_free(tmp, sizeof(struct drm_info_node), kfree(tmp);
_DRM_DRIVER);
} }
} }
} }
drivers/gpu/drm/drm_scatter.c
+12 -21
View File
@@ -58,11 +58,9 @@ void drm_sg_cleanup(struct drm_sg_mem * entry)
vfree(entry->virtual); vfree(entry->virtual);
drm_free(entry->busaddr, kfree(entry->busaddr);
entry->pages * sizeof(*entry->busaddr), DRM_MEM_PAGES); kfree(entry->pagelist);
drm_free(entry->pagelist, kfree(entry);
entry->pages * sizeof(*entry->pagelist), DRM_MEM_PAGES);
drm_free(entry, sizeof(*entry), DRM_MEM_SGLISTS);
} }
#ifdef _LP64 #ifdef _LP64
@@ -84,7 +82,7 @@ int drm_sg_alloc(struct drm_device *dev, struct drm_scatter_gather * request)
if (dev->sg) if (dev->sg)
return -EINVAL; return -EINVAL;
entry = drm_alloc(sizeof(*entry), DRM_MEM_SGLISTS); entry = kmalloc(sizeof(*entry), GFP_KERNEL);
if (!entry) if (!entry)
return -ENOMEM; return -ENOMEM;
@@ -93,34 +91,27 @@ int drm_sg_alloc(struct drm_device *dev, struct drm_scatter_gather * request)
DRM_DEBUG("size=%ld pages=%ld\n", request->size, pages); DRM_DEBUG("size=%ld pages=%ld\n", request->size, pages);
entry->pages = pages; entry->pages = pages;
entry->pagelist = drm_alloc(pages * sizeof(*entry->pagelist), entry->pagelist = kmalloc(pages * sizeof(*entry->pagelist), GFP_KERNEL);
DRM_MEM_PAGES);
if (!entry->pagelist) { if (!entry->pagelist) {
drm_free(entry, sizeof(*entry), DRM_MEM_SGLISTS); kfree(entry);
return -ENOMEM; return -ENOMEM;
} }
memset(entry->pagelist, 0, pages * sizeof(*entry->pagelist)); memset(entry->pagelist, 0, pages * sizeof(*entry->pagelist));
entry->busaddr = drm_alloc(pages * sizeof(*entry->busaddr), entry->busaddr = kmalloc(pages * sizeof(*entry->busaddr), GFP_KERNEL);
DRM_MEM_PAGES);
if (!entry->busaddr) { if (!entry->busaddr) {
drm_free(entry->pagelist, kfree(entry->pagelist);
entry->pages * sizeof(*entry->pagelist), kfree(entry);
DRM_MEM_PAGES);
drm_free(entry, sizeof(*entry), DRM_MEM_SGLISTS);
return -ENOMEM; return -ENOMEM;
} }
memset((void *)entry->busaddr, 0, pages * sizeof(*entry->busaddr)); memset((void *)entry->busaddr, 0, pages * sizeof(*entry->busaddr));
entry->virtual = drm_vmalloc_dma(pages << PAGE_SHIFT); entry->virtual = drm_vmalloc_dma(pages << PAGE_SHIFT);
if (!entry->virtual) { if (!entry->virtual) {
drm_free(entry->busaddr, kfree(entry->busaddr);
entry->pages * sizeof(*entry->busaddr), DRM_MEM_PAGES); kfree(entry->pagelist);
drm_free(entry->pagelist, kfree(entry);
entry->pages * sizeof(*entry->pagelist),
DRM_MEM_PAGES);
drm_free(entry, sizeof(*entry), DRM_MEM_SGLISTS);
return -ENOMEM; return -ENOMEM;
} }
drivers/gpu/drm/drm_sman.c
+14 -15
View File
@@ -48,9 +48,7 @@ void drm_sman_takedown(struct drm_sman * sman)
{ {
drm_ht_remove(&sman->user_hash_tab); drm_ht_remove(&sman->user_hash_tab);
drm_ht_remove(&sman->owner_hash_tab); drm_ht_remove(&sman->owner_hash_tab);
if (sman->mm) kfree(sman->mm);
drm_free(sman->mm, sman->num_managers * sizeof(*sman->mm),
DRM_MEM_MM);
} }
EXPORT_SYMBOL(drm_sman_takedown); EXPORT_SYMBOL(drm_sman_takedown);
@@ -61,8 +59,9 @@ drm_sman_init(struct drm_sman * sman, unsigned int num_managers,
{ {
int ret = 0; int ret = 0;
sman->mm = (struct drm_sman_mm *) drm_calloc(num_managers, sizeof(*sman->mm), sman->mm = (struct drm_sman_mm *) kcalloc(num_managers,
DRM_MEM_MM); sizeof(*sman->mm),
GFP_KERNEL);
if (!sman->mm) { if (!sman->mm) {
ret = -ENOMEM; ret = -ENOMEM;
goto out; goto out;
@@ -78,7 +77,7 @@ drm_sman_init(struct drm_sman * sman, unsigned int num_managers,
drm_ht_remove(&sman->owner_hash_tab); drm_ht_remove(&sman->owner_hash_tab);
out1: out1:
drm_free(sman->mm, num_managers * sizeof(*sman->mm), DRM_MEM_MM); kfree(sman->mm);
out: out:
return ret; return ret;
} }
@@ -110,7 +109,7 @@ static void drm_sman_mm_destroy(void *private)
{ {
struct drm_mm *mm = (struct drm_mm *) private; struct drm_mm *mm = (struct drm_mm *) private;
drm_mm_takedown(mm); drm_mm_takedown(mm);
drm_free(mm, sizeof(*mm), DRM_MEM_MM); kfree(mm);
} }
static unsigned long drm_sman_mm_offset(void *private, void *ref) static unsigned long drm_sman_mm_offset(void *private, void *ref)
@@ -130,7 +129,7 @@ drm_sman_set_range(struct drm_sman * sman, unsigned int manager,
BUG_ON(manager >= sman->num_managers); BUG_ON(manager >= sman->num_managers);
sman_mm = &sman->mm[manager]; sman_mm = &sman->mm[manager];
mm = drm_calloc(1, sizeof(*mm), DRM_MEM_MM); mm = kzalloc(sizeof(*mm), GFP_KERNEL);
if (!mm) { if (!mm) {
return -ENOMEM; return -ENOMEM;
} }
@@ -138,7 +137,7 @@ drm_sman_set_range(struct drm_sman * sman, unsigned int manager,
ret = drm_mm_init(mm, start, size); ret = drm_mm_init(mm, start, size);
if (ret) { if (ret) {
drm_free(mm, sizeof(*mm), DRM_MEM_MM); kfree(mm);
return ret; return ret;
} }
@@ -176,7 +175,7 @@ static struct drm_owner_item *drm_sman_get_owner_item(struct drm_sman * sman,
owner_hash); owner_hash);
} }
owner_item = drm_calloc(1, sizeof(*owner_item), DRM_MEM_MM); owner_item = kzalloc(sizeof(*owner_item), GFP_KERNEL);
if (!owner_item) if (!owner_item)
goto out; goto out;
@@ -189,7 +188,7 @@ static struct drm_owner_item *drm_sman_get_owner_item(struct drm_sman * sman,
return owner_item; return owner_item;
out1: out1:
drm_free(owner_item, sizeof(*owner_item), DRM_MEM_MM); kfree(owner_item);
out: out:
return NULL; return NULL;
} }
@@ -212,7 +211,7 @@ struct drm_memblock_item *drm_sman_alloc(struct drm_sman *sman, unsigned int man
return NULL; return NULL;
} }
memblock = drm_calloc(1, sizeof(*memblock), DRM_MEM_MM); memblock = kzalloc(sizeof(*memblock), GFP_KERNEL);
if (!memblock) if (!memblock)
goto out; goto out;
@@ -237,7 +236,7 @@ struct drm_memblock_item *drm_sman_alloc(struct drm_sman *sman, unsigned int man
out2: out2:
drm_ht_remove_item(&sman->user_hash_tab, &memblock->user_hash); drm_ht_remove_item(&sman->user_hash_tab, &memblock->user_hash);
out1: out1:
drm_free(memblock, sizeof(*memblock), DRM_MEM_MM); kfree(memblock);
out: out:
sman_mm->free(sman_mm->private, tmp); sman_mm->free(sman_mm->private, tmp);
@@ -253,7 +252,7 @@ static void drm_sman_free(struct drm_memblock_item *item)
list_del(&item->owner_list); list_del(&item->owner_list);
drm_ht_remove_item(&sman->user_hash_tab, &item->user_hash); drm_ht_remove_item(&sman->user_hash_tab, &item->user_hash);
item->mm->free(item->mm->private, item->mm_info); item->mm->free(item->mm->private, item->mm_info);
drm_free(item, sizeof(*item), DRM_MEM_MM); kfree(item);
} }
int drm_sman_free_key(struct drm_sman *sman, unsigned int key) int drm_sman_free_key(struct drm_sman *sman, unsigned int key)
@@ -277,7 +276,7 @@ static void drm_sman_remove_owner(struct drm_sman *sman,
{ {
list_del(&owner_item->sman_list); list_del(&owner_item->sman_list);
drm_ht_remove_item(&sman->owner_hash_tab, &owner_item->owner_hash); drm_ht_remove_item(&sman->owner_hash_tab, &owner_item->owner_hash);
drm_free(owner_item, sizeof(*owner_item), DRM_MEM_MM); kfree(owner_item);
} }
int drm_sman_owner_clean(struct drm_sman *sman, unsigned long owner) int drm_sman_owner_clean(struct drm_sman *sman, unsigned long owner)
drivers/gpu/drm/drm_stub.c
+9 -10
View File
@@ -107,7 +107,7 @@ struct drm_master *drm_master_create(struct drm_minor *minor)
{ {
struct drm_master *master; struct drm_master *master;
master = drm_calloc(1, sizeof(*master), DRM_MEM_DRIVER); master = kzalloc(sizeof(*master), GFP_KERNEL);
if (!master) if (!master)
return NULL; return NULL;
@@ -149,7 +149,7 @@ static void drm_master_destroy(struct kref *kref)
} }
if (master->unique) { if (master->unique) {
drm_free(master->unique, master->unique_size, DRM_MEM_DRIVER); kfree(master->unique);
master->unique = NULL; master->unique = NULL;
master->unique_len = 0; master->unique_len = 0;
} }
@@ -157,12 +157,12 @@ static void drm_master_destroy(struct kref *kref)
list_for_each_entry_safe(pt, next, &master->magicfree, head) { list_for_each_entry_safe(pt, next, &master->magicfree, head) {
list_del(&pt->head); list_del(&pt->head);
drm_ht_remove_item(&master->magiclist, &pt->hash_item); drm_ht_remove_item(&master->magiclist, &pt->hash_item);
drm_free(pt, sizeof(*pt), DRM_MEM_MAGIC); kfree(pt);
} }
drm_ht_remove(&master->magiclist); drm_ht_remove(&master->magiclist);
drm_free(master, sizeof(*master), DRM_MEM_DRIVER); kfree(master);
} }
void drm_master_put(struct drm_master **master) void drm_master_put(struct drm_master **master)
@@ -390,7 +390,7 @@ int drm_get_dev(struct pci_dev *pdev, const struct pci_device_id *ent,
DRM_DEBUG("\n"); DRM_DEBUG("\n");
dev = drm_calloc(1, sizeof(*dev), DRM_MEM_STUB); dev = kzalloc(sizeof(*dev), GFP_KERNEL);
if (!dev) if (!dev)
return -ENOMEM; return -ENOMEM;
@@ -443,7 +443,7 @@ err_g3:
err_g2: err_g2:
pci_disable_device(pdev); pci_disable_device(pdev);
err_g1: err_g1:
drm_free(dev, sizeof(*dev), DRM_MEM_STUB); kfree(dev);
return ret; return ret;
} }
EXPORT_SYMBOL(drm_get_dev); EXPORT_SYMBOL(drm_get_dev);
@@ -516,7 +516,7 @@ void drm_put_dev(struct drm_device *dev)
dev->driver->unload(dev); dev->driver->unload(dev);
if (drm_core_has_AGP(dev) && dev->agp) { if (drm_core_has_AGP(dev) && dev->agp) {
drm_free(dev->agp, sizeof(*dev->agp), DRM_MEM_AGPLISTS); kfree(dev->agp);
dev->agp = NULL; dev->agp = NULL;
} }
@@ -535,10 +535,9 @@ void drm_put_dev(struct drm_device *dev)
drm_put_minor(&dev->primary); drm_put_minor(&dev->primary);
if (dev->devname) { if (dev->devname) {
drm_free(dev->devname, strlen(dev->devname) + 1, kfree(dev->devname);
DRM_MEM_DRIVER);
dev->devname = NULL; dev->devname = NULL;
} }
drm_free(dev, sizeof(*dev), DRM_MEM_STUB); kfree(dev);
} }
EXPORT_SYMBOL(drm_put_dev); EXPORT_SYMBOL(drm_put_dev);
drivers/gpu/drm/drm_vm.c
+4 -4
View File
@@ -227,7 +227,7 @@ static void drm_vm_shm_close(struct vm_area_struct *vma)
found_maps++; found_maps++;
if (pt->vma == vma) { if (pt->vma == vma) {
list_del(&pt->head); list_del(&pt->head);
drm_free(pt, sizeof(*pt), DRM_MEM_VMAS); kfree(pt);
} }
} }
@@ -273,7 +273,7 @@ static void drm_vm_shm_close(struct vm_area_struct *vma)
DRM_ERROR("tried to rmmap GEM object\n"); DRM_ERROR("tried to rmmap GEM object\n");
break; break;
} }
drm_free(map, sizeof(*map), DRM_MEM_MAPS); kfree(map);
} }
} }
mutex_unlock(&dev->struct_mutex); mutex_unlock(&dev->struct_mutex);
@@ -414,7 +414,7 @@ void drm_vm_open_locked(struct vm_area_struct *vma)
vma->vm_start, vma->vm_end - vma->vm_start); vma->vm_start, vma->vm_end - vma->vm_start);
atomic_inc(&dev->vma_count); atomic_inc(&dev->vma_count);
vma_entry = drm_alloc(sizeof(*vma_entry), DRM_MEM_VMAS); vma_entry = kmalloc(sizeof(*vma_entry), GFP_KERNEL);
if (vma_entry) { if (vma_entry) {
vma_entry->vma = vma; vma_entry->vma = vma;
vma_entry->pid = current->pid; vma_entry->pid = current->pid;
@@ -454,7 +454,7 @@ static void drm_vm_close(struct vm_area_struct *vma)
list_for_each_entry_safe(pt, temp, &dev->vmalist, head) { list_for_each_entry_safe(pt, temp, &dev->vmalist, head) {
if (pt->vma == vma) { if (pt->vma == vma) {
list_del(&pt->head); list_del(&pt->head);
drm_free(pt, sizeof(*pt), DRM_MEM_VMAS); kfree(pt);
break; break;
} }
} }

Some files were not shown because too many files have changed in this diff Show More