Home | History | Annotate | Line # | Download | only in qxl
qxl_release.c revision 1.1.1.1.30.1
      1 /*	$NetBSD: qxl_release.c,v 1.1.1.1.30.1 2018/09/06 06:56:31 pgoyette Exp $	*/
      2 
      3 /*
      4  * Copyright 2011 Red Hat, Inc.
      5  *
      6  * Permission is hereby granted, free of charge, to any person obtaining a
      7  * copy of this software and associated documentation files (the "Software"),
      8  * to deal in the Software without restriction, including without limitation
      9  * on the rights to use, copy, modify, merge, publish, distribute, sub
     10  * license, and/or sell copies of the Software, and to permit persons to whom
     11  * the Software is furnished to do so, subject to the following conditions:
     12  *
     13  * The above copyright notice and this permission notice (including the next
     14  * paragraph) shall be included in all copies or substantial portions of the
     15  * Software.
     16  *
     17  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
     18  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
     19  * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.  IN NO EVENT SHALL
     20  * THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
     21  * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
     22  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
     23  */
     24 #include <sys/cdefs.h>
     25 __KERNEL_RCSID(0, "$NetBSD: qxl_release.c,v 1.1.1.1.30.1 2018/09/06 06:56:31 pgoyette Exp $");
     26 
     27 #include "qxl_drv.h"
     28 #include "qxl_object.h"
     29 #include <trace/events/fence.h>
     30 
     31 /*
     32  * drawable cmd cache - allocate a bunch of VRAM pages, suballocate
     33  * into 256 byte chunks for now - gives 16 cmds per page.
     34  *
     35  * use an ida to index into the chunks?
     36  */
     37 /* manage releaseables */
     38 /* stack them 16 high for now -drawable object is 191 */
     39 #define RELEASE_SIZE 256
     40 #define RELEASES_PER_BO (4096 / RELEASE_SIZE)
     41 /* put an alloc/dealloc surface cmd into one bo and round up to 128 */
     42 #define SURFACE_RELEASE_SIZE 128
     43 #define SURFACE_RELEASES_PER_BO (4096 / SURFACE_RELEASE_SIZE)
     44 
     45 static const int release_size_per_bo[] = { RELEASE_SIZE, SURFACE_RELEASE_SIZE, RELEASE_SIZE };
     46 static const int releases_per_bo[] = { RELEASES_PER_BO, SURFACE_RELEASES_PER_BO, RELEASES_PER_BO };
     47 
     48 static const char *qxl_get_driver_name(struct fence *fence)
     49 {
     50 	return "qxl";
     51 }
     52 
     53 static const char *qxl_get_timeline_name(struct fence *fence)
     54 {
     55 	return "release";
     56 }
     57 
     58 static bool qxl_nop_signaling(struct fence *fence)
     59 {
     60 	/* fences are always automatically signaled, so just pretend we did this.. */
     61 	return true;
     62 }
     63 
     64 static long qxl_fence_wait(struct fence *fence, bool intr, signed long timeout)
     65 {
     66 	struct qxl_device *qdev;
     67 	struct qxl_release *release;
     68 	int count = 0, sc = 0;
     69 	bool have_drawable_releases;
     70 	unsigned long cur, end = jiffies + timeout;
     71 
     72 	qdev = container_of(fence->lock, struct qxl_device, release_lock);
     73 	release = container_of(fence, struct qxl_release, base);
     74 	have_drawable_releases = release->type == QXL_RELEASE_DRAWABLE;
     75 
     76 retry:
     77 	sc++;
     78 
     79 	if (fence_is_signaled(fence))
     80 		goto signaled;
     81 
     82 	qxl_io_notify_oom(qdev);
     83 
     84 	for (count = 0; count < 11; count++) {
     85 		if (!qxl_queue_garbage_collect(qdev, true))
     86 			break;
     87 
     88 		if (fence_is_signaled(fence))
     89 			goto signaled;
     90 	}
     91 
     92 	if (fence_is_signaled(fence))
     93 		goto signaled;
     94 
     95 	if (have_drawable_releases || sc < 4) {
     96 		if (sc > 2)
     97 			/* back off */
     98 			usleep_range(500, 1000);
     99 
    100 		if (time_after(jiffies, end))
    101 			return 0;
    102 
    103 		if (have_drawable_releases && sc > 300) {
    104 			FENCE_WARN(fence, "failed to wait on release %d "
    105 					  "after spincount %d\n",
    106 					  fence->context & ~0xf0000000, sc);
    107 			goto signaled;
    108 		}
    109 		goto retry;
    110 	}
    111 	/*
    112 	 * yeah, original sync_obj_wait gave up after 3 spins when
    113 	 * have_drawable_releases is not set.
    114 	 */
    115 
    116 signaled:
    117 	cur = jiffies;
    118 	if (time_after(cur, end))
    119 		return 0;
    120 	return end - cur;
    121 }
    122 
    123 static const struct fence_ops qxl_fence_ops = {
    124 	.get_driver_name = qxl_get_driver_name,
    125 	.get_timeline_name = qxl_get_timeline_name,
    126 	.enable_signaling = qxl_nop_signaling,
    127 	.wait = qxl_fence_wait,
    128 };
    129 
    130 static int
    131 qxl_release_alloc(struct qxl_device *qdev, int type,
    132 		  struct qxl_release **ret)
    133 {
    134 	struct qxl_release *release;
    135 	int handle;
    136 	size_t size = sizeof(*release);
    137 
    138 	release = kmalloc(size, GFP_KERNEL);
    139 	if (!release) {
    140 		DRM_ERROR("Out of memory\n");
    141 		return 0;
    142 	}
    143 	release->base.ops = NULL;
    144 	release->type = type;
    145 	release->release_offset = 0;
    146 	release->surface_release_id = 0;
    147 	INIT_LIST_HEAD(&release->bos);
    148 
    149 	idr_preload(GFP_KERNEL);
    150 	spin_lock(&qdev->release_idr_lock);
    151 	handle = idr_alloc(&qdev->release_idr, release, 1, 0, GFP_NOWAIT);
    152 	release->base.seqno = ++qdev->release_seqno;
    153 	spin_unlock(&qdev->release_idr_lock);
    154 	idr_preload_end();
    155 	if (handle < 0) {
    156 		kfree(release);
    157 		*ret = NULL;
    158 		return handle;
    159 	}
    160 	*ret = release;
    161 	QXL_INFO(qdev, "allocated release %d\n", handle);
    162 	release->id = handle;
    163 	return handle;
    164 }
    165 
    166 static void
    167 qxl_release_free_list(struct qxl_release *release)
    168 {
    169 	while (!list_empty(&release->bos)) {
    170 		struct qxl_bo_list *entry;
    171 		struct qxl_bo *bo;
    172 
    173 		entry = container_of(release->bos.next,
    174 				     struct qxl_bo_list, tv.head);
    175 		bo = to_qxl_bo(entry->tv.bo);
    176 		qxl_bo_unref(&bo);
    177 		list_del(&entry->tv.head);
    178 		kfree(entry);
    179 	}
    180 }
    181 
    182 void
    183 qxl_release_free(struct qxl_device *qdev,
    184 		 struct qxl_release *release)
    185 {
    186 	QXL_INFO(qdev, "release %d, type %d\n", release->id,
    187 		 release->type);
    188 
    189 	if (release->surface_release_id)
    190 		qxl_surface_id_dealloc(qdev, release->surface_release_id);
    191 
    192 	spin_lock(&qdev->release_idr_lock);
    193 	idr_remove(&qdev->release_idr, release->id);
    194 	spin_unlock(&qdev->release_idr_lock);
    195 
    196 	if (release->base.ops) {
    197 		WARN_ON(list_empty(&release->bos));
    198 		qxl_release_free_list(release);
    199 
    200 		fence_signal(&release->base);
    201 		fence_put(&release->base);
    202 	} else {
    203 		qxl_release_free_list(release);
    204 		kfree(release);
    205 	}
    206 }
    207 
    208 static int qxl_release_bo_alloc(struct qxl_device *qdev,
    209 				struct qxl_bo **bo)
    210 {
    211 	int ret;
    212 	/* pin releases bo's they are too messy to evict */
    213 	ret = qxl_bo_create(qdev, PAGE_SIZE, false, true,
    214 			    QXL_GEM_DOMAIN_VRAM, NULL,
    215 			    bo);
    216 	return ret;
    217 }
    218 
    219 int qxl_release_list_add(struct qxl_release *release, struct qxl_bo *bo)
    220 {
    221 	struct qxl_bo_list *entry;
    222 
    223 	list_for_each_entry(entry, &release->bos, tv.head) {
    224 		if (entry->tv.bo == &bo->tbo)
    225 			return 0;
    226 	}
    227 
    228 	entry = kmalloc(sizeof(struct qxl_bo_list), GFP_KERNEL);
    229 	if (!entry)
    230 		return -ENOMEM;
    231 
    232 	qxl_bo_ref(bo);
    233 	entry->tv.bo = &bo->tbo;
    234 	entry->tv.shared = false;
    235 	list_add_tail(&entry->tv.head, &release->bos);
    236 	return 0;
    237 }
    238 
    239 static int qxl_release_validate_bo(struct qxl_bo *bo)
    240 {
    241 	int ret;
    242 
    243 	if (!bo->pin_count) {
    244 		qxl_ttm_placement_from_domain(bo, bo->type, false);
    245 		ret = ttm_bo_validate(&bo->tbo, &bo->placement,
    246 				      true, false);
    247 		if (ret)
    248 			return ret;
    249 	}
    250 
    251 	ret = reservation_object_reserve_shared(bo->tbo.resv);
    252 	if (ret)
    253 		return ret;
    254 
    255 	/* allocate a surface for reserved + validated buffers */
    256 	ret = qxl_bo_check_id(bo->gem_base.dev->dev_private, bo);
    257 	if (ret)
    258 		return ret;
    259 	return 0;
    260 }
    261 
    262 int qxl_release_reserve_list(struct qxl_release *release, bool no_intr)
    263 {
    264 	int ret;
    265 	struct qxl_bo_list *entry;
    266 
    267 	/* if only one object on the release its the release itself
    268 	   since these objects are pinned no need to reserve */
    269 	if (list_is_singular(&release->bos))
    270 		return 0;
    271 
    272 	ret = ttm_eu_reserve_buffers(&release->ticket, &release->bos,
    273 				     !no_intr, NULL);
    274 	if (ret)
    275 		return ret;
    276 
    277 	list_for_each_entry(entry, &release->bos, tv.head) {
    278 		struct qxl_bo *bo = to_qxl_bo(entry->tv.bo);
    279 
    280 		ret = qxl_release_validate_bo(bo);
    281 		if (ret) {
    282 			ttm_eu_backoff_reservation(&release->ticket, &release->bos);
    283 			return ret;
    284 		}
    285 	}
    286 	return 0;
    287 }
    288 
    289 void qxl_release_backoff_reserve_list(struct qxl_release *release)
    290 {
    291 	/* if only one object on the release its the release itself
    292 	   since these objects are pinned no need to reserve */
    293 	if (list_is_singular(&release->bos))
    294 		return;
    295 
    296 	ttm_eu_backoff_reservation(&release->ticket, &release->bos);
    297 }
    298 
    299 
    300 int qxl_alloc_surface_release_reserved(struct qxl_device *qdev,
    301 				       enum qxl_surface_cmd_type surface_cmd_type,
    302 				       struct qxl_release *create_rel,
    303 				       struct qxl_release **release)
    304 {
    305 	if (surface_cmd_type == QXL_SURFACE_CMD_DESTROY && create_rel) {
    306 		int idr_ret;
    307 		struct qxl_bo_list *entry = list_first_entry(&create_rel->bos, struct qxl_bo_list, tv.head);
    308 		struct qxl_bo *bo;
    309 		union qxl_release_info *info;
    310 
    311 		/* stash the release after the create command */
    312 		idr_ret = qxl_release_alloc(qdev, QXL_RELEASE_SURFACE_CMD, release);
    313 		if (idr_ret < 0)
    314 			return idr_ret;
    315 		bo = to_qxl_bo(entry->tv.bo);
    316 
    317 		(*release)->release_offset = create_rel->release_offset + 64;
    318 
    319 		qxl_release_list_add(*release, bo);
    320 
    321 		info = qxl_release_map(qdev, *release);
    322 		info->id = idr_ret;
    323 		qxl_release_unmap(qdev, *release, info);
    324 		return 0;
    325 	}
    326 
    327 	return qxl_alloc_release_reserved(qdev, sizeof(struct qxl_surface_cmd),
    328 					 QXL_RELEASE_SURFACE_CMD, release, NULL);
    329 }
    330 
    331 int qxl_alloc_release_reserved(struct qxl_device *qdev, unsigned long size,
    332 				       int type, struct qxl_release **release,
    333 				       struct qxl_bo **rbo)
    334 {
    335 	struct qxl_bo *bo;
    336 	int idr_ret;
    337 	int ret = 0;
    338 	union qxl_release_info *info;
    339 	int cur_idx;
    340 
    341 	if (type == QXL_RELEASE_DRAWABLE)
    342 		cur_idx = 0;
    343 	else if (type == QXL_RELEASE_SURFACE_CMD)
    344 		cur_idx = 1;
    345 	else if (type == QXL_RELEASE_CURSOR_CMD)
    346 		cur_idx = 2;
    347 	else {
    348 		DRM_ERROR("got illegal type: %d\n", type);
    349 		return -EINVAL;
    350 	}
    351 
    352 	idr_ret = qxl_release_alloc(qdev, type, release);
    353 	if (idr_ret < 0) {
    354 		if (rbo)
    355 			*rbo = NULL;
    356 		return idr_ret;
    357 	}
    358 
    359 	mutex_lock(&qdev->release_mutex);
    360 	if (qdev->current_release_bo_offset[cur_idx] + 1 >= releases_per_bo[cur_idx]) {
    361 		qxl_bo_unref(&qdev->current_release_bo[cur_idx]);
    362 		qdev->current_release_bo_offset[cur_idx] = 0;
    363 		qdev->current_release_bo[cur_idx] = NULL;
    364 	}
    365 	if (!qdev->current_release_bo[cur_idx]) {
    366 		ret = qxl_release_bo_alloc(qdev, &qdev->current_release_bo[cur_idx]);
    367 		if (ret) {
    368 			mutex_unlock(&qdev->release_mutex);
    369 			qxl_release_free(qdev, *release);
    370 			return ret;
    371 		}
    372 	}
    373 
    374 	bo = qxl_bo_ref(qdev->current_release_bo[cur_idx]);
    375 
    376 	(*release)->release_offset = qdev->current_release_bo_offset[cur_idx] * release_size_per_bo[cur_idx];
    377 	qdev->current_release_bo_offset[cur_idx]++;
    378 
    379 	if (rbo)
    380 		*rbo = bo;
    381 
    382 	mutex_unlock(&qdev->release_mutex);
    383 
    384 	ret = qxl_release_list_add(*release, bo);
    385 	qxl_bo_unref(&bo);
    386 	if (ret) {
    387 		qxl_release_free(qdev, *release);
    388 		return ret;
    389 	}
    390 
    391 	info = qxl_release_map(qdev, *release);
    392 	info->id = idr_ret;
    393 	qxl_release_unmap(qdev, *release, info);
    394 
    395 	return ret;
    396 }
    397 
    398 struct qxl_release *qxl_release_from_id_locked(struct qxl_device *qdev,
    399 						   uint64_t id)
    400 {
    401 	struct qxl_release *release;
    402 
    403 	spin_lock(&qdev->release_idr_lock);
    404 	release = idr_find(&qdev->release_idr, id);
    405 	spin_unlock(&qdev->release_idr_lock);
    406 	if (!release) {
    407 		DRM_ERROR("failed to find id in release_idr\n");
    408 		return NULL;
    409 	}
    410 
    411 	return release;
    412 }
    413 
    414 union qxl_release_info *qxl_release_map(struct qxl_device *qdev,
    415 					struct qxl_release *release)
    416 {
    417 	void *ptr;
    418 	union qxl_release_info *info;
    419 	struct qxl_bo_list *entry = list_first_entry(&release->bos, struct qxl_bo_list, tv.head);
    420 	struct qxl_bo *bo = to_qxl_bo(entry->tv.bo);
    421 
    422 	ptr = qxl_bo_kmap_atomic_page(qdev, bo, release->release_offset & PAGE_SIZE);
    423 	if (!ptr)
    424 		return NULL;
    425 	info = ptr + (release->release_offset & ~PAGE_SIZE);
    426 	return info;
    427 }
    428 
    429 void qxl_release_unmap(struct qxl_device *qdev,
    430 		       struct qxl_release *release,
    431 		       union qxl_release_info *info)
    432 {
    433 	struct qxl_bo_list *entry = list_first_entry(&release->bos, struct qxl_bo_list, tv.head);
    434 	struct qxl_bo *bo = to_qxl_bo(entry->tv.bo);
    435 	void *ptr;
    436 
    437 	ptr = ((void *)info) - (release->release_offset & ~PAGE_SIZE);
    438 	qxl_bo_kunmap_atomic_page(qdev, bo, ptr);
    439 }
    440 
    441 void qxl_release_fence_buffer_objects(struct qxl_release *release)
    442 {
    443 	struct ttm_buffer_object *bo;
    444 	struct ttm_bo_global *glob;
    445 	struct ttm_bo_device *bdev;
    446 	struct ttm_bo_driver *driver;
    447 	struct qxl_bo *qbo;
    448 	struct ttm_validate_buffer *entry;
    449 	struct qxl_device *qdev;
    450 
    451 	/* if only one object on the release its the release itself
    452 	   since these objects are pinned no need to reserve */
    453 	if (list_is_singular(&release->bos) || list_empty(&release->bos))
    454 		return;
    455 
    456 	bo = list_first_entry(&release->bos, struct ttm_validate_buffer, head)->bo;
    457 	bdev = bo->bdev;
    458 	qdev = container_of(bdev, struct qxl_device, mman.bdev);
    459 
    460 	/*
    461 	 * Since we never really allocated a context and we don't want to conflict,
    462 	 * set the highest bits. This will break if we really allow exporting of dma-bufs.
    463 	 */
    464 	fence_init(&release->base, &qxl_fence_ops, &qdev->release_lock,
    465 		   release->id | 0xf0000000, release->base.seqno);
    466 	trace_fence_emit(&release->base);
    467 
    468 	driver = bdev->driver;
    469 	glob = bo->glob;
    470 
    471 	spin_lock(&glob->lru_lock);
    472 
    473 	list_for_each_entry(entry, &release->bos, head) {
    474 		bo = entry->bo;
    475 		qbo = to_qxl_bo(bo);
    476 
    477 		reservation_object_add_shared_fence(bo->resv, &release->base);
    478 		ttm_bo_add_to_lru(bo);
    479 		__ttm_bo_unreserve(bo);
    480 	}
    481 	spin_unlock(&glob->lru_lock);
    482 	ww_acquire_fini(&release->ticket);
    483 }
    484 
    485