summaryrefslogtreecommitdiff
diff options
context:
space:
mode:
authorThomas Hellstrom <thomas-at-tungstengraphics-dot-com>2006-09-01 15:41:55 +0200
committerThomas Hellstrom <thomas-at-tungstengraphics-dot-com>2006-09-01 15:41:55 +0200
commit11f51a9a877d1231551e8c6482a6f70daf380cdd (patch)
treed3e6731ca1641ed0107336d8c41e1620cfe80b4f
parent4edb95d6e0a00a9a8885603cab2c99e3c6daa705 (diff)
Bugfixes,
Memory allocation optimizations. Buffer manager takedown.
-rw-r--r--linux-core/drmP.h13
-rw-r--r--linux-core/drm_bo.c135
-rw-r--r--linux-core/drm_drv.c29
-rw-r--r--linux-core/drm_fence.c6
-rw-r--r--linux-core/drm_mm.c39
-rw-r--r--linux-core/drm_stub.c30
6 files changed, 216 insertions, 36 deletions
diff --git a/linux-core/drmP.h b/linux-core/drmP.h
index 5242b287..c6646212 100644
--- a/linux-core/drmP.h
+++ b/linux-core/drmP.h
@@ -84,6 +84,7 @@
#include <linux/poll.h>
#include <asm/pgalloc.h>
#include "drm.h"
+#include <linux/slab.h>
#define __OS_HAS_AGP (defined(CONFIG_AGP) || (defined(CONFIG_AGP_MODULE) && defined(MODULE)))
#define __OS_HAS_MTRR (defined(CONFIG_MTRR))
@@ -779,6 +780,8 @@ typedef struct drm_buffer_manager{
int initialized;
int has_vram;
int has_tt;
+ int use_vram;
+ int use_tt;
drm_mm_t tt_manager;
struct list_head tt_lru;
drm_mm_t vram_manager;
@@ -922,6 +925,12 @@ typedef struct drm_device {
drm_fence_manager_t fm;
drm_buffer_manager_t bm;
+
+ /*
+ * Memory caches
+ */
+ kmem_cache_t *mm_cache;
+ kmem_cache_t *fence_object_cache;
} drm_device_t;
@@ -1293,7 +1302,8 @@ extern drm_mm_node_t *drm_mm_search_free(const drm_mm_t *mm, unsigned long size,
unsigned alignment, int best_match);
extern int drm_mm_init(drm_mm_t *mm, unsigned long start, unsigned long size);
extern void drm_mm_takedown(drm_mm_t *mm);
-
+extern void drm_mm_set_cache(kmem_cache_t *cache);
+extern int drm_mm_clean(drm_mm_t *mm);
/*
* User space object bookkeeping (drm_object.c)
@@ -1377,6 +1387,7 @@ extern int drm_fence_ioctl(DRM_IOCTL_ARGS);
extern int drm_bo_ioctl(DRM_IOCTL_ARGS);
extern int drm_mm_init_ioctl(DRM_IOCTL_ARGS);
+extern int drm_bo_clean_mm(drm_device_t *dev);
/* Inline replacements for DRM_IOREMAP macros */
diff --git a/linux-core/drm_bo.c b/linux-core/drm_bo.c
index dcbf2d91..1c71f345 100644
--- a/linux-core/drm_bo.c
+++ b/linux-core/drm_bo.c
@@ -231,7 +231,7 @@ int drm_fence_buffer_objects(drm_file_t * priv,
goto out;
}
} else {
- fence = drm_calloc(1, sizeof(*fence), DRM_MEM_FENCE);
+ fence = kmem_cache_alloc(dev->fence_object_cache, GFP_KERNEL);
if (!fence) {
ret = -ENOMEM;
@@ -241,7 +241,7 @@ int drm_fence_buffer_objects(drm_file_t * priv,
ret = drm_fence_object_init(dev, fence_flags, 1, fence);
if (ret) {
- drm_free(fence, sizeof(*fence), DRM_MEM_FENCE);
+ kmem_cache_free(dev->fence_object_cache, fence);
goto out;
}
}
@@ -468,18 +468,24 @@ static int drm_move_local_to_tt(drm_buffer_object_t * bo, int no_wait)
return 0;
}
-static int drm_bo_new_flags(drm_bo_driver_t * driver,
+static int drm_bo_new_flags(drm_device_t *dev,
uint32_t flags, uint32_t new_mask, uint32_t hint,
int init, uint32_t * n_flags, uint32_t * n_mask)
{
uint32_t new_flags = 0;
uint32_t new_props;
+ drm_bo_driver_t *driver = dev->driver->bo_driver;
+ drm_buffer_manager_t *bm = &dev->bm;
/*
- * First adjust the mask. Vram is not supported yet.
+ * First adjust the mask.
*/
- new_mask &= ~DRM_BO_FLAG_MEM_VRAM;
+ if (!bm->use_vram)
+ new_mask &= ~DRM_BO_FLAG_MEM_VRAM;
+ if (!bm->use_tt)
+ new_mask &= ~DRM_BO_FLAG_MEM_TT;
+
if (new_mask & DRM_BO_FLAG_BIND_CACHED) {
if (((new_mask & DRM_BO_FLAG_MEM_TT) && !driver->cached_tt) &&
@@ -986,7 +992,7 @@ static int drm_bo_handle_validate(drm_file_t * priv, uint32_t handle,
if (ret)
goto out;
- ret = drm_bo_new_flags(dev->driver->bo_driver, bo->flags,
+ ret = drm_bo_new_flags(dev, bo->flags,
(flags & mask) | (bo->flags & ~mask), hint,
0, &new_flags, &bo->mask);
@@ -1112,7 +1118,7 @@ int drm_buffer_object_create(drm_file_t * priv,
bo->buffer_start = buffer_start;
bo->priv_flags = 0;
bo->flags = DRM_BO_FLAG_MEM_LOCAL | DRM_BO_FLAG_CACHED;
- ret = drm_bo_new_flags(dev->driver->bo_driver, bo->flags, mask, hint,
+ ret = drm_bo_new_flags(dev, bo->flags, mask, hint,
1, &new_flags, &bo->mask);
DRM_ERROR("New flags: 0x%08x\n", new_flags);
if (ret)
@@ -1194,7 +1200,12 @@ int drm_bo_ioctl(DRM_IOCTL_ARGS)
unsigned long next;
drm_user_object_t *uo;
drm_buffer_object_t *entry;
-
+
+ if (!dev->bm.initialized) {
+ DRM_ERROR("Buffer object manager is not initialized.\n");
+ return -EINVAL;
+ }
+
do {
DRM_COPY_FROM_USER_IOCTL(arg, (void __user *)data, sizeof(arg));
@@ -1307,9 +1318,87 @@ int drm_bo_ioctl(DRM_IOCTL_ARGS)
return 0;
}
-int drm_bo_clean_mm(drm_file_t *priv)
+
+/*
+ * dev->struct_sem locked.
+ */
+
+
+static void drm_bo_force_clean(drm_device_t * dev)
{
- return 0;
+ drm_buffer_manager_t *bm = &dev->bm;
+
+ drm_buffer_object_t *entry, *next;
+ int nice_mode = 1;
+ int ret = 0;
+
+ list_for_each_entry_safe(entry, next, &bm->ddestroy, ddestroy) {
+ if (entry->fence) {
+ if (nice_mode) {
+ unsigned long _end = jiffies + 3*DRM_HZ;
+ do {
+ ret = drm_bo_wait(entry, 0, 0);
+ } while ((ret == -EINTR) &&
+ !time_after_eq(jiffies, _end));
+ } else {
+ drm_fence_usage_deref_locked(dev, entry->fence);
+ entry->fence = NULL;
+ }
+ if (entry->fence) {
+ DRM_ERROR("Detected GPU hang. "
+ "Removing waiting buffers.\n");
+ nice_mode = 0;
+ drm_fence_usage_deref_locked(dev, entry->fence);
+ entry->fence = NULL;
+ }
+
+ }
+ DRM_DEBUG("Destroying delayed buffer object\n");
+ list_del(&entry->ddestroy);
+ drm_bo_destroy_locked(dev, entry);
+ }
+}
+
+
+int drm_bo_clean_mm(drm_device_t *dev)
+{
+ drm_buffer_manager_t *bm = &dev->bm;
+ int ret = 0;
+
+
+ mutex_lock(&dev->struct_mutex);
+
+ if (!bm->initialized)
+ goto out;
+
+
+ drm_bo_force_clean(dev);
+ bm->use_vram = 0;
+ bm->use_tt = 0;
+
+ if (bm->has_vram) {
+ if (drm_mm_clean(&bm->vram_manager)) {
+ drm_mm_takedown(&bm->vram_manager);
+ bm->has_vram = 0;
+ } else
+ ret = -EBUSY;
+ }
+
+ if (bm->has_tt) {
+ if (drm_mm_clean(&bm->tt_manager)) {
+ drm_mm_takedown(&bm->tt_manager);
+ bm->has_tt = 0;
+ } else
+ ret = -EBUSY;
+
+ if (!ret)
+ bm->initialized = 0;
+ }
+
+ out:
+ mutex_unlock(&dev->struct_mutex);
+
+ return ret;
}
@@ -1331,33 +1420,38 @@ int drm_mm_init_ioctl(DRM_IOCTL_ARGS)
switch (arg.req.op) {
case mm_init:
-#if 0
if (bm->initialized) {
DRM_ERROR("Memory manager already initialized\n");
return -EINVAL;
}
-#endif
mutex_lock(&dev->struct_mutex);
bm->has_vram = 0;
bm->has_tt = 0;
-
+
if (arg.req.vr_p_size) {
ret = drm_mm_init(&bm->vram_manager,
arg.req.vr_p_offset,
arg.req.vr_p_size);
bm->has_vram = 1;
+ /*
+ * VRAM not supported yet.
+ */
+
+ bm->use_vram = 0;
if (ret)
break;
}
if (arg.req.tt_p_size) {
- DRM_ERROR("Initializing TT 0x%08x 0x%08x\n",
+ DRM_ERROR("Initializing TT 0x%08x 0x%08x\n",
arg.req.tt_p_offset,
arg.req.tt_p_size);
ret = drm_mm_init(&bm->tt_manager,
arg.req.tt_p_offset,
arg.req.tt_p_size);
bm->has_tt = 1;
+ bm->use_tt = 1;
+
if (ret) {
if (bm->has_vram)
drm_mm_takedown(&bm->vram_manager);
@@ -1379,17 +1473,10 @@ int drm_mm_init_ioctl(DRM_IOCTL_ARGS)
bm->initialized = 1;
break;
case mm_takedown:
- if (!bm->initialized) {
- DRM_ERROR("Memory manager was not initialized\n");
- return -EINVAL;
+ if (drm_bo_clean_mm(dev)) {
+ DRM_ERROR("Memory manager not clean. "
+ "Delaying takedown\n");
}
- mutex_lock(&dev->struct_mutex);
- drm_bo_clean_mm(priv);
- if (bm->has_vram)
- drm_mm_takedown(&bm->vram_manager);
- if (bm->has_tt)
- drm_mm_takedown(&bm->tt_manager);
- bm->initialized = 0;
break;
default:
DRM_ERROR("Function not implemented yet\n");
diff --git a/linux-core/drm_drv.c b/linux-core/drm_drv.c
index 1bf87703..8a1dcab9 100644
--- a/linux-core/drm_drv.c
+++ b/linux-core/drm_drv.c
@@ -128,6 +128,29 @@ static drm_ioctl_desc_t drm_ioctls[] = {
#define DRIVER_IOCTL_COUNT ARRAY_SIZE( drm_ioctls )
+
+static void drm_free_mem_cache(kmem_cache_t *cache,
+ const char *name)
+{
+ if (!cache)
+ return;
+ if (kmem_cache_destroy(cache)) {
+ DRM_ERROR("Warning! DRM is leaking %s memory.\n",
+ name);
+ }
+}
+
+static void drm_free_memory_caches(drm_device_t *dev)
+{
+
+ drm_free_mem_cache(dev->fence_object_cache, "fence object");
+ dev->fence_object_cache = NULL;
+ drm_mm_set_cache(NULL);
+ drm_free_mem_cache(dev->mm_cache, "memory manager block");
+ dev->mm_cache = NULL;
+}
+
+
/**
* Take down the DRM device.
*
@@ -249,6 +272,10 @@ int drm_lastclose(drm_device_t * dev)
}
mutex_unlock(&dev->struct_mutex);
+ if (drm_bo_clean_mm(dev)) {
+ DRM_ERROR("DRM memory manager still busy. "
+ "System is unstable. Please reboot.\n");
+ }
DRM_DEBUG("lastclose completed\n");
return 0;
}
@@ -351,7 +378,7 @@ static void drm_cleanup(drm_device_t * dev)
}
drm_lastclose(dev);
-
+ drm_free_memory_caches(dev);
drm_fence_manager_takedown(dev);
if (dev->maplist) {
diff --git a/linux-core/drm_fence.c b/linux-core/drm_fence.c
index 897f84c5..b4d13621 100644
--- a/linux-core/drm_fence.c
+++ b/linux-core/drm_fence.c
@@ -172,7 +172,7 @@ void drm_fence_usage_deref_locked(drm_device_t * dev,
{
if (atomic_dec_and_test(&fence->usage)) {
drm_fence_unring(dev, &fence->ring);
- drm_free(fence, sizeof(*fence), DRM_MEM_FENCE);
+ kmem_cache_free(dev->fence_object_cache, fence);
}
}
@@ -183,7 +183,7 @@ void drm_fence_usage_deref_unlocked(drm_device_t * dev,
mutex_lock(&dev->struct_mutex);
if (atomic_read(&fence->usage) == 0) {
drm_fence_unring(dev, &fence->ring);
- drm_free(fence, sizeof(*fence), DRM_MEM_FENCE);
+ kmem_cache_free(dev->fence_object_cache, fence);
}
mutex_unlock(&dev->struct_mutex);
}
@@ -426,7 +426,7 @@ static int drm_fence_object_create(drm_file_t * priv, uint32_t type,
int ret;
drm_fence_object_t *fence;
- fence = drm_calloc(1, sizeof(*fence), DRM_MEM_FENCE);
+ fence = kmem_cache_alloc(dev->fence_object_cache, GFP_KERNEL);
if (!fence)
return -ENOMEM;
ret = drm_fence_object_init(dev, type, emit, fence);
diff --git a/linux-core/drm_mm.c b/linux-core/drm_mm.c
index 617526bd..6e2da81a 100644
--- a/linux-core/drm_mm.c
+++ b/linux-core/drm_mm.c
@@ -42,6 +42,9 @@
*/
#include "drmP.h"
+#include <linux/slab.h>
+
+static kmem_cache_t *mm_cache = NULL;
drm_mm_node_t *drm_mm_get_block(drm_mm_node_t * parent,
unsigned long size, unsigned alignment)
@@ -57,7 +60,9 @@ drm_mm_node_t *drm_mm_get_block(drm_mm_node_t * parent,
parent->free = 0;
return parent;
} else {
- child = (drm_mm_node_t *) drm_alloc(sizeof(*child), DRM_MEM_MM);
+
+ child = (drm_mm_node_t *) kmem_cache_alloc(mm_cache,
+ GFP_KERNEL);
if (!child)
return NULL;
@@ -105,8 +110,8 @@ void drm_mm_put_block(drm_mm_t * mm, drm_mm_node_t * cur)
prev_node->size += next_node->size;
list_del(&next_node->ml_entry);
list_del(&next_node->fl_entry);
- drm_free(next_node, sizeof(*next_node),
- DRM_MEM_MM);
+ kmem_cache_free(mm_cache, next_node);
+
} else {
next_node->size += cur->size;
next_node->start = cur->start;
@@ -119,7 +124,7 @@ void drm_mm_put_block(drm_mm_t * mm, drm_mm_node_t * cur)
list_add(&cur->fl_entry, &list_root->fl_entry);
} else {
list_del(&cur->ml_entry);
- drm_free(cur, sizeof(*cur), DRM_MEM_MM);
+ kmem_cache_free(mm_cache, cur);
}
}
@@ -154,13 +159,34 @@ drm_mm_node_t *drm_mm_search_free(const drm_mm_t * mm,
return best;
}
+void drm_mm_set_cache(kmem_cache_t *cache)
+{
+ mm_cache = cache;
+}
+
+int drm_mm_clean(drm_mm_t *mm)
+{
+ struct list_head *head = &mm->root_node.ml_entry;
+
+ return (head->next->next == head);
+}
+
int drm_mm_init(drm_mm_t * mm, unsigned long start, unsigned long size)
{
drm_mm_node_t *child;
+ if (!mm_cache) {
+ DRM_ERROR("Memory manager memory cache "
+ "is not initialized.\n");
+ return -EINVAL;
+ }
+
INIT_LIST_HEAD(&mm->root_node.ml_entry);
INIT_LIST_HEAD(&mm->root_node.fl_entry);
- child = (drm_mm_node_t *) drm_alloc(sizeof(*child), DRM_MEM_MM);
+
+
+ child = (drm_mm_node_t *) kmem_cache_alloc(mm_cache, GFP_KERNEL);
+
if (!child)
return -ENOMEM;
@@ -194,8 +220,7 @@ void drm_mm_takedown(drm_mm_t * mm)
list_del(&entry->fl_entry);
list_del(&entry->ml_entry);
-
- drm_free(entry, sizeof(*entry), DRM_MEM_MM);
+ kmem_cache_free(mm_cache, entry);
}
EXPORT_SYMBOL(drm_mm_takedown);
diff --git a/linux-core/drm_stub.c b/linux-core/drm_stub.c
index 16e50a55..2d0f1d24 100644
--- a/linux-core/drm_stub.c
+++ b/linux-core/drm_stub.c
@@ -54,6 +54,30 @@ drm_head_t **drm_heads;
struct drm_sysfs_class *drm_class;
struct proc_dir_entry *drm_proc_root;
+
+static int drm_create_memory_caches(drm_device_t *dev)
+{
+ dev->mm_cache = kmem_cache_create("drm_mm_node_t",
+ sizeof(drm_mm_node_t),
+ 0,
+ SLAB_HWCACHE_ALIGN,
+ NULL,NULL);
+ if (!dev->mm_cache)
+ return -ENOMEM;
+
+ drm_mm_set_cache(dev->mm_cache);
+ dev->fence_object_cache = kmem_cache_create("drm_fence_object_t",
+ sizeof(drm_fence_object_t),
+ 0,
+ SLAB_HWCACHE_ALIGN,
+ NULL,NULL);
+ if (!dev->fence_object_cache)
+ return -ENOMEM;
+
+ return 0;
+}
+
+
static int drm_fill_in_dev(drm_device_t * dev, struct pci_dev *pdev,
const struct pci_device_id *ent,
struct drm_driver *driver)
@@ -127,6 +151,12 @@ static int drm_fill_in_dev(drm_device_t * dev, struct pci_dev *pdev,
goto error_out_unreg;
}
+ retcode = drm_create_memory_caches(dev);
+ if (retcode) {
+ DRM_ERROR("Failed creating memory caches\n");
+ goto error_out_unreg;
+ }
+
drm_fence_manager_init(dev);
return 0;