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

     memcpy(to, from, n);
     return 0;
+}
+struct eb_objects {
-struct eb_objects {
+	struct list_head objects;
+	int and;
+	union {
-	int and;
+		struct drm_i915_gem_object *lut[0];
 	struct hlist_head buckets[0];
+	};
 };
 static struct eb_objects *
-eb_create(int size)
+eb_create(struct drm_i915_gem_execbuffer2 *args)
+{
+	struct eb_objects *eb = NULL;
+	if (args->flags & I915_EXEC_HANDLE_LUT) {
+		int size = args->buffer_count;
+		size *= sizeof(struct drm_i915_gem_object *);
+		size += sizeof(struct eb_objects);
+		eb = kmalloc(size, GFP_TEMPORARY | __GFP_NOWARN | __GFP_NORETRY);
+	}
 	if (eb == NULL) {
-	struct eb_objects *eb;
+		int size = args->buffer_count;
 	int count = PAGE_SIZE / sizeof(struct hlist_head) / 2;
-	BUILD_BUG_ON(!is_power_of_2(PAGE_SIZE / sizeof(struct hlist_head)));
+		BUILD_BUG_ON_NOT_POWER_OF_2(PAGE_SIZE / sizeof(struct hlist_head));
-	while (count > size)
+		while (count > 2*size)
 		count >>= 1;
 	eb = kzalloc(count*sizeof(struct hlist_head) +
 		     sizeof(struct eb_objects),
-		     GFP_KERNEL);
+			     GFP_TEMPORARY);
 	if (eb == NULL)
+		return eb;
+	eb->and = count - 1;
+	} else
-		return eb;
+		eb->and = -args->buffer_count;
-	eb->and = count - 1;
+	INIT_LIST_HEAD(&eb->objects);
 	return eb;
+}
 static void
-static void
+eb_reset(struct eb_objects *eb)
-eb_reset(struct eb_objects *eb)
+{
-{
+	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_objects(struct eb_objects *eb,
+		  struct drm_i915_gem_exec_object2 *exec,
+		  const struct drm_i915_gem_execbuffer2 *args,
+		  struct drm_file *file)
+{
+	int i;
+	spin_lock(&file->table_lock);
+	for (i = 0; i < args->buffer_count; i++) {
+		struct drm_i915_gem_object *obj;
+        if(exec[i].handle == -2)
+            obj = get_fb_obj();
+        else
+		    obj = to_intel_bo(idr_find(&file->object_idr, exec[i].handle));
+		if (obj == NULL) {
+			spin_unlock(&file->table_lock);
+			DRM_DEBUG("Invalid object handle %d at index %d\n",
+				   exec[i].handle, i);
+			return -ENOENT;
+		}
+		if (!list_empty(&obj->exec_list)) {
+			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);
+			return -EINVAL;
+		}
+		drm_gem_object_reference(&obj->base);
+		list_add_tail(&obj->exec_list, &eb->objects);
+		obj->exec_entry = &exec[i];
 		if (eb->and < 0) {
+			eb->lut[i] = obj;
+		} else {
+			uint32_t handle = args->flags & I915_EXEC_HANDLE_LUT ? i : exec[i].handle;
+			obj->exec_handle = handle;
+	hlist_add_head(&obj->exec_node,
+				       &eb->buckets[handle & eb->and]);
 static void
 eb_add_object(struct eb_objects *eb, struct drm_i915_gem_object *obj)
 	spin_unlock(&file->table_lock);
 	hlist_add_head(&obj->exec_node,
+	return 0;
+}
+static struct drm_i915_gem_object *
+eb_get_object(struct eb_objects *eb, unsigned long handle)
 		       &eb->buckets[obj->exec_handle & eb->and]);
 	if (eb->and < 0) {
-static struct drm_i915_gem_object *
+		if (handle >= -eb->and)
-eb_get_object(struct eb_objects *eb, unsigned long handle)
+			return NULL;
+		return eb->lut[handle];
+	} else {
 	struct hlist_head *head;
-	struct hlist_head *head;
+	struct hlist_node *node;
 	struct hlist_node *node;
-	struct drm_i915_gem_object *obj;
+	head = &eb->buckets[handle & eb->and];
-	head = &eb->buckets[handle & eb->and];
+	hlist_for_each(node, head) {
-	hlist_for_each(node, head) {
+			struct drm_i915_gem_object *obj;
 		obj = hlist_entry(node, struct drm_i915_gem_object, exec_node);
 		if (obj->exec_handle == handle)
 			return obj;
+	}
+	return NULL;
+	}
+}
+static void
+eb_destroy(struct eb_objects *eb)
+{
+	while (!list_empty(&eb->objects)) {
 		struct drm_i915_gem_object *obj;
-	return NULL;
+		obj = list_first_entry(&eb->objects,
 				       struct drm_i915_gem_object,
 			  (int) reloc->offset,
 			  reloc->read_domains,
 			  reloc->write_domain);
 		return ret;
+	}
-	if (unlikely(reloc->write_domain && target_obj->pending_write_domain &&
-		     reloc->write_domain != target_obj->pending_write_domain)) {
-		DRM_DEBUG("Write domain conflict: "
-			  "obj %p target %d offset %d "
-			  "new %08x old %08x\n",
-			  obj, reloc->target_handle,
-			  (int) reloc->offset,
-			  reloc->write_domain,
-			  target_obj->pending_write_domain);
-		return ret;
-	}
 	target_obj->pending_read_domains |= reloc->read_domains;
 	target_obj->pending_write_domain |= reloc->write_domain;
 			  (int) reloc->offset);
 		return ret;
+	}
-	/* We can't wait for rendering with pagefaults disabled */
-//   if (obj->active && in_atomic())
-//       return -EFAULT;
 	/* We can't wait for rendering with pagefaults disabled */
 	reloc->delta += target_offset;
 	if (use_cpu_reloc(obj)) {
 	return 0;
+}
 static int
 i915_gem_execbuffer_relocate(struct drm_device *dev,
-			     struct eb_objects *eb,
-			     struct list_head *objects)
+			     struct eb_objects *eb)
+{
 	struct drm_i915_gem_object *obj;
 	int ret = 0;
 	 * 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, objects, exec_list) {
+	list_for_each_entry(obj, &eb->objects, exec_list) {
 		ret = i915_gem_execbuffer_relocate_object(obj, eb);
 		if (ret)
 			break;
+	}
 //   pagefault_enable();
 	return entry->relocation_count && !use_cpu_reloc(obj);
+}
 static int
 i915_gem_execbuffer_reserve_object(struct drm_i915_gem_object *obj,
+				   struct intel_ring_buffer *ring,
-				   struct intel_ring_buffer *ring)
+				   bool *need_reloc)
+{
 	struct drm_i915_private *dev_priv = obj->base.dev->dev_private;
 	struct drm_i915_gem_exec_object2 *entry = obj->exec_entry;
 	bool has_fenced_gpu_access = INTEL_INFO(ring->dev)->gen < 4;
 				       obj, obj->cache_level);
 		obj->has_aliasing_ppgtt_mapping = 1;
+	}
+	if (entry->offset != obj->gtt_offset) {
+	entry->offset = obj->gtt_offset;
+		*need_reloc = true;
+	}
+	if (entry->flags & EXEC_OBJECT_WRITE) {
+		obj->base.pending_read_domains = I915_GEM_DOMAIN_RENDER;
+		obj->base.pending_write_domain = I915_GEM_DOMAIN_RENDER;
+	}
+	if (entry->flags & EXEC_OBJECT_NEEDS_GTT &&
-	entry->offset = obj->gtt_offset;
+	    !obj->has_global_gtt_mapping)
-//    LEAVE();
+		i915_gem_gtt_bind_object(obj, obj->cache_level);
+}
 static int
 i915_gem_execbuffer_reserve(struct intel_ring_buffer *ring,
 			    struct drm_file *file,
+			    struct list_head *objects,
-			    struct list_head *objects)
+			    bool *need_relocs)
+{
 	struct drm_i915_gem_object *obj;
 	struct list_head ordered_objects;
 	bool has_fenced_gpu_access = INTEL_INFO(ring->dev)->gen < 4;
 		if (need_mappable)
 			list_move(&obj->exec_list, &ordered_objects);
 		else
 			list_move_tail(&obj->exec_list, &ordered_objects);
-		obj->base.pending_read_domains = 0;
+		obj->base.pending_read_domains = I915_GEM_GPU_DOMAINS & ~I915_GEM_DOMAIN_COMMAND;
 		obj->base.pending_write_domain = 0;
 		obj->pending_fenced_gpu_access = false;
+	}
 			if ((entry->alignment && obj->gtt_offset & (entry->alignment - 1)) ||
 			    (need_mappable && !obj->map_and_fenceable))
 				ret = i915_gem_object_unbind(obj);
 			else
-				ret = i915_gem_execbuffer_reserve_object(obj, ring);
+				ret = i915_gem_execbuffer_reserve_object(obj, ring, need_relocs);
 			if (ret)
 				goto err;
+		}
 		/* Bind fresh objects */
 		list_for_each_entry(obj, objects, exec_list) {
 			if (obj->gtt_space)
 				continue;
-			ret = i915_gem_execbuffer_reserve_object(obj, ring);
+			ret = i915_gem_execbuffer_reserve_object(obj, ring, need_relocs);
 			if (ret)
 	} while (1);
+}
 static int
+i915_gem_execbuffer_relocate_slow(struct drm_device *dev,
-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 list_head *objects,
+				  struct intel_ring_buffer *ring,
 				  struct eb_objects *eb,
-				  struct drm_i915_gem_exec_object2 *exec,
-				  int count)
+				  struct drm_i915_gem_exec_object2 *exec)
+{
 	struct drm_i915_gem_relocation_entry *reloc;
+	struct drm_i915_gem_object *obj;
-	struct drm_i915_gem_object *obj;
+	bool need_relocs;
 	int *reloc_offset;
+	int i, total, ret;
-	int i, total, ret;
+	int count = args->buffer_count;
 	/* We may process another execbuffer during the unlock... */
-	while (!list_empty(objects)) {
+	while (!list_empty(&eb->objects)) {
-		obj = list_first_entry(objects,
+		obj = list_first_entry(&eb->objects,
 				       struct drm_i915_gem_object,
 				       exec_list);
 		list_del_init(&obj->exec_list);
 		goto err;
+	}
 	/* reacquire the objects */
-	eb_reset(eb);
-	for (i = 0; i < count; i++) {
-        if(exec[i].handle == -2)
-        {
-            obj = get_fb_obj();
+	eb_reset(eb);
-            drm_gem_object_reference(&obj->base);
+	ret = eb_lookup_objects(eb, exec, args, file);
-        }
-        else
-            obj = to_intel_bo(drm_gem_object_lookup(dev, file,
-                              exec[i].handle));
-		if (&obj->base == NULL) {
-			DRM_DEBUG("Invalid object handle %d at index %d\n",
-				   exec[i].handle, i);
-			ret = -ENOENT;
+	if (ret)
-			goto err;
-		}
+			goto err;
-		list_add_tail(&obj->exec_list, objects);
-		obj->exec_handle = exec[i].handle;
-		obj->exec_entry = &exec[i];
-		eb_add_object(eb, obj);
-	}
 	need_relocs = (args->flags & I915_EXEC_NO_RELOC) == 0;
-	ret = i915_gem_execbuffer_reserve(ring, file, objects);
+	ret = i915_gem_execbuffer_reserve(ring, file, &eb->objects, &need_relocs);
 	if (ret)
 		goto err;
-	list_for_each_entry(obj, objects, exec_list) {
+	list_for_each_entry(obj, &eb->objects, exec_list) {
 		int offset = obj->exec_entry - exec;
 		ret = i915_gem_execbuffer_relocate_object_slow(obj, eb,
     kfree(reloc_offset);
 	return ret;
+}
-static int
-i915_gem_execbuffer_wait_for_flips(struct intel_ring_buffer *ring, u32 flips)
-{
-	u32 plane, flip_mask;
-	int ret;
-	/* Check for any pending flips. As we only maintain a flip queue depth
-	 * of 1, we can simply insert a WAIT for the next display flip prior
-	 * to executing the batch and avoid stalling the CPU.
-	 */
-	for (plane = 0; flips >> plane; plane++) {
-		if (((flips >> plane) & 1) == 0)
-			continue;
-		if (plane)
-			flip_mask = MI_WAIT_FOR_PLANE_B_FLIP;
-		else
-			flip_mask = MI_WAIT_FOR_PLANE_A_FLIP;
-		ret = intel_ring_begin(ring, 2);
-		if (ret)
-			return ret;
-		intel_ring_emit(ring, MI_WAIT_FOR_EVENT | flip_mask);
-		intel_ring_emit(ring, MI_NOOP);
-		intel_ring_advance(ring);
-	}
-	return 0;
-}
 static int
 i915_gem_execbuffer_move_to_gpu(struct intel_ring_buffer *ring,
 				struct list_head *objects)
+{
 	struct drm_i915_gem_object *obj;
-	uint32_t flush_domains = 0;
-	uint32_t flips = 0;
+	uint32_t flush_domains = 0;
 	int ret;
 	list_for_each_entry(obj, objects, exec_list) {
 		ret = i915_gem_object_sync(obj, ring);
 		if (ret)
 			return ret;
-		if (obj->base.write_domain & I915_GEM_DOMAIN_CPU)
-			i915_gem_clflush_object(obj);
-		if (obj->base.pending_write_domain)
+		if (obj->base.write_domain & I915_GEM_DOMAIN_CPU)
-			flips |= atomic_read(&obj->pending_flip);
-		flush_domains |= obj->base.write_domain;
-	}
-	if (flips) {
-		ret = i915_gem_execbuffer_wait_for_flips(ring, flips);
+			i915_gem_clflush_object(obj);
 		if (ret)
-			return ret;
+		flush_domains |= obj->base.write_domain;
+	}
+}
 static bool
 i915_gem_check_execbuffer(struct drm_i915_gem_execbuffer2 *exec)
+{
+	if (exec->flags & __I915_EXEC_UNKNOWN_FLAGS)
+		return false;
 	return ((exec->batch_start_offset | exec->batch_len) & 0x7) == 0;
+}
 static int
 validate_exec_list(struct drm_i915_gem_exec_object2 *exec,
 		   int count)
+{
+	int i;
 	int relocs_total = 0;
-	int i;
+	int relocs_max = INT_MAX / sizeof(struct drm_i915_gem_relocation_entry);
+	for (i = 0; i < count; i++) {
+		char __user *ptr = (char __user *)(uintptr_t)exec[i].relocs_ptr;
+		int length; /* limited by fault_in_pages_readable() */
-	for (i = 0; i < count; i++) {
+		if (exec[i].flags & __EXEC_OBJECT_UNKNOWN_FLAGS)
-		char __user *ptr = (char __user *)(uintptr_t)exec[i].relocs_ptr;
+			return -EINVAL;
-		int length; /* limited by fault_in_pages_readable() */
+		/* First check for malicious input causing overflow in
 		 * the worst case where we need to allocate the entire
+		 * relocation tree as a single array.
-		/* First check for malicious input causing overflow */
+		 */
-		if (exec[i].relocation_count >
+		if (exec[i].relocation_count > relocs_max - relocs_total)
-		    INT_MAX / sizeof(struct drm_i915_gem_relocation_entry))
-			return -EINVAL;
-		length = exec[i].relocation_count *
+			return -EINVAL;
-			sizeof(struct drm_i915_gem_relocation_entry);
+		relocs_total += exec[i].relocation_count;
 //       if (!access_ok(VERIFY_READ, ptr, length))
-//           return -EFAULT;
+		length = exec[i].relocation_count *
 	list_for_each_entry(obj, objects, exec_list) {
 		u32 old_read = obj->base.read_domains;
-		u32 old_write = obj->base.write_domain;
 		u32 old_write = obj->base.write_domain;
+		obj->base.write_domain = obj->base.pending_write_domain;
+		if (obj->base.write_domain == 0)
-		obj->base.read_domains = obj->base.pending_read_domains;
+			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;
 		obj->fenced_gpu_access = obj->pending_fenced_gpu_access;
 		       struct drm_file *file,
 		       struct drm_i915_gem_execbuffer2 *args,
 		       struct drm_i915_gem_exec_object2 *exec)
+{
 	drm_i915_private_t *dev_priv = dev->dev_private;
-	struct list_head objects;
 	struct eb_objects *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);
 	u32 exec_start, exec_len;
-	u32 mask;
-	u32 flags;
+	u32 mask, flags;
 	int ret, mode, i;
+	bool need_relocs;
-	if (!i915_gem_check_execbuffer(args)) {
+	if (!i915_gem_check_execbuffer(args))
 		DRM_DEBUG("execbuf with invalid offset/length\n");
         FAIL();
 		return -EINVAL;
+	}
 		return ret;
     };
 	flags = 0;
-	if (args->flags & I915_EXEC_SECURE) {
-//       if (!file->is_master || !capable(CAP_SYS_ADMIN))
-//           return -EPERM;
+	if (args->flags & I915_EXEC_SECURE) {
 		flags |= I915_DISPATCH_SECURE;
+	}
 		mutex_unlock(&dev->struct_mutex);
 		ret = -EBUSY;
 		goto pre_mutex_err;
+	}
-	eb = eb_create(args->buffer_count);
+	eb = eb_create(args);
 	if (eb == NULL) {
 		mutex_unlock(&dev->struct_mutex);
 		ret = -ENOMEM;
 		goto pre_mutex_err;
+	}
-	/* Look up object handles */
-	INIT_LIST_HEAD(&objects);
-	for (i = 0; i < args->buffer_count; i++) {
-		struct drm_i915_gem_object *obj;
-        if(exec[i].handle == -2)
-        {
-            obj = get_fb_obj();
+	/* Look up object handles */
-            drm_gem_object_reference(&obj->base);
-        }
-        else
-            obj = to_intel_bo(drm_gem_object_lookup(dev, file,
-                              exec[i].handle));
-//        printf("%s object %p handle %d\n", __FUNCTION__, obj, exec[i].handle);
-		if (&obj->base == NULL) {
-			DRM_DEBUG("Invalid object handle %d at index %d\n",
-				   exec[i].handle, i);
-			/* prevent error path from reading uninitialized data */
-			ret = -ENOENT;
-			goto err;
-		}
-		if (!list_empty(&obj->exec_list)) {
-			DRM_DEBUG("Object %p [handle %d, index %d] appears more than once in object list\n",
-				   obj, exec[i].handle, i);
+	ret = eb_lookup_objects(eb, exec, args, file);
-			ret = -EINVAL;
-			goto err;
-		}
-		list_add_tail(&obj->exec_list, &objects);
-		obj->exec_handle = exec[i].handle;
-		obj->exec_entry = &exec[i];
-		eb_add_object(eb, obj);
+	if (ret)
-	}
+			goto err;
 	/* take note of the batch buffer before we might reorder the lists */
-	batch_obj = list_entry(objects.prev,
+	batch_obj = list_entry(eb->objects.prev,
+			       struct drm_i915_gem_object,
-			       struct drm_i915_gem_object,
+			       exec_list);
 			       exec_list);
 	/* Move the objects en-masse into the GTT, evicting if necessary. */
-	/* 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, file, &eb->objects, &need_relocs);
-	ret = i915_gem_execbuffer_reserve(ring, file, &objects);
+	if (ret)
-	if (ret)
+		goto err;
 		goto err;
+	/* The objects are in their final locations, apply the relocations. */
-	/* The objects are in their final locations, apply the relocations. */
-	ret = i915_gem_execbuffer_relocate(dev, eb, &objects);
+	if (need_relocs)
-	if (ret) {
-		if (ret == -EFAULT) {
+		ret = i915_gem_execbuffer_relocate(dev, eb);
-			ret = i915_gem_execbuffer_relocate_slow(dev, file, ring,
+	if (ret) {
-								&objects, eb,
+		if (ret == -EFAULT) {
-								exec,
+			ret = i915_gem_execbuffer_relocate_slow(dev, args, file, ring,
-								args->buffer_count);
+								eb, exec);
 	 * hsw should have this fixed, but let's be paranoid and do it
 	 * unconditionally for now. */
 	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, &objects);
+	ret = i915_gem_execbuffer_move_to_gpu(ring, &eb->objects);
 	if (ret)
 		goto err;
+	}
 	exec_start = batch_obj->gtt_offset + args->batch_start_offset;
 	exec_len = args->batch_len;
-	if (cliprects) {
-//       for (i = 0; i < args->num_cliprects; i++) {
-//           ret = i915_emit_box(dev, &cliprects[i],
-//                       args->DR1, args->DR4);
-//           if (ret)
-//               goto err;
+	if (cliprects) {
-//           ret = ring->dispatch_execbuffer(ring,
-//                           exec_start, exec_len,
-//                           flags);
-//           if (ret)
-//               goto err;
 //       }
 	} else {
 		ret = ring->dispatch_execbuffer(ring,
 						exec_start, exec_len,
 						flags);
 		if (ret)
 			goto err;
+	}
 	trace_i915_gem_ring_dispatch(ring, intel_ring_get_seqno(ring), flags);
-	i915_gem_execbuffer_move_to_active(&objects, ring);
+	i915_gem_execbuffer_move_to_active(&eb->objects, ring);
-	i915_gem_execbuffer_retire_commands(dev, file, ring);
-err:
-	eb_destroy(eb);
-	while (!list_empty(&objects)) {
-		struct drm_i915_gem_object *obj;
-		obj = list_first_entry(&objects,
-				       struct drm_i915_gem_object,
-				       exec_list);
+	i915_gem_execbuffer_retire_commands(dev, file, ring);
 		list_del_init(&obj->exec_list);
-		drm_gem_object_unreference(&obj->base);
+err:
-	}
-	mutex_unlock(&dev->struct_mutex);
+	eb_destroy(eb);
+	mutex_unlock(&dev->struct_mutex);
 pre_mutex_err:
 	kfree(cliprects);
 	return ret;
+}
 	return ret;
 		DRM_DEBUG("execbuf2 with %d buffers\n", args->buffer_count);
         FAIL();
 		return -EINVAL;
+	}
-    exec2_list = malloc(sizeof(*exec2_list)*args->buffer_count);
-//	if (exec2_list == NULL)
+	exec2_list = kmalloc(sizeof(*exec2_list)*args->buffer_count,
-//		exec2_list = drm_malloc_ab(sizeof(*exec2_list),
-//					   args->buffer_count);
+			     GFP_TEMPORARY | __GFP_NOWARN | __GFP_NORETRY);
 	if (exec2_list == NULL) {
 		DRM_DEBUG("Failed to allocate exec list for %d buffers\n",
 			  args->buffer_count);
         FAIL();

Subversion Repositories Kolibri OS

(root)/drivers/video/drm/i915/i915_gem_execbuffer.c – Rev 3277 → 3480