Commit 9a298b2a authored by Eric Anholt's avatar Eric Anholt
Browse files

drm: Remove memory debugging infrastructure. 



It hasn't been used in ages, and having the user tell your how much
memory is being freed at free time is a recipe for disaster even if it
was ever used.

Signed-off-by: default avatarEric Anholt <eric@anholt.net>
parent 52dc7d32

drivers/gpu/drm/drm_agpsupport.c

+6 −6
Original line number Diff line number Diff line
@@ -203,7 +203,7 @@ int drm_agp_alloc(struct drm_device *dev, struct drm_agp_buffer *request) 


	if (!dev->agp || !dev->agp->acquired)

		return -EINVAL;

	if (!(entry = drm_alloc(sizeof(*entry), DRM_MEM_AGPLISTS)))

	if (!(entry = kmalloc(sizeof(*entry), GFP_KERNEL)))

		return -ENOMEM;



	memset(entry, 0, sizeof(*entry));
@@ -211,7 +211,7 @@ int drm_agp_alloc(struct drm_device *dev, struct drm_agp_buffer *request) 
	pages = (request->size + PAGE_SIZE - 1) / PAGE_SIZE;

	type = (u32) request->type;

	if (!(memory = drm_alloc_agp(dev, pages, type))) {

		drm_free(entry, sizeof(*entry), DRM_MEM_AGPLISTS);

		kfree(entry);

		return -ENOMEM;

	}
@@ -369,7 +369,7 @@ int drm_agp_free(struct drm_device *dev, struct drm_agp_buffer *request) 
	list_del(&entry->head);



	drm_free_agp(entry->memory, entry->pages);

	drm_free(entry, sizeof(*entry), DRM_MEM_AGPLISTS);

	kfree(entry);

	return 0;

}

EXPORT_SYMBOL(drm_agp_free);
@@ -397,13 +397,13 @@ struct drm_agp_head *drm_agp_init(struct drm_device *dev) 
{

	struct drm_agp_head *head = NULL;



	if (!(head = drm_alloc(sizeof(*head), DRM_MEM_AGPLISTS)))

	if (!(head = kmalloc(sizeof(*head), GFP_KERNEL)))

		return NULL;

	memset((void *)head, 0, sizeof(*head));

	head->bridge = agp_find_bridge(dev->pdev);

	if (!head->bridge) {

		if (!(head->bridge = agp_backend_acquire(dev->pdev))) {

			drm_free(head, sizeof(*head), DRM_MEM_AGPLISTS);

			kfree(head);

			return NULL;

		}

		agp_copy_info(head->bridge, &head->agp_info);
@@ -412,7 +412,7 @@ struct drm_agp_head *drm_agp_init(struct drm_device *dev) 
		agp_copy_info(head->bridge, &head->agp_info);

	}

	if (head->agp_info.chipset == NOT_SUPPORTED) {

		drm_free(head, sizeof(*head), DRM_MEM_AGPLISTS);

		kfree(head);

		return NULL;

	}

	INIT_LIST_HEAD(&head->memory);

drivers/gpu/drm/drm_auth.c

+2 −2
Original line number Diff line number Diff line
@@ -79,7 +79,7 @@ static int drm_add_magic(struct drm_master *master, struct drm_file *priv, 
	struct drm_device *dev = master->minor->dev;

	DRM_DEBUG("%d\n", magic);



	entry = drm_alloc(sizeof(*entry), DRM_MEM_MAGIC);

	entry = kmalloc(sizeof(*entry), GFP_KERNEL);

	if (!entry)

		return -ENOMEM;

	memset(entry, 0, sizeof(*entry));
@@ -120,7 +120,7 @@ static int drm_remove_magic(struct drm_master *master, drm_magic_t magic) 
	list_del(&pt->head);

	mutex_unlock(&dev->struct_mutex);



	drm_free(pt, sizeof(*pt), DRM_MEM_MAGIC);

	kfree(pt);



	return 0;

}

drivers/gpu/drm/drm_bufs.c

+56 −84
Original line number Diff line number Diff line
@@ -151,7 +151,7 @@ static int drm_addmap_core(struct drm_device * dev, resource_size_t offset, 
	unsigned long user_token;

	int ret;



	map = drm_alloc(sizeof(*map), DRM_MEM_MAPS);

	map = kmalloc(sizeof(*map), GFP_KERNEL);

	if (!map)

		return -ENOMEM;
@@ -165,7 +165,7 @@ static int drm_addmap_core(struct drm_device * dev, resource_size_t offset, 
	 * when processes fork.

	 */

	if ((map->flags & _DRM_REMOVABLE) && map->type != _DRM_SHM) {

		drm_free(map, sizeof(*map), DRM_MEM_MAPS);

		kfree(map);

		return -EINVAL;

	}

	DRM_DEBUG("offset = 0x%08llx, size = 0x%08lx, type = %d\n",
@@ -179,7 +179,7 @@ static int drm_addmap_core(struct drm_device * dev, resource_size_t offset, 
		map->size = PAGE_ALIGN(map->size);



	if ((map->offset & (~(resource_size_t)PAGE_MASK)) || (map->size & (~PAGE_MASK))) {

		drm_free(map, sizeof(*map), DRM_MEM_MAPS);

		kfree(map);

		return -EINVAL;

	}

	map->mtrr = -1;
@@ -191,7 +191,7 @@ static int drm_addmap_core(struct drm_device * dev, resource_size_t offset, 
#if !defined(__sparc__) && !defined(__alpha__) && !defined(__ia64__) && !defined(__powerpc64__) && !defined(__x86_64__)

		if (map->offset + (map->size-1) < map->offset ||

		    map->offset < virt_to_phys(high_memory)) {

			drm_free(map, sizeof(*map), DRM_MEM_MAPS);

			kfree(map);

			return -EINVAL;

		}

#endif
@@ -212,7 +212,7 @@ static int drm_addmap_core(struct drm_device * dev, resource_size_t offset, 
				list->map->size = map->size;

			}



			drm_free(map, sizeof(*map), DRM_MEM_MAPS);

			kfree(map);

			*maplist = list;

			return 0;

		}
@@ -227,7 +227,7 @@ static int drm_addmap_core(struct drm_device * dev, resource_size_t offset, 
		if (map->type == _DRM_REGISTERS) {

			map->handle = ioremap(map->offset, map->size);

			if (!map->handle) {

				drm_free(map, sizeof(*map), DRM_MEM_MAPS);

				kfree(map);

				return -ENOMEM;

			}

		}
@@ -243,7 +243,7 @@ static int drm_addmap_core(struct drm_device * dev, resource_size_t offset, 
				list->map->size = map->size;

			}



			drm_free(map, sizeof(*map), DRM_MEM_MAPS);

			kfree(map);

			*maplist = list;

			return 0;

		}
@@ -251,7 +251,7 @@ static int drm_addmap_core(struct drm_device * dev, resource_size_t offset, 
		DRM_DEBUG("%lu %d %p\n",

			  map->size, drm_order(map->size), map->handle);

		if (!map->handle) {

			drm_free(map, sizeof(*map), DRM_MEM_MAPS);

			kfree(map);

			return -ENOMEM;

		}

		map->offset = (unsigned long)map->handle;
@@ -259,7 +259,7 @@ static int drm_addmap_core(struct drm_device * dev, resource_size_t offset, 
			/* Prevent a 2nd X Server from creating a 2nd lock */

			if (dev->primary->master->lock.hw_lock != NULL) {

				vfree(map->handle);

				drm_free(map, sizeof(*map), DRM_MEM_MAPS);

				kfree(map);

				return -EBUSY;

			}

			dev->sigdata.lock = dev->primary->master->lock.hw_lock = map->handle;	/* Pointer to lock */
@@ -270,7 +270,7 @@ static int drm_addmap_core(struct drm_device * dev, resource_size_t offset, 
		int valid = 0;



		if (!drm_core_has_AGP(dev)) {

			drm_free(map, sizeof(*map), DRM_MEM_MAPS);

			kfree(map);

			return -EINVAL;

		}

#ifdef __alpha__
@@ -303,7 +303,7 @@ static int drm_addmap_core(struct drm_device * dev, resource_size_t offset, 
			}

		}

		if (!list_empty(&dev->agp->memory) && !valid) {

			drm_free(map, sizeof(*map), DRM_MEM_MAPS);

			kfree(map);

			return -EPERM;

		}

		DRM_DEBUG("AGP offset = 0x%08llx, size = 0x%08lx\n",
@@ -316,7 +316,7 @@ static int drm_addmap_core(struct drm_device * dev, resource_size_t offset, 
	}

	case _DRM_SCATTER_GATHER:

		if (!dev->sg) {

			drm_free(map, sizeof(*map), DRM_MEM_MAPS);

			kfree(map);

			return -EINVAL;

		}

		map->offset += (unsigned long)dev->sg->virtual;
@@ -328,7 +328,7 @@ static int drm_addmap_core(struct drm_device * dev, resource_size_t offset, 
		 * need to point to a 64bit variable first. */

		dmah = drm_pci_alloc(dev, map->size, map->size, 0xffffffffUL);

		if (!dmah) {

			drm_free(map, sizeof(*map), DRM_MEM_MAPS);

			kfree(map);

			return -ENOMEM;

		}

		map->handle = dmah->vaddr;
@@ -336,15 +336,15 @@ static int drm_addmap_core(struct drm_device * dev, resource_size_t offset, 
		kfree(dmah);

		break;

	default:

		drm_free(map, sizeof(*map), DRM_MEM_MAPS);

		kfree(map);

		return -EINVAL;

	}



	list = drm_alloc(sizeof(*list), DRM_MEM_MAPS);

	list = kmalloc(sizeof(*list), GFP_KERNEL);

	if (!list) {

		if (map->type == _DRM_REGISTERS)

			iounmap(map->handle);

		drm_free(map, sizeof(*map), DRM_MEM_MAPS);

		kfree(map);

		return -EINVAL;

	}

	memset(list, 0, sizeof(*list));
@@ -362,8 +362,8 @@ static int drm_addmap_core(struct drm_device * dev, resource_size_t offset, 
	if (ret) {

		if (map->type == _DRM_REGISTERS)

			iounmap(map->handle);

		drm_free(map, sizeof(*map), DRM_MEM_MAPS);

		drm_free(list, sizeof(*list), DRM_MEM_MAPS);

		kfree(map);

		kfree(list);

		mutex_unlock(&dev->struct_mutex);

		return ret;

	}
@@ -448,7 +448,7 @@ int drm_rmmap_locked(struct drm_device *dev, struct drm_local_map *map) 
			list_del(&r_list->head);

			drm_ht_remove_key(&dev->map_hash,

					  r_list->user_token >> PAGE_SHIFT);

			drm_free(r_list, sizeof(*r_list), DRM_MEM_MAPS);

			kfree(r_list);

			found = 1;

			break;

		}
@@ -491,7 +491,7 @@ int drm_rmmap_locked(struct drm_device *dev, struct drm_local_map *map) 
		DRM_ERROR("tried to rmmap GEM object\n");

		break;

	}

	drm_free(map, sizeof(*map), DRM_MEM_MAPS);

	kfree(map);



	return 0;

}
@@ -582,24 +582,16 @@ static void drm_cleanup_buf_error(struct drm_device * dev, 
				drm_pci_free(dev, entry->seglist[i]);

			}

		}

		drm_free(entry->seglist,

			 entry->seg_count *

			 sizeof(*entry->seglist), DRM_MEM_SEGS);

		kfree(entry->seglist);



		entry->seg_count = 0;

	}



	if (entry->buf_count) {

		for (i = 0; i < entry->buf_count; i++) {

			if (entry->buflist[i].dev_private) {

				drm_free(entry->buflist[i].dev_private,

					 entry->buflist[i].dev_priv_size,

					 DRM_MEM_BUFS);

			kfree(entry->buflist[i].dev_private);

		}

		}

		drm_free(entry->buflist,

			 entry->buf_count *

			 sizeof(*entry->buflist), DRM_MEM_BUFS);

		kfree(entry->buflist);



		entry->buf_count = 0;

	}
@@ -698,8 +690,7 @@ int drm_addbufs_agp(struct drm_device * dev, struct drm_buf_desc * request) 
		return -EINVAL;

	}



	entry->buflist = drm_alloc(count * sizeof(*entry->buflist),

				   DRM_MEM_BUFS);

	entry->buflist = kmalloc(count * sizeof(*entry->buflist), GFP_KERNEL);

	if (!entry->buflist) {

		mutex_unlock(&dev->struct_mutex);

		atomic_dec(&dev->buf_alloc);
@@ -729,7 +720,7 @@ int drm_addbufs_agp(struct drm_device * dev, struct drm_buf_desc * request) 
		buf->file_priv = NULL;



		buf->dev_priv_size = dev->driver->dev_priv_size;

		buf->dev_private = drm_alloc(buf->dev_priv_size, DRM_MEM_BUFS);

		buf->dev_private = kmalloc(buf->dev_priv_size, GFP_KERNEL);

		if (!buf->dev_private) {

			/* Set count correctly so we free the proper amount. */

			entry->buf_count = count;
@@ -749,10 +740,9 @@ int drm_addbufs_agp(struct drm_device * dev, struct drm_buf_desc * request) 


	DRM_DEBUG("byte_count: %d\n", byte_count);



	temp_buflist = drm_realloc(dma->buflist,

				   dma->buf_count * sizeof(*dma->buflist),

				   (dma->buf_count + entry->buf_count)

				   * sizeof(*dma->buflist), DRM_MEM_BUFS);

	temp_buflist = krealloc(dma->buflist,

				(dma->buf_count + entry->buf_count) *

				sizeof(*dma->buflist), GFP_KERNEL);

	if (!temp_buflist) {

		/* Free the entry because it isn't valid */

		drm_cleanup_buf_error(dev, entry);
@@ -854,8 +844,7 @@ int drm_addbufs_pci(struct drm_device * dev, struct drm_buf_desc * request) 
		return -EINVAL;

	}



	entry->buflist = drm_alloc(count * sizeof(*entry->buflist),

				   DRM_MEM_BUFS);

	entry->buflist = kmalloc(count * sizeof(*entry->buflist), GFP_KERNEL);

	if (!entry->buflist) {

		mutex_unlock(&dev->struct_mutex);

		atomic_dec(&dev->buf_alloc);
@@ -863,11 +852,9 @@ int drm_addbufs_pci(struct drm_device * dev, struct drm_buf_desc * request) 
	}

	memset(entry->buflist, 0, count * sizeof(*entry->buflist));



	entry->seglist = drm_alloc(count * sizeof(*entry->seglist),

				   DRM_MEM_SEGS);

	entry->seglist = kmalloc(count * sizeof(*entry->seglist), GFP_KERNEL);

	if (!entry->seglist) {

		drm_free(entry->buflist,

			 count * sizeof(*entry->buflist), DRM_MEM_BUFS);

		kfree(entry->buflist);

		mutex_unlock(&dev->struct_mutex);

		atomic_dec(&dev->buf_alloc);

		return -ENOMEM;
@@ -877,13 +864,11 @@ int drm_addbufs_pci(struct drm_device * dev, struct drm_buf_desc * request) 
	/* Keep the original pagelist until we know all the allocations

	 * have succeeded

	 */

	temp_pagelist = drm_alloc((dma->page_count + (count << page_order))

				  * sizeof(*dma->pagelist), DRM_MEM_PAGES);

	temp_pagelist = kmalloc((dma->page_count + (count << page_order)) *

			       sizeof(*dma->pagelist), GFP_KERNEL);

	if (!temp_pagelist) {

		drm_free(entry->buflist,

			 count * sizeof(*entry->buflist), DRM_MEM_BUFS);

		drm_free(entry->seglist,

			 count * sizeof(*entry->seglist), DRM_MEM_SEGS);

		kfree(entry->buflist);

		kfree(entry->seglist);

		mutex_unlock(&dev->struct_mutex);

		atomic_dec(&dev->buf_alloc);

		return -ENOMEM;
@@ -907,9 +892,7 @@ int drm_addbufs_pci(struct drm_device * dev, struct drm_buf_desc * request) 
			entry->buf_count = count;

			entry->seg_count = count;

			drm_cleanup_buf_error(dev, entry);

			drm_free(temp_pagelist,

				 (dma->page_count + (count << page_order))

				 * sizeof(*dma->pagelist), DRM_MEM_PAGES);

			kfree(temp_pagelist);

			mutex_unlock(&dev->struct_mutex);

			atomic_dec(&dev->buf_alloc);

			return -ENOMEM;
@@ -940,18 +923,14 @@ int drm_addbufs_pci(struct drm_device * dev, struct drm_buf_desc * request) 
			buf->file_priv = NULL;



			buf->dev_priv_size = dev->driver->dev_priv_size;

			buf->dev_private = drm_alloc(buf->dev_priv_size,

						     DRM_MEM_BUFS);

			buf->dev_private = kmalloc(buf->dev_priv_size,

						  GFP_KERNEL);

			if (!buf->dev_private) {

				/* Set count correctly so we free the proper amount. */

				entry->buf_count = count;

				entry->seg_count = count;

				drm_cleanup_buf_error(dev, entry);

				drm_free(temp_pagelist,

					 (dma->page_count +

					  (count << page_order))

					 * sizeof(*dma->pagelist),

					 DRM_MEM_PAGES);

				kfree(temp_pagelist);

				mutex_unlock(&dev->struct_mutex);

				atomic_dec(&dev->buf_alloc);

				return -ENOMEM;
@@ -964,16 +943,13 @@ int drm_addbufs_pci(struct drm_device * dev, struct drm_buf_desc * request) 
		byte_count += PAGE_SIZE << page_order;

	}



	temp_buflist = drm_realloc(dma->buflist,

				   dma->buf_count * sizeof(*dma->buflist),

				   (dma->buf_count + entry->buf_count)

				   * sizeof(*dma->buflist), DRM_MEM_BUFS);

	temp_buflist = krealloc(dma->buflist,

				(dma->buf_count + entry->buf_count) *

				sizeof(*dma->buflist), GFP_KERNEL);

	if (!temp_buflist) {

		/* Free the entry because it isn't valid */

		drm_cleanup_buf_error(dev, entry);

		drm_free(temp_pagelist,

			 (dma->page_count + (count << page_order))

			 * sizeof(*dma->pagelist), DRM_MEM_PAGES);

		kfree(temp_pagelist);

		mutex_unlock(&dev->struct_mutex);

		atomic_dec(&dev->buf_alloc);

		return -ENOMEM;
@@ -988,9 +964,7 @@ int drm_addbufs_pci(struct drm_device * dev, struct drm_buf_desc * request) 
	 * with the new one.

	 */

	if (dma->page_count) {

		drm_free(dma->pagelist,

			 dma->page_count * sizeof(*dma->pagelist),

			 DRM_MEM_PAGES);

		kfree(dma->pagelist);

	}

	dma->pagelist = temp_pagelist;
@@ -1086,8 +1060,8 @@ static int drm_addbufs_sg(struct drm_device * dev, struct drm_buf_desc * request 
		return -EINVAL;

	}



	entry->buflist = drm_alloc(count * sizeof(*entry->buflist),

				   DRM_MEM_BUFS);

	entry->buflist = kmalloc(count * sizeof(*entry->buflist),

				GFP_KERNEL);

	if (!entry->buflist) {

		mutex_unlock(&dev->struct_mutex);

		atomic_dec(&dev->buf_alloc);
@@ -1118,7 +1092,7 @@ static int drm_addbufs_sg(struct drm_device * dev, struct drm_buf_desc * request 
		buf->file_priv = NULL;



		buf->dev_priv_size = dev->driver->dev_priv_size;

		buf->dev_private = drm_alloc(buf->dev_priv_size, DRM_MEM_BUFS);

		buf->dev_private = kmalloc(buf->dev_priv_size, GFP_KERNEL);

		if (!buf->dev_private) {

			/* Set count correctly so we free the proper amount. */

			entry->buf_count = count;
@@ -1139,10 +1113,9 @@ static int drm_addbufs_sg(struct drm_device * dev, struct drm_buf_desc * request 


	DRM_DEBUG("byte_count: %d\n", byte_count);



	temp_buflist = drm_realloc(dma->buflist,

				   dma->buf_count * sizeof(*dma->buflist),

				   (dma->buf_count + entry->buf_count)

				   * sizeof(*dma->buflist), DRM_MEM_BUFS);

	temp_buflist = krealloc(dma->buflist,

				(dma->buf_count + entry->buf_count) *

				sizeof(*dma->buflist), GFP_KERNEL);

	if (!temp_buflist) {

		/* Free the entry because it isn't valid */

		drm_cleanup_buf_error(dev, entry);
@@ -1248,8 +1221,8 @@ static int drm_addbufs_fb(struct drm_device * dev, struct drm_buf_desc * request 
		return -EINVAL;

	}



	entry->buflist = drm_alloc(count * sizeof(*entry->buflist),

				   DRM_MEM_BUFS);

	entry->buflist = kmalloc(count * sizeof(*entry->buflist),

				GFP_KERNEL);

	if (!entry->buflist) {

		mutex_unlock(&dev->struct_mutex);

		atomic_dec(&dev->buf_alloc);
@@ -1279,7 +1252,7 @@ static int drm_addbufs_fb(struct drm_device * dev, struct drm_buf_desc * request 
		buf->file_priv = NULL;



		buf->dev_priv_size = dev->driver->dev_priv_size;

		buf->dev_private = drm_alloc(buf->dev_priv_size, DRM_MEM_BUFS);

		buf->dev_private = kmalloc(buf->dev_priv_size, GFP_KERNEL);

		if (!buf->dev_private) {

			/* Set count correctly so we free the proper amount. */

			entry->buf_count = count;
@@ -1299,10 +1272,9 @@ static int drm_addbufs_fb(struct drm_device * dev, struct drm_buf_desc * request 


	DRM_DEBUG("byte_count: %d\n", byte_count);



	temp_buflist = drm_realloc(dma->buflist,

				   dma->buf_count * sizeof(*dma->buflist),

				   (dma->buf_count + entry->buf_count)

				   * sizeof(*dma->buflist), DRM_MEM_BUFS);

	temp_buflist = krealloc(dma->buflist,

				(dma->buf_count + entry->buf_count) *

				sizeof(*dma->buflist), GFP_KERNEL);

	if (!temp_buflist) {

		/* Free the entry because it isn't valid */

		drm_cleanup_buf_error(dev, entry);

drivers/gpu/drm/drm_context.c

+2 −2
Original line number Diff line number Diff line
@@ -341,7 +341,7 @@ int drm_addctx(struct drm_device *dev, void *data, 
			}

	}



	ctx_entry = drm_alloc(sizeof(*ctx_entry), DRM_MEM_CTXLIST);

	ctx_entry = kmalloc(sizeof(*ctx_entry), GFP_KERNEL);

	if (!ctx_entry) {

		DRM_DEBUG("out of memory\n");

		return -ENOMEM;
@@ -456,7 +456,7 @@ int drm_rmctx(struct drm_device *dev, void *data, 
		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);

				kfree(pos);

				--dev->ctx_count;

			}

		}

drivers/gpu/drm/drm_debugfs.c

+3 −6
Original line number Diff line number Diff line
@@ -100,15 +100,13 @@ int drm_debugfs_create_files(struct drm_info_list *files, int count, 
		    (dev->driver->driver_features & features) != features)

			continue;



		tmp = drm_alloc(sizeof(struct drm_info_node),

				_DRM_DRIVER);

		tmp = kmalloc(sizeof(struct drm_info_node), GFP_KERNEL);

		ent = debugfs_create_file(files[i].name, S_IFREG | S_IRUGO,

					  root, tmp, &drm_debugfs_fops);

		if (!ent) {

			DRM_ERROR("Cannot create /sys/kernel/debug/dri/%s/%s\n",

				  name, files[i].name);

			drm_free(tmp, sizeof(struct drm_info_node),

				 _DRM_DRIVER);

			kfree(tmp);

			ret = -1;

			goto fail;

		}
@@ -196,8 +194,7 @@ int drm_debugfs_remove_files(struct drm_info_list *files, int count, 
			if (tmp->info_ent == &files[i]) {

				debugfs_remove(tmp->dent);

				list_del(pos);

				drm_free(tmp, sizeof(struct drm_info_node),

					 _DRM_DRIVER);

				kfree(tmp);

			}

		}

	}