18 files changed, 116 insertions, 195 deletions

diff --git a/drivers/char/drm/drmP.h b/drivers/char/drm/drmP.h
index d494315752a2..22779582ee5b 100644
--- a/drivers/char/drm/drmP.h
+++ b/drivers/char/drm/drmP.h
@@ -279,20 +279,15 @@ typedef struct drm_devstate {
 } drm_devstate_t;
 
 typedef struct drm_magic_entry {
-        drm_hash_item_t hash_item;
         struct list_head head;
+        drm_hash_item_t hash_item;
         struct drm_file *priv;
         struct drm_magic_entry *next;
 } drm_magic_entry_t;
 
-typedef struct drm_magic_head {
-        struct drm_magic_entry *head;
-        struct drm_magic_entry *tail;
-} drm_magic_head_t;
-
 typedef struct drm_vma_entry {
+        struct list_head head;
         struct vm_area_struct *vma;
-        struct drm_vma_entry *next;
         pid_t pid;
 } drm_vma_entry_t;
 
@@ -379,8 +374,7 @@ typedef struct drm_file {
         uid_t uid;
         drm_magic_t magic;
         unsigned long ioctl_count;
-        struct drm_file *next;
-        struct drm_file *prev;
+        struct list_head lhead;
         struct drm_head *head;
         int remove_auth_on_close;
         unsigned long lock_count;
@@ -449,8 +443,7 @@ typedef struct drm_agp_mem {
         DRM_AGP_MEM *memory;
         unsigned long bound;            /**< address */
         int pages;
-        struct drm_agp_mem *prev;       /**< previous entry */
-        struct drm_agp_mem *next;       /**< next entry */
+        struct list_head head;
 } drm_agp_mem_t;
 
 /**
@@ -460,7 +453,7 @@ typedef struct drm_agp_mem {
  */
 typedef struct drm_agp_head {
         DRM_AGP_KERN agp_info;          /**< AGP device information */
-        drm_agp_mem_t *memory;          /**< memory entries */
+        struct list_head memory;
         unsigned long mode;             /**< AGP mode */
         struct agp_bridge_data *bridge;
         int enabled;                    /**< whether the AGP bus as been enabled */
@@ -669,28 +662,27 @@ typedef struct drm_device {
 
         /** \name Authentication */
         /*@{ */
-        drm_file_t *file_first;         /**< file list head */
-        drm_file_t *file_last;          /**< file list tail */
+        struct list_head filelist;
         drm_open_hash_t magiclist;      /**< magic hash table */
         struct list_head magicfree;
         /*@} */
 
         /** \name Memory management */
         /*@{ */
-        drm_map_list_t *maplist;        /**< Linked list of regions */
+        struct list_head maplist;       /**< Linked list of regions */
         int map_count;                  /**< Number of mappable regions */
         drm_open_hash_t map_hash;       /**< User token hash table for maps */
 
         /** \name Context handle management */
         /*@{ */
-        drm_ctx_list_t *ctxlist;        /**< Linked list of context handles */
+        struct list_head ctxlist;       /**< Linked list of context handles */
         int ctx_count;                  /**< Number of context handles */
         struct mutex ctxlist_mutex;     /**< For ctxlist */
 
         drm_map_t **context_sareas;         /**< per-context SAREA's */
         int max_context;
 
-        drm_vma_entry_t *vmalist;       /**< List of vmas (for debugging) */
+        struct list_head vmalist;       /**< List of vmas (for debugging) */
         drm_lock_data_t lock;           /**< Information on hardware lock */
         /*@} */
 
@@ -725,8 +717,8 @@ typedef struct drm_device {
         atomic_t vbl_received;
         atomic_t vbl_received2;         /**< number of secondary VBLANK interrupts */
         spinlock_t vbl_lock;
-        drm_vbl_sig_t vbl_sigs;         /**< signal list to send on VBLANK */
-        drm_vbl_sig_t vbl_sigs2;        /**< signals to send on secondary VBLANK */
+        struct list_head vbl_sigs;              /**< signal list to send on VBLANK */
+        struct list_head vbl_sigs2;     /**< signals to send on secondary VBLANK */
         unsigned int vbl_pending;
         spinlock_t tasklet_lock;        /**< For drm_locked_tasklet */
         void (*locked_tasklet_func)(struct drm_device *dev);
@@ -1089,7 +1081,7 @@ static __inline__ struct drm_map *drm_core_findmap(struct drm_device *dev,
                                                    unsigned int token)
 {
         drm_map_list_t *_entry;
-        list_for_each_entry(_entry, &dev->maplist->head, head)
+        list_for_each_entry(_entry, &dev->maplist, head)
             if (_entry->user_token == token)
                 return _entry->map;
         return NULL;
diff --git a/drivers/char/drm/drm_agpsupport.c b/drivers/char/drm/drm_agpsupport.c
index 40bfd9b01e39..54c59e7ec7b6 100644
--- a/drivers/char/drm/drm_agpsupport.c
+++ b/drivers/char/drm/drm_agpsupport.c
@@ -232,11 +232,7 @@ int drm_agp_alloc(drm_device_t *dev, drm_agp_buffer_t *request)
         entry->memory = memory;
         entry->bound = 0;
         entry->pages = pages;
-        entry->prev = NULL;
-        entry->next = dev->agp->memory;
-        if (dev->agp->memory)
-                dev->agp->memory->prev = entry;
-        dev->agp->memory = entry;
+        list_add(&entry->head, &dev->agp->memory);
 
         request->handle = entry->handle;
         request->physical = memory->physical;
@@ -262,10 +258,12 @@ int drm_agp_alloc_ioctl(struct inode *inode, struct file *filp,
                 return err;
 
         if (copy_to_user(argp, &request, sizeof(request))) {
-                drm_agp_mem_t *entry = dev->agp->memory;
-
-                dev->agp->memory = entry->next;
-                dev->agp->memory->prev = NULL;
+                drm_agp_mem_t *entry;
+                list_for_each_entry(entry, &dev->agp->memory, head) {
+                        if (entry->handle == request.handle)
+                                break;
+                }
+                list_del(&entry->head);
                 drm_free_agp(entry->memory, entry->pages);
                 drm_free(entry, sizeof(*entry), DRM_MEM_AGPLISTS);
                 return -EFAULT;
@@ -288,7 +286,7 @@ static drm_agp_mem_t *drm_agp_lookup_entry(drm_device_t * dev,
 {
         drm_agp_mem_t *entry;
 
-        for (entry = dev->agp->memory; entry; entry = entry->next) {
+        list_for_each_entry(entry, &dev->agp->memory, head) {
                 if (entry->handle == handle)
                         return entry;
         }
@@ -413,13 +411,7 @@ int drm_agp_free(drm_device_t *dev, drm_agp_buffer_t *request)
         if (entry->bound)
                 drm_unbind_agp(entry->memory);
 
-        if (entry->prev)
-                entry->prev->next = entry->next;
-        else
-                dev->agp->memory = entry->next;
-
-        if (entry->next)
-                entry->next->prev = entry->prev;
+        list_del(&entry->head);
 
         drm_free_agp(entry->memory, entry->pages);
         drm_free(entry, sizeof(*entry), DRM_MEM_AGPLISTS);
@@ -472,7 +464,7 @@ drm_agp_head_t *drm_agp_init(drm_device_t * dev)
                 drm_free(head, sizeof(*head), DRM_MEM_AGPLISTS);
                 return NULL;
         }
-        head->memory = NULL;
+        INIT_LIST_HEAD(&head->memory);
         head->cant_use_aperture = head->agp_info.cant_use_aperture;
         head->page_mask = head->agp_info.page_mask;
 
diff --git a/drivers/char/drm/drm_bufs.c b/drivers/char/drm/drm_bufs.c
index c11345856ffe..dac057879594 100644
--- a/drivers/char/drm/drm_bufs.c
+++ b/drivers/char/drm/drm_bufs.c
@@ -52,10 +52,8 @@ EXPORT_SYMBOL(drm_get_resource_len);
 static drm_map_list_t *drm_find_matching_map(drm_device_t *dev,
                                              drm_local_map_t *map)
 {
-        struct list_head *list;
-
-        list_for_each(list, &dev->maplist->head) {
-                drm_map_list_t *entry = list_entry(list, drm_map_list_t, head);
+        drm_map_list_t *entry;
+        list_for_each_entry(entry, &dev->maplist, head) {
                 if (entry->map && map->type == entry->map->type &&
                     ((entry->map->offset == map->offset) ||
                      (map->type == _DRM_SHM && map->flags==_DRM_CONTAINS_LOCK))) {
@@ -237,14 +235,14 @@ static int drm_addmap_core(drm_device_t * dev, unsigned int offset,
                  * skipped and we double check that dev->agp->memory is
                  * actually set as well as being invalid before EPERM'ing
                  */
-                for (entry = dev->agp->memory; entry; entry = entry->next) {
+                list_for_each_entry(entry, &dev->agp->memory, head) {
                         if ((map->offset >= entry->bound) &&
                             (map->offset + map->size <= entry->bound + entry->pages * PAGE_SIZE)) {
                                 valid = 1;
                                 break;
                         }
                 }
-                if (dev->agp->memory && !valid) {
+                if (!list_empty(&dev->agp->memory) && !valid) {
                         drm_free(map, sizeof(*map), DRM_MEM_MAPS);
                         return -EPERM;
                 }
@@ -289,7 +287,7 @@ static int drm_addmap_core(drm_device_t * dev, unsigned int offset,
         list->map = map;
 
         mutex_lock(&dev->struct_mutex);
-        list_add(&list->head, &dev->maplist->head);
+        list_add(&list->head, &dev->maplist);
 
         /* Assign a 32-bit handle */
         /* We do it here so that dev->struct_mutex protects the increment */
@@ -380,29 +378,24 @@ int drm_addmap_ioctl(struct inode *inode, struct file *filp,
  */
 int drm_rmmap_locked(drm_device_t *dev, drm_local_map_t *map)
 {
-        struct list_head *list;
-        drm_map_list_t *r_list = NULL;
+        drm_map_list_t *r_list = NULL, *list_t;
         drm_dma_handle_t dmah;
+        int found = 0;
 
         /* Find the list entry for the map and remove it */
-        list_for_each(list, &dev->maplist->head) {
-                r_list = list_entry(list, drm_map_list_t, head);
-
+        list_for_each_entry_safe(r_list, list_t, &dev->maplist, head) {
                 if (r_list->map == map) {
-                        list_del(list);
+                        list_del(&r_list->head);
                         drm_ht_remove_key(&dev->map_hash,
                                           r_list->user_token >> PAGE_SHIFT);
-                        drm_free(list, sizeof(*list), DRM_MEM_MAPS);
+                        drm_free(r_list, sizeof(*r_list), DRM_MEM_MAPS);
+                        found = 1;
                         break;
                 }
         }
 
-        /* List has wrapped around to the head pointer, or it's empty and we
-         * didn't find anything.
-         */
-        if (list == (&dev->maplist->head)) {
+        if (!found)
                 return -EINVAL;
-        }
 
         switch (map->type) {
         case _DRM_REGISTERS:
@@ -460,7 +453,7 @@ int drm_rmmap_ioctl(struct inode *inode, struct file *filp,
         drm_device_t *dev = priv->head->dev;
         drm_map_t request;
         drm_local_map_t *map = NULL;
-        struct list_head *list;
+        drm_map_list_t *r_list;
         int ret;
 
         if (copy_from_user(&request, (drm_map_t __user *) arg, sizeof(request))) {
@@ -468,9 +461,7 @@ int drm_rmmap_ioctl(struct inode *inode, struct file *filp,
         }
 
         mutex_lock(&dev->struct_mutex);
-        list_for_each(list, &dev->maplist->head) {
-                drm_map_list_t *r_list = list_entry(list, drm_map_list_t, head);
-
+        list_for_each_entry(r_list, &dev->maplist, head) {
                 if (r_list->map &&
                     r_list->user_token == (unsigned long)request.handle &&
                     r_list->map->flags & _DRM_REMOVABLE) {
@@ -482,7 +473,7 @@ int drm_rmmap_ioctl(struct inode *inode, struct file *filp,
         /* List has wrapped around to the head pointer, or its empty we didn't
          * find anything.
          */
-        if (list == (&dev->maplist->head)) {
+        if (list_empty(&dev->maplist) || !map) {
                 mutex_unlock(&dev->struct_mutex);
                 return -EINVAL;
         }
@@ -606,14 +597,14 @@ int drm_addbufs_agp(drm_device_t * dev, drm_buf_desc_t * request)
 
         /* Make sure buffers are located in AGP memory that we own */
         valid = 0;
-        for (agp_entry = dev->agp->memory; agp_entry; agp_entry = agp_entry->next) {
+        list_for_each_entry(agp_entry, &dev->agp->memory, head) {
                 if ((agp_offset >= agp_entry->bound) &&
                     (agp_offset + total * count <= agp_entry->bound + agp_entry->pages * PAGE_SIZE)) {
                         valid = 1;
                         break;
                 }
         }
-        if (dev->agp->memory && !valid) {
+        if (!list_empty(&dev->agp->memory) && !valid) {
                 DRM_DEBUG("zone invalid\n");
                 return -EINVAL;
         }
diff --git a/drivers/char/drm/drm_context.c b/drivers/char/drm/drm_context.c
index 83094c73da67..e1f882dc55aa 100644
--- a/drivers/char/drm/drm_context.c
+++ b/drivers/char/drm/drm_context.c
@@ -233,7 +233,7 @@ int drm_getsareactx(struct inode *inode, struct file *filp,
         mutex_unlock(&dev->struct_mutex);
 
         request.handle = NULL;
-        list_for_each_entry(_entry, &dev->maplist->head, head) {
+        list_for_each_entry(_entry, &dev->maplist, head) {
                 if (_entry->map == map) {
                         request.handle =
                             (void *)(unsigned long)_entry->user_token;
@@ -268,15 +268,13 @@ int drm_setsareactx(struct inode *inode, struct file *filp,
         drm_ctx_priv_map_t request;
         drm_map_t *map = NULL;
         drm_map_list_t *r_list = NULL;
-        struct list_head *list;
 
         if (copy_from_user(&request,
                            (drm_ctx_priv_map_t __user *) arg, sizeof(request)))
                 return -EFAULT;
 
         mutex_lock(&dev->struct_mutex);
-        list_for_each(list, &dev->maplist->head) {
-                r_list = list_entry(list, drm_map_list_t, head);
+        list_for_each_entry(r_list, &dev->maplist, head) {
                 if (r_list->map
                     && r_list->user_token == (unsigned long)request.handle)
                         goto found;
@@ -449,7 +447,7 @@ int drm_addctx(struct inode *inode, struct file *filp,
         ctx_entry->tag = priv;
 
         mutex_lock(&dev->ctxlist_mutex);
-        list_add(&ctx_entry->head, &dev->ctxlist->head);
+        list_add(&ctx_entry->head, &dev->ctxlist);
         ++dev->ctx_count;
         mutex_unlock(&dev->ctxlist_mutex);
 
@@ -575,10 +573,10 @@ int drm_rmctx(struct inode *inode, struct file *filp,
         }
 
         mutex_lock(&dev->ctxlist_mutex);
-        if (!list_empty(&dev->ctxlist->head)) {
+        if (!list_empty(&dev->ctxlist)) {
                 drm_ctx_list_t *pos, *n;
 
-                list_for_each_entry_safe(pos, n, &dev->ctxlist->head, head) {
+                list_for_each_entry_safe(pos, n, &dev->ctxlist, head) {
                         if (pos->handle == ctx.handle) {
                                 list_del(&pos->head);
                                 drm_free(pos, sizeof(*pos), DRM_MEM_CTXLIST);
diff --git a/drivers/char/drm/drm_drv.c b/drivers/char/drm/drm_drv.c
index 8e77b7ed0f44..d7d10f118eaa 100644
--- a/drivers/char/drm/drm_drv.c
+++ b/drivers/char/drm/drm_drv.c
@@ -132,8 +132,8 @@ static drm_ioctl_desc_t drm_ioctls[] = {
 int drm_lastclose(drm_device_t * dev)
 {
         drm_magic_entry_t *pt, *next;
-        drm_map_list_t *r_list;
-        drm_vma_entry_t *vma, *vma_next;
+        drm_map_list_t *r_list, *list_t;
+        drm_vma_entry_t *vma, *vma_temp;
         int i;
 
         DRM_DEBUG("\n");
@@ -178,19 +178,17 @@ int drm_lastclose(drm_device_t * dev)
 
         /* Clear AGP information */
         if (drm_core_has_AGP(dev) && dev->agp) {
-                drm_agp_mem_t *entry;
-                drm_agp_mem_t *nexte;
+                drm_agp_mem_t *entry, *tempe;
 
                 /* Remove AGP resources, but leave dev->agp
                    intact until drv_cleanup is called. */
-                for (entry = dev->agp->memory; entry; entry = nexte) {
-                        nexte = entry->next;
+                list_for_each_entry_safe(entry, tempe, &dev->agp->memory, head) {
                         if (entry->bound)
                                 drm_unbind_agp(entry->memory);
                         drm_free_agp(entry->memory, entry->pages);
                         drm_free(entry, sizeof(*entry), DRM_MEM_AGPLISTS);
                 }
-                dev->agp->memory = NULL;
+                INIT_LIST_HEAD(&dev->agp->memory);
 
                 if (dev->agp->acquired)
                         drm_agp_release(dev);
@@ -204,20 +202,14 @@ int drm_lastclose(drm_device_t * dev)
         }
 
         /* Clear vma list (only built for debugging) */
-        if (dev->vmalist) {
-                for (vma = dev->vmalist; vma; vma = vma_next) {
-                        vma_next = vma->next;
-                        drm_free(vma, sizeof(*vma), DRM_MEM_VMAS);
-                }
-                dev->vmalist = NULL;
+        list_for_each_entry_safe(vma, vma_temp, &dev->vmalist, head) {
+                list_del(&vma->head);
+                drm_free(vma, sizeof(*vma), DRM_MEM_VMAS);
         }
 
-        if (dev->maplist) {
-                while (!list_empty(&dev->maplist->head)) {
-                        struct list_head *list = dev->maplist->head.next;
-                        r_list = list_entry(list, drm_map_list_t, head);
-                        drm_rmmap_locked(dev, r_list->map);
-                }
+        list_for_each_entry_safe(r_list, list_t, &dev->maplist, head) {
+                drm_rmmap_locked(dev, r_list->map);
+                r_list = NULL;
         }
 
         if (drm_core_check_feature(dev, DRIVER_DMA_QUEUE) && dev->queuelist) {
@@ -309,11 +301,7 @@ static void drm_cleanup(drm_device_t * dev)
 
         drm_lastclose(dev);
 
-        if (dev->maplist) {
-                drm_free(dev->maplist, sizeof(*dev->maplist), DRM_MEM_MAPS);
-                dev->maplist = NULL;
-                drm_ht_remove(&dev->map_hash);
-        }
+        drm_ht_remove(&dev->map_hash);
 
         drm_ctxbitmap_cleanup(dev);
 
diff --git a/drivers/char/drm/drm_fops.c b/drivers/char/drm/drm_fops.c
index 3b159cab3bc8..e82e78fa42b0 100644
--- a/drivers/char/drm/drm_fops.c
+++ b/drivers/char/drm/drm_fops.c
@@ -79,13 +79,9 @@ static int drm_setup(drm_device_t * dev)
         drm_ht_create(&dev->magiclist, DRM_MAGIC_HASH_ORDER);
         INIT_LIST_HEAD(&dev->magicfree);
 
-        dev->ctxlist = drm_alloc(sizeof(*dev->ctxlist), DRM_MEM_CTXLIST);
-        if (dev->ctxlist == NULL)
-                return -ENOMEM;
-        memset(dev->ctxlist, 0, sizeof(*dev->ctxlist));
-        INIT_LIST_HEAD(&dev->ctxlist->head);
+        INIT_LIST_HEAD(&dev->ctxlist);
+        INIT_LIST_HEAD(&dev->vmalist);
 
-        dev->vmalist = NULL;
         dev->sigdata.lock = NULL;
         init_waitqueue_head(&dev->lock.lock_queue);
         dev->queue_count = 0;
@@ -258,6 +254,8 @@ static int drm_open_helper(struct inode *inode, struct file *filp,
         priv->authenticated = capable(CAP_SYS_ADMIN);
         priv->lock_count = 0;
 
+        INIT_LIST_HEAD(&priv->lhead);
+
         if (dev->driver->open) {
                 ret = dev->driver->open(dev, priv);
                 if (ret < 0)
@@ -265,19 +263,10 @@ static int drm_open_helper(struct inode *inode, struct file *filp,
         }
 
         mutex_lock(&dev->struct_mutex);
-        if (!dev->file_last) {
-                priv->next = NULL;
-                priv->prev = NULL;
-                dev->file_first = priv;
-                dev->file_last = priv;
-                /* first opener automatically becomes master */
+        if (list_empty(&dev->filelist))
                 priv->master = 1;
-        } else {
-                priv->next = NULL;
-                priv->prev = dev->file_last;
-                dev->file_last->next = priv;
-                dev->file_last = priv;
-        }
+
+        list_add(&priv->lhead, &dev->filelist);
         mutex_unlock(&dev->struct_mutex);
 
 #ifdef __alpha__
@@ -414,10 +403,10 @@ int drm_release(struct inode *inode, struct file *filp)
         drm_fasync(-1, filp, 0);
 
         mutex_lock(&dev->ctxlist_mutex);
-        if (dev->ctxlist && (!list_empty(&dev->ctxlist->head))) {
+        if (!list_empty(&dev->ctxlist)) {
                 drm_ctx_list_t *pos, *n;
 
-                list_for_each_entry_safe(pos, n, &dev->ctxlist->head, head) {
+                list_for_each_entry_safe(pos, n, &dev->ctxlist, head) {
                         if (pos->tag == priv &&
                             pos->handle != DRM_KERNEL_CONTEXT) {
                                 if (dev->driver->context_dtor)
@@ -436,22 +425,12 @@ int drm_release(struct inode *inode, struct file *filp)
 
         mutex_lock(&dev->struct_mutex);
         if (priv->remove_auth_on_close == 1) {
-                drm_file_t *temp = dev->file_first;
-                while (temp) {
+                drm_file_t *temp;
+
+                list_for_each_entry(temp, &dev->filelist, lhead)
                         temp->authenticated = 0;
-                        temp = temp->next;
-                }
-        }
-        if (priv->prev) {
-                priv->prev->next = priv->next;
-        } else {
-                dev->file_first = priv->next;
-        }
-        if (priv->next) {
-                priv->next->prev = priv->prev;
-        } else {
-                dev->file_last = priv->prev;
         }
+        list_del(&priv->lhead);
         mutex_unlock(&dev->struct_mutex);
 
         if (dev->driver->postclose)
diff --git a/drivers/char/drm/drm_ioctl.c b/drivers/char/drm/drm_ioctl.c
index 565895547d75..96b982f1f4a4 100644
--- a/drivers/char/drm/drm_ioctl.c
+++ b/drivers/char/drm/drm_ioctl.c
@@ -204,7 +204,7 @@ int drm_getmap(struct inode *inode, struct file *filp,
         }
 
         i = 0;
-        list_for_each(list, &dev->maplist->head) {
+        list_for_each(list, &dev->maplist) {
                 if (i == idx) {
                         r_list = list_entry(list, drm_map_list_t, head);
                         break;
@@ -257,12 +257,18 @@ int drm_getclient(struct inode *inode, struct file *filp,
                 return -EFAULT;
         idx = client.idx;
         mutex_lock(&dev->struct_mutex);
-        for (i = 0, pt = dev->file_first; i < idx && pt; i++, pt = pt->next) ;
-
-        if (!pt) {
+        
+        if (list_empty(&dev->filelist)) {
                 mutex_unlock(&dev->struct_mutex);
                 return -EINVAL;
         }
+
+        i = 0;
+        list_for_each_entry(pt, &dev->filelist, lhead) {
+                if (i++ >= idx)
+                        break;
+        }
+
         client.auth = pt->authenticated;
         client.pid = pt->pid;
         client.uid = pt->uid;
diff --git a/drivers/char/drm/drm_irq.c b/drivers/char/drm/drm_irq.c
index 2e75331fd83e..ae3053ce7b2c 100644
--- a/drivers/char/drm/drm_irq.c
+++ b/drivers/char/drm/drm_irq.c
@@ -120,8 +120,8 @@ static int drm_irq_install(drm_device_t * dev)
 
                 spin_lock_init(&dev->vbl_lock);
 
-                INIT_LIST_HEAD(&dev->vbl_sigs.head);
-                INIT_LIST_HEAD(&dev->vbl_sigs2.head);
+                INIT_LIST_HEAD(&dev->vbl_sigs);
+                INIT_LIST_HEAD(&dev->vbl_sigs2);
 
                 dev->vbl_pending = 0;
         }
@@ -292,7 +292,7 @@ int drm_wait_vblank(DRM_IOCTL_ARGS)
 
         if (flags & _DRM_VBLANK_SIGNAL) {
                 unsigned long irqflags;
-                drm_vbl_sig_t *vbl_sigs = (flags & _DRM_VBLANK_SECONDARY)
+                struct list_head *vbl_sigs = (flags & _DRM_VBLANK_SECONDARY)
                                       ? &dev->vbl_sigs2 : &dev->vbl_sigs;
                 drm_vbl_sig_t *vbl_sig;
 
@@ -302,7 +302,7 @@ int drm_wait_vblank(DRM_IOCTL_ARGS)
                  * for the same vblank sequence number; nothing to be done in
                  * that case
                  */
-                list_for_each_entry(vbl_sig, &vbl_sigs->head, head) {
+                list_for_each_entry(vbl_sig, vbl_sigs, head) {
                         if (vbl_sig->sequence == vblwait.request.sequence
                             && vbl_sig->info.si_signo == vblwait.request.signal
                             && vbl_sig->task == current) {
@@ -336,7 +336,7 @@ int drm_wait_vblank(DRM_IOCTL_ARGS)
 
                 spin_lock_irqsave(&dev->vbl_lock, irqflags);
 
-                list_add_tail((struct list_head *)vbl_sig, &vbl_sigs->head);
+                list_add_tail(&vbl_sig->head, vbl_sigs);
 
                 spin_unlock_irqrestore(&dev->vbl_lock, irqflags);
 
@@ -379,20 +379,18 @@ void drm_vbl_send_signals(drm_device_t * dev)
         spin_lock_irqsave(&dev->vbl_lock, flags);
 
         for (i = 0; i < 2; i++) {
-                struct list_head *list, *tmp;
-                drm_vbl_sig_t *vbl_sig;
-                drm_vbl_sig_t *vbl_sigs = i ? &dev->vbl_sigs2 : &dev->vbl_sigs;
+                drm_vbl_sig_t *vbl_sig, *tmp;
+                struct list_head *vbl_sigs = i ? &dev->vbl_sigs2 : &dev->vbl_sigs;
                 unsigned int vbl_seq = atomic_read(i ? &dev->vbl_received2 :
                                                    &dev->vbl_received);
 
-                list_for_each_safe(list, tmp, &vbl_sigs->head) {
-                        vbl_sig = list_entry(list, drm_vbl_sig_t, head);
+                list_for_each_entry_safe(vbl_sig, tmp, vbl_sigs, head) {
                         if ((vbl_seq - vbl_sig->sequence) <= (1 << 23)) {
                                 vbl_sig->info.si_code = vbl_seq;
                                 send_sig_info(vbl_sig->info.si_signo,
                                               &vbl_sig->info, vbl_sig->task);
 
-                                list_del(list);
+                                list_del(&vbl_sig->head);
 
                                 drm_free(vbl_sig, sizeof(*vbl_sig),
                                          DRM_MEM_DRIVER);
diff --git a/drivers/char/drm/drm_memory.c b/drivers/char/drm/drm_memory.c
index 92a867082376..0683334f16c9 100644
--- a/drivers/char/drm/drm_memory.c
+++ b/drivers/char/drm/drm_memory.c
@@ -94,7 +94,7 @@ static void *agp_remap(unsigned long offset, unsigned long size,
         offset -= dev->hose->mem_space->start;
 #endif
 
-        for (agpmem = dev->agp->memory; agpmem; agpmem = agpmem->next)
+        list_for_each_entry(agpmem, &dev->agp->memory, head)
                 if (agpmem->bound <= offset
                     && (agpmem->bound + (agpmem->pages << PAGE_SHIFT)) >=
                     (offset + size))
diff --git a/drivers/char/drm/drm_os_linux.h b/drivers/char/drm/drm_os_linux.h
index 0fe7b4497927..e6e5ae89e100 100644
--- a/drivers/char/drm/drm_os_linux.h
+++ b/drivers/char/drm/drm_os_linux.h
@@ -104,7 +104,7 @@ static __inline__ int mtrr_del(int reg, unsigned long base, unsigned long size)
 #define DRM_GETSAREA()                                                   \
 do {                                                                     \
         drm_map_list_t *entry;                                           \
-        list_for_each_entry( entry, &dev->maplist->head, head ) {        \
+        list_for_each_entry( entry, &dev->maplist, head ) {              \
                 if ( entry->map &&                                       \
                      entry->map->type == _DRM_SHM &&                     \
                      (entry->map->flags & _DRM_CONTAINS_LOCK) ) {        \
diff --git a/drivers/char/drm/drm_proc.c b/drivers/char/drm/drm_proc.c
index b204498d1a28..1b1735ab3fbf 100644
--- a/drivers/char/drm/drm_proc.c
+++ b/drivers/char/drm/drm_proc.c
@@ -209,7 +209,6 @@ static int drm__vm_info(char *buf, char **start, off_t offset, int request,
         int len = 0;
         drm_map_t *map;
         drm_map_list_t *r_list;
-        struct list_head *list;
 
         /* Hardcoded from _DRM_FRAME_BUFFER,
            _DRM_REGISTERS, _DRM_SHM, _DRM_AGP, and
@@ -229,9 +228,7 @@ static int drm__vm_info(char *buf, char **start, off_t offset, int request,
         DRM_PROC_PRINT("slot     offset       size type flags    "
                        "address mtrr\n\n");
         i = 0;
-        if (dev->maplist != NULL)
-                list_for_each(list, &dev->maplist->head) {
-                r_list = list_entry(list, drm_map_list_t, head);
+        list_for_each_entry(r_list, &dev->maplist, head) {
                 map = r_list->map;
                 if (!map)
                         continue;
@@ -242,14 +239,15 @@ static int drm__vm_info(char *buf, char **start, off_t offset, int request,
                 DRM_PROC_PRINT("%4d 0x%08lx 0x%08lx %4.4s  0x%02x 0x%08x ",
                                i,
                                map->offset,
-                               map->size, type, map->flags, r_list->user_token);
+                               map->size, type, map->flags,
+                               r_list->user_token);
                 if (map->mtrr < 0) {
                         DRM_PROC_PRINT("none\n");
                 } else {
                         DRM_PROC_PRINT("%4d\n", map->mtrr);
                 }
                 i++;
-                }
+        }
 
         if (len > request + offset)
                 return request;
@@ -444,7 +442,7 @@ static int drm__clients_info(char *buf, char **start, off_t offset,
         *eof = 0;
 
         DRM_PROC_PRINT("a dev   pid    uid      magic     ioctls\n\n");
-        for (priv = dev->file_first; priv; priv = priv->next) {
+        list_for_each_entry(priv, &dev->filelist, lhead) {
                 DRM_PROC_PRINT("%c %3d %5d %5d %10u %10lu\n",
                                priv->authenticated ? 'y' : 'n',
                                priv->minor,
@@ -497,7 +495,7 @@ static int drm__vma_info(char *buf, char **start, off_t offset, int request,
         DRM_PROC_PRINT("vma use count: %d, high_memory = %p, 0x%08lx\n",
                        atomic_read(&dev->vma_count),
                        high_memory, virt_to_phys(high_memory));
-        for (pt = dev->vmalist; pt; pt = pt->next) {
+        list_for_each_entry(pt, &dev->vmalist, head) {
                 if (!(vma = pt->vma))
                         continue;
                 DRM_PROC_PRINT("\n%5d 0x%08lx-0x%08lx %c%c%c%c%c%c 0x%08lx000",
diff --git a/drivers/char/drm/drm_stub.c b/drivers/char/drm/drm_stub.c
index 19408adcc775..59a9e7e5f128 100644
--- a/drivers/char/drm/drm_stub.c
+++ b/drivers/char/drm/drm_stub.c
@@ -59,6 +59,7 @@ static int drm_fill_in_dev(drm_device_t * dev, struct pci_dev *pdev,
 {
         int retcode;
 
+        INIT_LIST_HEAD(&dev->filelist);
         spin_lock_init(&dev->count_lock);
         spin_lock_init(&dev->drw_lock);
         spin_lock_init(&dev->tasklet_lock);
@@ -76,15 +77,12 @@ static int drm_fill_in_dev(drm_device_t * dev, struct pci_dev *pdev,
 #endif
         dev->irq = pdev->irq;
 
-        dev->maplist = drm_calloc(1, sizeof(*dev->maplist), DRM_MEM_MAPS);
-        if (dev->maplist == NULL)
-                return -ENOMEM;
-        INIT_LIST_HEAD(&dev->maplist->head);
         if (drm_ht_create(&dev->map_hash, 12)) {
-                drm_free(dev->maplist, sizeof(*dev->maplist), DRM_MEM_MAPS);
                 return -ENOMEM;
         }
 
+        INIT_LIST_HEAD(&dev->maplist);
+
         /* the DRM has 6 basic counters */
         dev->counters = 6;
         dev->types[0] = _DRM_STAT_LOCK;
diff --git a/drivers/char/drm/drm_vm.c b/drivers/char/drm/drm_vm.c
index b5c5b9fa84c3..948e60d272df 100644
--- a/drivers/char/drm/drm_vm.c
+++ b/drivers/char/drm/drm_vm.c
@@ -116,7 +116,7 @@ static __inline__ struct page *drm_do_vm_nopage(struct vm_area_struct *vma,
                 /*
                  * It's AGP memory - find the real physical page to map
                  */
-                for (agpmem = dev->agp->memory; agpmem; agpmem = agpmem->next) {
+                list_for_each_entry(agpmem, &dev->agp->memory, head) {
                         if (agpmem->bound <= baddr &&
                             agpmem->bound + agpmem->pages * PAGE_SIZE > baddr)
                                 break;
@@ -196,10 +196,9 @@ static void drm_vm_shm_close(struct vm_area_struct *vma)
 {
         drm_file_t *priv = vma->vm_file->private_data;
         drm_device_t *dev = priv->head->dev;
-        drm_vma_entry_t *pt, *prev, *next;
+        drm_vma_entry_t *pt, *temp;
         drm_map_t *map;
         drm_map_list_t *r_list;
-        struct list_head *list;
         int found_maps = 0;
 
         DRM_DEBUG("0x%08lx,0x%08lx\n",
@@ -209,30 +208,22 @@ static void drm_vm_shm_close(struct vm_area_struct *vma)
         map = vma->vm_private_data;
 
         mutex_lock(&dev->struct_mutex);
-        for (pt = dev->vmalist, prev = NULL; pt; pt = next) {
-                next = pt->next;
+        list_for_each_entry_safe(pt, temp, &dev->vmalist, head) {
                 if (pt->vma->vm_private_data == map)
                         found_maps++;
                 if (pt->vma == vma) {
-                        if (prev) {
-                                prev->next = pt->next;
-                        } else {
-                                dev->vmalist = pt->next;
-                        }
+                        list_del(&pt->head);
                         drm_free(pt, sizeof(*pt), DRM_MEM_VMAS);
-                } else {
-                        prev = pt;
                 }
         }
+
         /* We were the only map that was found */
         if (found_maps == 1 && map->flags & _DRM_REMOVABLE) {
                 /* Check to see if we are in the maplist, if we are not, then
                  * we delete this mappings information.
                  */
                 found_maps = 0;
-                list = &dev->maplist->head;
-                list_for_each(list, &dev->maplist->head) {
-                        r_list = list_entry(list, drm_map_list_t, head);
+                list_for_each_entry(r_list, &dev->maplist, head) {
                         if (r_list->map == map)
                                 found_maps++;
                 }
@@ -425,9 +416,8 @@ static void drm_vm_open_locked(struct vm_area_struct *vma)
         vma_entry = drm_alloc(sizeof(*vma_entry), DRM_MEM_VMAS);
         if (vma_entry) {
                 vma_entry->vma = vma;
-                vma_entry->next = dev->vmalist;
                 vma_entry->pid = current->pid;
-                dev->vmalist = vma_entry;
+                list_add(&vma_entry->head, &dev->vmalist);
         }
 }
 
@@ -453,20 +443,16 @@ static void drm_vm_close(struct vm_area_struct *vma)
 {
         drm_file_t *priv = vma->vm_file->private_data;
         drm_device_t *dev = priv->head->dev;
-        drm_vma_entry_t *pt, *prev;
+        drm_vma_entry_t *pt, *temp;
 
         DRM_DEBUG("0x%08lx,0x%08lx\n",
                   vma->vm_start, vma->vm_end - vma->vm_start);
         atomic_dec(&dev->vma_count);
 
         mutex_lock(&dev->struct_mutex);
-        for (pt = dev->vmalist, prev = NULL; pt; prev = pt, pt = pt->next) {
+        list_for_each_entry_safe(pt, temp, &dev->vmalist, head) {
                 if (pt->vma == vma) {
-                        if (prev) {
-                                prev->next = pt->next;
-                        } else {
-                                dev->vmalist = pt->next;
-                        }
+                        list_del(&pt->head);
                         drm_free(pt, sizeof(*pt), DRM_MEM_VMAS);
                         break;
                 }
diff --git a/drivers/char/drm/i810_dma.c b/drivers/char/drm/i810_dma.c
index 603d17fd2d69..53b8a7931955 100644
--- a/drivers/char/drm/i810_dma.c
+++ b/drivers/char/drm/i810_dma.c
@@ -327,12 +327,10 @@ static int i810_dma_initialize(drm_device_t * dev,
                                drm_i810_private_t * dev_priv,
                                drm_i810_init_t * init)
 {
-        struct list_head *list;
-
+        drm_map_list_t *r_list;
         memset(dev_priv, 0, sizeof(drm_i810_private_t));
 
-        list_for_each(list, &dev->maplist->head) {
-                drm_map_list_t *r_list = list_entry(list, drm_map_list_t, head);
+        list_for_each_entry(r_list, &dev->maplist, head) {
                 if (r_list->map &&
                     r_list->map->type == _DRM_SHM &&
                     r_list->map->flags & _DRM_CONTAINS_LOCK) {
diff --git a/drivers/char/drm/i830_dma.c b/drivers/char/drm/i830_dma.c
index 3314a9fea9e5..3103258df61e 100644
--- a/drivers/char/drm/i830_dma.c
+++ b/drivers/char/drm/i830_dma.c
@@ -334,12 +334,11 @@ static int i830_dma_initialize(drm_device_t * dev,
                                drm_i830_private_t * dev_priv,
                                drm_i830_init_t * init)
 {
-        struct list_head *list;
+        drm_map_list_t *r_list;
 
         memset(dev_priv, 0, sizeof(drm_i830_private_t));
 
-        list_for_each(list, &dev->maplist->head) {
-                drm_map_list_t *r_list = list_entry(list, drm_map_list_t, head);
+        list_for_each_entry(r_list, &dev->maplist, head) {
                 if (r_list->map &&
                     r_list->map->type == _DRM_SHM &&
                     r_list->map->flags & _DRM_CONTAINS_LOCK) {
diff --git a/drivers/char/drm/mga_dma.c b/drivers/char/drm/mga_dma.c
index c2a4bac14521..5781a8d934f8 100644
--- a/drivers/char/drm/mga_dma.c
+++ b/drivers/char/drm/mga_dma.c
@@ -551,7 +551,7 @@ static int mga_do_agp_dma_bootstrap(drm_device_t * dev,
                 drm_map_list_t *_entry;
                 unsigned long agp_token = 0;
                 
-                list_for_each_entry(_entry, &dev->maplist->head, head) {
+                list_for_each_entry(_entry, &dev->maplist, head) {
                         if (_entry->map == dev->agp_buffer_map)
                                 agp_token = _entry->user_token;
                 }
diff --git a/drivers/char/drm/sis_mm.c b/drivers/char/drm/sis_mm.c
index d26f5dbb7853..6875a2eda09d 100644
--- a/drivers/char/drm/sis_mm.c
+++ b/drivers/char/drm/sis_mm.c
@@ -234,7 +234,7 @@ static drm_local_map_t *sis_reg_init(drm_device_t *dev)
         drm_map_list_t *entry;
         drm_local_map_t *map;
 
-        list_for_each_entry(entry, &dev->maplist->head, head) {
+        list_for_each_entry(entry, &dev->maplist, head) {
                 map = entry->map;
                 if (!map)
                         continue;
diff --git a/drivers/char/drm/via_verifier.c b/drivers/char/drm/via_verifier.c
index 2e7e08078287..8b4ea3027b2c 100644
--- a/drivers/char/drm/via_verifier.c
+++ b/drivers/char/drm/via_verifier.c
@@ -254,7 +254,6 @@ static __inline__ drm_local_map_t *via_drm_lookup_agp_map(drm_via_state_t *seq,
                                                     unsigned long size,
                                                     drm_device_t * dev)
 {
-        struct list_head *list;
         drm_map_list_t *r_list;
         drm_local_map_t *map = seq->map_cache;
 
@@ -263,8 +262,7 @@ static __inline__ drm_local_map_t *via_drm_lookup_agp_map(drm_via_state_t *seq,
                 return map;
         }
 
-        list_for_each(list, &dev->maplist->head) {
-                r_list = (drm_map_list_t *) list;
+        list_for_each_entry(r_list, &dev->maplist, head) {
                 map = r_list->map;
                 if (!map)
                         continue;