tech-x11 archive
[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index][Old Index]
Re: DRM scatter/gather mem allocation fix
On Sat, Apr 04, 2009 at 06:39:57AM +0000, Andrew Doran wrote:
> On Fri, Apr 03, 2009 at 09:19:09PM -0400, Rafal Boni wrote:
>
> > - entry = malloc(sizeof(*entry), M_DRM, M_WAITOK | M_ZERO);
> > + entry = malloc(sizeof(*entry), M_DRM, M_ZERO | M_NOWAIT);
> ...
> > + M_ZERO | M_NOWAIT);
> > + dmah = malloc(sizeof(struct drm_dma_handle), M_DRM,
> > + M_ZERO | M_NOWAIT);
> ...
> > + ret = bus_dmamem_alloc(dmah->dmat, request->size, PAGE_SIZE, 0,
> > + dmah->segs, 1, &nsegs, BUS_DMA_NOWAIT);
> ...
> > + ret = bus_dmamem_map(dmah->dmat, dmah->segs, nsegs, request->size,
> > + &dmah->addr, BUS_DMA_NOWAIT | BUS_DMA_COHERENT);
> ...
> > + ret = bus_dmamap_create(dmah->dmat, request->size, pages, PAGE_SIZE,
> > + 0, BUS_DMA_NOWAIT | BUS_DMA_ALLOCNOW, &dmah->map);
>
> - Do these need to be NOWAIT allocations? See kmem_alloc(9)
> - Can you use kmem_alloc+kmem_free?
I suspect not; I've converted things over to kmem_alloc(9) / kmem_free(9)
and make them all KM_SLEEP. The NOWAITS / ALLOCNOW's came over from the
rev in FreeBSD; I'm not sure what their rationale for that was, but it
doesn't to be required / the right thing here.
I've also removed the ALLOCNOW since we do the bus_dma_load() immediately
after creating the map; it shouldn't matter if we get a failure in one
vs. the other.
Finally, I fixed up the sg_free() ioctl logic and removed the big XXX
since the incorrect input-only definition for the sg_alloc ioctl has
been fixed in our xsrc DRM includes (thanks mrg@ for helping find the
right copy of that file...).
Updated patch (and complete new drm_scatter.c) attached.. and is running
happily on my T43.
Thanks for the feedback!
--rafal
--
Time is an illusion; lunchtime, doubly so. |/\/\| Rafal Boni
-- Ford Prefect |\/\/|
rafal%pobox.com@localhost
diff --git a/sys/dev/drm/drmP.h b/sys/dev/drm/drmP.h
index 3ffce87..9984f12 100644
--- a/sys/dev/drm/drmP.h
+++ b/sys/dev/drm/drmP.h
@@ -698,11 +698,13 @@ typedef struct drm_agp_head {
} drm_agp_head_t;
typedef struct drm_sg_mem {
- unsigned long handle;
- void *virtual;
- int pages;
- dma_addr_t *busaddr;
- drm_dma_handle_t *dmah; /* Handle to PCI memory for ATI PCIGART table */
+ unsigned long handle;
+ void *virtual;
+ int pages;
+ dma_addr_t *busaddr;
+ struct drm_dma_handle *sg_dmah; /* Handle for sg_pages */
+ struct drm_dma_handle *dmah; /* Handle to PCI memory */
+ /* for ATI PCIGART table */
} drm_sg_mem_t;
typedef TAILQ_HEAD(drm_map_list, drm_local_map) drm_map_list_t;
@@ -1057,6 +1059,7 @@ int drm_agp_unbind(drm_device_t *dev,
drm_agp_binding_t *request);
/* Scatter Gather Support (drm_scatter.c) */
void drm_sg_cleanup(drm_sg_mem_t *entry);
+int drm_sg_alloc(struct drm_device *dev, struct drm_scatter_gather *
request);
#if defined(__FreeBSD__) || defined (__NetBSD__)
/* sysctl support (drm_sysctl.h) */
@@ -1131,8 +1134,8 @@ int drm_agp_unbind_ioctl(DRM_IOCTL_ARGS);
int drm_agp_bind_ioctl(DRM_IOCTL_ARGS);
/* Scatter Gather Support (drm_scatter.c) */
-int drm_sg_alloc(DRM_IOCTL_ARGS);
-int drm_sg_free(DRM_IOCTL_ARGS);
+int drm_sg_alloc_ioctl(DRM_IOCTL_ARGS);
+int drm_sg_free_ioctl(DRM_IOCTL_ARGS);
/* consistent PCI memory functions (drm_pci.c) */
drm_dma_handle_t *drm_pci_alloc(drm_device_t *dev, size_t size, size_t align,
diff --git a/sys/dev/drm/drm_drv.c b/sys/dev/drm/drm_drv.c
index 046f9c8..31a908b 100644
--- a/sys/dev/drm/drm_drv.c
+++ b/sys/dev/drm/drm_drv.c
@@ -114,8 +114,8 @@ static drm_ioctl_desc_t drm_ioctls[256] = {
[DRM_IOCTL_NR(DRM_IOCTL_AGP_BIND)] = { drm_agp_bind_ioctl,
DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY },
[DRM_IOCTL_NR(DRM_IOCTL_AGP_UNBIND)] = { drm_agp_unbind_ioctl,
DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY },
- [DRM_IOCTL_NR(DRM_IOCTL_SG_ALLOC)] = { drm_sg_alloc,
DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY },
- [DRM_IOCTL_NR(DRM_IOCTL_SG_FREE)] = { drm_sg_free,
DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY },
+ [DRM_IOCTL_NR(DRM_IOCTL_SG_ALLOC)] = { drm_sg_alloc_ioctl,
DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY },
+ [DRM_IOCTL_NR(DRM_IOCTL_SG_FREE)] = { drm_sg_free_ioctl,
DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY },
[DRM_IOCTL_NR(DRM_IOCTL_WAIT_VBLANK)] = { drm_wait_vblank, 0 },
};
diff --git a/sys/dev/drm/drm_scatter.c b/sys/dev/drm/drm_scatter.c
index 90326df..68c9f56 100644
--- a/sys/dev/drm/drm_scatter.c
+++ b/sys/dev/drm/drm_scatter.c
@@ -37,68 +37,102 @@ __KERNEL_RCSID(0, "$NetBSD: drm_scatter.c,v 1.7 2008/07/07
00:33:23 mrg Exp $");
__FBSDID("$FreeBSD: src/sys/dev/drm/drm_scatter.c,v 1.3 2006/05/17 06:29:36
anholt Exp $");
*/
-#include "drmP.h"
-
-#define DEBUG_SCATTER 0
+/** @file drm_scatter.c
+ * Allocation of memory for scatter-gather mappings by the graphics chip.
+ *
+ * The memory allocated here is then made into an aperture in the card
+ * by drm_ati_pcigart_init().
+ */
-void drm_sg_cleanup(drm_sg_mem_t *entry)
-{
- free((void *)entry->handle, M_DRM);
- free(entry->busaddr, M_DRM);
- free(entry, M_DRM);
-}
+#include "drmP.h"
-int drm_sg_alloc(DRM_IOCTL_ARGS)
+int
+drm_sg_alloc(struct drm_device *dev, struct drm_scatter_gather *request)
{
- DRM_DEVICE;
- drm_scatter_gather_t request;
drm_sg_mem_t *entry;
+ struct drm_dma_handle *dmah;
unsigned long pages;
- int i;
-
- DRM_DEBUG( "%s\n", __FUNCTION__ );
-
- if ( dev->sg )
- return EINVAL;
-
- DRM_COPY_FROM_USER_IOCTL(request, (drm_scatter_gather_t *)data,
- sizeof(request) );
+ int nsegs, ret, i;
- entry = malloc(sizeof(*entry), M_DRM, M_WAITOK | M_ZERO);
+ entry = kmem_zalloc(sizeof(*entry), KM_SLEEP);
if ( !entry )
return ENOMEM;
- pages = round_page(request.size) / PAGE_SIZE;
- DRM_DEBUG( "sg size=%ld pages=%ld\n", request.size, pages );
+ pages = round_page(request->size) / PAGE_SIZE;
+ DRM_DEBUG( "sg size=%ld pages=%ld\n", request->size, pages );
entry->pages = pages;
- entry->busaddr = malloc(pages * sizeof(*entry->busaddr), M_DRM,
- M_WAITOK | M_ZERO);
+ entry->busaddr = kmem_zalloc(pages * sizeof(*entry->busaddr), KM_SLEEP);
if ( !entry->busaddr ) {
- drm_sg_cleanup(entry);
+ kmem_free(entry, sizeof(*entry));
return ENOMEM;
}
- entry->handle = (long)malloc(pages << PAGE_SHIFT, M_DRM,
- M_WAITOK | M_ZERO);
- if (entry->handle == 0) {
- drm_sg_cleanup(entry);
+ dmah = kmem_zalloc(sizeof(struct drm_dma_handle), KM_SLEEP);
+ if (dmah == NULL) {
+ kmem_free(entry->busaddr, pages * sizeof(*entry->busaddr));
+ kmem_free(entry, sizeof(*entry));
+ return ENOMEM;
+ }
+
+ dmah->dmat = dev->pa.pa_dmat;
+
+ ret = bus_dmamem_alloc(dmah->dmat, request->size, PAGE_SIZE, 0,
+ dmah->segs, 1, &nsegs, 0);
+ if (ret != 0) {
+ kmem_free(dmah, sizeof(struct drm_dma_handle));
+ kmem_free(entry->busaddr, pages * sizeof(*entry->busaddr));
+ kmem_free(entry, sizeof(*entry));
+ return ENOMEM;
+ }
+
+ ret = bus_dmamem_map(dmah->dmat, dmah->segs, nsegs, request->size,
+ &dmah->addr, BUS_DMA_COHERENT);
+ if (ret != 0) {
+ bus_dmamem_free(dmah->dmat, dmah->segs, nsegs);
+ kmem_free(dmah, sizeof(struct drm_dma_handle));
+ kmem_free(entry->busaddr, pages * sizeof(*entry->busaddr));
+ kmem_free(entry, sizeof(*entry));
+ return ENOMEM;
+ }
+
+ ret = bus_dmamap_create(dmah->dmat, request->size, pages, PAGE_SIZE,
+ 0, 0, &dmah->map);
+
+ if (ret != 0) {
+ bus_dmamem_unmap(dmah->dmat, dmah->addr, request->size);
+ bus_dmamem_free(dmah->dmat, dmah->segs, nsegs);
+ kmem_free(dmah, sizeof(struct drm_dma_handle));
+ kmem_free(entry->busaddr, pages * sizeof(*entry->busaddr));
+ kmem_free(entry, sizeof(*entry));
+ return ENOMEM;
+ }
+
+ ret = bus_dmamap_load(dmah->dmat, dmah->map, dmah->addr, request->size,
+ NULL, 0);
+ if (ret != 0) {
+ bus_dmamem_unmap(dmah->dmat, dmah->addr, request->size);
+ bus_dmamem_free(dmah->dmat, dmah->segs, nsegs);
+ kmem_free(dmah, sizeof(struct drm_dma_handle));
+ kmem_free(entry->busaddr, pages * sizeof(*entry->busaddr));
+ kmem_free(entry, sizeof(*entry));
return ENOMEM;
}
- for (i = 0; i < pages; i++) {
- entry->busaddr[i] = vtophys(entry->handle + i * PAGE_SIZE);
+ DRM_DEBUG( "sg alloc nsegs = %d\n", dmah->map->dm_nsegs);
+
+ for (i = 0; i < pages; i++) {
+ entry->busaddr[i] = dmah->map->dm_segs[i].ds_addr;
}
+ entry->handle = (unsigned long)dmah->addr;
+ entry->sg_dmah = dmah;
+
DRM_DEBUG( "sg alloc handle = %08lx\n", entry->handle );
entry->virtual = (void *)entry->handle;
- request.handle = entry->handle;
-
- DRM_COPY_TO_USER_IOCTL( (drm_scatter_gather_t *)data,
- request,
- sizeof(request) );
+ request->handle = entry->handle;
DRM_LOCK();
if (dev->sg) {
@@ -112,7 +146,47 @@ int drm_sg_alloc(DRM_IOCTL_ARGS)
return 0;
}
-int drm_sg_free(DRM_IOCTL_ARGS)
+int
+drm_sg_alloc_ioctl(DRM_IOCTL_ARGS)
+{
+ DRM_DEVICE;
+ drm_scatter_gather_t request;
+ int ret;
+
+ if ( dev->sg )
+ return EINVAL;
+
+ DRM_DEBUG( "%s\n", __FUNCTION__ );
+
+ DRM_COPY_FROM_USER_IOCTL(request, (drm_scatter_gather_t *)data,
+ sizeof(request) );
+
+ ret = drm_sg_alloc(dev, &request);
+ if (ret != 0)
+ return ret;
+
+ DRM_COPY_TO_USER_IOCTL( (drm_scatter_gather_t *)data,
+ request,
+ sizeof(request) );
+
+ return 0;
+}
+
+void
+drm_sg_cleanup(drm_sg_mem_t *entry)
+{
+ struct drm_dma_handle *dmah = entry->sg_dmah;
+
+ bus_dmamap_unload(dmah->dmat, dmah->map);
+ bus_dmamem_unmap(dmah->dmat, dmah->addr, entry->pages << PAGE_SHIFT);
+ bus_dmamem_free(dmah->dmat, dmah->segs, 1);
+ kmem_free(dmah, sizeof(struct drm_dma_handle));
+ kmem_free(entry->busaddr, entry->pages * sizeof(*entry->busaddr));
+ kmem_free(entry, sizeof(*entry));
+}
+
+int
+drm_sg_free_ioctl(DRM_IOCTL_ARGS)
{
DRM_DEVICE;
drm_scatter_gather_t request;
@@ -123,12 +197,14 @@ int drm_sg_free(DRM_IOCTL_ARGS)
DRM_LOCK();
entry = dev->sg;
+ if ( !entry || entry->handle != request.handle ) {
+ DRM_UNLOCK();
+ DRM_DEBUG( "sg free: error: %s handle\n", entry ? "invalid" :
"no allocated");
+ return EINVAL;
+ }
dev->sg = NULL;
DRM_UNLOCK();
- if ( !entry || entry->handle != request.handle )
- return EINVAL;
-
DRM_DEBUG( "sg free virtual = 0x%lx\n", entry->handle );
drm_sg_cleanup(entry);
/* $NetBSD: drm_scatter.c,v 1.7 2008/07/07 00:33:23 mrg Exp $ */
/* drm_scatter.h -- IOCTLs to manage scatter/gather memory -*- linux-c -*-
* Created: Mon Dec 18 23:20:54 2000 by gareth%valinux.com@localhost */
/*-
* Copyright 2000 VA Linux Systems, Inc., Sunnyvale, California.
* All Rights Reserved.
*
* Permission is hereby granted, free of charge, to any person obtaining a
* copy of this software and associated documentation files (the "Software"),
* to deal in the Software without restriction, including without limitation
* the rights to use, copy, modify, merge, publish, distribute, sublicense,
* and/or sell copies of the Software, and to permit persons to whom the
* Software is furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice (including the next
* paragraph) shall be included in all copies or substantial portions of the
* Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
* PRECISION INSIGHT AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
* OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
* ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
* DEALINGS IN THE SOFTWARE.
*
* Authors:
* Gareth Hughes <gareth%valinux.com@localhost>
* Eric Anholt <anholt%FreeBSD.org@localhost>
*
*/
#include <sys/cdefs.h>
__KERNEL_RCSID(0, "$NetBSD: drm_scatter.c,v 1.7 2008/07/07 00:33:23 mrg Exp $");
/*
__FBSDID("$FreeBSD: src/sys/dev/drm/drm_scatter.c,v 1.3 2006/05/17 06:29:36
anholt Exp $");
*/
/** @file drm_scatter.c
* Allocation of memory for scatter-gather mappings by the graphics chip.
*
* The memory allocated here is then made into an aperture in the card
* by drm_ati_pcigart_init().
*/
#include "drmP.h"
int
drm_sg_alloc(struct drm_device *dev, struct drm_scatter_gather *request)
{
drm_sg_mem_t *entry;
struct drm_dma_handle *dmah;
unsigned long pages;
int nsegs, ret, i;
entry = kmem_zalloc(sizeof(*entry), KM_SLEEP);
if ( !entry )
return ENOMEM;
pages = round_page(request->size) / PAGE_SIZE;
DRM_DEBUG( "sg size=%ld pages=%ld\n", request->size, pages );
entry->pages = pages;
entry->busaddr = kmem_zalloc(pages * sizeof(*entry->busaddr), KM_SLEEP);
if ( !entry->busaddr ) {
kmem_free(entry, sizeof(*entry));
return ENOMEM;
}
dmah = kmem_zalloc(sizeof(struct drm_dma_handle), KM_SLEEP);
if (dmah == NULL) {
kmem_free(entry->busaddr, pages * sizeof(*entry->busaddr));
kmem_free(entry, sizeof(*entry));
return ENOMEM;
}
dmah->dmat = dev->pa.pa_dmat;
ret = bus_dmamem_alloc(dmah->dmat, request->size, PAGE_SIZE, 0,
dmah->segs, 1, &nsegs, 0);
if (ret != 0) {
kmem_free(dmah, sizeof(struct drm_dma_handle));
kmem_free(entry->busaddr, pages * sizeof(*entry->busaddr));
kmem_free(entry, sizeof(*entry));
return ENOMEM;
}
ret = bus_dmamem_map(dmah->dmat, dmah->segs, nsegs, request->size,
&dmah->addr, BUS_DMA_COHERENT);
if (ret != 0) {
bus_dmamem_free(dmah->dmat, dmah->segs, nsegs);
kmem_free(dmah, sizeof(struct drm_dma_handle));
kmem_free(entry->busaddr, pages * sizeof(*entry->busaddr));
kmem_free(entry, sizeof(*entry));
return ENOMEM;
}
ret = bus_dmamap_create(dmah->dmat, request->size, pages, PAGE_SIZE,
0, 0, &dmah->map);
if (ret != 0) {
bus_dmamem_unmap(dmah->dmat, dmah->addr, request->size);
bus_dmamem_free(dmah->dmat, dmah->segs, nsegs);
kmem_free(dmah, sizeof(struct drm_dma_handle));
kmem_free(entry->busaddr, pages * sizeof(*entry->busaddr));
kmem_free(entry, sizeof(*entry));
return ENOMEM;
}
ret = bus_dmamap_load(dmah->dmat, dmah->map, dmah->addr, request->size,
NULL, 0);
if (ret != 0) {
bus_dmamem_unmap(dmah->dmat, dmah->addr, request->size);
bus_dmamem_free(dmah->dmat, dmah->segs, nsegs);
kmem_free(dmah, sizeof(struct drm_dma_handle));
kmem_free(entry->busaddr, pages * sizeof(*entry->busaddr));
kmem_free(entry, sizeof(*entry));
return ENOMEM;
}
DRM_DEBUG( "sg alloc nsegs = %d\n", dmah->map->dm_nsegs);
for (i = 0; i < pages; i++) {
entry->busaddr[i] = dmah->map->dm_segs[i].ds_addr;
}
entry->handle = (unsigned long)dmah->addr;
entry->sg_dmah = dmah;
DRM_DEBUG( "sg alloc handle = %08lx\n", entry->handle );
entry->virtual = (void *)entry->handle;
request->handle = entry->handle;
DRM_LOCK();
if (dev->sg) {
DRM_UNLOCK();
drm_sg_cleanup(entry);
return EINVAL;
}
dev->sg = entry;
DRM_UNLOCK();
return 0;
}
int
drm_sg_alloc_ioctl(DRM_IOCTL_ARGS)
{
DRM_DEVICE;
drm_scatter_gather_t request;
int ret;
if ( dev->sg )
return EINVAL;
DRM_DEBUG( "%s\n", __FUNCTION__ );
DRM_COPY_FROM_USER_IOCTL(request, (drm_scatter_gather_t *)data,
sizeof(request) );
ret = drm_sg_alloc(dev, &request);
if (ret != 0)
return ret;
DRM_COPY_TO_USER_IOCTL( (drm_scatter_gather_t *)data,
request,
sizeof(request) );
return 0;
}
void
drm_sg_cleanup(drm_sg_mem_t *entry)
{
struct drm_dma_handle *dmah = entry->sg_dmah;
bus_dmamap_unload(dmah->dmat, dmah->map);
bus_dmamem_unmap(dmah->dmat, dmah->addr, entry->pages << PAGE_SHIFT);
bus_dmamem_free(dmah->dmat, dmah->segs, 1);
kmem_free(dmah, sizeof(struct drm_dma_handle));
kmem_free(entry->busaddr, entry->pages * sizeof(*entry->busaddr));
kmem_free(entry, sizeof(*entry));
}
int
drm_sg_free_ioctl(DRM_IOCTL_ARGS)
{
DRM_DEVICE;
drm_scatter_gather_t request;
drm_sg_mem_t *entry;
DRM_COPY_FROM_USER_IOCTL( request, (drm_scatter_gather_t *)data,
sizeof(request) );
DRM_LOCK();
entry = dev->sg;
if ( !entry || entry->handle != request.handle ) {
DRM_UNLOCK();
DRM_DEBUG( "sg free: error: %s handle\n", entry ? "invalid" :
"no allocated");
return EINVAL;
}
dev->sg = NULL;
DRM_UNLOCK();
DRM_DEBUG( "sg free virtual = 0x%lx\n", entry->handle );
drm_sg_cleanup(entry);
return 0;
}
Home |
Main Index |
Thread Index |
Old Index