Remove the stupid root_node field from the core memory manager.

diff --git a/linux-core/drmP.h b/linux-core/drmP.h
index 2b364f7..77212d1 100644 (file)
--- a/linux-core/drmP.h
+++ b/linux-core/drmP.h
@@ -545,7 +545,8 @@ typedef struct drm_mm_node {
 } drm_mm_node_t;
 
 typedef struct drm_mm {
-       drm_mm_node_t root_node;
+       struct list_head fl_entry;
+       struct list_head ml_entry;
 } drm_mm_t;
 
 

diff --git a/linux-core/drm_mm.c b/linux-core/drm_mm.c
index 34708ef..0e54447 100644 (file)
--- a/linux-core/drm_mm.c
+++ b/linux-core/drm_mm.c
@@ -49,7 +49,7 @@ unsigned long drm_mm_tail_space(drm_mm_t *mm)
        struct list_head *tail_node;
        drm_mm_node_t *entry;
 
-       tail_node = mm->root_node.ml_entry.prev;
+       tail_node = mm->ml_entry.prev;
        entry = list_entry(tail_node, drm_mm_node_t, ml_entry);
        if (!entry->free)
                return 0;
@@ -62,7 +62,7 @@ int drm_mm_remove_space_from_tail(drm_mm_t *mm, unsigned long size)
        struct list_head *tail_node;
        drm_mm_node_t *entry;
 
-       tail_node = mm->root_node.ml_entry.prev;
+       tail_node = mm->ml_entry.prev;
        entry = list_entry(tail_node, drm_mm_node_t, ml_entry);
        if (!entry->free)
                return -ENOMEM;
@@ -91,8 +91,8 @@ static int drm_mm_create_tail_node(drm_mm_t *mm,
        child->start = start;
        child->mm = mm;
 
-       list_add_tail(&child->ml_entry, &mm->root_node.ml_entry);
-       list_add_tail(&child->fl_entry, &mm->root_node.fl_entry);
+       list_add_tail(&child->ml_entry, &mm->ml_entry);
+       list_add_tail(&child->fl_entry, &mm->fl_entry);
 
        return 0;
 }
@@ -103,7 +103,7 @@ int drm_mm_add_space_to_tail(drm_mm_t *mm, unsigned long size)
        struct list_head *tail_node;
        drm_mm_node_t *entry;
 
-       tail_node = mm->root_node.ml_entry.prev;
+       tail_node = mm->ml_entry.prev;
        entry = list_entry(tail_node, drm_mm_node_t, ml_entry);
        if (!entry->free) {
                return drm_mm_create_tail_node(mm, entry->start + entry->size, size);
@@ -183,9 +183,8 @@ void drm_mm_put_block(drm_mm_node_t * cur)
 {
 
        drm_mm_t *mm = cur->mm;
-       drm_mm_node_t *list_root = &mm->root_node;
        struct list_head *cur_head = &cur->ml_entry;
-       struct list_head *root_head = &list_root->ml_entry;
+       struct list_head *root_head = &mm->ml_entry;
        drm_mm_node_t *prev_node = NULL;
        drm_mm_node_t *next_node;
 
@@ -216,7 +215,7 @@ void drm_mm_put_block(drm_mm_node_t * cur)
        }
        if (!merged) {
                cur->free = 1;
-               list_add(&cur->fl_entry, &list_root->fl_entry);
+               list_add(&cur->fl_entry, &mm->fl_entry);
        } else {
                list_del(&cur->ml_entry);
                drm_ctl_free(cur, sizeof(*cur), DRM_MEM_MM);
@@ -228,7 +227,7 @@ drm_mm_node_t *drm_mm_search_free(const drm_mm_t * mm,
                                  unsigned alignment, int best_match)
 {
        struct list_head *list;
-       const struct list_head *free_stack = &mm->root_node.fl_entry;
+       const struct list_head *free_stack = &mm->fl_entry;
        drm_mm_node_t *entry;
        drm_mm_node_t *best;
        unsigned long best_size;
@@ -263,15 +262,15 @@ drm_mm_node_t *drm_mm_search_free(const drm_mm_t * mm,
 
 int drm_mm_clean(drm_mm_t * mm)
 {
-       struct list_head *head = &mm->root_node.ml_entry;
+       struct list_head *head = &mm->ml_entry;
 
        return (head->next->next == head);
 }
 
 int drm_mm_init(drm_mm_t * mm, unsigned long start, unsigned long size)
 {
-       INIT_LIST_HEAD(&mm->root_node.ml_entry);
-       INIT_LIST_HEAD(&mm->root_node.fl_entry);
+       INIT_LIST_HEAD(&mm->ml_entry);
+       INIT_LIST_HEAD(&mm->fl_entry);
 
        return drm_mm_create_tail_node(mm, start, size);
 }
@@ -280,13 +279,13 @@ EXPORT_SYMBOL(drm_mm_init);
 
 void drm_mm_takedown(drm_mm_t * mm)
 {
-       struct list_head *bnode = mm->root_node.fl_entry.next;
+       struct list_head *bnode = mm->fl_entry.next;
        drm_mm_node_t *entry;
 
        entry = list_entry(bnode, drm_mm_node_t, fl_entry);
 
-       if (entry->ml_entry.next != &mm->root_node.ml_entry ||
-           entry->fl_entry.next != &mm->root_node.fl_entry) {
+       if (entry->ml_entry.next != &mm->ml_entry ||
+           entry->fl_entry.next != &mm->fl_entry) {
                DRM_ERROR("Memory manager not clean. Delaying takedown\n");
                return;
        }