Attachment 10071 Details for Bug 11037 – patch to make better use of linux list macros in drm

[patch] patch to make better use of linux list macros in drm

use_linux_lists_properly.diff (text/plain), 30.58 KB, created by Dave Airlie on 2007-05-22 10:01:33 UTC

(hide)

Description:

Filename:

MIME Type:

Creator: Dave Airlie

Created: 2007-05-22 10:01:33 UTC

Size: 30.58 KB

patch

obsolete

>diff --git a/linux-core/drmP.h b/linux-core/drmP.h
>index a3f9ca8..6cede35 100644
>--- a/linux-core/drmP.h
>+++ b/linux-core/drmP.h
>@@ -300,19 +300,14 @@ 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;
> } 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;
> 
>@@ -411,8 +406,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;
>@@ -493,8 +487,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;
> 
> /**
>@@ -504,7 +497,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 */
> #if LINUX_VERSION_CODE > KERNEL_VERSION(2,6,11)
> 	struct agp_bridge_data  *bridge;
>@@ -726,15 +719,14 @@ 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;
> 	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 */
> 	drm_mm_t offset_manager;        /**< User token manager */
>@@ -744,14 +736,14 @@ typedef struct drm_device {
> 
> 	/** \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 */
> 	/*@} */
> 
>@@ -787,8 +779,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);
>@@ -1194,7 +1186,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/linux-core/drm_agpsupport.c b/linux-core/drm_agpsupport.c
>index 7d8f073..f134563 100644
>--- a/linux-core/drm_agpsupport.c
>+++ b/linux-core/drm_agpsupport.c
>@@ -249,11 +249,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;
>@@ -280,10 +276,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;
>@@ -306,7 +304,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;
> 	}
>@@ -435,13 +433,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);
>@@ -502,7 +494,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;
> 	return head;
>diff --git a/linux-core/drm_bufs.c b/linux-core/drm_bufs.c
>index 8793ba0..a2c8a75 100644
>--- a/linux-core/drm_bufs.c
>+++ b/linux-core/drm_bufs.c
>@@ -51,10 +51,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;
> 		}
>@@ -288,7 +286,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 */
> 
>@@ -380,29 +378,28 @@ 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;
> 		}
> 	}
> 
>+	if (!found) {
>+		return -EINVAL;
>+	}
> 	/* List has wrapped around to the head pointer, or it's empty and we
> 	 * didn't find anything.
> 	 */
>-	if (list == (&dev->maplist->head)) {
>-		return -EINVAL;
>-	}
> 
> 	switch (map->type) {
> 	case _DRM_REGISTERS:
>@@ -464,7 +461,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))) {
>@@ -472,9 +469,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) {
>@@ -486,7 +481,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;
> 	}
>@@ -610,14 +605,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/linux-core/drm_compat.c b/linux-core/drm_compat.c
>index 9ac5658..a45710c 100644
>--- a/linux-core/drm_compat.c
>+++ b/linux-core/drm_compat.c
>@@ -154,7 +154,7 @@ struct page *drm_bo_vm_nopage(struct vm_area_struct *vma,
> #if !defined(DRM_FULL_MM_COMPAT) && \
>   ((LINUX_VERSION_CODE < KERNEL_VERSION(2,6,15)) || \
>    (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,19)))
>-
>+#if 0
> static int drm_pte_is_clear(struct vm_area_struct *vma,
> 			    unsigned long addr)
> {
>@@ -195,7 +195,7 @@ static int vm_insert_pfn(struct vm_area_struct *vma, unsigned long addr,
> 	ret = io_remap_pfn_range(vma, addr, pfn, PAGE_SIZE, vma->vm_page_prot);
> 	return ret;
> }
>-
>+#endif
> static struct page *drm_bo_vm_fault(struct vm_area_struct *vma, 
> 				    struct fault_data *data)
> {
>diff --git a/linux-core/drm_context.c b/linux-core/drm_context.c
>index 4904227..3bfee12 100644
>--- a/linux-core/drm_context.c
>+++ b/linux-core/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/linux-core/drm_drv.c b/linux-core/drm_drv.c
>index e5788d7..9a0ecdf 100644
>--- a/linux-core/drm_drv.c
>+++ b/linux-core/drm_drv.c
>@@ -140,8 +140,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");
>@@ -198,19 +198,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);
>@@ -224,20 +222,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_ctl_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_ctl_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) {
>@@ -372,13 +364,9 @@ static void drm_cleanup(drm_device_t * dev)
> 	drm_lastclose(dev);
> 	drm_fence_manager_takedown(dev);
> 
>-	if (dev->maplist) {
>-		drm_free(dev->maplist, sizeof(*dev->maplist), DRM_MEM_MAPS);
>-		dev->maplist = NULL;
>-		drm_ht_remove(&dev->map_hash);
>-		drm_mm_takedown(&dev->offset_manager);
>-		drm_ht_remove(&dev->object_hash);
>-	}
>+	drm_ht_remove(&dev->map_hash);
>+	drm_mm_takedown(&dev->offset_manager);
>+	drm_ht_remove(&dev->object_hash);
> 
> 	if (!drm_fb_loaded)
> 		pci_disable_device(dev->pdev);
>@@ -655,7 +643,7 @@ drm_local_map_t *drm_getsarea(struct drm_device *dev)
> {
> 	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)) {
> 			return entry->map;
>diff --git a/linux-core/drm_fops.c b/linux-core/drm_fops.c
>index d400a4d..fce2be9 100644
>--- a/linux-core/drm_fops.c
>+++ b/linux-core/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;
>@@ -268,6 +264,7 @@ 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);
> 	INIT_LIST_HEAD(&priv->user_objects);
> 	INIT_LIST_HEAD(&priv->refd_objects);
> 
>@@ -291,19 +288,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__
>@@ -480,10 +468,10 @@ int drm_release(struct inode *inode, struct file *filp)
> 
> 	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)
>@@ -503,22 +491,12 @@ int drm_release(struct inode *inode, struct file *filp)
> 	mutex_lock(&dev->struct_mutex);
> 	drm_object_release(filp);
> 	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/linux-core/drm_ioctl.c b/linux-core/drm_ioctl.c
>index f790a4b..97df972 100644
>--- a/linux-core/drm_ioctl.c
>+++ b/linux-core/drm_ioctl.c
>@@ -199,7 +199,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;
>@@ -252,12 +252,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/linux-core/drm_irq.c b/linux-core/drm_irq.c
>index b0f6e3e..8871671 100644
>--- a/linux-core/drm_irq.c
>+++ b/linux-core/drm_irq.c
>@@ -119,8 +119,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;
> 	}
>@@ -290,7 +290,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;
> 
>@@ -300,7 +300,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) {
>@@ -334,7 +334,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);
> 
>@@ -377,20 +377,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/linux-core/drm_memory.c b/linux-core/drm_memory.c
>index 759e1f1..b1423c1 100644
>--- a/linux-core/drm_memory.c
>+++ b/linux-core/drm_memory.c
>@@ -228,7 +228,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/linux-core/drm_proc.c b/linux-core/drm_proc.c
>index af62c62..e93a040 100644
>--- a/linux-core/drm_proc.c
>+++ b/linux-core/drm_proc.c
>@@ -211,7 +211,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,
>@@ -231,9 +230,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,10 +239,10 @@ static int drm__vm_info(char *buf, char **start, off_t offset, int request,
> 		else
> 			type = types[map->type];
> 		DRM_PROC_PRINT("%4d 0x%08lx 0x%08lx %4.4s  0x%02x 0x%08lx ",
>-			       i,
>-			       map->offset,
>-			       map->size, type, map->flags,
>-			       (unsigned long) r_list->user_token);
>+		       i,
>+		       map->offset,
>+		       map->size, type, map->flags,
>+		       (unsigned long) r_list->user_token);
> 
> 		if (map->mtrr < 0) {
> 			DRM_PROC_PRINT("none\n");
>@@ -253,7 +250,7 @@ static int drm__vm_info(char *buf, char **start, off_t offset, int request,
> 			DRM_PROC_PRINT("%4d\n", map->mtrr);
> 		}
> 		i++;
>-		}
>+	}
> 
> 	if (len > request + offset)
> 		return request;
>@@ -535,7 +532,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,
>@@ -588,7 +585,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/linux-core/drm_stub.c b/linux-core/drm_stub.c
>index f4da7da..bcbabf8 100644
>--- a/linux-core/drm_stub.c
>+++ b/linux-core/drm_stub.c
>@@ -60,6 +60,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);
>@@ -80,27 +81,21 @@ static int drm_fill_in_dev(drm_device_t * dev, struct pci_dev *pdev,
> 	dev->irq = pdev->irq;
> 
> 	if (drm_ht_create(&dev->map_hash, DRM_MAP_HASH_ORDER)) {
>-		drm_free(dev->maplist, sizeof(*dev->maplist), DRM_MEM_MAPS);
> 		return -ENOMEM;
> 	}
> 	if (drm_mm_init(&dev->offset_manager, DRM_FILE_PAGE_OFFSET_START,
> 			DRM_FILE_PAGE_OFFSET_SIZE)) {
>-		drm_free(dev->maplist, sizeof(*dev->maplist), DRM_MEM_MAPS);
> 		drm_ht_remove(&dev->map_hash);
> 		return -ENOMEM;
> 	}
> 
> 	if (drm_ht_create(&dev->object_hash, DRM_OBJECT_HASH_ORDER)) {
>-                drm_free(dev->maplist, sizeof(*dev->maplist), DRM_MEM_MAPS);
> 		drm_ht_remove(&dev->map_hash);
> 		drm_mm_takedown(&dev->offset_manager);
> 		return -ENOMEM;
> 	}
> 
>-	dev->maplist = drm_calloc(1, sizeof(*dev->maplist), DRM_MEM_MAPS);
>-	if (dev->maplist == NULL)
>-		return -ENOMEM;
>-	INIT_LIST_HEAD(&dev->maplist->head);
>+	INIT_LIST_HEAD(&dev->maplist);
> 
> 	/* the DRM has 6 counters */
> 	dev->counters = 6;
>diff --git a/linux-core/drm_vm.c b/linux-core/drm_vm.c
>index b887153..f2c4350 100644
>--- a/linux-core/drm_vm.c
>+++ b/linux-core/drm_vm.c
>@@ -122,7 +122,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;
>@@ -205,10 +205,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",
>@@ -218,19 +217,12 @@ 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_ctl_free(pt, sizeof(*pt), DRM_MEM_VMAS);
>-		} else {
>-			prev = pt;
> 		}
> 	}
> 	/* We were the only map that was found */
>@@ -239,9 +231,7 @@ static void drm_vm_shm_close(struct vm_area_struct *vma)
> 		 * 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++;
> 		}
>@@ -439,9 +429,8 @@ static void drm_vm_open_locked(struct vm_area_struct *vma)
> 	vma_entry = drm_ctl_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);
> 	}
> }
> 
>@@ -467,20 +456,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_ctl_free(pt, sizeof(*pt), DRM_MEM_VMAS);
> 			break;
> 		}
>diff --git a/linux-core/i810_dma.c b/linux-core/i810_dma.c
>index 3f2dad3..4937943 100644
>--- a/linux-core/i810_dma.c
>+++ b/linux-core/i810_dma.c
>@@ -346,12 +346,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/linux-core/sis_mm.c b/linux-core/sis_mm.c
>index 5efbada..21c1f2d 100644
>--- a/linux-core/sis_mm.c
>+++ b/linux-core/sis_mm.c
>@@ -233,7 +233,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/shared-core/mga_dma.c b/shared-core/mga_dma.c
>index 7844828..d48313c 100644
>--- a/shared-core/mga_dma.c
>+++ b/shared-core/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/shared-core/via_verifier.c b/shared-core/via_verifier.c
>index b5a1d33..4b844af 100644
>--- a/shared-core/via_verifier.c
>+++ b/shared-core/via_verifier.c
>@@ -255,7 +255,6 @@ static __inline__ drm_local_map_t *via_drm_lookup_agp_map(drm_via_state_t * seq,
> 							  drm_device_t * dev)
> {
> #ifdef __linux__
>-	struct list_head *list;
> 	drm_map_list_t *r_list;
> #endif
> 	drm_local_map_t *map = seq->map_cache;
>@@ -265,8 +264,7 @@ static __inline__ drm_local_map_t *via_drm_lookup_agp_map(drm_via_state_t * seq,
> 		return map;
> 	}
> #ifdef __linux__
>-	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;

Actions: View | Splinter Review

Attachments on bug 11037: 10071

Use of freedesktop.org services, including Bugzilla, is subject to our Code of Conduct. How we collect and use information is described in our Privacy Policy.