From fa3fdbd99c6b6e5cec59f1044ce6ce1105b5e8dd Mon Sep 17 00:00:00 2001 From: Eric Anholt Date: Sun, 7 Nov 2004 00:25:49 +0000 Subject: 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. --- bsd-core/drm_agpsupport.c | 13 ++--- bsd-core/drm_auth.c | 7 +-- bsd-core/drm_bufs.c | 144 ++++++++++++++++++---------------------------- bsd-core/drm_context.c | 21 +++---- bsd-core/drm_dma.c | 37 ++++-------- bsd-core/drm_drv.c | 28 ++++----- bsd-core/drm_fops.c | 3 +- bsd-core/drm_ioctl.c | 4 +- bsd-core/drm_irq.c | 6 +- bsd-core/drm_pci.c | 2 + bsd-core/drm_scatter.c | 27 +++------ bsd-core/drm_sysctl.c | 17 +++--- 12 files changed, 123 insertions(+), 186 deletions(-) diff --git a/bsd-core/drm_agpsupport.c b/bsd-core/drm_agpsupport.c index eecf2e59..e26be833 100644 --- a/bsd-core/drm_agpsupport.c +++ b/bsd-core/drm_agpsupport.c @@ -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; diff --git a/bsd-core/drm_auth.c b/bsd-core/drm_auth.c index c04c6546..fb556f33 100644 --- a/bsd-core/drm_auth.c +++ b/bsd-core/drm_auth.c @@ -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); } diff --git a/bsd-core/drm_bufs.c b/bsd-core/drm_bufs.c index 860b38b5..26007a4d 100644 --- a/bsd-core/drm_bufs.c +++ b/bsd-core/drm_bufs.c @@ -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); diff --git a/bsd-core/drm_context.c b/bsd-core/drm_context.c index 87185f4e..d785d361 100644 --- a/bsd-core/drm_context.c +++ b/bsd-core/drm_context.c @@ -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(); } diff --git a/bsd-core/drm_dma.c b/bsd-core/drm_dma.c index 28828703..f421eb8f 100644 --- a/bsd-core/drm_dma.c +++ b/bsd-core/drm_dma.c @@ -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); } diff --git a/bsd-core/drm_drv.c b/bsd-core/drm_drv.c index 21cf8f79..7880f76c 100644 --- a/bsd-core/drm_drv.c +++ b/bsd-core/drm_drv.c @@ -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); } /* ======================================================== diff --git a/bsd-core/drm_fops.c b/bsd-core/drm_fops.c index 072a6e22..eeb4847a 100644 --- a/bsd-core/drm_fops.c +++ b/bsd-core/drm_fops.c @@ -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; diff --git a/bsd-core/drm_ioctl.c b/bsd-core/drm_ioctl.c index 014c6b4e..829a99fe 100644 --- a/bsd-core/drm_ioctl.c +++ b/bsd-core/drm_ioctl.c @@ -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; diff --git a/bsd-core/drm_irq.c b/bsd-core/drm_irq.c index 32ad5a61..eb32bac4 100644 --- a/bsd-core/drm_irq.c +++ b/bsd-core/drm_irq.c @@ -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; diff --git a/bsd-core/drm_pci.c b/bsd-core/drm_pci.c index 07b8a643..4c8941d0 100644 --- a/bsd-core/drm_pci.c +++ b/bsd-core/drm_pci.c @@ -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 } diff --git a/bsd-core/drm_scatter.c b/bsd-core/drm_scatter.c index 82e6ef9a..03e82439 100644 --- a/bsd-core/drm_scatter.c +++ b/bsd-core/drm_scatter.c @@ -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 ); diff --git a/bsd-core/drm_sysctl.c b/bsd-core/drm_sysctl.c index 09cba5b9..d1a3dd8f 100644 --- a/bsd-core/drm_sysctl.c +++ b/bsd-core/drm_sysctl.c @@ -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; } -- cgit v1.2.3