geemili
/
drm
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Now that the memory debug code is gone, and all 3 BSDs have M_ZERO, stop 

using drm_alloc/drm_free in the core and instead use plain malloc/free.
main
Eric Anholt 2004-11-07 00:25:49 +00:00
parent d37457b599
commit fa3fdbd99c
12 changed files with 123 additions and 186 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

13
bsd-core/drm_agpsupport.c
View File

@ -131,16 +131,15 @@ int drm_agp_alloc(DRM_IOCTL_ARGS)
request = *(drm_agp_buffer_t *) data;
if (!(entry = drm_alloc(sizeof(*entry), DRM_MEM_AGPLISTS)))
entry = malloc(sizeof(*entry), M_DRM, M_NOWAIT | M_ZERO);
if (entry == NULL)
return ENOMEM;
bzero(entry, sizeof(*entry));
pages = (request.size + PAGE_SIZE - 1) / PAGE_SIZE;
type = (u_int32_t) request.type;
if (!(handle = drm_agp_allocate_memory(pages, type))) {
drm_free(entry, sizeof(*entry), DRM_MEM_AGPLISTS);
free(entry, M_DRM);
return ENOMEM;
}
@ -239,7 +238,7 @@ int drm_agp_free(DRM_IOCTL_ARGS)
if (entry->next)
entry->next->prev = entry->prev;
drm_agp_free_memory(entry->handle);
drm_free(entry, sizeof(*entry), DRM_MEM_AGPLISTS);
free(entry, M_DRM);
return 0;
}
@ -256,9 +255,9 @@ drm_agp_head_t *drm_agp_init(void)
DRM_DEBUG("agp_available = %d\n", agp_available);
if (agp_available) {
if (!(head = drm_alloc(sizeof(*head), DRM_MEM_AGPLISTS)))
head = malloc(sizeof(*head), M_DRM, M_NOWAIT | M_ZERO);
if (head == NULL)
return NULL;
bzero((void *)head, sizeof(*head));
head->agpdev = agpdev;
agp_get_info(agpdev, &head->info);
head->memory = NULL;

7
bsd-core/drm_auth.c
View File

@ -63,10 +63,9 @@ static int drm_add_magic(drm_device_t *dev, drm_file_t *priv, drm_magic_t magic)
DRM_DEBUG("%d\n", magic);
hash = drm_hash_magic(magic);
entry = (drm_magic_entry_t*) drm_alloc(sizeof(*entry), DRM_MEM_MAGIC);
hash = drm_hash_magic(magic);
entry = malloc(sizeof(*entry), M_DRM, M_ZERO | M_NOWAIT);
if (!entry) return DRM_ERR(ENOMEM);
memset(entry, 0, sizeof(*entry));
entry->magic = magic;
entry->priv = priv;
entry->next = NULL;
@ -111,7 +110,7 @@ static int drm_remove_magic(drm_device_t *dev, drm_magic_t magic)
}
DRM_UNLOCK();
drm_free(pt, sizeof(*pt), DRM_MEM_MAGIC);
free(pt, M_DRM);
return DRM_ERR(EINVAL);
}

144
bsd-core/drm_bufs.c
View File

@ -60,7 +60,7 @@ int drm_addmap(DRM_IOCTL_ARGS)
DRM_COPY_FROM_USER_IOCTL( request, (drm_map_t *)data, sizeof(drm_map_t) );
map = (drm_local_map_t *) drm_alloc(sizeof(*map), DRM_MEM_MAPS);
map = malloc(sizeof(*map), M_DRM, M_NOWAIT);
if ( !map )
return DRM_ERR(ENOMEM);
@ -76,17 +76,17 @@ int drm_addmap(DRM_IOCTL_ARGS)
* when processes fork.
*/
if ( (map->flags & _DRM_REMOVABLE) && map->type != _DRM_SHM ) {
drm_free(map, sizeof(*map), DRM_MEM_MAPS);
free(map, M_DRM);
return DRM_ERR(EINVAL);
}
DRM_DEBUG( "offset = 0x%08lx, size = 0x%08lx, type = %d\n",
map->offset, map->size, map->type );
if ( (map->offset & PAGE_MASK) || (map->size & PAGE_MASK) ) {
drm_free(map, sizeof(*map), DRM_MEM_MAPS);
free(map, M_DRM);
return DRM_ERR(EINVAL);
}
if (map->offset + map->size < map->offset) {
drm_free(map, sizeof(*map), DRM_MEM_MAPS);
free(map, M_DRM);
return DRM_ERR(EINVAL);
}
@ -101,11 +101,11 @@ int drm_addmap(DRM_IOCTL_ARGS)
map->mtrr = 1;
break;
case _DRM_SHM:
map->handle = (void *)drm_alloc(map->size, DRM_MEM_SAREA);
map->handle = malloc(map->size, M_DRM, M_NOWAIT);
DRM_DEBUG( "%lu %d %p\n",
map->size, drm_order(map->size), map->handle );
if ( !map->handle ) {
drm_free(map, sizeof(*map), DRM_MEM_MAPS);
free(map, M_DRM);
return DRM_ERR(ENOMEM);
}
map->offset = (unsigned long)map->handle;
@ -114,8 +114,8 @@ int drm_addmap(DRM_IOCTL_ARGS)
DRM_LOCK();
if (dev->lock.hw_lock != NULL) {
DRM_UNLOCK();
drm_free(map->handle, map->size, DRM_MEM_SAREA);
drm_free(map, sizeof(*map), DRM_MEM_MAPS);
free(map->handle, M_DRM);
free(map, M_DRM);
return DRM_ERR(EBUSY);
}
dev->lock.hw_lock = map->handle; /* Pointer to lock */
@ -128,20 +128,20 @@ int drm_addmap(DRM_IOCTL_ARGS)
break;
case _DRM_SCATTER_GATHER:
if (!dev->sg) {
drm_free(map, sizeof(*map), DRM_MEM_MAPS);
free(map, M_DRM);
return DRM_ERR(EINVAL);
}
map->offset = map->offset + dev->sg->handle;
break;
default:
drm_free( map, sizeof(*map), DRM_MEM_MAPS );
free(map, M_DRM);
return DRM_ERR(EINVAL);
}
list = drm_calloc(1, sizeof(*list), DRM_MEM_MAPS);
list = malloc(sizeof(*list), M_DRM, M_NOWAIT | M_ZERO);
if (list == NULL) {
drm_free(map, sizeof(*map), DRM_MEM_MAPS);
free(map, M_DRM);
return DRM_ERR(EINVAL);
}
list->map = map;
@ -196,7 +196,7 @@ int drm_rmmap(DRM_IOCTL_ARGS)
TAILQ_REMOVE(dev->maplist, list, link);
DRM_UNLOCK();
drm_free(list, sizeof(*list), DRM_MEM_MAPS);
free(list, M_DRM);
switch (map->type) {
case _DRM_REGISTERS:
@ -211,13 +211,13 @@ int drm_rmmap(DRM_IOCTL_ARGS)
drm_ioremapfree(map);
break;
case _DRM_SHM:
drm_free(map->handle, map->size, DRM_MEM_SAREA);
free(map->handle, M_DRM);
break;
case _DRM_AGP:
case _DRM_SCATTER_GATHER:
break;
}
drm_free(map, sizeof(*map), DRM_MEM_MAPS);
free(map, M_DRM);
return 0;
}
@ -228,30 +228,21 @@ static void drm_cleanup_buf_error(drm_device_t *dev, drm_buf_entry_t *entry)
if (entry->seg_count) {
for (i = 0; i < entry->seg_count; i++) {
if (entry->seglist[i] != 0)
drm_pci_free(dev, entry->buf_size,
(void *)entry->seglist[i],
entry->seglist_bus[i]);
drm_pci_free(dev, entry->buf_size,
(void *)entry->seglist[i],
entry->seglist_bus[i]);
}
drm_free(entry->seglist,
entry->seg_count *
sizeof(*entry->seglist),
DRM_MEM_SEGS);
drm_free(entry->seglist_bus, entry->seg_count *
sizeof(*entry->seglist_bus), DRM_MEM_SEGS);
free(entry->seglist, M_DRM);
free(entry->seglist_bus, M_DRM);
entry->seg_count = 0;
}
if (entry->buf_count) {
for (i = 0; i < entry->buf_count; i++) {
drm_free(entry->buflist[i].dev_private,
entry->buflist[i].dev_priv_size, DRM_MEM_BUFS);
free(entry->buflist[i].dev_private, M_DRM);
}
drm_free(entry->buflist,
entry->buf_count *
sizeof(*entry->buflist),
DRM_MEM_BUFS);
free(entry->buflist, M_DRM);
entry->buf_count = 0;
}
@ -296,12 +287,11 @@ static int drm_addbufs_agp(drm_device_t *dev, drm_buf_desc_t *request)
entry = &dma->bufs[order];
entry->buflist = drm_alloc(count * sizeof(*entry->buflist),
DRM_MEM_BUFS);
entry->buflist = malloc(count * sizeof(*entry->buflist), M_DRM,
M_NOWAIT | M_ZERO);
if ( !entry->buflist ) {
return DRM_ERR(ENOMEM);
}
memset( entry->buflist, 0, count * sizeof(*entry->buflist) );
entry->buf_size = size;
entry->page_order = page_order;
@ -323,8 +313,8 @@ static int drm_addbufs_agp(drm_device_t *dev, drm_buf_desc_t *request)
buf->filp = NULL;
buf->dev_priv_size = dev->dev_priv_size;
buf->dev_private = drm_calloc(1, buf->dev_priv_size,
DRM_MEM_BUFS);
buf->dev_private = malloc(buf->dev_priv_size, M_DRM,
M_NOWAIT | M_ZERO);
if (buf->dev_private == NULL) {
/* Set count correctly so we free the proper amount. */
entry->buf_count = count;
@ -339,11 +329,9 @@ static int drm_addbufs_agp(drm_device_t *dev, drm_buf_desc_t *request)
DRM_DEBUG( "byte_count: %d\n", byte_count );
temp_buflist = drm_realloc(dma->buflist,
dma->buf_count * sizeof(*dma->buflist),
(dma->buf_count + entry->buf_count)
* sizeof(*dma->buflist),
DRM_MEM_BUFS );
temp_buflist = realloc(dma->buflist,
(dma->buf_count + entry->buf_count) * sizeof(*dma->buflist), M_DRM,
M_NOWAIT);
if (temp_buflist == NULL) {
/* Free the entry because it isn't valid */
drm_cleanup_buf_error(dev, entry);
@ -403,32 +391,26 @@ static int drm_addbufs_pci(drm_device_t *dev, drm_buf_desc_t *request)
entry = &dma->bufs[order];
entry->buflist = drm_alloc(count * sizeof(*entry->buflist),
DRM_MEM_BUFS);
entry->seglist = drm_alloc(count * sizeof(*entry->seglist),
DRM_MEM_SEGS);
entry->seglist_bus = drm_alloc(count * sizeof(*entry->seglist_bus),
DRM_MEM_SEGS);
entry->buflist = malloc(count * sizeof(*entry->buflist), M_DRM,
M_NOWAIT | M_ZERO);
entry->seglist = malloc(count * sizeof(*entry->seglist), M_DRM,
M_NOWAIT | M_ZERO);
entry->seglist_bus = malloc(count * sizeof(*entry->seglist_bus), M_DRM,
M_NOWAIT | M_ZERO);
/* Keep the original pagelist until we know all the allocations
* have succeeded
*/
temp_pagelist = drm_alloc((dma->page_count + (count << page_order)) *
sizeof(*dma->pagelist), DRM_MEM_PAGES);
temp_pagelist = malloc((dma->page_count + (count << page_order)) *
sizeof(*dma->pagelist), M_DRM, M_NOWAIT);
if (entry->buflist == NULL || entry->seglist == NULL ||
temp_pagelist == NULL) {
drm_free(entry->buflist, count * sizeof(*entry->buflist),
DRM_MEM_BUFS);
drm_free(entry->seglist, count * sizeof(*entry->seglist),
DRM_MEM_SEGS);
drm_free(entry->seglist_bus, count *
sizeof(*entry->seglist_bus), DRM_MEM_SEGS);
entry->seglist_bus == NULL || temp_pagelist == NULL) {
free(entry->buflist, M_DRM);
free(entry->seglist, M_DRM);
free(entry->seglist_bus, M_DRM);
return DRM_ERR(ENOMEM);
}
bzero(entry->buflist, count * sizeof(*entry->buflist));
bzero(entry->seglist, count * sizeof(*entry->seglist));
memcpy(temp_pagelist, dma->pagelist, dma->page_count *
sizeof(*dma->pagelist));
@ -449,9 +431,7 @@ static int drm_addbufs_pci(drm_device_t *dev, drm_buf_desc_t *request)
entry->buf_count = count;
entry->seg_count = count;
drm_cleanup_buf_error(dev, entry);
drm_free(temp_pagelist, (dma->page_count +
(count << page_order)) * sizeof(*dma->pagelist),
DRM_MEM_PAGES);
free(temp_pagelist, M_DRM);
return DRM_ERR(ENOMEM);
}
@ -480,19 +460,16 @@ static int drm_addbufs_pci(drm_device_t *dev, drm_buf_desc_t *request)
buf->filp = NULL;
buf->dev_priv_size = dev->dev_priv_size;
buf->dev_private = drm_alloc(buf->dev_priv_size,
DRM_MEM_BUFS);
buf->dev_private = malloc(buf->dev_priv_size, M_DRM,
M_NOWAIT | M_ZERO);
if (buf->dev_private == NULL) {
/* Set count correctly so we free the proper amount. */
entry->buf_count = count;
entry->seg_count = count;
drm_cleanup_buf_error(dev, entry);
drm_free(temp_pagelist, (dma->page_count +
(count << page_order)) *
sizeof(*dma->pagelist), DRM_MEM_PAGES );
free(temp_pagelist, M_DRM);
return DRM_ERR(ENOMEM);
}
bzero(buf->dev_private, buf->dev_priv_size);
DRM_DEBUG( "buffer %d @ %p\n",
entry->buf_count, buf->address );
@ -500,17 +477,13 @@ static int drm_addbufs_pci(drm_device_t *dev, drm_buf_desc_t *request)
byte_count += PAGE_SIZE << page_order;
}
temp_buflist = drm_realloc(dma->buflist,
dma->buf_count * sizeof(*dma->buflist),
(dma->buf_count + entry->buf_count)
* sizeof(*dma->buflist),
DRM_MEM_BUFS);
temp_buflist = realloc(dma->buflist,
(dma->buf_count + entry->buf_count) * sizeof(*dma->buflist), M_DRM,
M_NOWAIT);
if (temp_buflist == NULL) {
/* Free the entry because it isn't valid */
drm_cleanup_buf_error(dev, entry);
drm_free(temp_pagelist, (dma->page_count +
(count << page_order)) * sizeof(*dma->pagelist),
DRM_MEM_PAGES);
free(temp_pagelist, M_DRM);
return DRM_ERR(ENOMEM);
}
dma->buflist = temp_buflist;
@ -522,8 +495,7 @@ static int drm_addbufs_pci(drm_device_t *dev, drm_buf_desc_t *request)
/* No allocations failed, so now we can replace the orginal pagelist
* with the new one.
*/
drm_free(dma->pagelist, dma->page_count * sizeof(*dma->pagelist),
DRM_MEM_PAGES);
free(dma->pagelist, M_DRM);
dma->pagelist = temp_pagelist;
dma->buf_count += entry->buf_count;
@ -577,8 +549,8 @@ static int drm_addbufs_sg(drm_device_t *dev, drm_buf_desc_t *request)
entry = &dma->bufs[order];
entry->buflist = drm_calloc(1, count * sizeof(*entry->buflist),
DRM_MEM_BUFS);
entry->buflist = malloc(count * sizeof(*entry->buflist), M_DRM,
M_NOWAIT | M_ZERO);
if (entry->buflist == NULL)
return DRM_ERR(ENOMEM);
@ -602,8 +574,8 @@ static int drm_addbufs_sg(drm_device_t *dev, drm_buf_desc_t *request)
buf->filp = NULL;
buf->dev_priv_size = dev->dev_priv_size;
buf->dev_private = drm_calloc(1, buf->dev_priv_size,
DRM_MEM_BUFS);
buf->dev_private = malloc(buf->dev_priv_size, M_DRM,
M_NOWAIT | M_ZERO);
if (buf->dev_private == NULL) {
/* Set count correctly so we free the proper amount. */
entry->buf_count = count;
@ -621,11 +593,9 @@ static int drm_addbufs_sg(drm_device_t *dev, drm_buf_desc_t *request)
DRM_DEBUG( "byte_count: %d\n", byte_count );
temp_buflist = drm_realloc(dma->buflist,
dma->buf_count * sizeof(*dma->buflist),
(dma->buf_count + entry->buf_count)
* sizeof(*dma->buflist),
DRM_MEM_BUFS );
temp_buflist = realloc(dma->buflist,
(dma->buf_count + entry->buf_count) * sizeof(*dma->buflist), M_DRM,
M_NOWAIT);
if (temp_buflist == NULL) {
/* Free the entry because it isn't valid */
drm_cleanup_buf_error(dev, entry);

21
bsd-core/drm_context.c
View File

@ -73,12 +73,9 @@ int drm_ctxbitmap_next(drm_device_t *dev)
if (dev->context_sareas != NULL) {
drm_local_map_t **ctx_sareas;
ctx_sareas = drm_realloc(dev->context_sareas,
(dev->max_context - 1) *
sizeof(*dev->context_sareas),
dev->max_context *
sizeof(*dev->context_sareas),
DRM_MEM_MAPS);
ctx_sareas = realloc(dev->context_sareas,
dev->max_context * sizeof(*dev->context_sareas),
M_DRM, M_NOWAIT);
if (ctx_sareas == NULL) {
clear_bit(bit, dev->ctx_bitmap);
DRM_UNLOCK();
@ -88,8 +85,8 @@ int drm_ctxbitmap_next(drm_device_t *dev)
dev->context_sareas[bit] = NULL;
} else {
/* max_context == 1 at this point */
dev->context_sareas = drm_alloc(dev->max_context *
sizeof(*dev->context_sareas), DRM_MEM_MAPS);
dev->context_sareas = malloc(dev->max_context *
sizeof(*dev->context_sareas), M_DRM, M_NOWAIT);
if (dev->context_sareas == NULL) {
clear_bit(bit, dev->ctx_bitmap);
DRM_UNLOCK();
@ -108,8 +105,7 @@ int drm_ctxbitmap_init(drm_device_t *dev)
int temp;
DRM_LOCK();
dev->ctx_bitmap = (atomic_t *)drm_calloc(1, PAGE_SIZE,
DRM_MEM_CTXBITMAP);
dev->ctx_bitmap = malloc(PAGE_SIZE, M_DRM, M_NOWAIT | M_ZERO);
if ( dev->ctx_bitmap == NULL ) {
DRM_UNLOCK();
return DRM_ERR(ENOMEM);
@ -130,9 +126,8 @@ void drm_ctxbitmap_cleanup(drm_device_t *dev)
{
DRM_LOCK();
if (dev->context_sareas != NULL)
drm_free(dev->context_sareas, sizeof(*dev->context_sareas) *
dev->max_context, DRM_MEM_MAPS);
drm_free((void *)dev->ctx_bitmap, PAGE_SIZE, DRM_MEM_CTXBITMAP);
free(dev->context_sareas, M_DRM);
free(dev->ctx_bitmap, M_DRM);
DRM_UNLOCK();
}

37
bsd-core/drm_dma.c
View File

@ -35,7 +35,7 @@
int drm_dma_setup(drm_device_t *dev)
{
dev->dma = drm_calloc(1, sizeof(*dev->dma), DRM_MEM_DRIVER);
dev->dma = malloc(sizeof(*dev->dma), M_DRM, M_NOWAIT | M_ZERO);
if (dev->dma == NULL)
return DRM_ERR(ENOMEM);
@ -61,39 +61,26 @@ void drm_dma_takedown(drm_device_t *dev)
dma->bufs[i].buf_count,
dma->bufs[i].seg_count);
for (j = 0; j < dma->bufs[i].seg_count; j++) {
if (dma->bufs[i].seglist[j] != 0)
drm_pci_free(dev, dma->bufs[i].buf_size,
(void *)dma->bufs[i].seglist[j],
dma->bufs[i].seglist_bus[j]);
drm_pci_free(dev, dma->bufs[i].buf_size,
(void *)dma->bufs[i].seglist[j],
dma->bufs[i].seglist_bus[j]);
}
drm_free(dma->bufs[i].seglist,
dma->bufs[i].seg_count
* sizeof(*dma->bufs[0].seglist),
DRM_MEM_SEGS);
drm_free(dma->bufs[i].seglist_bus,
dma->bufs[i].seg_count
* sizeof(*dma->bufs[0].seglist_bus),
DRM_MEM_SEGS);
free(dma->bufs[i].seglist, M_DRM);
free(dma->bufs[i].seglist_bus, M_DRM);
}
if (dma->bufs[i].buf_count) {
for (j = 0; j < dma->bufs[i].buf_count; j++) {
drm_free(dma->bufs[i].buflist[j].dev_private,
dma->bufs[i].buflist[j].dev_priv_size,
DRM_MEM_BUFS);
free(dma->bufs[i].buflist[j].dev_private,
M_DRM);
}
drm_free(dma->bufs[i].buflist,
dma->bufs[i].buf_count *
sizeof(*dma->bufs[0].buflist),
DRM_MEM_BUFS);
free(dma->bufs[i].buflist, M_DRM);
}
}
drm_free(dma->buflist, dma->buf_count * sizeof(*dma->buflist),
DRM_MEM_BUFS);
drm_free(dma->pagelist, dma->page_count * sizeof(*dma->pagelist),
DRM_MEM_PAGES);
drm_free(dev->dma, sizeof(*dev->dma), DRM_MEM_DRIVER);
free(dma->buflist, M_DRM);
free(dma->pagelist, M_DRM);
free(dev->dma, M_DRM);
dev->dma = NULL;
DRM_SPINUNINIT(dev->dma_lock);
}

28
bsd-core/drm_drv.c
View File

@ -275,8 +275,7 @@ void drm_attach(struct pci_attach_args *pa, dev_t kdev,
drm_device_t *dev;
config_makeroom(kdev, &drm_cd);
drm_cd.cd_devs[(kdev)] = drm_alloc(sizeof(drm_device_t),
DRM_MEM_DRIVER);
drm_cd.cd_devs[(kdev)] = malloc(sizeof(drm_device_t), M_DRM, M_WAITOK);
dev = DRIVER_SOFTC(kdev);
memset(dev, 0, sizeof(drm_device_t));
@ -393,8 +392,7 @@ static int drm_takedown(drm_device_t *dev)
drm_irq_uninstall(dev);
if ( dev->unique ) {
drm_free(dev->unique, strlen( dev->unique ) + 1,
DRM_MEM_DRIVER);
free(dev->unique, M_DRM);
dev->unique = NULL;
dev->unique_len = 0;
}
@ -402,7 +400,7 @@ static int drm_takedown(drm_device_t *dev)
for ( i = 0 ; i < DRM_HASH_SIZE ; i++ ) {
for ( pt = dev->magiclist[i].head ; pt ; pt = next ) {
next = pt->next;
drm_free(pt, sizeof(*pt), DRM_MEM_MAGIC);
free(pt, M_DRM);
}
dev->magiclist[i].head = dev->magiclist[i].tail = NULL;
}
@ -419,7 +417,7 @@ static int drm_takedown(drm_device_t *dev)
if ( entry->bound )
drm_agp_unbind_memory(entry->handle);
drm_agp_free_memory(entry->handle);
drm_free(entry, sizeof(*entry), DRM_MEM_AGPLISTS);
free(entry, M_DRM);
}
dev->agp->memory = NULL;
@ -451,9 +449,7 @@ static int drm_takedown(drm_device_t *dev)
}
break;
case _DRM_SHM:
drm_free(map->handle,
map->size,
DRM_MEM_SAREA);
free(map->handle, M_DRM);
break;
case _DRM_AGP:
@ -464,8 +460,8 @@ static int drm_takedown(drm_device_t *dev)
break;
}
TAILQ_REMOVE(dev->maplist, list, link);
drm_free(list, sizeof(*list), DRM_MEM_MAPS);
drm_free(map, sizeof(*map), DRM_MEM_MAPS);
free(list, M_DRM);
free(map, M_DRM);
}
}
@ -526,7 +522,7 @@ static int drm_init(device_t nbdev)
dev->pci_slot = pci_get_slot(dev->device);
dev->pci_func = pci_get_function(dev->device);
dev->maplist = drm_calloc(1, sizeof(*dev->maplist), DRM_MEM_MAPS);
dev->maplist = malloc(sizeof(*dev->maplist), M_DRM, M_WAITOK);
if (dev->maplist == NULL) {
retcode = ENOMEM;
goto error;
@ -585,7 +581,7 @@ error:
mtx_destroy(&dev->dev_lock);
#endif
#endif
drm_free(dev->maplist, sizeof(*dev->maplist), DRM_MEM_MAPS);
free(dev->maplist, M_DRM);
return retcode;
}
@ -619,7 +615,7 @@ static void drm_cleanup(drm_device_t *dev)
if ( dev->agp ) {
drm_agp_uninit();
drm_free(dev->agp, sizeof(*dev->agp), DRM_MEM_AGPLISTS);
free(dev->agp, M_DRM);
dev->agp = NULL;
}
@ -630,7 +626,7 @@ static void drm_cleanup(drm_device_t *dev)
#if defined(__FreeBSD__) && __FreeBSD_version >= 500000
mtx_destroy(&dev->dev_lock);
#endif
drm_free(dev->maplist, sizeof(*dev->maplist), DRM_MEM_MAPS);
free(dev->maplist, M_DRM);
}
@ -783,7 +779,7 @@ int drm_close(struct cdev *kdev, int flags, int fmt, DRM_STRUCTPROC *p)
if (--priv->refs == 0) {
TAILQ_REMOVE(&dev->files, priv, link);
drm_free(priv, sizeof(*priv), DRM_MEM_FILES);
free(priv, M_DRM);
}
/* ========================================================

3
bsd-core/drm_fops.c
View File

@ -70,12 +70,11 @@ int drm_open_helper(struct cdev *kdev, int flags, int fmt, DRM_STRUCTPROC *p,
if (priv) {
priv->refs++;
} else {
priv = (drm_file_t *)drm_alloc(sizeof(*priv), DRM_MEM_FILES);
priv = malloc(sizeof(*priv), M_DRM, M_NOWAIT | M_ZERO);
if (priv == NULL) {
DRM_UNLOCK();
return DRM_ERR(ENOMEM);
}
bzero(priv, sizeof(*priv));
#if __FreeBSD_version >= 500000
priv->uid = p->td_ucred->cr_svuid;
priv->pid = p->td_proc->p_pid;

4
bsd-core/drm_ioctl.c
View File

@ -74,7 +74,7 @@ int drm_setunique(DRM_IOCTL_ARGS)
return DRM_ERR(EINVAL);
dev->unique_len = u.unique_len;
dev->unique = drm_alloc(u.unique_len + 1, DRM_MEM_DRIVER);
dev->unique = malloc(u.unique_len + 1, M_DRM, M_NOWAIT);
if (dev->unique == NULL)
return DRM_ERR(ENOMEM);
@ -111,7 +111,7 @@ drm_set_busid(drm_device_t *dev)
return EBUSY;
dev->unique_len = 20;
dev->unique = drm_alloc(dev->unique_len + 1, DRM_MEM_DRIVER);
dev->unique = malloc(dev->unique_len + 1, M_DRM, M_NOWAIT);
if (dev->unique == NULL)
return ENOMEM;

6
bsd-core/drm_irq.c
View File

@ -224,11 +224,11 @@ int drm_wait_vblank(DRM_IOCTL_ARGS)
flags = vblwait.request.type & _DRM_VBLANK_FLAGS_MASK;
if (flags & _DRM_VBLANK_SIGNAL) {
#if 0 /* disabled */
drm_vbl_sig_t *vbl_sig = DRM_MALLOC(sizeof(drm_vbl_sig_t));
drm_vbl_sig_t *vbl_sig = malloc(sizeof(drm_vbl_sig_t), M_DRM,
M_NOWAIT | M_ZERO);
if (vbl_sig == NULL)
return ENOMEM;
bzero(vbl_sig, sizeof(*vbl_sig));
vbl_sig->sequence = vblwait.request.sequence;
vbl_sig->signo = vblwait.request.signal;
vbl_sig->pid = DRM_CURRENTPID;

2
bsd-core/drm_pci.c
View File

@ -58,6 +58,8 @@ void
drm_pci_free(drm_device_t *dev, size_t size, void *vaddr, dma_addr_t busaddr)
{
#if __FreeBSD_version > 500000
if (vaddr == NULL)
return;
contigfree(vaddr, size, M_DRM); /* Not available on 4.x */
#endif
}

27
bsd-core/drm_scatter.c
View File

@ -37,10 +37,8 @@ void drm_sg_cleanup(drm_sg_mem_t *entry)
{
free(entry->virtual, M_DRM);
drm_free(entry->busaddr,
entry->pages * sizeof(*entry->busaddr),
DRM_MEM_PAGES );
drm_free(entry, sizeof(*entry), DRM_MEM_SGLISTS);
free(entry->busaddr, M_DRM);
free(entry, M_DRM);
}
int drm_sg_alloc(DRM_IOCTL_ARGS)
@ -58,36 +56,29 @@ int drm_sg_alloc(DRM_IOCTL_ARGS)
DRM_COPY_FROM_USER_IOCTL(request, (drm_scatter_gather_t *)data,
sizeof(request) );
entry = drm_alloc(sizeof(*entry), DRM_MEM_SGLISTS);
entry = malloc(sizeof(*entry), M_DRM, M_NOWAIT | M_ZERO);
if ( !entry )
return ENOMEM;
bzero( entry, sizeof(*entry) );
pages = round_page(request.size) / PAGE_SIZE;
DRM_DEBUG( "sg size=%ld pages=%ld\n", request.size, pages );
entry->pages = pages;
entry->busaddr = drm_alloc(pages * sizeof(*entry->busaddr),
DRM_MEM_PAGES);
entry->busaddr = malloc(pages * sizeof(*entry->busaddr), M_DRM,
M_NOWAIT | M_ZERO);
if ( !entry->busaddr ) {
drm_free(entry, sizeof(*entry), DRM_MEM_SGLISTS);
free(entry, M_DRM);
return ENOMEM;
}
bzero( (void *)entry->busaddr, pages * sizeof(*entry->busaddr) );
entry->virtual = malloc(pages << PAGE_SHIFT, M_DRM, M_WAITOK);
entry->virtual = malloc(pages << PAGE_SHIFT, M_DRM, M_WAITOK | M_ZERO);
if ( !entry->virtual ) {
drm_free(entry->busaddr,
entry->pages * sizeof(*entry->busaddr),
DRM_MEM_PAGES);
drm_free(entry, sizeof(*entry), DRM_MEM_SGLISTS);
free(entry->busaddr, M_DRM);
free(entry, M_DRM);
return ENOMEM;
}
bzero( entry->virtual, pages << PAGE_SHIFT );
entry->handle = (unsigned long)entry->virtual;
DRM_DEBUG( "sg alloc handle = %08lx\n", entry->handle );

17
bsd-core/drm_sysctl.c
View File

@ -55,10 +55,9 @@ int drm_sysctl_init(drm_device_t *dev)
struct sysctl_oid *top, *drioid;
int i;
info = drm_alloc(sizeof *info, DRM_MEM_DRIVER);
info = malloc(sizeof *info, M_DRM, M_WAITOK | M_ZERO);
if ( !info )
return 1;
bzero(info, sizeof *info);
dev->sysctl = info;
/* Add the sysctl node for DRI if it doesn't already exist */
@ -108,7 +107,7 @@ int drm_sysctl_cleanup(drm_device_t *dev)
int error;
error = sysctl_ctx_free( &dev->sysctl->ctx );
drm_free(dev->sysctl, sizeof *dev->sysctl, DRM_MEM_DRIVER);
free(dev->sysctl, M_DRM);
dev->sysctl = NULL;
return error;
@ -167,7 +166,7 @@ static int drm_vm_info DRM_SYSCTL_HANDLER_ARGS
TAILQ_FOREACH(listentry, dev->maplist, link)
mapcount++;
tempmaps = drm_alloc(sizeof(drm_local_map_t) * mapcount, DRM_MEM_MAPS);
tempmaps = malloc(sizeof(drm_local_map_t) * mapcount, M_DRM, M_NOWAIT);
if (tempmaps == NULL) {
DRM_UNLOCK();
return ENOMEM;
@ -203,7 +202,7 @@ static int drm_vm_info DRM_SYSCTL_HANDLER_ARGS
SYSCTL_OUT(req, "", 1);
done:
drm_free(tempmaps, sizeof(drm_local_map_t) * mapcount, DRM_MEM_MAPS);
free(tempmaps, M_DRM);
return retcode;
}
@ -227,7 +226,7 @@ static int drm_bufs_info DRM_SYSCTL_HANDLER_ARGS
}
DRM_SPINLOCK(&dev->dma_lock);
tempdma = *dma;
templists = drm_alloc(sizeof(int) * dma->buf_count, DRM_MEM_BUFS);
templists = malloc(sizeof(int) * dma->buf_count, M_DRM, M_NOWAIT);
for (i = 0; i < dma->buf_count; i++)
templists[i] = dma->buflist[i]->list;
dma = &tempdma;
@ -259,7 +258,7 @@ static int drm_bufs_info DRM_SYSCTL_HANDLER_ARGS
SYSCTL_OUT(req, "", 1);
done:
drm_free(templists, sizeof(int) * dma->buf_count, DRM_MEM_BUFS);
free(templists, M_DRM);
return retcode;
}
@ -277,7 +276,7 @@ static int drm_clients_info DRM_SYSCTL_HANDLER_ARGS
TAILQ_FOREACH(priv, &dev->files, link)
privcount++;
tempprivs = drm_alloc(sizeof(drm_file_t) * privcount, DRM_MEM_FILES);
tempprivs = malloc(sizeof(drm_file_t) * privcount, M_DRM, M_NOWAIT);
if (tempprivs == NULL) {
DRM_UNLOCK();
return ENOMEM;
@ -302,6 +301,6 @@ static int drm_clients_info DRM_SYSCTL_HANDLER_ARGS
SYSCTL_OUT(req, "", 1);
done:
drm_free(tempprivs, sizeof(drm_file_t) * privcount, DRM_MEM_FILES);
free(tempprivs, M_DRM);
return retcode;
}