drivers/gpu/drm/i915/selftests/i915_vma.c

   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 "../i915_selftest.h"
  28
  29 #include "mock_gem_device.h"
  30 #include "mock_context.h"
  31
  32 static bool assert_vma(struct i915_vma *vma,
  33                        struct drm_i915_gem_object *obj,
  34                        struct i915_gem_context *ctx)
  35 {
  36         bool ok = true;
  37
  38         if (vma->vm != &ctx->ppgtt->base) {
  39                 pr_err("VMA created with wrong VM\n");
  40                 ok = false;
  41         }
  42
  43         if (vma->size != obj->base.size) {
  44                 pr_err("VMA created with wrong size, found %llu, expected %zu\n",
  45                        vma->size, obj->base.size);
  46                 ok = false;
  47         }
  48
  49         if (vma->ggtt_view.type != I915_GGTT_VIEW_NORMAL) {
  50                 pr_err("VMA created with wrong type [%d]\n",
  51                        vma->ggtt_view.type);
  52                 ok = false;
  53         }
  54
  55         return ok;
  56 }
  57
  58 static struct i915_vma *
  59 checked_vma_instance(struct drm_i915_gem_object *obj,
  60                      struct i915_address_space *vm,
  61                      struct i915_ggtt_view *view)
  62 {
  63         struct i915_vma *vma;
  64         bool ok = true;
  65
  66         vma = i915_vma_instance(obj, vm, view);
  67         if (IS_ERR(vma))
  68                 return vma;
  69
  70         /* Manual checks, will be reinforced by i915_vma_compare! */
  71         if (vma->vm != vm) {
  72                 pr_err("VMA's vm [%p] does not match request [%p]\n",
  73                        vma->vm, vm);
  74                 ok = false;
  75         }
  76
  77         if (i915_is_ggtt(vm) != i915_vma_is_ggtt(vma)) {
  78                 pr_err("VMA ggtt status [%d] does not match parent [%d]\n",
  79                        i915_vma_is_ggtt(vma), i915_is_ggtt(vm));
  80                 ok = false;
  81         }
  82
  83         if (i915_vma_compare(vma, vm, view)) {
  84                 pr_err("i915_vma_compare failed with create parmaters!\n");
  85                 return ERR_PTR(-EINVAL);
  86         }
  87
  88         if (i915_vma_compare(vma, vma->vm,
  89                              i915_vma_is_ggtt(vma) ? &vma->ggtt_view : NULL)) {
  90                 pr_err("i915_vma_compare failed with itself\n");
  91                 return ERR_PTR(-EINVAL);
  92         }
  93
  94         if (!ok) {
  95                 pr_err("i915_vma_compare failed to detect the difference!\n");
  96                 return ERR_PTR(-EINVAL);
  97         }
  98
  99         return vma;
 100 }
 101
 102 static int create_vmas(struct drm_i915_private *i915,
 103                        struct list_head *objects,
 104                        struct list_head *contexts)
 105 {
 106         struct drm_i915_gem_object *obj;
 107         struct i915_gem_context *ctx;
 108         int pinned;
 109
 110         list_for_each_entry(obj, objects, st_link) {
 111                 for (pinned = 0; pinned <= 1; pinned++) {
 112                         list_for_each_entry(ctx, contexts, link) {
 113                                 struct i915_address_space *vm =
 114                                         &ctx->ppgtt->base;
 115                                 struct i915_vma *vma;
 116                                 int err;
 117
 118                                 vma = checked_vma_instance(obj, vm, NULL);
 119                                 if (IS_ERR(vma))
 120                                         return PTR_ERR(vma);
 121
 122                                 if (!assert_vma(vma, obj, ctx)) {
 123                                         pr_err("VMA lookup/create failed\n");
 124                                         return -EINVAL;
 125                                 }
 126
 127                                 if (!pinned) {
 128                                         err = i915_vma_pin(vma, 0, 0, PIN_USER);
 129                                         if (err) {
 130                                                 pr_err("Failed to pin VMA\n");
 131                                                 return err;
 132                                         }
 133                                 } else {
 134                                         i915_vma_unpin(vma);
 135                                 }
 136                         }
 137                 }
 138         }
 139
 140         return 0;
 141 }
 142
 143 static int igt_vma_create(void *arg)
 144 {
 145         struct drm_i915_private *i915 = arg;
 146         struct drm_i915_gem_object *obj, *on;
 147         struct i915_gem_context *ctx, *cn;
 148         unsigned long num_obj, num_ctx;
 149         unsigned long no, nc;
 150         IGT_TIMEOUT(end_time);
 151         LIST_HEAD(contexts);
 152         LIST_HEAD(objects);
 153         int err;
 154
 155         /* Exercise creating many vma amonst many objections, checking the
 156          * vma creation and lookup routines.
 157          */
 158
 159         no = 0;
 160         for_each_prime_number(num_obj, ULONG_MAX - 1) {
 161                 for (; no < num_obj; no++) {
 162                         obj = i915_gem_object_create_internal(i915, PAGE_SIZE);
 163                         if (IS_ERR(obj))
 164                                 goto out;
 165
 166                         list_add(&obj->st_link, &objects);
 167                 }
 168
 169                 nc = 0;
 170                 for_each_prime_number(num_ctx, MAX_CONTEXT_HW_ID) {
 171                         for (; nc < num_ctx; nc++) {
 172                                 ctx = mock_context(i915, "mock");
 173                                 if (!ctx)
 174                                         goto out;
 175
 176                                 list_move(&ctx->link, &contexts);
 177                         }
 178
 179                         err = create_vmas(i915, &objects, &contexts);
 180                         if (err)
 181                                 goto out;
 182
 183                         if (igt_timeout(end_time,
 184                                         "%s timed out: after %lu objects in %lu contexts\n",
 185                                         __func__, no, nc))
 186                                 goto end;
 187                 }
 188
 189                 list_for_each_entry_safe(ctx, cn, &contexts, link)
 190                         mock_context_close(ctx);
 191         }
 192
 193 end:
 194         /* Final pass to lookup all created contexts */
 195         err = create_vmas(i915, &objects, &contexts);
 196 out:
 197         list_for_each_entry_safe(ctx, cn, &contexts, link)
 198                 mock_context_close(ctx);
 199
 200         list_for_each_entry_safe(obj, on, &objects, st_link)
 201                 i915_gem_object_put(obj);
 202         return err;
 203 }
 204
 205 struct pin_mode {
 206         u64 size;
 207         u64 flags;
 208         bool (*assert)(const struct i915_vma *,
 209                        const struct pin_mode *mode,
 210                        int result);
 211         const char *string;
 212 };
 213
 214 static bool assert_pin_valid(const struct i915_vma *vma,
 215                              const struct pin_mode *mode,
 216                              int result)
 217 {
 218         if (result)
 219                 return false;
 220
 221         if (i915_vma_misplaced(vma, mode->size, 0, mode->flags))
 222                 return false;
 223
 224         return true;
 225 }
 226
 227 __maybe_unused
 228 static bool assert_pin_e2big(const struct i915_vma *vma,
 229                              const struct pin_mode *mode,
 230                              int result)
 231 {
 232         return result == -E2BIG;
 233 }
 234
 235 __maybe_unused
 236 static bool assert_pin_enospc(const struct i915_vma *vma,
 237                               const struct pin_mode *mode,
 238                               int result)
 239 {
 240         return result == -ENOSPC;
 241 }
 242
 243 __maybe_unused
 244 static bool assert_pin_einval(const struct i915_vma *vma,
 245                               const struct pin_mode *mode,
 246                               int result)
 247 {
 248         return result == -EINVAL;
 249 }
 250
 251 static int igt_vma_pin1(void *arg)
 252 {
 253         struct drm_i915_private *i915 = arg;
 254         const struct pin_mode modes[] = {
 255 #define VALID(sz, fl) { .size = (sz), .flags = (fl), .assert = assert_pin_valid, .string = #sz ", " #fl ", (valid) " }
 256 #define __INVALID(sz, fl, check, eval) { .size = (sz), .flags = (fl), .assert = (check), .string = #sz ", " #fl ", (invalid " #eval ")" }
 257 #define INVALID(sz, fl) __INVALID(sz, fl, assert_pin_einval, EINVAL)
 258 #define TOOBIG(sz, fl) __INVALID(sz, fl, assert_pin_e2big, E2BIG)
 259 #define NOSPACE(sz, fl) __INVALID(sz, fl, assert_pin_enospc, ENOSPC)
 260                 VALID(0, PIN_GLOBAL),
 261                 VALID(0, PIN_GLOBAL | PIN_MAPPABLE),
 262
 263                 VALID(0, PIN_GLOBAL | PIN_OFFSET_BIAS | 4096),
 264                 VALID(0, PIN_GLOBAL | PIN_OFFSET_BIAS | 8192),
 265                 VALID(0, PIN_GLOBAL | PIN_OFFSET_BIAS | (i915->ggtt.mappable_end - 4096)),
 266                 VALID(0, PIN_GLOBAL | PIN_MAPPABLE | PIN_OFFSET_BIAS | (i915->ggtt.mappable_end - 4096)),
 267                 VALID(0, PIN_GLOBAL | PIN_OFFSET_BIAS | (i915->ggtt.base.total - 4096)),
 268
 269                 VALID(0, PIN_GLOBAL | PIN_MAPPABLE | PIN_OFFSET_FIXED | (i915->ggtt.mappable_end - 4096)),
 270                 INVALID(0, PIN_GLOBAL | PIN_MAPPABLE | PIN_OFFSET_FIXED | i915->ggtt.mappable_end),
 271                 VALID(0, PIN_GLOBAL | PIN_OFFSET_FIXED | (i915->ggtt.base.total - 4096)),
 272                 INVALID(0, PIN_GLOBAL | PIN_OFFSET_FIXED | i915->ggtt.base.total),
 273                 INVALID(0, PIN_GLOBAL | PIN_OFFSET_FIXED | round_down(U64_MAX, PAGE_SIZE)),
 274
 275                 VALID(4096, PIN_GLOBAL),
 276                 VALID(8192, PIN_GLOBAL),
 277                 VALID(i915->ggtt.mappable_end - 4096, PIN_GLOBAL | PIN_MAPPABLE),
 278                 VALID(i915->ggtt.mappable_end, PIN_GLOBAL | PIN_MAPPABLE),
 279                 TOOBIG(i915->ggtt.mappable_end + 4096, PIN_GLOBAL | PIN_MAPPABLE),
 280                 VALID(i915->ggtt.base.total - 4096, PIN_GLOBAL),
 281                 VALID(i915->ggtt.base.total, PIN_GLOBAL),
 282                 TOOBIG(i915->ggtt.base.total + 4096, PIN_GLOBAL),
 283                 TOOBIG(round_down(U64_MAX, PAGE_SIZE), PIN_GLOBAL),
 284                 INVALID(8192, PIN_GLOBAL | PIN_MAPPABLE | PIN_OFFSET_FIXED | (i915->ggtt.mappable_end - 4096)),
 285                 INVALID(8192, PIN_GLOBAL | PIN_OFFSET_FIXED | (i915->ggtt.base.total - 4096)),
 286                 INVALID(8192, PIN_GLOBAL | PIN_OFFSET_FIXED | (round_down(U64_MAX, PAGE_SIZE) - 4096)),
 287
 288                 VALID(8192, PIN_GLOBAL | PIN_OFFSET_BIAS | (i915->ggtt.mappable_end - 4096)),
 289
 290 #if !IS_ENABLED(CONFIG_DRM_I915_DEBUG_GEM)
 291                 /* Misusing BIAS is a programming error (it is not controllable
 292                  * from userspace) so when debugging is enabled, it explodes.
 293                  * However, the tests are still quite interesting for checking
 294                  * variable start, end and size.
 295                  */
 296                 NOSPACE(0, PIN_GLOBAL | PIN_MAPPABLE | PIN_OFFSET_BIAS | i915->ggtt.mappable_end),
 297                 NOSPACE(0, PIN_GLOBAL | PIN_OFFSET_BIAS | i915->ggtt.base.total),
 298                 NOSPACE(8192, PIN_GLOBAL | PIN_MAPPABLE | PIN_OFFSET_BIAS | (i915->ggtt.mappable_end - 4096)),
 299                 NOSPACE(8192, PIN_GLOBAL | PIN_OFFSET_BIAS | (i915->ggtt.base.total - 4096)),
 300 #endif
 301                 { },
 302 #undef NOSPACE
 303 #undef TOOBIG
 304 #undef INVALID
 305 #undef __INVALID
 306 #undef VALID
 307         }, *m;
 308         struct drm_i915_gem_object *obj;
 309         struct i915_vma *vma;
 310         int err = -EINVAL;
 311
 312         /* Exercise all the weird and wonderful i915_vma_pin requests,
 313          * focusing on error handling of boundary conditions.
 314          */
 315
 316         GEM_BUG_ON(!drm_mm_clean(&i915->ggtt.base.mm));
 317
 318         obj = i915_gem_object_create_internal(i915, PAGE_SIZE);
 319         if (IS_ERR(obj))
 320                 return PTR_ERR(obj);
 321
 322         vma = checked_vma_instance(obj, &i915->ggtt.base, NULL);
 323         if (IS_ERR(vma))
 324                 goto out;
 325
 326         for (m = modes; m->assert; m++) {
 327                 err = i915_vma_pin(vma, m->size, 0, m->flags);
 328                 if (!m->assert(vma, m, err)) {
 329                         pr_err("%s to pin single page into GGTT with mode[%d:%s]: size=%llx flags=%llx, err=%d\n",
 330                                m->assert == assert_pin_valid ? "Failed" : "Unexpectedly succeeded",
 331                                (int)(m - modes), m->string, m->size, m->flags,
 332                                err);
 333                         if (!err)
 334                                 i915_vma_unpin(vma);
 335                         err = -EINVAL;
 336                         goto out;
 337                 }
 338
 339                 if (!err) {
 340                         i915_vma_unpin(vma);
 341                         err = i915_vma_unbind(vma);
 342                         if (err) {
 343                                 pr_err("Failed to unbind single page from GGTT, err=%d\n", err);
 344                                 goto out;
 345                         }
 346                 }
 347         }
 348
 349         err = 0;
 350 out:
 351         i915_gem_object_put(obj);
 352         return err;
 353 }
 354
 355 static unsigned long rotated_index(const struct intel_rotation_info *r,
 356                                    unsigned int n,
 357                                    unsigned int x,
 358                                    unsigned int y)
 359 {
 360         return (r->plane[n].stride * (r->plane[n].height - y - 1) +
 361                 r->plane[n].offset + x);
 362 }
 363
 364 static struct scatterlist *
 365 assert_rotated(struct drm_i915_gem_object *obj,
 366                const struct intel_rotation_info *r, unsigned int n,
 367                struct scatterlist *sg)
 368 {
 369         unsigned int x, y;
 370
 371         for (x = 0; x < r->plane[n].width; x++) {
 372                 for (y = 0; y < r->plane[n].height; y++) {
 373                         unsigned long src_idx;
 374                         dma_addr_t src;
 375
 376                         if (!sg) {
 377                                 pr_err("Invalid sg table: too short at plane %d, (%d, %d)!\n",
 378                                        n, x, y);
 379                                 return ERR_PTR(-EINVAL);
 380                         }
 381
 382                         src_idx = rotated_index(r, n, x, y);
 383                         src = i915_gem_object_get_dma_address(obj, src_idx);
 384
 385                         if (sg_dma_len(sg) != PAGE_SIZE) {
 386                                 pr_err("Invalid sg.length, found %d, expected %lu for rotated page (%d, %d) [src index %lu]\n",
 387                                        sg_dma_len(sg), PAGE_SIZE,
 388                                        x, y, src_idx);
 389                                 return ERR_PTR(-EINVAL);
 390                         }
 391
 392                         if (sg_dma_address(sg) != src) {
 393                                 pr_err("Invalid address for rotated page (%d, %d) [src index %lu]\n",
 394                                        x, y, src_idx);
 395                                 return ERR_PTR(-EINVAL);
 396                         }
 397
 398                         sg = sg_next(sg);
 399                 }
 400         }
 401
 402         return sg;
 403 }
 404
 405 static unsigned int rotated_size(const struct intel_rotation_plane_info *a,
 406                                  const struct intel_rotation_plane_info *b)
 407 {
 408         return a->width * a->height + b->width * b->height;
 409 }
 410
 411 static int igt_vma_rotate(void *arg)
 412 {
 413         struct drm_i915_private *i915 = arg;
 414         struct i915_address_space *vm = &i915->ggtt.base;
 415         struct drm_i915_gem_object *obj;
 416         const struct intel_rotation_plane_info planes[] = {
 417                 { .width = 1, .height = 1, .stride = 1 },
 418                 { .width = 2, .height = 2, .stride = 2 },
 419                 { .width = 4, .height = 4, .stride = 4 },
 420                 { .width = 8, .height = 8, .stride = 8 },
 421
 422                 { .width = 3, .height = 5, .stride = 3 },
 423                 { .width = 3, .height = 5, .stride = 4 },
 424                 { .width = 3, .height = 5, .stride = 5 },
 425
 426                 { .width = 5, .height = 3, .stride = 5 },
 427                 { .width = 5, .height = 3, .stride = 7 },
 428                 { .width = 5, .height = 3, .stride = 9 },
 429
 430                 { .width = 4, .height = 6, .stride = 6 },
 431                 { .width = 6, .height = 4, .stride = 6 },
 432                 { }
 433         }, *a, *b;
 434         const unsigned int max_pages = 64;
 435         int err = -ENOMEM;
 436
 437         /* Create VMA for many different combinations of planes and check
 438          * that the page layout within the rotated VMA match our expectations.
 439          */
 440
 441         obj = i915_gem_object_create_internal(i915, max_pages * PAGE_SIZE);
 442         if (IS_ERR(obj))
 443                 goto out;
 444
 445         for (a = planes; a->width; a++) {
 446                 for (b = planes + ARRAY_SIZE(planes); b-- != planes; ) {
 447                         struct i915_ggtt_view view;
 448                         unsigned int n, max_offset;
 449
 450                         max_offset = max(a->stride * a->height,
 451                                          b->stride * b->height);
 452                         GEM_BUG_ON(max_offset > max_pages);
 453                         max_offset = max_pages - max_offset;
 454
 455                         view.type = I915_GGTT_VIEW_ROTATED;
 456                         view.rotated.plane[0] = *a;
 457                         view.rotated.plane[1] = *b;
 458
 459                         for_each_prime_number_from(view.rotated.plane[0].offset, 0, max_offset) {
 460                                 for_each_prime_number_from(view.rotated.plane[1].offset, 0, max_offset) {
 461                                         struct scatterlist *sg;
 462                                         struct i915_vma *vma;
 463
 464                                         vma = checked_vma_instance(obj, vm, &view);
 465                                         if (IS_ERR(vma)) {
 466                                                 err = PTR_ERR(vma);
 467                                                 goto out_object;
 468                                         }
 469
 470                                         err = i915_vma_pin(vma, 0, 0, PIN_GLOBAL);
 471                                         if (err) {
 472                                                 pr_err("Failed to pin VMA, err=%d\n", err);
 473                                                 goto out_object;
 474                                         }
 475
 476                                         if (vma->size != rotated_size(a, b) * PAGE_SIZE) {
 477                                                 pr_err("VMA is wrong size, expected %lu, found %llu\n",
 478                                                        PAGE_SIZE * rotated_size(a, b), vma->size);
 479                                                 err = -EINVAL;
 480                                                 goto out_object;
 481                                         }
 482
 483                                         if (vma->pages->nents != rotated_size(a, b)) {
 484                                                 pr_err("sg table is wrong sizeo, expected %u, found %u nents\n",
 485                                                        rotated_size(a, b), vma->pages->nents);
 486                                                 err = -EINVAL;
 487                                                 goto out_object;
 488                                         }
 489
 490                                         if (vma->node.size < vma->size) {
 491                                                 pr_err("VMA binding too small, expected %llu, found %llu\n",
 492                                                        vma->size, vma->node.size);
 493                                                 err = -EINVAL;
 494                                                 goto out_object;
 495                                         }
 496
 497                                         if (vma->pages == obj->mm.pages) {
 498                                                 pr_err("VMA using unrotated object pages!\n");
 499                                                 err = -EINVAL;
 500                                                 goto out_object;
 501                                         }
 502
 503                                         sg = vma->pages->sgl;
 504                                         for (n = 0; n < ARRAY_SIZE(view.rotated.plane); n++) {
 505                                                 sg = assert_rotated(obj, &view.rotated, n, sg);
 506                                                 if (IS_ERR(sg)) {
 507                                                         pr_err("Inconsistent VMA pages for plane %d: [(%d, %d, %d, %d), (%d, %d, %d, %d)]\n", n,
 508                                                                view.rotated.plane[0].width,
 509                                                                view.rotated.plane[0].height,
 510                                                                view.rotated.plane[0].stride,
 511                                                                view.rotated.plane[0].offset,
 512                                                                view.rotated.plane[1].width,
 513                                                                view.rotated.plane[1].height,
 514                                                                view.rotated.plane[1].stride,
 515                                                                view.rotated.plane[1].offset);
 516                                                         err = -EINVAL;
 517                                                         goto out_object;
 518                                                 }
 519                                         }
 520
 521                                         i915_vma_unpin(vma);
 522                                 }
 523                         }
 524                 }
 525         }
 526
 527 out_object:
 528         i915_gem_object_put(obj);
 529 out:
 530         return err;
 531 }
 532
 533 static bool assert_partial(struct drm_i915_gem_object *obj,
 534                            struct i915_vma *vma,
 535                            unsigned long offset,
 536                            unsigned long size)
 537 {
 538         struct sgt_iter sgt;
 539         dma_addr_t dma;
 540
 541         for_each_sgt_dma(dma, sgt, vma->pages) {
 542                 dma_addr_t src;
 543
 544                 if (!size) {
 545                         pr_err("Partial scattergather list too long\n");
 546                         return false;
 547                 }
 548
 549                 src = i915_gem_object_get_dma_address(obj, offset);
 550                 if (src != dma) {
 551                         pr_err("DMA mismatch for partial page offset %lu\n",
 552                                offset);
 553                         return false;
 554                 }
 555
 556                 offset++;
 557                 size--;
 558         }
 559
 560         return true;
 561 }
 562
 563 static bool assert_pin(struct i915_vma *vma,
 564                        struct i915_ggtt_view *view,
 565                        u64 size,
 566                        const char *name)
 567 {
 568         bool ok = true;
 569
 570         if (vma->size != size) {
 571                 pr_err("(%s) VMA is wrong size, expected %llu, found %llu\n",
 572                        name, size, vma->size);
 573                 ok = false;
 574         }
 575
 576         if (vma->node.size < vma->size) {
 577                 pr_err("(%s) VMA binding too small, expected %llu, found %llu\n",
 578                        name, vma->size, vma->node.size);
 579                 ok = false;
 580         }
 581
 582         if (view && view->type != I915_GGTT_VIEW_NORMAL) {
 583                 if (memcmp(&vma->ggtt_view, view, sizeof(*view))) {
 584                         pr_err("(%s) VMA mismatch upon creation!\n",
 585                                name);
 586                         ok = false;
 587                 }
 588
 589                 if (vma->pages == vma->obj->mm.pages) {
 590                         pr_err("(%s) VMA using original object pages!\n",
 591                                name);
 592                         ok = false;
 593                 }
 594         } else {
 595                 if (vma->ggtt_view.type != I915_GGTT_VIEW_NORMAL) {
 596                         pr_err("Not the normal ggtt view! Found %d\n",
 597                                vma->ggtt_view.type);
 598                         ok = false;
 599                 }
 600
 601                 if (vma->pages != vma->obj->mm.pages) {
 602                         pr_err("VMA not using object pages!\n");
 603                         ok = false;
 604                 }
 605         }
 606
 607         return ok;
 608 }
 609
 610 static int igt_vma_partial(void *arg)
 611 {
 612         struct drm_i915_private *i915 = arg;
 613         struct i915_address_space *vm = &i915->ggtt.base;
 614         const unsigned int npages = 1021; /* prime! */
 615         struct drm_i915_gem_object *obj;
 616         const struct phase {
 617                 const char *name;
 618         } phases[] = {
 619                 { "create" },
 620                 { "lookup" },
 621                 { },
 622         }, *p;
 623         unsigned int sz, offset;
 624         struct i915_vma *vma;
 625         int err = -ENOMEM;
 626
 627         /* Create lots of different VMA for the object and check that
 628          * we are returned the same VMA when we later request the same range.
 629          */
 630
 631         obj = i915_gem_object_create_internal(i915, npages*PAGE_SIZE);
 632         if (IS_ERR(obj))
 633                 goto out;
 634
 635         for (p = phases; p->name; p++) { /* exercise both create/lookup */
 636                 unsigned int count, nvma;
 637
 638                 nvma = 0;
 639                 for_each_prime_number_from(sz, 1, npages) {
 640                         for_each_prime_number_from(offset, 0, npages - sz) {
 641                                 struct i915_ggtt_view view;
 642
 643                                 view.type = I915_GGTT_VIEW_PARTIAL;
 644                                 view.partial.offset = offset;
 645                                 view.partial.size = sz;
 646
 647                                 if (sz == npages)
 648                                         view.type = I915_GGTT_VIEW_NORMAL;
 649
 650                                 vma = checked_vma_instance(obj, vm, &view);
 651                                 if (IS_ERR(vma)) {
 652                                         err = PTR_ERR(vma);
 653                                         goto out_object;
 654                                 }
 655
 656                                 err = i915_vma_pin(vma, 0, 0, PIN_GLOBAL);
 657                                 if (err)
 658                                         goto out_object;
 659
 660                                 if (!assert_pin(vma, &view, sz*PAGE_SIZE, p->name)) {
 661                                         pr_err("(%s) Inconsistent partial pinning for (offset=%d, size=%d)\n",
 662                                                p->name, offset, sz);
 663                                         err = -EINVAL;
 664                                         goto out_object;
 665                                 }
 666
 667                                 if (!assert_partial(obj, vma, offset, sz)) {
 668                                         pr_err("(%s) Inconsistent partial pages for (offset=%d, size=%d)\n",
 669                                                p->name, offset, sz);
 670                                         err = -EINVAL;
 671                                         goto out_object;
 672                                 }
 673
 674                                 i915_vma_unpin(vma);
 675                                 nvma++;
 676                         }
 677                 }
 678
 679                 count = 0;
 680                 list_for_each_entry(vma, &obj->vma_list, obj_link)
 681                         count++;
 682                 if (count != nvma) {
 683                         pr_err("(%s) All partial vma were not recorded on the obj->vma_list: found %u, expected %u\n",
 684                                p->name, count, nvma);
 685                         err = -EINVAL;
 686                         goto out_object;
 687                 }
 688
 689                 /* Check that we did create the whole object mapping */
 690                 vma = checked_vma_instance(obj, vm, NULL);
 691                 if (IS_ERR(vma)) {
 692                         err = PTR_ERR(vma);
 693                         goto out_object;
 694                 }
 695
 696                 err = i915_vma_pin(vma, 0, 0, PIN_GLOBAL);
 697                 if (err)
 698                         goto out_object;
 699
 700                 if (!assert_pin(vma, NULL, obj->base.size, p->name)) {
 701                         pr_err("(%s) inconsistent full pin\n", p->name);
 702                         err = -EINVAL;
 703                         goto out_object;
 704                 }
 705
 706                 i915_vma_unpin(vma);
 707
 708                 count = 0;
 709                 list_for_each_entry(vma, &obj->vma_list, obj_link)
 710                         count++;
 711                 if (count != nvma) {
 712                         pr_err("(%s) allocated an extra full vma!\n", p->name);
 713                         err = -EINVAL;
 714                         goto out_object;
 715                 }
 716         }
 717
 718 out_object:
 719         i915_gem_object_put(obj);
 720 out:
 721         return err;
 722 }
 723
 724 int i915_vma_mock_selftests(void)
 725 {
 726         static const struct i915_subtest tests[] = {
 727                 SUBTEST(igt_vma_create),
 728                 SUBTEST(igt_vma_pin1),
 729                 SUBTEST(igt_vma_rotate),
 730                 SUBTEST(igt_vma_partial),
 731         };
 732         struct drm_i915_private *i915;
 733         int err;
 734
 735         i915 = mock_gem_device();
 736         if (!i915)
 737                 return -ENOMEM;
 738
 739         mutex_lock(&i915->drm.struct_mutex);
 740         err = i915_subtests(tests, i915);
 741         mutex_unlock(&i915->drm.struct_mutex);
 742
 743         drm_dev_unref(&i915->drm);
 744         return err;
 745 }
 746