WebSVN – Kolibri OS – Diff – /drivers/video/drm/i915/i915_gem_execbuffer.c

 #include "i915_drv.h"
 #include "i915_trace.h"
 #include "intel_drv.h"
 //#include
+#define  __EXEC_OBJECT_HAS_PIN (1<<31)
 #define  __EXEC_OBJECT_HAS_FENCE (1<<30)
 static unsigned long
 copy_to_user(void __user *to, const void *from, unsigned long n)
+{
     memcpy(to, from, n);
     return 0;
+}
-struct eb_objects {
+struct eb_vmas {
-	struct list_head objects;
+	struct list_head vmas;
 	int and;
 	union {
-		struct drm_i915_gem_object *lut[0];
+		struct i915_vma *lut[0];
 	struct hlist_head buckets[0];
 	};
 };
-static struct eb_objects *
+static struct eb_vmas *
 eb_create(struct drm_i915_gem_execbuffer2 *args)
+{
-	struct eb_objects *eb = NULL;
+	struct eb_vmas *eb = NULL;
 	if (args->flags & I915_EXEC_HANDLE_LUT) {
-		int size = args->buffer_count;
+		unsigned size = args->buffer_count;
-		size *= sizeof(struct drm_i915_gem_object *);
+		size *= sizeof(struct i915_vma *);
-		size += sizeof(struct eb_objects);
+		size += sizeof(struct eb_vmas);
 		eb = kmalloc(size, GFP_TEMPORARY | __GFP_NOWARN | __GFP_NORETRY);
 	}
 	if (eb == NULL) {
-		int size = args->buffer_count;
+		unsigned size = args->buffer_count;
-	int count = PAGE_SIZE / sizeof(struct hlist_head) / 2;
+		unsigned count = PAGE_SIZE / sizeof(struct hlist_head) / 2;
 		BUILD_BUG_ON_NOT_POWER_OF_2(PAGE_SIZE / sizeof(struct hlist_head));
 		while (count > 2*size)
 		count >>= 1;
 	eb = kzalloc(count*sizeof(struct hlist_head) +
-		     sizeof(struct eb_objects),
+			     sizeof(struct eb_vmas),
 			     GFP_TEMPORARY);
 	if (eb == NULL)
 		return eb;
 	eb->and = count - 1;
 	} else
 		eb->and = -args->buffer_count;
-	INIT_LIST_HEAD(&eb->objects);
+	INIT_LIST_HEAD(&eb->vmas);
 	return eb;
+}
 static void
-eb_reset(struct eb_objects *eb)
+eb_reset(struct eb_vmas *eb)
+{
+	if (eb->and >= 0)
-	if (eb->and >= 0)
+	memset(eb->buckets, 0, (eb->and+1)*sizeof(struct hlist_head));
 	memset(eb->buckets, 0, (eb->and+1)*sizeof(struct hlist_head));
+static int
-}
+eb_lookup_vmas(struct eb_vmas *eb,
+		  struct drm_i915_gem_exec_object2 *exec,
 		  const struct drm_i915_gem_execbuffer2 *args,
+	       struct i915_address_space *vm,
+		  struct drm_file *file)
 static int
-eb_lookup_objects(struct eb_objects *eb,
-		  struct drm_i915_gem_exec_object2 *exec,
-		  const struct drm_i915_gem_execbuffer2 *args,
+	struct drm_i915_gem_object *obj;
-		  struct drm_file *file)
+	struct list_head objects;
 	int i, ret;
 	int i;
 	INIT_LIST_HEAD(&objects);
 	spin_lock(&file->table_lock);
+	/* Grab a reference to the object and release the lock so we can lookup
-	for (i = 0; i < args->buffer_count; i++) {
+	 * or create the VMA without using GFP_ATOMIC */
-		struct drm_i915_gem_object *obj;
+	for (i = 0; i < args->buffer_count; i++) {
 		    obj = to_intel_bo(idr_find(&file->object_idr, exec[i].handle));
-		    obj = to_intel_bo(idr_find(&file->object_idr, exec[i].handle));
+		if (obj == NULL) {
-		if (obj == NULL) {
+			spin_unlock(&file->table_lock);
-			spin_unlock(&file->table_lock);
+			DRM_DEBUG("Invalid object handle %d at index %d\n",
+				   exec[i].handle, i);
-			DRM_DEBUG("Invalid object handle %d at index %d\n",
+			ret = -ENOENT;
-				   exec[i].handle, i);
+			goto err;
-			return -ENOENT;
+		}
+		if (!list_empty(&obj->obj_exec_link)) {
+			spin_unlock(&file->table_lock);
+			DRM_DEBUG("Object %p [handle %d, index %d] appears more than once in object list\n",
+				   obj, exec[i].handle, i);
+			ret = -EINVAL;
+			goto err;
+		}
+		drm_gem_object_reference(&obj->base);
+		list_add_tail(&obj->obj_exec_link, &objects);
+	}
+	spin_unlock(&file->table_lock);
+	i = 0;
+	while (!list_empty(&objects)) {
+		struct i915_vma *vma;
+		obj = list_first_entry(&objects,
+				       struct drm_i915_gem_object,
+				       obj_exec_link);
+		/*
+		 * NOTE: We can leak any vmas created here when something fails
+		 * later on. But that's no issue since vma_unbind can deal with
+		 * vmas which are not actually bound. And since only
+		 * lookup_or_create exists as an interface to get at the vma
+		 * from the (obj, vm) we don't run the risk of creating
+		 * duplicated vmas for the same vm.
-		}
+		 */
 		vma = i915_gem_obj_lookup_or_create_vma(obj, vm);
-		if (!list_empty(&obj->exec_list)) {
+		if (IS_ERR(vma)) {
-			spin_unlock(&file->table_lock);
+			DRM_DEBUG("Failed to lookup VMA\n");
-			DRM_DEBUG("Object %p [handle %d, index %d] appears more than once in object list\n",
+			ret = PTR_ERR(vma);
-				   obj, exec[i].handle, i);
+			goto err;
-			return -EINVAL;
+		}
 		/* Transfer ownership from the objects list to the vmas list. */
+		list_add_tail(&vma->exec_list, &eb->vmas);
-		drm_gem_object_reference(&obj->base);
+		list_del_init(&obj->obj_exec_link);
-		list_add_tail(&obj->exec_list, &eb->objects);
+		vma->exec_entry = &exec[i];
+		if (eb->and < 0) {
+			eb->lut[i] = vma;
+		} else {
+			uint32_t handle = args->flags & I915_EXEC_HANDLE_LUT ? i : exec[i].handle;
+			vma->exec_handle = handle;
+			hlist_add_head(&vma->exec_node,
+				       &eb->buckets[handle & eb->and]);
+		}
+		++i;
+	}
+	return 0;
+err:
-		obj->exec_entry = &exec[i];
+	while (!list_empty(&objects)) {
-		if (eb->and < 0) {
-			eb->lut[i] = obj;
+		obj = list_first_entry(&objects,
-		} else {
+				       struct drm_i915_gem_object,
-			uint32_t handle = args->flags & I915_EXEC_HANDLE_LUT ? i : exec[i].handle;
+				       obj_exec_link);
-			obj->exec_handle = handle;
+		list_del_init(&obj->obj_exec_link);
-	hlist_add_head(&obj->exec_node,
+		drm_gem_object_unreference(&obj->base);
 				       &eb->buckets[handle & eb->and]);
 	struct hlist_head *head;
 	struct hlist_node *node;
 	head = &eb->buckets[handle & eb->and];
 	hlist_for_each(node, head) {
-			struct drm_i915_gem_object *obj;
+			struct i915_vma *vma;
-		obj = hlist_entry(node, struct drm_i915_gem_object, exec_node);
+			vma = hlist_entry(node, struct i915_vma, exec_node);
-		if (obj->exec_handle == handle)
+			if (vma->exec_handle == handle)
-			return obj;
+				return vma;
+	}
 	return NULL;
+	}
 }
 static void
-eb_destroy(struct eb_objects *eb)
+i915_gem_execbuffer_unreserve_vma(struct i915_vma *vma)
+{
+	struct drm_i915_gem_exec_object2 *entry;
+	struct drm_i915_gem_object *obj = vma->obj;
+	if (!drm_mm_node_allocated(&vma->node))
+		return;
+	entry = vma->exec_entry;
+	if (entry->flags & __EXEC_OBJECT_HAS_FENCE)
+		i915_gem_object_unpin_fence(obj);
+	if (entry->flags & __EXEC_OBJECT_HAS_PIN)
+		i915_gem_object_unpin(obj);
+	entry->flags &= ~(__EXEC_OBJECT_HAS_FENCE | __EXEC_OBJECT_HAS_PIN);
+}
+static void eb_destroy(struct eb_vmas *eb)
 {
-	while (!list_empty(&eb->objects)) {
+	while (!list_empty(&eb->vmas)) {
-		struct drm_i915_gem_object *obj;
+		struct i915_vma *vma;
+		vma = list_first_entry(&eb->vmas,
-		obj = list_first_entry(&eb->objects,
+				       struct i915_vma,
-				       struct drm_i915_gem_object,
+				       exec_list);
-				       exec_list);
+		list_del_init(&vma->exec_list);
-		list_del_init(&obj->exec_list);
+		i915_gem_execbuffer_unreserve_vma(vma);
-		drm_gem_object_unreference(&obj->base);
+		drm_gem_object_unreference(&vma->obj->base);
+	}
+	kfree(eb);
-	kfree(eb);
+}
 static inline int use_cpu_reloc(struct drm_i915_gem_object *obj)
 static inline int use_cpu_reloc(struct drm_i915_gem_object *obj)
 	return (HAS_LLC(obj->base.dev) ||
+{
     struct drm_device *dev = obj->base.dev;
     struct drm_i915_private *dev_priv = dev->dev_private;
 	uint32_t page_offset = offset_in_page(reloc->offset);
 	char *vaddr;
-	int ret = -EINVAL;
+	int ret;
-	ret = i915_gem_object_set_to_cpu_domain(obj, 1);
+	ret = i915_gem_object_set_to_cpu_domain(obj, true);
 	if (ret)
 		return ret;
+{
 	struct drm_device *dev = obj->base.dev;
 	struct drm_i915_private *dev_priv = dev->dev_private;
 	uint32_t __iomem *reloc_entry;
 	void __iomem *reloc_page;
-	int ret = -EINVAL;
+	int ret;
 	ret = i915_gem_object_set_to_gtt_domain(obj, true);
 	if (ret)
 	return 0;
+}
 static int
 i915_gem_execbuffer_relocate_entry(struct drm_i915_gem_object *obj,
-				   struct eb_objects *eb,
+				   struct eb_vmas *eb,
 				   struct drm_i915_gem_relocation_entry *reloc,
 				   struct i915_address_space *vm)
+{
 	struct drm_device *dev = obj->base.dev;
 	struct drm_gem_object *target_obj;
+	struct drm_i915_gem_object *target_i915_obj;
-	struct drm_i915_gem_object *target_i915_obj;
+	struct i915_vma *target_vma;
 	uint32_t target_offset;
-	int ret = -EINVAL;
+	int ret;
 	/* we've already hold a reference to all valid objects */
-	target_obj = &eb_get_object(eb, reloc->target_handle)->base;
+	target_vma = eb_get_vma(eb, reloc->target_handle);
+	if (unlikely(target_vma == NULL))
+		return -ENOENT;
-	if (unlikely(target_obj == NULL))
-		return -ENOENT;
+	target_i915_obj = target_vma->obj;
 	target_obj = &target_vma->obj->base;
 	target_i915_obj = to_intel_bo(target_obj);
-	target_offset = i915_gem_obj_ggtt_offset(target_i915_obj);
+	target_offset = target_vma->node.start;
 			  "read %08x write %08x",
 			  obj, reloc->target_handle,
 			  (int) reloc->offset,
 			  reloc->read_domains,
 			  reloc->write_domain);
-		return ret;
+		return -EINVAL;
+	}
 	if (unlikely((reloc->write_domain | reloc->read_domains)
 		     & ~I915_GEM_GPU_DOMAINS)) {
 		DRM_DEBUG("reloc with read/write non-GPU domains: "
 			  "obj %p target %d offset %d "
 			  "read %08x write %08x",
 			  obj, reloc->target_handle,
 			  (int) reloc->offset,
 			  reloc->read_domains,
 			  reloc->write_domain);
-		return ret;
+		return -EINVAL;
+	}
 	target_obj->pending_read_domains |= reloc->read_domains;
 	 */
 	if (target_offset == reloc->presumed_offset)
 		return 0;
 	/* Check that the relocation address is valid... */
+	if (unlikely(reloc->offset >
-	if (unlikely(reloc->offset > obj->base.size - 4)) {
+		obj->base.size - (INTEL_INFO(dev)->gen >= 8 ? 8 : 4))) {
 		DRM_DEBUG("Relocation beyond object bounds: "
 			  "obj %p target %d offset %d size %d.\n",
 			  obj, reloc->target_handle,
 			  (int) reloc->offset,
 			  (int) obj->base.size);
-		return ret;
+		return -EINVAL;
+	}
 	if (unlikely(reloc->offset & 3)) {
 		DRM_DEBUG("Relocation not 4-byte aligned: "
 			  "obj %p target %d offset %d.\n",
 			  obj, reloc->target_handle,
 			  (int) reloc->offset);
-		return ret;
+		return -EINVAL;
+	}
 	return 0;
+}
 static int
-i915_gem_execbuffer_relocate_object(struct drm_i915_gem_object *obj,
-				    struct eb_objects *eb,
+i915_gem_execbuffer_relocate_vma(struct i915_vma *vma,
-				    struct i915_address_space *vm)
+				 struct eb_vmas *eb)
+{
 #define N_RELOC(x) ((x) / sizeof(struct drm_i915_gem_relocation_entry))
 	struct drm_i915_gem_relocation_entry stack_reloc[N_RELOC(64)];
 	struct drm_i915_gem_relocation_entry __user *user_relocs;
-	struct drm_i915_gem_exec_object2 *entry = obj->exec_entry;
+	struct drm_i915_gem_exec_object2 *entry = vma->exec_entry;
 	int remain, ret;
         memcpy(r, user_relocs, count*sizeof(r[0]));
 		do {
 			u64 offset = r->presumed_offset;
-			ret = i915_gem_execbuffer_relocate_entry(obj, eb, r,
+			ret = i915_gem_execbuffer_relocate_entry(vma->obj, eb, r,
-								 vm);
+								 vma->vm);
 			if (ret)
 				return ret;
 	return 0;
 #undef N_RELOC
+}
 static int
-i915_gem_execbuffer_relocate_object_slow(struct drm_i915_gem_object *obj,
+i915_gem_execbuffer_relocate_vma_slow(struct i915_vma *vma,
-					 struct eb_objects *eb,
+				      struct eb_vmas *eb,
-					 struct drm_i915_gem_relocation_entry *relocs,
-					 struct i915_address_space *vm)
+				      struct drm_i915_gem_relocation_entry *relocs)
 {
-	const struct drm_i915_gem_exec_object2 *entry = obj->exec_entry;
+	const struct drm_i915_gem_exec_object2 *entry = vma->exec_entry;
 	int i, ret;
 	for (i = 0; i < entry->relocation_count; i++) {
-		ret = i915_gem_execbuffer_relocate_entry(obj, eb, &relocs[i],
+		ret = i915_gem_execbuffer_relocate_entry(vma->obj, eb, &relocs[i],
-							 vm);
+							 vma->vm);
 		if (ret)
 			return ret;
+	}
 	return 0;
-}
+}
-static int
-i915_gem_execbuffer_relocate(struct eb_objects *eb,
+static int
-			     struct i915_address_space *vm)
+i915_gem_execbuffer_relocate(struct eb_vmas *eb)
+{
-	struct drm_i915_gem_object *obj;
+	struct i915_vma *vma;
 	int ret = 0;
 	/* This is the fast path and we cannot handle a pagefault whilst
 	 * holding the struct mutex lest the user pass in the relocations
 	 * contained within a mmaped bo. For in such a case we, the page
 	 * fault handler would call i915_gem_fault() and we would try to
 	 * acquire the struct mutex again. Obviously this is bad and so
 	 * lockdep complains vehemently.
 	 */
 //	pagefault_disable();
-	list_for_each_entry(obj, &eb->objects, exec_list) {
+	list_for_each_entry(vma, &eb->vmas, exec_list) {
-		ret = i915_gem_execbuffer_relocate_object(obj, eb, vm);
+		ret = i915_gem_execbuffer_relocate_vma(vma, eb);
 		if (ret)
-			break;
-	}
-//   pagefault_enable();
 			break;
-	return ret;
+	}
 //   pagefault_enable();
-#define  __EXEC_OBJECT_HAS_PIN (1<<31)
+	return ret;
+}
 #define  __EXEC_OBJECT_HAS_FENCE (1<<30)
 static int
-static int
+need_reloc_mappable(struct i915_vma *vma)
 need_reloc_mappable(struct drm_i915_gem_object *obj)
-{
-	struct drm_i915_gem_exec_object2 *entry = obj->exec_entry;
+	struct drm_i915_gem_exec_object2 *entry = vma->exec_entry;
-	return entry->relocation_count && !use_cpu_reloc(obj);
+	return entry->relocation_count && !use_cpu_reloc(vma->obj) &&
-}
+		i915_is_ggtt(vma->vm);
+}
 static int
-i915_gem_execbuffer_reserve_object(struct drm_i915_gem_object *obj,
+static int
+i915_gem_execbuffer_reserve_vma(struct i915_vma *vma,
 				   struct intel_ring_buffer *ring,
-				   struct i915_address_space *vm,
+				   bool *need_reloc)
 				   bool *need_reloc)
 	struct drm_i915_private *dev_priv = ring->dev->dev_private;
-	struct drm_i915_private *dev_priv = obj->base.dev->dev_private;
+	struct drm_i915_gem_exec_object2 *entry = vma->exec_entry;
-	struct drm_i915_gem_exec_object2 *entry = obj->exec_entry;
+	bool has_fenced_gpu_access = INTEL_INFO(ring->dev)->gen < 4;
-	bool has_fenced_gpu_access = INTEL_INFO(ring->dev)->gen < 4;
+	bool need_fence, need_mappable;
-	bool need_fence, need_mappable;
+	struct drm_i915_gem_object *obj = vma->obj;
 	int ret;
 	need_fence =
 				       obj, obj->cache_level);
 		obj->has_aliasing_ppgtt_mapping = 1;
 	}
-	if (entry->offset != i915_gem_obj_offset(obj, vm)) {
+	if (entry->offset != vma->node.start) {
-		entry->offset = i915_gem_obj_offset(obj, vm);
+		entry->offset = vma->node.start;
 		*need_reloc = true;
+	}
 		i915_gem_gtt_bind_object(obj, obj->cache_level);
 	return 0;
-}
-static void
-i915_gem_execbuffer_unreserve_object(struct drm_i915_gem_object *obj)
-{
-	struct drm_i915_gem_exec_object2 *entry;
-	if (!i915_gem_obj_bound_any(obj))
-		return;
-	entry = obj->exec_entry;
-	if (entry->flags & __EXEC_OBJECT_HAS_FENCE)
-		i915_gem_object_unpin_fence(obj);
-	if (entry->flags & __EXEC_OBJECT_HAS_PIN)
-		i915_gem_object_unpin(obj);
-	entry->flags &= ~(__EXEC_OBJECT_HAS_FENCE | __EXEC_OBJECT_HAS_PIN);
+}
 static int
-i915_gem_execbuffer_reserve(struct intel_ring_buffer *ring,
-			    struct list_head *objects,
+i915_gem_execbuffer_reserve(struct intel_ring_buffer *ring,
-			    struct i915_address_space *vm,
+			    struct list_head *vmas,
 			    bool *need_relocs)
+{
+	struct drm_i915_gem_object *obj;
-{
+	struct i915_vma *vma;
-	struct drm_i915_gem_object *obj;
+	struct i915_address_space *vm;
-	struct list_head ordered_objects;
+	struct list_head ordered_vmas;
+	bool has_fenced_gpu_access = INTEL_INFO(ring->dev)->gen < 4;
+	int retry;
+	if (list_empty(vmas))
+		return 0;
-	bool has_fenced_gpu_access = INTEL_INFO(ring->dev)->gen < 4;
-	int retry;
+	vm = list_first_entry(vmas, struct i915_vma, exec_list)->vm;
-	INIT_LIST_HEAD(&ordered_objects);
+	INIT_LIST_HEAD(&ordered_vmas);
-	while (!list_empty(objects)) {
+	while (!list_empty(vmas)) {
-		struct drm_i915_gem_exec_object2 *entry;
-		bool need_fence, need_mappable;
+		struct drm_i915_gem_exec_object2 *entry;
+		bool need_fence, need_mappable;
 		obj = list_first_entry(objects,
-				       struct drm_i915_gem_object,
+		vma = list_first_entry(vmas, struct i915_vma, exec_list);
-				       exec_list);
+		obj = vma->obj;
-		entry = obj->exec_entry;
+		entry = vma->exec_entry;
 		need_fence =
 			has_fenced_gpu_access &&
 			entry->flags & EXEC_OBJECT_NEEDS_FENCE &&
 			obj->tiling_mode != I915_TILING_NONE;
-		need_mappable = need_fence || need_reloc_mappable(obj);
+		need_mappable = need_fence || need_reloc_mappable(vma);
 		if (need_mappable)
-			list_move(&obj->exec_list, &ordered_objects);
+			list_move(&vma->exec_list, &ordered_vmas);
 		else
-			list_move_tail(&obj->exec_list, &ordered_objects);
+			list_move_tail(&vma->exec_list, &ordered_vmas);
 		obj->base.pending_read_domains = I915_GEM_GPU_DOMAINS & ~I915_GEM_DOMAIN_COMMAND;
 		obj->base.pending_write_domain = 0;
 	retry = 0;
 	do {
 		int ret = 0;
 		/* Unbind any ill-fitting objects or pin. */
-		list_for_each_entry(obj, objects, exec_list) {
+		list_for_each_entry(vma, vmas, exec_list) {
-			struct drm_i915_gem_exec_object2 *entry = obj->exec_entry;
+			struct drm_i915_gem_exec_object2 *entry = vma->exec_entry;
-			bool need_fence, need_mappable;
+			bool need_fence, need_mappable;
-			u32 obj_offset;
+			obj = vma->obj;
-			if (!i915_gem_obj_bound(obj, vm))
-				continue;
+			if (!drm_mm_node_allocated(&vma->node))
 				continue;
 			obj_offset = i915_gem_obj_offset(obj, vm);
 			need_fence =
 				has_fenced_gpu_access &&
 				entry->flags & EXEC_OBJECT_NEEDS_FENCE &&
 				obj->tiling_mode != I915_TILING_NONE;
-			need_mappable = need_fence || need_reloc_mappable(obj);
+			need_mappable = need_fence || need_reloc_mappable(vma);
 			WARN_ON((need_mappable || need_fence) &&
-				!i915_is_ggtt(vm));
+			       !i915_is_ggtt(vma->vm));
 			if ((entry->alignment &&
-			     obj_offset & (entry->alignment - 1)) ||
+			     vma->node.start & (entry->alignment - 1)) ||
 			    (need_mappable && !obj->map_and_fenceable))
-				ret = i915_vma_unbind(i915_gem_obj_to_vma(obj, vm));
+				ret = i915_vma_unbind(vma);
 			else
-				ret = i915_gem_execbuffer_reserve_object(obj, ring, vm, need_relocs);
+				ret = i915_gem_execbuffer_reserve_vma(vma, ring, need_relocs);
 			if (ret)
 				goto err;
 		}
 		/* Bind fresh objects */
-		list_for_each_entry(obj, objects, exec_list) {
+		list_for_each_entry(vma, vmas, exec_list) {
-			if (i915_gem_obj_bound(obj, vm))
-				continue;
-			ret = i915_gem_execbuffer_reserve_object(obj, ring, vm, need_relocs);
+			if (drm_mm_node_allocated(&vma->node))
-			if (ret)
+				continue;
 				goto err;
+			ret = i915_gem_execbuffer_reserve_vma(vma, ring, need_relocs);
+			if (ret)
+				goto err;
+		}
-		}
 err:
-err:		/* Decrement pin count for bound objects */
+		if (ret != -ENOSPC || retry++)
-		list_for_each_entry(obj, objects, exec_list)
+			return ret;
 			i915_gem_execbuffer_unreserve_object(obj);
 		/* Decrement pin count for bound objects */
-		if (ret != -ENOSPC || retry++)
+		list_for_each_entry(vma, vmas, exec_list)
-			return ret;
+			i915_gem_execbuffer_unreserve_vma(vma);
-//       ret = i915_gem_evict_everything(ring->dev);
+//		ret = i915_gem_evict_vm(vm, true);
 		if (ret)
 			return ret;
-	} while (1);
 	} while (1);
+}
-static int
+static int
 i915_gem_execbuffer_relocate_slow(struct drm_device *dev,
 				  struct drm_i915_gem_execbuffer2 *args,
 				  struct drm_file *file,
 				  struct intel_ring_buffer *ring,
+				  struct eb_vmas *eb,
+				  struct drm_i915_gem_exec_object2 *exec)
+{
+	struct drm_i915_gem_relocation_entry *reloc;
+	struct i915_address_space *vm;
-				  struct eb_objects *eb,
+	struct i915_vma *vma;
-				  struct drm_i915_gem_exec_object2 *exec,
+	bool need_relocs;
-				  struct i915_address_space *vm)
+	int *reloc_offset;
-{
-	struct drm_i915_gem_relocation_entry *reloc;
+	int i, total, ret;
-	struct drm_i915_gem_object *obj;
+	unsigned count = args->buffer_count;
-	bool need_relocs;
-	int *reloc_offset;
+	if (WARN_ON(list_empty(&eb->vmas)))
-	int i, total, ret;
+		return 0;
 	int count = args->buffer_count;
 		goto err;
+	}
 	/* reacquire the objects */
 	eb_reset(eb);
-	ret = eb_lookup_objects(eb, exec, args, file);
+	ret = eb_lookup_vmas(eb, exec, args, vm, file);
 	if (ret)
 			goto err;
 	need_relocs = (args->flags & I915_EXEC_NO_RELOC) == 0;
-	ret = i915_gem_execbuffer_reserve(ring, &eb->objects, vm, &need_relocs);
+	ret = i915_gem_execbuffer_reserve(ring, &eb->vmas, &need_relocs);
 	if (ret)
 		goto err;
-	list_for_each_entry(obj, &eb->objects, exec_list) {
+	list_for_each_entry(vma, &eb->vmas, exec_list) {
-		int offset = obj->exec_entry - exec;
-		ret = i915_gem_execbuffer_relocate_object_slow(obj, eb,
+		int offset = vma->exec_entry - exec;
-							       reloc + reloc_offset[offset],
+		ret = i915_gem_execbuffer_relocate_vma_slow(vma, eb,
-							       vm);
+							    reloc + reloc_offset[offset]);
 		if (ret)
 	return ret;
+}
 static int
 i915_gem_execbuffer_move_to_gpu(struct intel_ring_buffer *ring,
-				struct list_head *objects)
+				struct list_head *vmas)
 {
-	struct drm_i915_gem_object *obj;
+	struct i915_vma *vma;
 	uint32_t flush_domains = 0;
 	bool flush_chipset = false;
 	int ret;
 	list_for_each_entry(vma, vmas, exec_list) {
-	list_for_each_entry(obj, objects, exec_list) {
+		struct drm_i915_gem_object *obj = vma->obj;
 		ret = i915_gem_object_sync(obj, ring);
 		if (ret)
 static int
 validate_exec_list(struct drm_i915_gem_exec_object2 *exec,
 		   int count)
+{
 	int i;
-	int relocs_total = 0;
+	unsigned relocs_total = 0;
-	int relocs_max = INT_MAX / sizeof(struct drm_i915_gem_relocation_entry);
+	unsigned relocs_max = UINT_MAX / sizeof(struct drm_i915_gem_relocation_entry);
 	for (i = 0; i < count; i++) {
 		char __user *ptr = to_user_ptr(exec[i].relocs_ptr);
 		/*
 		 * We must check that the entire relocation array is safe
 		 * to read, but since we may need to update the presumed
 		 * offsets during execution, check for full write access.
 		 */
+	}
+	return 0;
+}
+static int
+i915_gem_validate_context(struct drm_device *dev, struct drm_file *file,
+			  const u32 ctx_id)
+{
+	struct i915_ctx_hang_stats *hs;
+	hs = i915_gem_context_get_hang_stats(dev, file, ctx_id);
+	if (IS_ERR(hs))
+		return PTR_ERR(hs);
+	if (hs->banned) {
+		DRM_DEBUG("Context %u tried to submit while banned\n", ctx_id);
 		return -EIO;
+	}
 	return 0;
 }
 static void
-i915_gem_execbuffer_move_to_active(struct list_head *objects,
+static void
-				   struct i915_address_space *vm,
+i915_gem_execbuffer_move_to_active(struct list_head *vmas,
 				   struct intel_ring_buffer *ring)
+{
 	struct i915_vma *vma;
 	struct drm_i915_gem_object *obj;
 	list_for_each_entry(vma, vmas, exec_list) {
-	list_for_each_entry(obj, objects, exec_list) {
+		struct drm_i915_gem_object *obj = vma->obj;
 		u32 old_read = obj->base.read_domains;
 		u32 old_write = obj->base.write_domain;
-		obj->base.write_domain = obj->base.pending_write_domain;
-		if (obj->base.write_domain == 0)
-			obj->base.pending_read_domains |= obj->base.read_domains;
+		obj->base.write_domain = obj->base.pending_write_domain;
-		obj->base.read_domains = obj->base.pending_read_domains;
+		if (obj->base.write_domain == 0)
-		obj->fenced_gpu_access = obj->pending_fenced_gpu_access;
+			obj->base.pending_read_domains |= obj->base.read_domains;
 		obj->base.read_domains = obj->base.pending_read_domains;
-		/* FIXME: This lookup gets fixed later <-- danvet */
+		obj->fenced_gpu_access = obj->pending_fenced_gpu_access;
 		list_move_tail(&i915_gem_obj_to_vma(obj, vm)->mm_list, &vm->active_list);
 		       struct drm_i915_gem_execbuffer2 *args,
 		       struct drm_i915_gem_exec_object2 *exec,
 		       struct i915_address_space *vm)
+{
 	drm_i915_private_t *dev_priv = dev->dev_private;
-	struct eb_objects *eb;
+	struct eb_vmas *eb;
 	struct drm_i915_gem_object *batch_obj;
 	struct drm_clip_rect *cliprects = NULL;
 	struct intel_ring_buffer *ring;
-	u32 ctx_id = i915_execbuffer2_get_context_id(*args);
+	const u32 ctx_id = i915_execbuffer2_get_context_id(*args);
 	u32 exec_start, exec_len;
 	u32 mask, flags;
 	int ret, mode, i;
 	bool need_relocs;
 			DRM_DEBUG("execbuf with %u cliprects\n",
 				  args->num_cliprects);
 			return -EINVAL;
+		}
+		cliprects = kcalloc(args->num_cliprects,
-		cliprects = kmalloc(args->num_cliprects * sizeof(*cliprects),
+				    sizeof(*cliprects),
 				    GFP_KERNEL);
 		if (cliprects == NULL) {
 			ret = -ENOMEM;
 			goto pre_mutex_err;
 			ret = -EFAULT;
 			goto pre_mutex_err;
+		}
+	}
+	intel_runtime_pm_get(dev_priv);
 	ret = i915_mutex_lock_interruptible(dev);
 	if (ret)
 		goto pre_mutex_err;
 	if (dev_priv->ums.mm_suspended) {
 		mutex_unlock(&dev->struct_mutex);
 		ret = -EBUSY;
+		goto pre_mutex_err;
+	}
+	ret = i915_gem_validate_context(dev, file, ctx_id);
+	if (ret) {
+		mutex_unlock(&dev->struct_mutex);
 		goto pre_mutex_err;
+	}
 	eb = eb_create(args);
 	if (eb == NULL) {
 		mutex_unlock(&dev->struct_mutex);
 		ret = -ENOMEM;
 		goto pre_mutex_err;
+	}
 	/* Look up object handles */
-	ret = eb_lookup_objects(eb, exec, args, file);
+	ret = eb_lookup_vmas(eb, exec, args, vm, file);
-	if (ret)
-			goto err;
 	if (ret)
-	/* take note of the batch buffer before we might reorder the lists */
+			goto err;
-	batch_obj = list_entry(eb->objects.prev,
-			       struct drm_i915_gem_object,
+	/* take note of the batch buffer before we might reorder the lists */
-			       exec_list);
+	batch_obj = list_entry(eb->vmas.prev, struct i915_vma, exec_list)->obj;
 	/* Move the objects en-masse into the GTT, evicting if necessary. */
 	need_relocs = (args->flags & I915_EXEC_NO_RELOC) == 0;
-	ret = i915_gem_execbuffer_reserve(ring, &eb->objects, vm, &need_relocs);
+	ret = i915_gem_execbuffer_reserve(ring, &eb->vmas, &need_relocs);
 	if (ret)
 		goto err;
 	/* The objects are in their final locations, apply the relocations. */
 	if (need_relocs)
-		ret = i915_gem_execbuffer_relocate(eb, vm);
+		ret = i915_gem_execbuffer_relocate(eb);
 	if (ret) {
 		if (ret == -EFAULT) {
+	}
 	batch_obj->base.pending_read_domains |= I915_GEM_DOMAIN_COMMAND;
 	/* snb/ivb/vlv conflate the "batch in ppgtt" bit with the "non-secure
 	 * batch" bit. Hence we need to pin secure batches into the global gtt.
-	 * hsw should have this fixed, but let's be paranoid and do it
-	 * unconditionally for now. */
+	 * hsw should have this fixed, but bdw mucks it up again. */
 	if (flags & I915_DISPATCH_SECURE && !batch_obj->has_global_gtt_mapping)
 		i915_gem_gtt_bind_object(batch_obj, batch_obj->cache_level);
-	ret = i915_gem_execbuffer_move_to_gpu(ring, &eb->objects);
+	ret = i915_gem_execbuffer_move_to_gpu(ring, &eb->vmas);
 	if (ret)
 		goto err;
 			goto err;
+	}
 	trace_i915_gem_ring_dispatch(ring, intel_ring_get_seqno(ring), flags);
-	i915_gem_execbuffer_move_to_active(&eb->objects, vm, ring);
+	i915_gem_execbuffer_move_to_active(&eb->vmas, ring);
 	i915_gem_execbuffer_retire_commands(dev, file, ring, batch_obj);
 err:
 	eb_destroy(eb);
+	mutex_unlock(&dev->struct_mutex);
+pre_mutex_err:
     kfree(cliprects);
 	mutex_unlock(&dev->struct_mutex);
 	/* intel_gpu_busy should also get a ref, so it will free when the device
-pre_mutex_err:
+	 * is really idle. */

Subversion Repositories Kolibri OS

(root)/drivers/video/drm/i915/i915_gem_execbuffer.c – Rev 4539 → 4560