1 // SPDX-License-Identifier: GPL-2.0 OR MIT
2 /**************************************************************************
3  *
4  * Copyright 2009-2023 VMware, Inc., Palo Alto, CA., USA
5  *
6  * Permission is hereby granted, free of charge, to any person obtaining a
7  * copy of this software and associated documentation files (the
8  * "Software"), to deal in the Software without restriction, including
9  * without limitation the rights to use, copy, modify, merge, publish,
10  * distribute, sub license, and/or sell copies of the Software, and to
11  * permit persons to whom the Software is furnished to do so, subject to
12  * the following conditions:
13  *
14  * The above copyright notice and this permission notice (including the
15  * next paragraph) shall be included in all copies or substantial portions
16  * of the Software.
17  *
18  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
19  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
20  * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL
21  * THE COPYRIGHT HOLDERS, AUTHORS AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM,
22  * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
23  * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
24  * USE OR OTHER DEALINGS IN THE SOFTWARE.
25  *
26  **************************************************************************/
27 
28 #include <drm/ttm/ttm_placement.h>
29 
30 #include "vmwgfx_binding.h"
31 #include "vmwgfx_bo.h"
32 #include "vmwgfx_drv.h"
33 #include "vmwgfx_resource_priv.h"
34 
35 #define VMW_RES_EVICT_ERR_COUNT 10
36 
37 /**
38  * vmw_resource_mob_attach - Mark a resource as attached to its backing mob
39  * @res: The resource
40  */
41 void vmw_resource_mob_attach(struct vmw_resource *res)
42 {
43 	struct vmw_bo *gbo = res->guest_memory_bo;
44 	struct rb_node **new = &gbo->res_tree.rb_node, *parent = NULL;
45 
46 	dma_resv_assert_held(gbo->tbo.base.resv);
47 	res->used_prio = (res->res_dirty) ? res->func->dirty_prio :
48 		res->func->prio;
49 
50 	while (*new) {
51 		struct vmw_resource *this =
52 			container_of(*new, struct vmw_resource, mob_node);
53 
54 		parent = *new;
55 		new = (res->guest_memory_offset < this->guest_memory_offset) ?
56 			&((*new)->rb_left) : &((*new)->rb_right);
57 	}
58 
59 	rb_link_node(&res->mob_node, parent, new);
60 	rb_insert_color(&res->mob_node, &gbo->res_tree);
61 
62 	vmw_bo_prio_add(gbo, res->used_prio);
63 }
64 
65 /**
66  * vmw_resource_mob_detach - Mark a resource as detached from its backing mob
67  * @res: The resource
68  */
69 void vmw_resource_mob_detach(struct vmw_resource *res)
70 {
71 	struct vmw_bo *gbo = res->guest_memory_bo;
72 
73 	dma_resv_assert_held(gbo->tbo.base.resv);
74 	if (vmw_resource_mob_attached(res)) {
75 		rb_erase(&res->mob_node, &gbo->res_tree);
76 		RB_CLEAR_NODE(&res->mob_node);
77 		vmw_bo_prio_del(gbo, res->used_prio);
78 	}
79 }
80 
81 struct vmw_resource *vmw_resource_reference(struct vmw_resource *res)
82 {
83 	kref_get(&res->kref);
84 	return res;
85 }
86 
87 struct vmw_resource *
88 vmw_resource_reference_unless_doomed(struct vmw_resource *res)
89 {
90 	return kref_get_unless_zero(&res->kref) ? res : NULL;
91 }
92 
93 /**
94  * vmw_resource_release_id - release a resource id to the id manager.
95  *
96  * @res: Pointer to the resource.
97  *
98  * Release the resource id to the resource id manager and set it to -1
99  */
100 void vmw_resource_release_id(struct vmw_resource *res)
101 {
102 	struct vmw_private *dev_priv = res->dev_priv;
103 	struct idr *idr = &dev_priv->res_idr[res->func->res_type];
104 
105 	spin_lock(&dev_priv->resource_lock);
106 	if (res->id != -1)
107 		idr_remove(idr, res->id);
108 	res->id = -1;
109 	spin_unlock(&dev_priv->resource_lock);
110 }
111 
112 static void vmw_resource_release(struct kref *kref)
113 {
114 	struct vmw_resource *res =
115 	    container_of(kref, struct vmw_resource, kref);
116 	struct vmw_private *dev_priv = res->dev_priv;
117 	int id;
118 	int ret;
119 	struct idr *idr = &dev_priv->res_idr[res->func->res_type];
120 
121 	spin_lock(&dev_priv->resource_lock);
122 	list_del_init(&res->lru_head);
123 	spin_unlock(&dev_priv->resource_lock);
124 	if (res->guest_memory_bo) {
125 		struct ttm_buffer_object *bo = &res->guest_memory_bo->tbo;
126 
127 		ret = ttm_bo_reserve(bo, false, false, NULL);
128 		BUG_ON(ret);
129 		if (vmw_resource_mob_attached(res) &&
130 		    res->func->unbind != NULL) {
131 			struct ttm_validate_buffer val_buf;
132 
133 			val_buf.bo = bo;
134 			val_buf.num_shared = 0;
135 			res->func->unbind(res, false, &val_buf);
136 		}
137 		res->guest_memory_size = false;
138 		vmw_resource_mob_detach(res);
139 		if (res->dirty)
140 			res->func->dirty_free(res);
141 		if (res->coherent)
142 			vmw_bo_dirty_release(res->guest_memory_bo);
143 		ttm_bo_unreserve(bo);
144 		vmw_bo_unreference(&res->guest_memory_bo);
145 	}
146 
147 	if (likely(res->hw_destroy != NULL)) {
148 		mutex_lock(&dev_priv->binding_mutex);
149 		vmw_binding_res_list_kill(&res->binding_head);
150 		mutex_unlock(&dev_priv->binding_mutex);
151 		res->hw_destroy(res);
152 	}
153 
154 	id = res->id;
155 	if (res->res_free != NULL)
156 		res->res_free(res);
157 	else
158 		kfree(res);
159 
160 	spin_lock(&dev_priv->resource_lock);
161 	if (id != -1)
162 		idr_remove(idr, id);
163 	spin_unlock(&dev_priv->resource_lock);
164 }
165 
166 void vmw_resource_unreference(struct vmw_resource **p_res)
167 {
168 	struct vmw_resource *res = *p_res;
169 
170 	*p_res = NULL;
171 	kref_put(&res->kref, vmw_resource_release);
172 }
173 
174 
175 /**
176  * vmw_resource_alloc_id - release a resource id to the id manager.
177  *
178  * @res: Pointer to the resource.
179  *
180  * Allocate the lowest free resource from the resource manager, and set
181  * @res->id to that id. Returns 0 on success and -ENOMEM on failure.
182  */
183 int vmw_resource_alloc_id(struct vmw_resource *res)
184 {
185 	struct vmw_private *dev_priv = res->dev_priv;
186 	int ret;
187 	struct idr *idr = &dev_priv->res_idr[res->func->res_type];
188 
189 	BUG_ON(res->id != -1);
190 
191 	idr_preload(GFP_KERNEL);
192 	spin_lock(&dev_priv->resource_lock);
193 
194 	ret = idr_alloc(idr, res, 1, 0, GFP_NOWAIT);
195 	if (ret >= 0)
196 		res->id = ret;
197 
198 	spin_unlock(&dev_priv->resource_lock);
199 	idr_preload_end();
200 	return ret < 0 ? ret : 0;
201 }
202 
203 /**
204  * vmw_resource_init - initialize a struct vmw_resource
205  *
206  * @dev_priv:       Pointer to a device private struct.
207  * @res:            The struct vmw_resource to initialize.
208  * @delay_id:       Boolean whether to defer device id allocation until
209  *                  the first validation.
210  * @res_free:       Resource destructor.
211  * @func:           Resource function table.
212  */
213 int vmw_resource_init(struct vmw_private *dev_priv, struct vmw_resource *res,
214 		      bool delay_id,
215 		      void (*res_free) (struct vmw_resource *res),
216 		      const struct vmw_res_func *func)
217 {
218 	kref_init(&res->kref);
219 	res->hw_destroy = NULL;
220 	res->res_free = res_free;
221 	res->dev_priv = dev_priv;
222 	res->func = func;
223 	RB_CLEAR_NODE(&res->mob_node);
224 	INIT_LIST_HEAD(&res->lru_head);
225 	INIT_LIST_HEAD(&res->binding_head);
226 	res->id = -1;
227 	res->guest_memory_bo = NULL;
228 	res->guest_memory_offset = 0;
229 	res->guest_memory_dirty = false;
230 	res->res_dirty = false;
231 	res->coherent = false;
232 	res->used_prio = 3;
233 	res->dirty = NULL;
234 	if (delay_id)
235 		return 0;
236 	else
237 		return vmw_resource_alloc_id(res);
238 }
239 
240 
241 /**
242  * vmw_user_resource_lookup_handle - lookup a struct resource from a
243  * TTM user-space handle and perform basic type checks
244  *
245  * @dev_priv:     Pointer to a device private struct
246  * @tfile:        Pointer to a struct ttm_object_file identifying the caller
247  * @handle:       The TTM user-space handle
248  * @converter:    Pointer to an object describing the resource type
249  * @p_res:        On successful return the location pointed to will contain
250  *                a pointer to a refcounted struct vmw_resource.
251  *
252  * If the handle can't be found or is associated with an incorrect resource
253  * type, -EINVAL will be returned.
254  */
255 int vmw_user_resource_lookup_handle(struct vmw_private *dev_priv,
256 				    struct ttm_object_file *tfile,
257 				    uint32_t handle,
258 				    const struct vmw_user_resource_conv
259 				    *converter,
260 				    struct vmw_resource **p_res)
261 {
262 	struct ttm_base_object *base;
263 	struct vmw_resource *res;
264 	int ret = -EINVAL;
265 
266 	base = ttm_base_object_lookup(tfile, handle);
267 	if (unlikely(!base))
268 		return -EINVAL;
269 
270 	if (unlikely(ttm_base_object_type(base) != converter->object_type))
271 		goto out_bad_resource;
272 
273 	res = converter->base_obj_to_res(base);
274 	kref_get(&res->kref);
275 
276 	*p_res = res;
277 	ret = 0;
278 
279 out_bad_resource:
280 	ttm_base_object_unref(&base);
281 
282 	return ret;
283 }
284 
285 /*
286  * Helper function that looks either a surface or bo.
287  *
288  * The pointer this pointed at by out_surf and out_buf needs to be null.
289  */
290 int vmw_user_lookup_handle(struct vmw_private *dev_priv,
291 			   struct drm_file *filp,
292 			   uint32_t handle,
293 			   struct vmw_surface **out_surf,
294 			   struct vmw_bo **out_buf)
295 {
296 	struct ttm_object_file *tfile = vmw_fpriv(filp)->tfile;
297 	struct vmw_resource *res;
298 	int ret;
299 
300 	BUG_ON(*out_surf || *out_buf);
301 
302 	ret = vmw_user_resource_lookup_handle(dev_priv, tfile, handle,
303 					      user_surface_converter,
304 					      &res);
305 	if (!ret) {
306 		*out_surf = vmw_res_to_srf(res);
307 		return 0;
308 	}
309 
310 	*out_surf = NULL;
311 	ret = vmw_user_bo_lookup(filp, handle, out_buf);
312 	return ret;
313 }
314 
315 /**
316  * vmw_resource_buf_alloc - Allocate a guest memory buffer for a resource.
317  *
318  * @res:            The resource for which to allocate a gbo buffer.
319  * @interruptible:  Whether any sleeps during allocation should be
320  *                  performed while interruptible.
321  */
322 static int vmw_resource_buf_alloc(struct vmw_resource *res,
323 				  bool interruptible)
324 {
325 	unsigned long size = PFN_ALIGN(res->guest_memory_size);
326 	struct vmw_bo *gbo;
327 	struct vmw_bo_params bo_params = {
328 		.domain = res->func->domain,
329 		.busy_domain = res->func->busy_domain,
330 		.bo_type = ttm_bo_type_device,
331 		.size = res->guest_memory_size,
332 		.pin = false
333 	};
334 	int ret;
335 
336 	if (likely(res->guest_memory_bo)) {
337 		BUG_ON(res->guest_memory_bo->tbo.base.size < size);
338 		return 0;
339 	}
340 
341 	ret = vmw_bo_create(res->dev_priv, &bo_params, &gbo);
342 	if (unlikely(ret != 0))
343 		goto out_no_bo;
344 
345 	res->guest_memory_bo = gbo;
346 
347 out_no_bo:
348 	return ret;
349 }
350 
351 /**
352  * vmw_resource_do_validate - Make a resource up-to-date and visible
353  *                            to the device.
354  *
355  * @res:            The resource to make visible to the device.
356  * @val_buf:        Information about a buffer possibly
357  *                  containing backup data if a bind operation is needed.
358  * @dirtying:       Transfer dirty regions.
359  *
360  * On hardware resource shortage, this function returns -EBUSY and
361  * should be retried once resources have been freed up.
362  */
363 static int vmw_resource_do_validate(struct vmw_resource *res,
364 				    struct ttm_validate_buffer *val_buf,
365 				    bool dirtying)
366 {
367 	int ret = 0;
368 	const struct vmw_res_func *func = res->func;
369 
370 	if (unlikely(res->id == -1)) {
371 		ret = func->create(res);
372 		if (unlikely(ret != 0))
373 			return ret;
374 	}
375 
376 	if (func->bind &&
377 	    ((func->needs_guest_memory && !vmw_resource_mob_attached(res) &&
378 	      val_buf->bo) ||
379 	     (!func->needs_guest_memory && val_buf->bo))) {
380 		ret = func->bind(res, val_buf);
381 		if (unlikely(ret != 0))
382 			goto out_bind_failed;
383 		if (func->needs_guest_memory)
384 			vmw_resource_mob_attach(res);
385 	}
386 
387 	/*
388 	 * Handle the case where the backup mob is marked coherent but
389 	 * the resource isn't.
390 	 */
391 	if (func->dirty_alloc && vmw_resource_mob_attached(res) &&
392 	    !res->coherent) {
393 		if (res->guest_memory_bo->dirty && !res->dirty) {
394 			ret = func->dirty_alloc(res);
395 			if (ret)
396 				return ret;
397 		} else if (!res->guest_memory_bo->dirty && res->dirty) {
398 			func->dirty_free(res);
399 		}
400 	}
401 
402 	/*
403 	 * Transfer the dirty regions to the resource and update
404 	 * the resource.
405 	 */
406 	if (res->dirty) {
407 		if (dirtying && !res->res_dirty) {
408 			pgoff_t start = res->guest_memory_offset >> PAGE_SHIFT;
409 			pgoff_t end = __KERNEL_DIV_ROUND_UP
410 				(res->guest_memory_offset + res->guest_memory_size,
411 				 PAGE_SIZE);
412 
413 			vmw_bo_dirty_unmap(res->guest_memory_bo, start, end);
414 		}
415 
416 		vmw_bo_dirty_transfer_to_res(res);
417 		return func->dirty_sync(res);
418 	}
419 
420 	return 0;
421 
422 out_bind_failed:
423 	func->destroy(res);
424 
425 	return ret;
426 }
427 
428 /**
429  * vmw_resource_unreserve - Unreserve a resource previously reserved for
430  * command submission.
431  *
432  * @res:               Pointer to the struct vmw_resource to unreserve.
433  * @dirty_set:         Change dirty status of the resource.
434  * @dirty:             When changing dirty status indicates the new status.
435  * @switch_guest_memory: Guest memory buffer has been switched.
436  * @new_guest_memory_bo: Pointer to new guest memory buffer if command submission
437  *                     switched. May be NULL.
438  * @new_guest_memory_offset: New gbo offset if @switch_guest_memory is true.
439  *
440  * Currently unreserving a resource means putting it back on the device's
441  * resource lru list, so that it can be evicted if necessary.
442  */
443 void vmw_resource_unreserve(struct vmw_resource *res,
444 			    bool dirty_set,
445 			    bool dirty,
446 			    bool switch_guest_memory,
447 			    struct vmw_bo *new_guest_memory_bo,
448 			    unsigned long new_guest_memory_offset)
449 {
450 	struct vmw_private *dev_priv = res->dev_priv;
451 
452 	if (!list_empty(&res->lru_head))
453 		return;
454 
455 	if (switch_guest_memory && new_guest_memory_bo != res->guest_memory_bo) {
456 		if (res->guest_memory_bo) {
457 			vmw_resource_mob_detach(res);
458 			if (res->coherent)
459 				vmw_bo_dirty_release(res->guest_memory_bo);
460 			vmw_bo_unreference(&res->guest_memory_bo);
461 		}
462 
463 		if (new_guest_memory_bo) {
464 			res->guest_memory_bo = vmw_bo_reference(new_guest_memory_bo);
465 
466 			/*
467 			 * The validation code should already have added a
468 			 * dirty tracker here.
469 			 */
470 			WARN_ON(res->coherent && !new_guest_memory_bo->dirty);
471 
472 			vmw_resource_mob_attach(res);
473 		} else {
474 			res->guest_memory_bo = NULL;
475 		}
476 	} else if (switch_guest_memory && res->coherent) {
477 		vmw_bo_dirty_release(res->guest_memory_bo);
478 	}
479 
480 	if (switch_guest_memory)
481 		res->guest_memory_offset = new_guest_memory_offset;
482 
483 	if (dirty_set)
484 		res->res_dirty = dirty;
485 
486 	if (!res->func->may_evict || res->id == -1 || res->pin_count)
487 		return;
488 
489 	spin_lock(&dev_priv->resource_lock);
490 	list_add_tail(&res->lru_head,
491 		      &res->dev_priv->res_lru[res->func->res_type]);
492 	spin_unlock(&dev_priv->resource_lock);
493 }
494 
495 /**
496  * vmw_resource_check_buffer - Check whether a backup buffer is needed
497  *                             for a resource and in that case, allocate
498  *                             one, reserve and validate it.
499  *
500  * @ticket:         The ww acquire context to use, or NULL if trylocking.
501  * @res:            The resource for which to allocate a backup buffer.
502  * @interruptible:  Whether any sleeps during allocation should be
503  *                  performed while interruptible.
504  * @val_buf:        On successful return contains data about the
505  *                  reserved and validated backup buffer.
506  */
507 static int
508 vmw_resource_check_buffer(struct ww_acquire_ctx *ticket,
509 			  struct vmw_resource *res,
510 			  bool interruptible,
511 			  struct ttm_validate_buffer *val_buf)
512 {
513 	struct ttm_operation_ctx ctx = { true, false };
514 	struct list_head val_list;
515 	bool guest_memory_dirty = false;
516 	int ret;
517 
518 	if (unlikely(!res->guest_memory_bo)) {
519 		ret = vmw_resource_buf_alloc(res, interruptible);
520 		if (unlikely(ret != 0))
521 			return ret;
522 	}
523 
524 	INIT_LIST_HEAD(&val_list);
525 	ttm_bo_get(&res->guest_memory_bo->tbo);
526 	val_buf->bo = &res->guest_memory_bo->tbo;
527 	val_buf->num_shared = 0;
528 	list_add_tail(&val_buf->head, &val_list);
529 	ret = ttm_eu_reserve_buffers(ticket, &val_list, interruptible, NULL);
530 	if (unlikely(ret != 0))
531 		goto out_no_reserve;
532 
533 	if (res->func->needs_guest_memory && !vmw_resource_mob_attached(res))
534 		return 0;
535 
536 	guest_memory_dirty = res->guest_memory_dirty;
537 	vmw_bo_placement_set(res->guest_memory_bo, res->func->domain,
538 			     res->func->busy_domain);
539 	ret = ttm_bo_validate(&res->guest_memory_bo->tbo,
540 			      &res->guest_memory_bo->placement,
541 			      &ctx);
542 
543 	if (unlikely(ret != 0))
544 		goto out_no_validate;
545 
546 	return 0;
547 
548 out_no_validate:
549 	ttm_eu_backoff_reservation(ticket, &val_list);
550 out_no_reserve:
551 	ttm_bo_put(val_buf->bo);
552 	val_buf->bo = NULL;
553 	if (guest_memory_dirty)
554 		vmw_bo_unreference(&res->guest_memory_bo);
555 
556 	return ret;
557 }
558 
559 /*
560  * vmw_resource_reserve - Reserve a resource for command submission
561  *
562  * @res:            The resource to reserve.
563  *
564  * This function takes the resource off the LRU list and make sure
565  * a guest memory buffer is present for guest-backed resources.
566  * However, the buffer may not be bound to the resource at this
567  * point.
568  *
569  */
570 int vmw_resource_reserve(struct vmw_resource *res, bool interruptible,
571 			 bool no_guest_memory)
572 {
573 	struct vmw_private *dev_priv = res->dev_priv;
574 	int ret;
575 
576 	spin_lock(&dev_priv->resource_lock);
577 	list_del_init(&res->lru_head);
578 	spin_unlock(&dev_priv->resource_lock);
579 
580 	if (res->func->needs_guest_memory && !res->guest_memory_bo &&
581 	    !no_guest_memory) {
582 		ret = vmw_resource_buf_alloc(res, interruptible);
583 		if (unlikely(ret != 0)) {
584 			DRM_ERROR("Failed to allocate a guest memory buffer "
585 				  "of size %lu. bytes\n",
586 				  (unsigned long) res->guest_memory_size);
587 			return ret;
588 		}
589 	}
590 
591 	return 0;
592 }
593 
594 /**
595  * vmw_resource_backoff_reservation - Unreserve and unreference a
596  *                                    guest memory buffer
597  *.
598  * @ticket:         The ww acquire ctx used for reservation.
599  * @val_buf:        Guest memory buffer information.
600  */
601 static void
602 vmw_resource_backoff_reservation(struct ww_acquire_ctx *ticket,
603 				 struct ttm_validate_buffer *val_buf)
604 {
605 	struct list_head val_list;
606 
607 	if (likely(val_buf->bo == NULL))
608 		return;
609 
610 	INIT_LIST_HEAD(&val_list);
611 	list_add_tail(&val_buf->head, &val_list);
612 	ttm_eu_backoff_reservation(ticket, &val_list);
613 	ttm_bo_put(val_buf->bo);
614 	val_buf->bo = NULL;
615 }
616 
617 /**
618  * vmw_resource_do_evict - Evict a resource, and transfer its data
619  *                         to a backup buffer.
620  *
621  * @ticket:         The ww acquire ticket to use, or NULL if trylocking.
622  * @res:            The resource to evict.
623  * @interruptible:  Whether to wait interruptible.
624  */
625 static int vmw_resource_do_evict(struct ww_acquire_ctx *ticket,
626 				 struct vmw_resource *res, bool interruptible)
627 {
628 	struct ttm_validate_buffer val_buf;
629 	const struct vmw_res_func *func = res->func;
630 	int ret;
631 
632 	BUG_ON(!func->may_evict);
633 
634 	val_buf.bo = NULL;
635 	val_buf.num_shared = 0;
636 	ret = vmw_resource_check_buffer(ticket, res, interruptible, &val_buf);
637 	if (unlikely(ret != 0))
638 		return ret;
639 
640 	if (unlikely(func->unbind != NULL &&
641 		     (!func->needs_guest_memory || vmw_resource_mob_attached(res)))) {
642 		ret = func->unbind(res, res->res_dirty, &val_buf);
643 		if (unlikely(ret != 0))
644 			goto out_no_unbind;
645 		vmw_resource_mob_detach(res);
646 	}
647 	ret = func->destroy(res);
648 	res->guest_memory_dirty = true;
649 	res->res_dirty = false;
650 out_no_unbind:
651 	vmw_resource_backoff_reservation(ticket, &val_buf);
652 
653 	return ret;
654 }
655 
656 
657 /**
658  * vmw_resource_validate - Make a resource up-to-date and visible
659  *                         to the device.
660  * @res: The resource to make visible to the device.
661  * @intr: Perform waits interruptible if possible.
662  * @dirtying: Pending GPU operation will dirty the resource
663  *
664  * On successful return, any backup DMA buffer pointed to by @res->backup will
665  * be reserved and validated.
666  * On hardware resource shortage, this function will repeatedly evict
667  * resources of the same type until the validation succeeds.
668  *
669  * Return: Zero on success, -ERESTARTSYS if interrupted, negative error code
670  * on failure.
671  */
672 int vmw_resource_validate(struct vmw_resource *res, bool intr,
673 			  bool dirtying)
674 {
675 	int ret;
676 	struct vmw_resource *evict_res;
677 	struct vmw_private *dev_priv = res->dev_priv;
678 	struct list_head *lru_list = &dev_priv->res_lru[res->func->res_type];
679 	struct ttm_validate_buffer val_buf;
680 	unsigned err_count = 0;
681 
682 	if (!res->func->create)
683 		return 0;
684 
685 	val_buf.bo = NULL;
686 	val_buf.num_shared = 0;
687 	if (res->guest_memory_bo)
688 		val_buf.bo = &res->guest_memory_bo->tbo;
689 	do {
690 		ret = vmw_resource_do_validate(res, &val_buf, dirtying);
691 		if (likely(ret != -EBUSY))
692 			break;
693 
694 		spin_lock(&dev_priv->resource_lock);
695 		if (list_empty(lru_list) || !res->func->may_evict) {
696 			DRM_ERROR("Out of device device resources "
697 				  "for %s.\n", res->func->type_name);
698 			ret = -EBUSY;
699 			spin_unlock(&dev_priv->resource_lock);
700 			break;
701 		}
702 
703 		evict_res = vmw_resource_reference
704 			(list_first_entry(lru_list, struct vmw_resource,
705 					  lru_head));
706 		list_del_init(&evict_res->lru_head);
707 
708 		spin_unlock(&dev_priv->resource_lock);
709 
710 		/* Trylock backup buffers with a NULL ticket. */
711 		ret = vmw_resource_do_evict(NULL, evict_res, intr);
712 		if (unlikely(ret != 0)) {
713 			spin_lock(&dev_priv->resource_lock);
714 			list_add_tail(&evict_res->lru_head, lru_list);
715 			spin_unlock(&dev_priv->resource_lock);
716 			if (ret == -ERESTARTSYS ||
717 			    ++err_count > VMW_RES_EVICT_ERR_COUNT) {
718 				vmw_resource_unreference(&evict_res);
719 				goto out_no_validate;
720 			}
721 		}
722 
723 		vmw_resource_unreference(&evict_res);
724 	} while (1);
725 
726 	if (unlikely(ret != 0))
727 		goto out_no_validate;
728 	else if (!res->func->needs_guest_memory && res->guest_memory_bo) {
729 		WARN_ON_ONCE(vmw_resource_mob_attached(res));
730 		vmw_bo_unreference(&res->guest_memory_bo);
731 	}
732 
733 	return 0;
734 
735 out_no_validate:
736 	return ret;
737 }
738 
739 
740 /**
741  * vmw_resource_unbind_list
742  *
743  * @vbo: Pointer to the current backing MOB.
744  *
745  * Evicts the Guest Backed hardware resource if the backup
746  * buffer is being moved out of MOB memory.
747  * Note that this function will not race with the resource
748  * validation code, since resource validation and eviction
749  * both require the backup buffer to be reserved.
750  */
751 void vmw_resource_unbind_list(struct vmw_bo *vbo)
752 {
753 	struct ttm_validate_buffer val_buf = {
754 		.bo = &vbo->tbo,
755 		.num_shared = 0
756 	};
757 
758 	dma_resv_assert_held(vbo->tbo.base.resv);
759 	while (!RB_EMPTY_ROOT(&vbo->res_tree)) {
760 		struct rb_node *node = vbo->res_tree.rb_node;
761 		struct vmw_resource *res =
762 			container_of(node, struct vmw_resource, mob_node);
763 
764 		if (!WARN_ON_ONCE(!res->func->unbind))
765 			(void) res->func->unbind(res, res->res_dirty, &val_buf);
766 
767 		res->guest_memory_size = true;
768 		res->res_dirty = false;
769 		vmw_resource_mob_detach(res);
770 	}
771 
772 	(void) ttm_bo_wait(&vbo->tbo, false, false);
773 }
774 
775 
776 /**
777  * vmw_query_readback_all - Read back cached query states
778  *
779  * @dx_query_mob: Buffer containing the DX query MOB
780  *
781  * Read back cached states from the device if they exist.  This function
782  * assumes binding_mutex is held.
783  */
784 int vmw_query_readback_all(struct vmw_bo *dx_query_mob)
785 {
786 	struct vmw_resource *dx_query_ctx;
787 	struct vmw_private *dev_priv;
788 	struct {
789 		SVGA3dCmdHeader header;
790 		SVGA3dCmdDXReadbackAllQuery body;
791 	} *cmd;
792 
793 
794 	/* No query bound, so do nothing */
795 	if (!dx_query_mob || !dx_query_mob->dx_query_ctx)
796 		return 0;
797 
798 	dx_query_ctx = dx_query_mob->dx_query_ctx;
799 	dev_priv     = dx_query_ctx->dev_priv;
800 
801 	cmd = VMW_CMD_CTX_RESERVE(dev_priv, sizeof(*cmd), dx_query_ctx->id);
802 	if (unlikely(cmd == NULL))
803 		return -ENOMEM;
804 
805 	cmd->header.id   = SVGA_3D_CMD_DX_READBACK_ALL_QUERY;
806 	cmd->header.size = sizeof(cmd->body);
807 	cmd->body.cid    = dx_query_ctx->id;
808 
809 	vmw_cmd_commit(dev_priv, sizeof(*cmd));
810 
811 	/* Triggers a rebind the next time affected context is bound */
812 	dx_query_mob->dx_query_ctx = NULL;
813 
814 	return 0;
815 }
816 
817 
818 
819 /**
820  * vmw_query_move_notify - Read back cached query states
821  *
822  * @bo: The TTM buffer object about to move.
823  * @old_mem: The memory region @bo is moving from.
824  * @new_mem: The memory region @bo is moving to.
825  *
826  * Called before the query MOB is swapped out to read back cached query
827  * states from the device.
828  */
829 void vmw_query_move_notify(struct ttm_buffer_object *bo,
830 			   struct ttm_resource *old_mem,
831 			   struct ttm_resource *new_mem)
832 {
833 	struct vmw_bo *dx_query_mob;
834 	struct ttm_device *bdev = bo->bdev;
835 	struct vmw_private *dev_priv = vmw_priv_from_ttm(bdev);
836 
837 	mutex_lock(&dev_priv->binding_mutex);
838 
839 	/* If BO is being moved from MOB to system memory */
840 	if (old_mem &&
841 	    new_mem->mem_type == TTM_PL_SYSTEM &&
842 	    old_mem->mem_type == VMW_PL_MOB) {
843 		struct vmw_fence_obj *fence;
844 
845 		dx_query_mob = to_vmw_bo(&bo->base);
846 		if (!dx_query_mob || !dx_query_mob->dx_query_ctx) {
847 			mutex_unlock(&dev_priv->binding_mutex);
848 			return;
849 		}
850 
851 		(void) vmw_query_readback_all(dx_query_mob);
852 		mutex_unlock(&dev_priv->binding_mutex);
853 
854 		/* Create a fence and attach the BO to it */
855 		(void) vmw_execbuf_fence_commands(NULL, dev_priv, &fence, NULL);
856 		vmw_bo_fence_single(bo, fence);
857 
858 		if (fence != NULL)
859 			vmw_fence_obj_unreference(&fence);
860 
861 		(void) ttm_bo_wait(bo, false, false);
862 	} else
863 		mutex_unlock(&dev_priv->binding_mutex);
864 }
865 
866 /**
867  * vmw_resource_needs_backup - Return whether a resource needs a backup buffer.
868  *
869  * @res:            The resource being queried.
870  */
871 bool vmw_resource_needs_backup(const struct vmw_resource *res)
872 {
873 	return res->func->needs_guest_memory;
874 }
875 
876 /**
877  * vmw_resource_evict_type - Evict all resources of a specific type
878  *
879  * @dev_priv:       Pointer to a device private struct
880  * @type:           The resource type to evict
881  *
882  * To avoid thrashing starvation or as part of the hibernation sequence,
883  * try to evict all evictable resources of a specific type.
884  */
885 static void vmw_resource_evict_type(struct vmw_private *dev_priv,
886 				    enum vmw_res_type type)
887 {
888 	struct list_head *lru_list = &dev_priv->res_lru[type];
889 	struct vmw_resource *evict_res;
890 	unsigned err_count = 0;
891 	int ret;
892 	struct ww_acquire_ctx ticket;
893 
894 	do {
895 		spin_lock(&dev_priv->resource_lock);
896 
897 		if (list_empty(lru_list))
898 			goto out_unlock;
899 
900 		evict_res = vmw_resource_reference(
901 			list_first_entry(lru_list, struct vmw_resource,
902 					 lru_head));
903 		list_del_init(&evict_res->lru_head);
904 		spin_unlock(&dev_priv->resource_lock);
905 
906 		/* Wait lock backup buffers with a ticket. */
907 		ret = vmw_resource_do_evict(&ticket, evict_res, false);
908 		if (unlikely(ret != 0)) {
909 			spin_lock(&dev_priv->resource_lock);
910 			list_add_tail(&evict_res->lru_head, lru_list);
911 			spin_unlock(&dev_priv->resource_lock);
912 			if (++err_count > VMW_RES_EVICT_ERR_COUNT) {
913 				vmw_resource_unreference(&evict_res);
914 				return;
915 			}
916 		}
917 
918 		vmw_resource_unreference(&evict_res);
919 	} while (1);
920 
921 out_unlock:
922 	spin_unlock(&dev_priv->resource_lock);
923 }
924 
925 /**
926  * vmw_resource_evict_all - Evict all evictable resources
927  *
928  * @dev_priv:       Pointer to a device private struct
929  *
930  * To avoid thrashing starvation or as part of the hibernation sequence,
931  * evict all evictable resources. In particular this means that all
932  * guest-backed resources that are registered with the device are
933  * evicted and the OTable becomes clean.
934  */
935 void vmw_resource_evict_all(struct vmw_private *dev_priv)
936 {
937 	enum vmw_res_type type;
938 
939 	mutex_lock(&dev_priv->cmdbuf_mutex);
940 
941 	for (type = 0; type < vmw_res_max; ++type)
942 		vmw_resource_evict_type(dev_priv, type);
943 
944 	mutex_unlock(&dev_priv->cmdbuf_mutex);
945 }
946 
947 /*
948  * vmw_resource_pin - Add a pin reference on a resource
949  *
950  * @res: The resource to add a pin reference on
951  *
952  * This function adds a pin reference, and if needed validates the resource.
953  * Having a pin reference means that the resource can never be evicted, and
954  * its id will never change as long as there is a pin reference.
955  * This function returns 0 on success and a negative error code on failure.
956  */
957 int vmw_resource_pin(struct vmw_resource *res, bool interruptible)
958 {
959 	struct ttm_operation_ctx ctx = { interruptible, false };
960 	struct vmw_private *dev_priv = res->dev_priv;
961 	int ret;
962 
963 	mutex_lock(&dev_priv->cmdbuf_mutex);
964 	ret = vmw_resource_reserve(res, interruptible, false);
965 	if (ret)
966 		goto out_no_reserve;
967 
968 	if (res->pin_count == 0) {
969 		struct vmw_bo *vbo = NULL;
970 
971 		if (res->guest_memory_bo) {
972 			vbo = res->guest_memory_bo;
973 
974 			ret = ttm_bo_reserve(&vbo->tbo, interruptible, false, NULL);
975 			if (ret)
976 				goto out_no_validate;
977 			if (!vbo->tbo.pin_count) {
978 				vmw_bo_placement_set(vbo,
979 						     res->func->domain,
980 						     res->func->busy_domain);
981 				ret = ttm_bo_validate
982 					(&vbo->tbo,
983 					 &vbo->placement,
984 					 &ctx);
985 				if (ret) {
986 					ttm_bo_unreserve(&vbo->tbo);
987 					goto out_no_validate;
988 				}
989 			}
990 
991 			/* Do we really need to pin the MOB as well? */
992 			vmw_bo_pin_reserved(vbo, true);
993 		}
994 		ret = vmw_resource_validate(res, interruptible, true);
995 		if (vbo)
996 			ttm_bo_unreserve(&vbo->tbo);
997 		if (ret)
998 			goto out_no_validate;
999 	}
1000 	res->pin_count++;
1001 
1002 out_no_validate:
1003 	vmw_resource_unreserve(res, false, false, false, NULL, 0UL);
1004 out_no_reserve:
1005 	mutex_unlock(&dev_priv->cmdbuf_mutex);
1006 
1007 	return ret;
1008 }
1009 
1010 /**
1011  * vmw_resource_unpin - Remove a pin reference from a resource
1012  *
1013  * @res: The resource to remove a pin reference from
1014  *
1015  * Having a pin reference means that the resource can never be evicted, and
1016  * its id will never change as long as there is a pin reference.
1017  */
1018 void vmw_resource_unpin(struct vmw_resource *res)
1019 {
1020 	struct vmw_private *dev_priv = res->dev_priv;
1021 	int ret;
1022 
1023 	mutex_lock(&dev_priv->cmdbuf_mutex);
1024 
1025 	ret = vmw_resource_reserve(res, false, true);
1026 	WARN_ON(ret);
1027 
1028 	WARN_ON(res->pin_count == 0);
1029 	if (--res->pin_count == 0 && res->guest_memory_bo) {
1030 		struct vmw_bo *vbo = res->guest_memory_bo;
1031 
1032 		(void) ttm_bo_reserve(&vbo->tbo, false, false, NULL);
1033 		vmw_bo_pin_reserved(vbo, false);
1034 		ttm_bo_unreserve(&vbo->tbo);
1035 	}
1036 
1037 	vmw_resource_unreserve(res, false, false, false, NULL, 0UL);
1038 
1039 	mutex_unlock(&dev_priv->cmdbuf_mutex);
1040 }
1041 
1042 /**
1043  * vmw_res_type - Return the resource type
1044  *
1045  * @res: Pointer to the resource
1046  */
1047 enum vmw_res_type vmw_res_type(const struct vmw_resource *res)
1048 {
1049 	return res->func->res_type;
1050 }
1051 
1052 /**
1053  * vmw_resource_dirty_update - Update a resource's dirty tracker with a
1054  * sequential range of touched backing store memory.
1055  * @res: The resource.
1056  * @start: The first page touched.
1057  * @end: The last page touched + 1.
1058  */
1059 void vmw_resource_dirty_update(struct vmw_resource *res, pgoff_t start,
1060 			       pgoff_t end)
1061 {
1062 	if (res->dirty)
1063 		res->func->dirty_range_add(res, start << PAGE_SHIFT,
1064 					   end << PAGE_SHIFT);
1065 }
1066 
1067 /**
1068  * vmw_resources_clean - Clean resources intersecting a mob range
1069  * @vbo: The mob buffer object
1070  * @start: The mob page offset starting the range
1071  * @end: The mob page offset ending the range
1072  * @num_prefault: Returns how many pages including the first have been
1073  * cleaned and are ok to prefault
1074  */
1075 int vmw_resources_clean(struct vmw_bo *vbo, pgoff_t start,
1076 			pgoff_t end, pgoff_t *num_prefault)
1077 {
1078 	struct rb_node *cur = vbo->res_tree.rb_node;
1079 	struct vmw_resource *found = NULL;
1080 	unsigned long res_start = start << PAGE_SHIFT;
1081 	unsigned long res_end = end << PAGE_SHIFT;
1082 	unsigned long last_cleaned = 0;
1083 
1084 	/*
1085 	 * Find the resource with lowest backup_offset that intersects the
1086 	 * range.
1087 	 */
1088 	while (cur) {
1089 		struct vmw_resource *cur_res =
1090 			container_of(cur, struct vmw_resource, mob_node);
1091 
1092 		if (cur_res->guest_memory_offset >= res_end) {
1093 			cur = cur->rb_left;
1094 		} else if (cur_res->guest_memory_offset + cur_res->guest_memory_size <=
1095 			   res_start) {
1096 			cur = cur->rb_right;
1097 		} else {
1098 			found = cur_res;
1099 			cur = cur->rb_left;
1100 			/* Continue to look for resources with lower offsets */
1101 		}
1102 	}
1103 
1104 	/*
1105 	 * In order of increasing guest_memory_offset, clean dirty resources
1106 	 * intersecting the range.
1107 	 */
1108 	while (found) {
1109 		if (found->res_dirty) {
1110 			int ret;
1111 
1112 			if (!found->func->clean)
1113 				return -EINVAL;
1114 
1115 			ret = found->func->clean(found);
1116 			if (ret)
1117 				return ret;
1118 
1119 			found->res_dirty = false;
1120 		}
1121 		last_cleaned = found->guest_memory_offset + found->guest_memory_size;
1122 		cur = rb_next(&found->mob_node);
1123 		if (!cur)
1124 			break;
1125 
1126 		found = container_of(cur, struct vmw_resource, mob_node);
1127 		if (found->guest_memory_offset >= res_end)
1128 			break;
1129 	}
1130 
1131 	/*
1132 	 * Set number of pages allowed prefaulting and fence the buffer object
1133 	 */
1134 	*num_prefault = 1;
1135 	if (last_cleaned > res_start) {
1136 		struct ttm_buffer_object *bo = &vbo->tbo;
1137 
1138 		*num_prefault = __KERNEL_DIV_ROUND_UP(last_cleaned - res_start,
1139 						      PAGE_SIZE);
1140 		vmw_bo_fence_single(bo, NULL);
1141 	}
1142 
1143 	return 0;
1144 }
1145