1 /*
2 * Copyright © 2016 Intel Corporation
3 *
4 * Permission is hereby granted, free of charge, to any person obtaining a
5 * copy of this software and associated documentation files (the "Software"),
6 * to deal in the Software without restriction, including without limitation
7 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
8 * and/or sell copies of the Software, and to permit persons to whom the
9 * Software is furnished to do so, subject to the following conditions:
10 *
11 * The above copyright notice and this permission notice (including the next
12 * paragraph) shall be included in all copies or substantial portions of the
13 * Software.
14 *
15 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
18 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
20 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
21 * IN THE SOFTWARE.
22 *
23 */
24
25 #include <linux/prime_numbers.h>
26
27 #include "gem/i915_gem_context.h"
28 #include "gem/selftests/mock_context.h"
29
30 #include "i915_scatterlist.h"
31 #include "i915_selftest.h"
32
33 #include "mock_gem_device.h"
34 #include "mock_gtt.h"
35
assert_vma(struct i915_vma * vma,struct drm_i915_gem_object * obj,struct i915_gem_context * ctx)36 static bool assert_vma(struct i915_vma *vma,
37 struct drm_i915_gem_object *obj,
38 struct i915_gem_context *ctx)
39 {
40 bool ok = true;
41
42 if (vma->vm != rcu_access_pointer(ctx->vm)) {
43 pr_err("VMA created with wrong VM\n");
44 ok = false;
45 }
46
47 if (vma->size != obj->base.size) {
48 pr_err("VMA created with wrong size, found %llu, expected %zu\n",
49 vma->size, obj->base.size);
50 ok = false;
51 }
52
53 if (vma->ggtt_view.type != I915_GGTT_VIEW_NORMAL) {
54 pr_err("VMA created with wrong type [%d]\n",
55 vma->ggtt_view.type);
56 ok = false;
57 }
58
59 return ok;
60 }
61
62 static struct i915_vma *
checked_vma_instance(struct drm_i915_gem_object * obj,struct i915_address_space * vm,const struct i915_ggtt_view * view)63 checked_vma_instance(struct drm_i915_gem_object *obj,
64 struct i915_address_space *vm,
65 const struct i915_ggtt_view *view)
66 {
67 struct i915_vma *vma;
68 bool ok = true;
69
70 vma = i915_vma_instance(obj, vm, view);
71 if (IS_ERR(vma))
72 return vma;
73
74 /* Manual checks, will be reinforced by i915_vma_compare! */
75 if (vma->vm != vm) {
76 pr_err("VMA's vm [%p] does not match request [%p]\n",
77 vma->vm, vm);
78 ok = false;
79 }
80
81 if (i915_is_ggtt(vm) != i915_vma_is_ggtt(vma)) {
82 pr_err("VMA ggtt status [%d] does not match parent [%d]\n",
83 i915_vma_is_ggtt(vma), i915_is_ggtt(vm));
84 ok = false;
85 }
86
87 if (i915_vma_compare(vma, vm, view)) {
88 pr_err("i915_vma_compare failed with create parameters!\n");
89 return ERR_PTR(-EINVAL);
90 }
91
92 if (i915_vma_compare(vma, vma->vm,
93 i915_vma_is_ggtt(vma) ? &vma->ggtt_view : NULL)) {
94 pr_err("i915_vma_compare failed with itself\n");
95 return ERR_PTR(-EINVAL);
96 }
97
98 if (!ok) {
99 pr_err("i915_vma_compare failed to detect the difference!\n");
100 return ERR_PTR(-EINVAL);
101 }
102
103 return vma;
104 }
105
create_vmas(struct drm_i915_private * i915,struct list_head * objects,struct list_head * contexts)106 static int create_vmas(struct drm_i915_private *i915,
107 struct list_head *objects,
108 struct list_head *contexts)
109 {
110 struct drm_i915_gem_object *obj;
111 struct i915_gem_context *ctx;
112 int pinned;
113
114 list_for_each_entry(obj, objects, st_link) {
115 for (pinned = 0; pinned <= 1; pinned++) {
116 list_for_each_entry(ctx, contexts, link) {
117 struct i915_address_space *vm;
118 struct i915_vma *vma;
119 int err;
120
121 vm = i915_gem_context_get_vm_rcu(ctx);
122 vma = checked_vma_instance(obj, vm, NULL);
123 i915_vm_put(vm);
124 if (IS_ERR(vma))
125 return PTR_ERR(vma);
126
127 if (!assert_vma(vma, obj, ctx)) {
128 pr_err("VMA lookup/create failed\n");
129 return -EINVAL;
130 }
131
132 if (!pinned) {
133 err = i915_vma_pin(vma, 0, 0, PIN_USER);
134 if (err) {
135 pr_err("Failed to pin VMA\n");
136 return err;
137 }
138 } else {
139 i915_vma_unpin(vma);
140 }
141 }
142 }
143 }
144
145 return 0;
146 }
147
igt_vma_create(void * arg)148 static int igt_vma_create(void *arg)
149 {
150 struct i915_ggtt *ggtt = arg;
151 struct drm_i915_private *i915 = ggtt->vm.i915;
152 struct drm_i915_gem_object *obj, *on;
153 struct i915_gem_context *ctx, *cn;
154 unsigned long num_obj, num_ctx;
155 unsigned long no, nc;
156 IGT_TIMEOUT(end_time);
157 LIST_HEAD(contexts);
158 LIST_HEAD(objects);
159 int err = -ENOMEM;
160
161 /* Exercise creating many vma amonst many objections, checking the
162 * vma creation and lookup routines.
163 */
164
165 no = 0;
166 for_each_prime_number(num_obj, ULONG_MAX - 1) {
167 for (; no < num_obj; no++) {
168 obj = i915_gem_object_create_internal(i915, PAGE_SIZE);
169 if (IS_ERR(obj))
170 goto out;
171
172 list_add(&obj->st_link, &objects);
173 }
174
175 nc = 0;
176 for_each_prime_number(num_ctx, 2 * BITS_PER_LONG) {
177 for (; nc < num_ctx; nc++) {
178 ctx = mock_context(i915, "mock");
179 if (!ctx)
180 goto out;
181
182 list_move(&ctx->link, &contexts);
183 }
184
185 err = create_vmas(i915, &objects, &contexts);
186 if (err)
187 goto out;
188
189 if (igt_timeout(end_time,
190 "%s timed out: after %lu objects in %lu contexts\n",
191 __func__, no, nc))
192 goto end;
193 }
194
195 list_for_each_entry_safe(ctx, cn, &contexts, link) {
196 list_del_init(&ctx->link);
197 mock_context_close(ctx);
198 }
199
200 cond_resched();
201 }
202
203 end:
204 /* Final pass to lookup all created contexts */
205 err = create_vmas(i915, &objects, &contexts);
206 out:
207 list_for_each_entry_safe(ctx, cn, &contexts, link) {
208 list_del_init(&ctx->link);
209 mock_context_close(ctx);
210 }
211
212 list_for_each_entry_safe(obj, on, &objects, st_link)
213 i915_gem_object_put(obj);
214 return err;
215 }
216
217 struct pin_mode {
218 u64 size;
219 u64 flags;
220 bool (*assert)(const struct i915_vma *,
221 const struct pin_mode *mode,
222 int result);
223 const char *string;
224 };
225
assert_pin_valid(const struct i915_vma * vma,const struct pin_mode * mode,int result)226 static bool assert_pin_valid(const struct i915_vma *vma,
227 const struct pin_mode *mode,
228 int result)
229 {
230 if (result)
231 return false;
232
233 if (i915_vma_misplaced(vma, mode->size, 0, mode->flags))
234 return false;
235
236 return true;
237 }
238
239 __maybe_unused
assert_pin_enospc(const struct i915_vma * vma,const struct pin_mode * mode,int result)240 static bool assert_pin_enospc(const struct i915_vma *vma,
241 const struct pin_mode *mode,
242 int result)
243 {
244 return result == -ENOSPC;
245 }
246
247 __maybe_unused
assert_pin_einval(const struct i915_vma * vma,const struct pin_mode * mode,int result)248 static bool assert_pin_einval(const struct i915_vma *vma,
249 const struct pin_mode *mode,
250 int result)
251 {
252 return result == -EINVAL;
253 }
254
igt_vma_pin1(void * arg)255 static int igt_vma_pin1(void *arg)
256 {
257 struct i915_ggtt *ggtt = arg;
258 const struct pin_mode modes[] = {
259 #define VALID(sz, fl) { .size = (sz), .flags = (fl), .assert = assert_pin_valid, .string = #sz ", " #fl ", (valid) " }
260 #define __INVALID(sz, fl, check, eval) { .size = (sz), .flags = (fl), .assert = (check), .string = #sz ", " #fl ", (invalid " #eval ")" }
261 #define INVALID(sz, fl) __INVALID(sz, fl, assert_pin_einval, EINVAL)
262 #define NOSPACE(sz, fl) __INVALID(sz, fl, assert_pin_enospc, ENOSPC)
263 VALID(0, PIN_GLOBAL),
264 VALID(0, PIN_GLOBAL | PIN_MAPPABLE),
265
266 VALID(0, PIN_GLOBAL | PIN_OFFSET_BIAS | 4096),
267 VALID(0, PIN_GLOBAL | PIN_OFFSET_BIAS | 8192),
268 VALID(0, PIN_GLOBAL | PIN_OFFSET_BIAS | (ggtt->mappable_end - 4096)),
269 VALID(0, PIN_GLOBAL | PIN_MAPPABLE | PIN_OFFSET_BIAS | (ggtt->mappable_end - 4096)),
270 VALID(0, PIN_GLOBAL | PIN_OFFSET_BIAS | (ggtt->vm.total - 4096)),
271
272 VALID(0, PIN_GLOBAL | PIN_MAPPABLE | PIN_OFFSET_FIXED | (ggtt->mappable_end - 4096)),
273 INVALID(0, PIN_GLOBAL | PIN_MAPPABLE | PIN_OFFSET_FIXED | ggtt->mappable_end),
274 VALID(0, PIN_GLOBAL | PIN_OFFSET_FIXED | (ggtt->vm.total - 4096)),
275 INVALID(0, PIN_GLOBAL | PIN_OFFSET_FIXED | ggtt->vm.total),
276 INVALID(0, PIN_GLOBAL | PIN_OFFSET_FIXED | round_down(U64_MAX, PAGE_SIZE)),
277
278 VALID(4096, PIN_GLOBAL),
279 VALID(8192, PIN_GLOBAL),
280 VALID(ggtt->mappable_end - 4096, PIN_GLOBAL | PIN_MAPPABLE),
281 VALID(ggtt->mappable_end, PIN_GLOBAL | PIN_MAPPABLE),
282 NOSPACE(ggtt->mappable_end + 4096, PIN_GLOBAL | PIN_MAPPABLE),
283 VALID(ggtt->vm.total - 4096, PIN_GLOBAL),
284 VALID(ggtt->vm.total, PIN_GLOBAL),
285 NOSPACE(ggtt->vm.total + 4096, PIN_GLOBAL),
286 NOSPACE(round_down(U64_MAX, PAGE_SIZE), PIN_GLOBAL),
287 INVALID(8192, PIN_GLOBAL | PIN_MAPPABLE | PIN_OFFSET_FIXED | (ggtt->mappable_end - 4096)),
288 INVALID(8192, PIN_GLOBAL | PIN_OFFSET_FIXED | (ggtt->vm.total - 4096)),
289 INVALID(8192, PIN_GLOBAL | PIN_OFFSET_FIXED | (round_down(U64_MAX, PAGE_SIZE) - 4096)),
290
291 VALID(8192, PIN_GLOBAL | PIN_OFFSET_BIAS | (ggtt->mappable_end - 4096)),
292
293 #if !IS_ENABLED(CONFIG_DRM_I915_DEBUG_GEM)
294 /* Misusing BIAS is a programming error (it is not controllable
295 * from userspace) so when debugging is enabled, it explodes.
296 * However, the tests are still quite interesting for checking
297 * variable start, end and size.
298 */
299 NOSPACE(0, PIN_GLOBAL | PIN_MAPPABLE | PIN_OFFSET_BIAS | ggtt->mappable_end),
300 NOSPACE(0, PIN_GLOBAL | PIN_OFFSET_BIAS | ggtt->vm.total),
301 NOSPACE(8192, PIN_GLOBAL | PIN_MAPPABLE | PIN_OFFSET_BIAS | (ggtt->mappable_end - 4096)),
302 NOSPACE(8192, PIN_GLOBAL | PIN_OFFSET_BIAS | (ggtt->vm.total - 4096)),
303 #endif
304 { },
305 #undef NOSPACE
306 #undef INVALID
307 #undef __INVALID
308 #undef VALID
309 }, *m;
310 struct drm_i915_gem_object *obj;
311 struct i915_vma *vma;
312 int err = -EINVAL;
313
314 /* Exercise all the weird and wonderful i915_vma_pin requests,
315 * focusing on error handling of boundary conditions.
316 */
317
318 GEM_BUG_ON(!drm_mm_clean(&ggtt->vm.mm));
319
320 obj = i915_gem_object_create_internal(ggtt->vm.i915, PAGE_SIZE);
321 if (IS_ERR(obj))
322 return PTR_ERR(obj);
323
324 vma = checked_vma_instance(obj, &ggtt->vm, NULL);
325 if (IS_ERR(vma))
326 goto out;
327
328 for (m = modes; m->assert; m++) {
329 err = i915_vma_pin(vma, m->size, 0, m->flags);
330 if (!m->assert(vma, m, err)) {
331 pr_err("%s to pin single page into GGTT with mode[%d:%s]: size=%llx flags=%llx, err=%d\n",
332 m->assert == assert_pin_valid ? "Failed" : "Unexpectedly succeeded",
333 (int)(m - modes), m->string, m->size, m->flags,
334 err);
335 if (!err)
336 i915_vma_unpin(vma);
337 err = -EINVAL;
338 goto out;
339 }
340
341 if (!err) {
342 i915_vma_unpin(vma);
343 err = i915_vma_unbind(vma);
344 if (err) {
345 pr_err("Failed to unbind single page from GGTT, err=%d\n", err);
346 goto out;
347 }
348 }
349
350 cond_resched();
351 }
352
353 err = 0;
354 out:
355 i915_gem_object_put(obj);
356 return err;
357 }
358
rotated_index(const struct intel_rotation_info * r,unsigned int n,unsigned int x,unsigned int y)359 static unsigned long rotated_index(const struct intel_rotation_info *r,
360 unsigned int n,
361 unsigned int x,
362 unsigned int y)
363 {
364 return (r->plane[n].stride * (r->plane[n].height - y - 1) +
365 r->plane[n].offset + x);
366 }
367
368 static struct scatterlist *
assert_rotated(struct drm_i915_gem_object * obj,const struct intel_rotation_info * r,unsigned int n,struct scatterlist * sg)369 assert_rotated(struct drm_i915_gem_object *obj,
370 const struct intel_rotation_info *r, unsigned int n,
371 struct scatterlist *sg)
372 {
373 unsigned int x, y;
374
375 for (x = 0; x < r->plane[n].width; x++) {
376 for (y = 0; y < r->plane[n].height; y++) {
377 unsigned long src_idx;
378 dma_addr_t src;
379
380 if (!sg) {
381 pr_err("Invalid sg table: too short at plane %d, (%d, %d)!\n",
382 n, x, y);
383 return ERR_PTR(-EINVAL);
384 }
385
386 src_idx = rotated_index(r, n, x, y);
387 src = i915_gem_object_get_dma_address(obj, src_idx);
388
389 if (sg_dma_len(sg) != PAGE_SIZE) {
390 pr_err("Invalid sg.length, found %d, expected %lu for rotated page (%d, %d) [src index %lu]\n",
391 sg_dma_len(sg), PAGE_SIZE,
392 x, y, src_idx);
393 return ERR_PTR(-EINVAL);
394 }
395
396 if (sg_dma_address(sg) != src) {
397 pr_err("Invalid address for rotated page (%d, %d) [src index %lu]\n",
398 x, y, src_idx);
399 return ERR_PTR(-EINVAL);
400 }
401
402 sg = sg_next(sg);
403 }
404 }
405
406 return sg;
407 }
408
remapped_index(const struct intel_remapped_info * r,unsigned int n,unsigned int x,unsigned int y)409 static unsigned long remapped_index(const struct intel_remapped_info *r,
410 unsigned int n,
411 unsigned int x,
412 unsigned int y)
413 {
414 return (r->plane[n].stride * y +
415 r->plane[n].offset + x);
416 }
417
418 static struct scatterlist *
assert_remapped(struct drm_i915_gem_object * obj,const struct intel_remapped_info * r,unsigned int n,struct scatterlist * sg)419 assert_remapped(struct drm_i915_gem_object *obj,
420 const struct intel_remapped_info *r, unsigned int n,
421 struct scatterlist *sg)
422 {
423 unsigned int x, y;
424 unsigned int left = 0;
425 unsigned int offset;
426
427 for (y = 0; y < r->plane[n].height; y++) {
428 for (x = 0; x < r->plane[n].width; x++) {
429 unsigned long src_idx;
430 dma_addr_t src;
431
432 if (!sg) {
433 pr_err("Invalid sg table: too short at plane %d, (%d, %d)!\n",
434 n, x, y);
435 return ERR_PTR(-EINVAL);
436 }
437 if (!left) {
438 offset = 0;
439 left = sg_dma_len(sg);
440 }
441
442 src_idx = remapped_index(r, n, x, y);
443 src = i915_gem_object_get_dma_address(obj, src_idx);
444
445 if (left < PAGE_SIZE || left & (PAGE_SIZE-1)) {
446 pr_err("Invalid sg.length, found %d, expected %lu for remapped page (%d, %d) [src index %lu]\n",
447 sg_dma_len(sg), PAGE_SIZE,
448 x, y, src_idx);
449 return ERR_PTR(-EINVAL);
450 }
451
452 if (sg_dma_address(sg) + offset != src) {
453 pr_err("Invalid address for remapped page (%d, %d) [src index %lu]\n",
454 x, y, src_idx);
455 return ERR_PTR(-EINVAL);
456 }
457
458 left -= PAGE_SIZE;
459 offset += PAGE_SIZE;
460
461
462 if (!left)
463 sg = sg_next(sg);
464 }
465 }
466
467 return sg;
468 }
469
rotated_size(const struct intel_remapped_plane_info * a,const struct intel_remapped_plane_info * b)470 static unsigned int rotated_size(const struct intel_remapped_plane_info *a,
471 const struct intel_remapped_plane_info *b)
472 {
473 return a->width * a->height + b->width * b->height;
474 }
475
igt_vma_rotate_remap(void * arg)476 static int igt_vma_rotate_remap(void *arg)
477 {
478 struct i915_ggtt *ggtt = arg;
479 struct i915_address_space *vm = &ggtt->vm;
480 struct drm_i915_gem_object *obj;
481 const struct intel_remapped_plane_info planes[] = {
482 { .width = 1, .height = 1, .stride = 1 },
483 { .width = 2, .height = 2, .stride = 2 },
484 { .width = 4, .height = 4, .stride = 4 },
485 { .width = 8, .height = 8, .stride = 8 },
486
487 { .width = 3, .height = 5, .stride = 3 },
488 { .width = 3, .height = 5, .stride = 4 },
489 { .width = 3, .height = 5, .stride = 5 },
490
491 { .width = 5, .height = 3, .stride = 5 },
492 { .width = 5, .height = 3, .stride = 7 },
493 { .width = 5, .height = 3, .stride = 9 },
494
495 { .width = 4, .height = 6, .stride = 6 },
496 { .width = 6, .height = 4, .stride = 6 },
497 { }
498 }, *a, *b;
499 enum i915_ggtt_view_type types[] = {
500 I915_GGTT_VIEW_ROTATED,
501 I915_GGTT_VIEW_REMAPPED,
502 0,
503 }, *t;
504 const unsigned int max_pages = 64;
505 int err = -ENOMEM;
506
507 /* Create VMA for many different combinations of planes and check
508 * that the page layout within the rotated VMA match our expectations.
509 */
510
511 obj = i915_gem_object_create_internal(vm->i915, max_pages * PAGE_SIZE);
512 if (IS_ERR(obj))
513 goto out;
514
515 for (t = types; *t; t++) {
516 for (a = planes; a->width; a++) {
517 for (b = planes + ARRAY_SIZE(planes); b-- != planes; ) {
518 struct i915_ggtt_view view;
519 unsigned int n, max_offset;
520
521 max_offset = max(a->stride * a->height,
522 b->stride * b->height);
523 GEM_BUG_ON(max_offset > max_pages);
524 max_offset = max_pages - max_offset;
525
526 view.type = *t;
527 view.rotated.plane[0] = *a;
528 view.rotated.plane[1] = *b;
529
530 for_each_prime_number_from(view.rotated.plane[0].offset, 0, max_offset) {
531 for_each_prime_number_from(view.rotated.plane[1].offset, 0, max_offset) {
532 struct scatterlist *sg;
533 struct i915_vma *vma;
534
535 vma = checked_vma_instance(obj, vm, &view);
536 if (IS_ERR(vma)) {
537 err = PTR_ERR(vma);
538 goto out_object;
539 }
540
541 err = i915_vma_pin(vma, 0, 0, PIN_GLOBAL);
542 if (err) {
543 pr_err("Failed to pin VMA, err=%d\n", err);
544 goto out_object;
545 }
546
547 if (view.type == I915_GGTT_VIEW_ROTATED &&
548 vma->size != rotated_size(a, b) * PAGE_SIZE) {
549 pr_err("VMA is wrong size, expected %lu, found %llu\n",
550 PAGE_SIZE * rotated_size(a, b), vma->size);
551 err = -EINVAL;
552 goto out_object;
553 }
554
555 if (view.type == I915_GGTT_VIEW_REMAPPED &&
556 vma->size > rotated_size(a, b) * PAGE_SIZE) {
557 pr_err("VMA is wrong size, expected %lu, found %llu\n",
558 PAGE_SIZE * rotated_size(a, b), vma->size);
559 err = -EINVAL;
560 goto out_object;
561 }
562
563 if (vma->pages->nents > rotated_size(a, b)) {
564 pr_err("sg table is wrong sizeo, expected %u, found %u nents\n",
565 rotated_size(a, b), vma->pages->nents);
566 err = -EINVAL;
567 goto out_object;
568 }
569
570 if (vma->node.size < vma->size) {
571 pr_err("VMA binding too small, expected %llu, found %llu\n",
572 vma->size, vma->node.size);
573 err = -EINVAL;
574 goto out_object;
575 }
576
577 if (vma->pages == obj->mm.pages) {
578 pr_err("VMA using unrotated object pages!\n");
579 err = -EINVAL;
580 goto out_object;
581 }
582
583 sg = vma->pages->sgl;
584 for (n = 0; n < ARRAY_SIZE(view.rotated.plane); n++) {
585 if (view.type == I915_GGTT_VIEW_ROTATED)
586 sg = assert_rotated(obj, &view.rotated, n, sg);
587 else
588 sg = assert_remapped(obj, &view.remapped, n, sg);
589 if (IS_ERR(sg)) {
590 pr_err("Inconsistent %s VMA pages for plane %d: [(%d, %d, %d, %d), (%d, %d, %d, %d)]\n",
591 view.type == I915_GGTT_VIEW_ROTATED ?
592 "rotated" : "remapped", n,
593 view.rotated.plane[0].width,
594 view.rotated.plane[0].height,
595 view.rotated.plane[0].stride,
596 view.rotated.plane[0].offset,
597 view.rotated.plane[1].width,
598 view.rotated.plane[1].height,
599 view.rotated.plane[1].stride,
600 view.rotated.plane[1].offset);
601 err = -EINVAL;
602 goto out_object;
603 }
604 }
605
606 i915_vma_unpin(vma);
607
608 cond_resched();
609 }
610 }
611 }
612 }
613 }
614
615 out_object:
616 i915_gem_object_put(obj);
617 out:
618 return err;
619 }
620
assert_partial(struct drm_i915_gem_object * obj,struct i915_vma * vma,unsigned long offset,unsigned long size)621 static bool assert_partial(struct drm_i915_gem_object *obj,
622 struct i915_vma *vma,
623 unsigned long offset,
624 unsigned long size)
625 {
626 struct sgt_iter sgt;
627 dma_addr_t dma;
628
629 for_each_sgt_daddr(dma, sgt, vma->pages) {
630 dma_addr_t src;
631
632 if (!size) {
633 pr_err("Partial scattergather list too long\n");
634 return false;
635 }
636
637 src = i915_gem_object_get_dma_address(obj, offset);
638 if (src != dma) {
639 pr_err("DMA mismatch for partial page offset %lu\n",
640 offset);
641 return false;
642 }
643
644 offset++;
645 size--;
646 }
647
648 return true;
649 }
650
assert_pin(struct i915_vma * vma,struct i915_ggtt_view * view,u64 size,const char * name)651 static bool assert_pin(struct i915_vma *vma,
652 struct i915_ggtt_view *view,
653 u64 size,
654 const char *name)
655 {
656 bool ok = true;
657
658 if (vma->size != size) {
659 pr_err("(%s) VMA is wrong size, expected %llu, found %llu\n",
660 name, size, vma->size);
661 ok = false;
662 }
663
664 if (vma->node.size < vma->size) {
665 pr_err("(%s) VMA binding too small, expected %llu, found %llu\n",
666 name, vma->size, vma->node.size);
667 ok = false;
668 }
669
670 if (view && view->type != I915_GGTT_VIEW_NORMAL) {
671 if (memcmp(&vma->ggtt_view, view, sizeof(*view))) {
672 pr_err("(%s) VMA mismatch upon creation!\n",
673 name);
674 ok = false;
675 }
676
677 if (vma->pages == vma->obj->mm.pages) {
678 pr_err("(%s) VMA using original object pages!\n",
679 name);
680 ok = false;
681 }
682 } else {
683 if (vma->ggtt_view.type != I915_GGTT_VIEW_NORMAL) {
684 pr_err("Not the normal ggtt view! Found %d\n",
685 vma->ggtt_view.type);
686 ok = false;
687 }
688
689 if (vma->pages != vma->obj->mm.pages) {
690 pr_err("VMA not using object pages!\n");
691 ok = false;
692 }
693 }
694
695 return ok;
696 }
697
igt_vma_partial(void * arg)698 static int igt_vma_partial(void *arg)
699 {
700 struct i915_ggtt *ggtt = arg;
701 struct i915_address_space *vm = &ggtt->vm;
702 const unsigned int npages = 1021; /* prime! */
703 struct drm_i915_gem_object *obj;
704 const struct phase {
705 const char *name;
706 } phases[] = {
707 { "create" },
708 { "lookup" },
709 { },
710 }, *p;
711 unsigned int sz, offset;
712 struct i915_vma *vma;
713 int err = -ENOMEM;
714
715 /* Create lots of different VMA for the object and check that
716 * we are returned the same VMA when we later request the same range.
717 */
718
719 obj = i915_gem_object_create_internal(vm->i915, npages * PAGE_SIZE);
720 if (IS_ERR(obj))
721 goto out;
722
723 for (p = phases; p->name; p++) { /* exercise both create/lookup */
724 unsigned int count, nvma;
725
726 nvma = 0;
727 for_each_prime_number_from(sz, 1, npages) {
728 for_each_prime_number_from(offset, 0, npages - sz) {
729 struct i915_ggtt_view view;
730
731 view.type = I915_GGTT_VIEW_PARTIAL;
732 view.partial.offset = offset;
733 view.partial.size = sz;
734
735 if (sz == npages)
736 view.type = I915_GGTT_VIEW_NORMAL;
737
738 vma = checked_vma_instance(obj, vm, &view);
739 if (IS_ERR(vma)) {
740 err = PTR_ERR(vma);
741 goto out_object;
742 }
743
744 err = i915_vma_pin(vma, 0, 0, PIN_GLOBAL);
745 if (err)
746 goto out_object;
747
748 if (!assert_pin(vma, &view, sz*PAGE_SIZE, p->name)) {
749 pr_err("(%s) Inconsistent partial pinning for (offset=%d, size=%d)\n",
750 p->name, offset, sz);
751 err = -EINVAL;
752 goto out_object;
753 }
754
755 if (!assert_partial(obj, vma, offset, sz)) {
756 pr_err("(%s) Inconsistent partial pages for (offset=%d, size=%d)\n",
757 p->name, offset, sz);
758 err = -EINVAL;
759 goto out_object;
760 }
761
762 i915_vma_unpin(vma);
763 nvma++;
764
765 cond_resched();
766 }
767 }
768
769 count = 0;
770 list_for_each_entry(vma, &obj->vma.list, obj_link)
771 count++;
772 if (count != nvma) {
773 pr_err("(%s) All partial vma were not recorded on the obj->vma_list: found %u, expected %u\n",
774 p->name, count, nvma);
775 err = -EINVAL;
776 goto out_object;
777 }
778
779 /* Check that we did create the whole object mapping */
780 vma = checked_vma_instance(obj, vm, NULL);
781 if (IS_ERR(vma)) {
782 err = PTR_ERR(vma);
783 goto out_object;
784 }
785
786 err = i915_vma_pin(vma, 0, 0, PIN_GLOBAL);
787 if (err)
788 goto out_object;
789
790 if (!assert_pin(vma, NULL, obj->base.size, p->name)) {
791 pr_err("(%s) inconsistent full pin\n", p->name);
792 err = -EINVAL;
793 goto out_object;
794 }
795
796 i915_vma_unpin(vma);
797
798 count = 0;
799 list_for_each_entry(vma, &obj->vma.list, obj_link)
800 count++;
801 if (count != nvma) {
802 pr_err("(%s) allocated an extra full vma!\n", p->name);
803 err = -EINVAL;
804 goto out_object;
805 }
806 }
807
808 out_object:
809 i915_gem_object_put(obj);
810 out:
811 return err;
812 }
813
i915_vma_mock_selftests(void)814 int i915_vma_mock_selftests(void)
815 {
816 static const struct i915_subtest tests[] = {
817 SUBTEST(igt_vma_create),
818 SUBTEST(igt_vma_pin1),
819 SUBTEST(igt_vma_rotate_remap),
820 SUBTEST(igt_vma_partial),
821 };
822 struct drm_i915_private *i915;
823 struct i915_ggtt *ggtt;
824 int err;
825
826 i915 = mock_gem_device();
827 if (!i915)
828 return -ENOMEM;
829
830 ggtt = kmalloc(sizeof(*ggtt), GFP_KERNEL);
831 if (!ggtt) {
832 err = -ENOMEM;
833 goto out_put;
834 }
835 mock_init_ggtt(i915, ggtt);
836
837 err = i915_subtests(tests, ggtt);
838
839 mock_device_flush(i915);
840 i915_gem_drain_freed_objects(i915);
841 mock_fini_ggtt(ggtt);
842 kfree(ggtt);
843 out_put:
844 mock_destroy_device(i915);
845 return err;
846 }
847
igt_vma_remapped_gtt(void * arg)848 static int igt_vma_remapped_gtt(void *arg)
849 {
850 struct drm_i915_private *i915 = arg;
851 const struct intel_remapped_plane_info planes[] = {
852 { .width = 1, .height = 1, .stride = 1 },
853 { .width = 2, .height = 2, .stride = 2 },
854 { .width = 4, .height = 4, .stride = 4 },
855 { .width = 8, .height = 8, .stride = 8 },
856
857 { .width = 3, .height = 5, .stride = 3 },
858 { .width = 3, .height = 5, .stride = 4 },
859 { .width = 3, .height = 5, .stride = 5 },
860
861 { .width = 5, .height = 3, .stride = 5 },
862 { .width = 5, .height = 3, .stride = 7 },
863 { .width = 5, .height = 3, .stride = 9 },
864
865 { .width = 4, .height = 6, .stride = 6 },
866 { .width = 6, .height = 4, .stride = 6 },
867 { }
868 }, *p;
869 enum i915_ggtt_view_type types[] = {
870 I915_GGTT_VIEW_ROTATED,
871 I915_GGTT_VIEW_REMAPPED,
872 0,
873 }, *t;
874 struct drm_i915_gem_object *obj;
875 intel_wakeref_t wakeref;
876 int err = 0;
877
878 obj = i915_gem_object_create_internal(i915, 10 * 10 * PAGE_SIZE);
879 if (IS_ERR(obj))
880 return PTR_ERR(obj);
881
882 wakeref = intel_runtime_pm_get(&i915->runtime_pm);
883
884 for (t = types; *t; t++) {
885 for (p = planes; p->width; p++) {
886 struct i915_ggtt_view view = {
887 .type = *t,
888 .rotated.plane[0] = *p,
889 };
890 struct i915_vma *vma;
891 u32 __iomem *map;
892 unsigned int x, y;
893 int err;
894
895 i915_gem_object_lock(obj, NULL);
896 err = i915_gem_object_set_to_gtt_domain(obj, true);
897 i915_gem_object_unlock(obj);
898 if (err)
899 goto out;
900
901 vma = i915_gem_object_ggtt_pin(obj, &view, 0, 0, PIN_MAPPABLE);
902 if (IS_ERR(vma)) {
903 err = PTR_ERR(vma);
904 goto out;
905 }
906
907 GEM_BUG_ON(vma->ggtt_view.type != *t);
908
909 map = i915_vma_pin_iomap(vma);
910 i915_vma_unpin(vma);
911 if (IS_ERR(map)) {
912 err = PTR_ERR(map);
913 goto out;
914 }
915
916 for (y = 0 ; y < p->height; y++) {
917 for (x = 0 ; x < p->width; x++) {
918 unsigned int offset;
919 u32 val = y << 16 | x;
920
921 if (*t == I915_GGTT_VIEW_ROTATED)
922 offset = (x * p->height + y) * PAGE_SIZE;
923 else
924 offset = (y * p->width + x) * PAGE_SIZE;
925
926 iowrite32(val, &map[offset / sizeof(*map)]);
927 }
928 }
929
930 i915_vma_unpin_iomap(vma);
931
932 vma = i915_gem_object_ggtt_pin(obj, NULL, 0, 0, PIN_MAPPABLE);
933 if (IS_ERR(vma)) {
934 err = PTR_ERR(vma);
935 goto out;
936 }
937
938 GEM_BUG_ON(vma->ggtt_view.type != I915_GGTT_VIEW_NORMAL);
939
940 map = i915_vma_pin_iomap(vma);
941 i915_vma_unpin(vma);
942 if (IS_ERR(map)) {
943 err = PTR_ERR(map);
944 goto out;
945 }
946
947 for (y = 0 ; y < p->height; y++) {
948 for (x = 0 ; x < p->width; x++) {
949 unsigned int offset, src_idx;
950 u32 exp = y << 16 | x;
951 u32 val;
952
953 if (*t == I915_GGTT_VIEW_ROTATED)
954 src_idx = rotated_index(&view.rotated, 0, x, y);
955 else
956 src_idx = remapped_index(&view.remapped, 0, x, y);
957 offset = src_idx * PAGE_SIZE;
958
959 val = ioread32(&map[offset / sizeof(*map)]);
960 if (val != exp) {
961 pr_err("%s VMA write test failed, expected 0x%x, found 0x%x\n",
962 *t == I915_GGTT_VIEW_ROTATED ? "Rotated" : "Remapped",
963 val, exp);
964 i915_vma_unpin_iomap(vma);
965 goto out;
966 }
967 }
968 }
969 i915_vma_unpin_iomap(vma);
970
971 cond_resched();
972 }
973 }
974
975 out:
976 intel_runtime_pm_put(&i915->runtime_pm, wakeref);
977 i915_gem_object_put(obj);
978
979 return err;
980 }
981
i915_vma_live_selftests(struct drm_i915_private * i915)982 int i915_vma_live_selftests(struct drm_i915_private *i915)
983 {
984 static const struct i915_subtest tests[] = {
985 SUBTEST(igt_vma_remapped_gtt),
986 };
987
988 return i915_subtests(tests, i915);
989 }
990
