Commit bd1b331f authored by Dave Airlie's avatar Dave Airlie
Browse files

drm: cleanup use of Linux list handling macros 



This makes the drms use of the list handling macros a lot cleaner
and more along the lines of how they should be used and uses them
in some more places.

Signed-off-by: default avatarDave Airlie <airlied@linux.ie>
parent 4eb6bf6b

drivers/char/drm/drmP.h

+12 −20
Original line number Diff line number Diff line
@@ -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;

drivers/char/drm/drm_agpsupport.c

+10 −18
Original line number Diff line number Diff line
@@ -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;

drivers/char/drm/drm_bufs.c

+17 −26
Original line number Diff line number Diff line
@@ -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;

	}

drivers/char/drm/drm_context.c

+5 −7
Original line number Diff line number Diff line
@@ -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);

drivers/char/drm/drm_drv.c

+12 −24
Original line number Diff line number Diff line
@@ -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;

	list_for_each_entry_safe(vma, vma_temp, &dev->vmalist, head) {

		list_del(&vma->head);

		drm_free(vma, sizeof(*vma), DRM_MEM_VMAS);

	}

		dev->vmalist = NULL;

	}



	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);

	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_ctxbitmap_cleanup(dev);