tests/prime_nv_api.c

   1 /* wierd use of API tests */
   2
   3 /* test1- export buffer from intel, import same fd twice into nouveau,
   4    check handles match
   5    test2 - export buffer from intel, import fd once, close fd, try import again
   6    fail if it succeeds
   7    test3 - export buffer from intel, import twice on nouveau, check handle is the same
   8    test4 - export handle twice from intel, import into nouveau twice, check handle is the same
   9 */
  10
  11 #include <stdio.h>
  12 #include <stdlib.h>
  13 #include <unistd.h>
  14 #include <fcntl.h>
  15 #include <sys/stat.h>
  16
  17 #include "intel_bufmgr.h"
  18 #include "nouveau.h"
  19 #include "intel_io.h"
  20 #include "intel_batchbuffer.h"
  21 #include "drmtest.h"
  22 #include "intel_chipset.h"
  23
  24 #define BO_SIZE (256*1024)
  25
  26 int intel_fd = -1, intel_fd2 = -1, nouveau_fd = -1, nouveau_fd2 = -1;
  27 drm_intel_bufmgr *bufmgr;
  28 drm_intel_bufmgr *bufmgr2;
  29 struct nouveau_device *ndev, *ndev2;
  30 struct nouveau_client *nclient, *nclient2;
  31 uint32_t devid;
  32 struct intel_batchbuffer *intel_batch;
  33
  34 static void find_and_open_devices(void)
  35 {
  36         int i;
  37         char path[80];
  38         struct stat buf;
  39         FILE *fl;
  40         char vendor_id[8];
  41         int venid;
  42         for (i = 0; i < 9; i++) {
  43                 char *ret;
  44
  45                 sprintf(path, "/sys/class/drm/card%d/device/vendor", i);
  46                 if (stat(path, &buf))
  47                         break;
  48
  49                 fl = fopen(path, "r");
  50                 if (!fl)
  51                         break;
  52
  53                 ret = fgets(vendor_id, 8, fl);
  54                 igt_assert(ret);
  55                 fclose(fl);
  56
  57                 venid = strtoul(vendor_id, NULL, 16);
  58                 sprintf(path, "/dev/dri/card%d", i);
  59                 if (venid == 0x8086) {
  60                         intel_fd = open(path, O_RDWR);
  61                         igt_assert(intel_fd);
  62                         intel_fd2 = open(path, O_RDWR);
  63                         igt_assert(intel_fd2);
  64                 } else if (venid == 0x10de) {
  65                         nouveau_fd = open(path, O_RDWR);
  66                         igt_assert(nouveau_fd);
  67                         nouveau_fd2 = open(path, O_RDWR);
  68                         igt_assert(nouveau_fd2);
  69                 }
  70         }
  71 }
  72
  73 static void test_i915_nv_import_twice(void)
  74 {
  75         drm_intel_bo *test_intel_bo;
  76         int prime_fd;
  77         struct nouveau_bo *nvbo = NULL, *nvbo2 = NULL;
  78
  79         test_intel_bo = drm_intel_bo_alloc(bufmgr, "test bo", BO_SIZE, 4096);
  80
  81         igt_assert(drm_intel_bo_gem_export_to_prime(test_intel_bo, &prime_fd) == 0);
  82
  83         igt_assert(nouveau_bo_prime_handle_ref(ndev, prime_fd, &nvbo) == 0);
  84         igt_assert(nouveau_bo_prime_handle_ref(ndev2, prime_fd, &nvbo2) == 0);
  85         close(prime_fd);
  86
  87         nouveau_bo_ref(NULL, &nvbo2);
  88         nouveau_bo_ref(NULL, &nvbo);
  89         drm_intel_bo_unreference(test_intel_bo);
  90 }
  91
  92 static void test_i915_nv_import_twice_check_flink_name(void)
  93 {
  94         drm_intel_bo *test_intel_bo;
  95         int prime_fd;
  96         struct nouveau_bo *nvbo = NULL, *nvbo2 = NULL;
  97         uint32_t flink_name1, flink_name2;
  98
  99         test_intel_bo = drm_intel_bo_alloc(bufmgr, "test bo", BO_SIZE, 4096);
 100
 101         igt_assert(drm_intel_bo_gem_export_to_prime(test_intel_bo, &prime_fd) == 0);
 102
 103         igt_assert(nouveau_bo_prime_handle_ref(ndev, prime_fd, &nvbo) == 0);
 104         igt_assert(nouveau_bo_prime_handle_ref(ndev2, prime_fd, &nvbo2) == 0);
 105         close(prime_fd);
 106
 107         igt_assert(nouveau_bo_name_get(nvbo, &flink_name1) == 0);
 108         igt_assert(nouveau_bo_name_get(nvbo2, &flink_name2) == 0);
 109
 110         igt_assert(flink_name1 == flink_name2);
 111
 112         nouveau_bo_ref(NULL, &nvbo2);
 113         nouveau_bo_ref(NULL, &nvbo);
 114         drm_intel_bo_unreference(test_intel_bo);
 115 }
 116
 117 static void test_i915_nv_reimport_twice_check_flink_name(void)
 118 {
 119         drm_intel_bo *test_intel_bo;
 120         int prime_fd;
 121         struct nouveau_bo *nvbo = NULL, *nvbo2 = NULL;
 122         uint32_t flink_name1, flink_name2;
 123
 124         test_intel_bo = drm_intel_bo_alloc(bufmgr, "test bo", BO_SIZE, 4096);
 125
 126         igt_assert(drm_intel_bo_gem_export_to_prime(test_intel_bo, &prime_fd) == 0);
 127
 128         igt_assert(nouveau_bo_prime_handle_ref(ndev, prime_fd, &nvbo) == 0);
 129
 130         /* create a new dma-buf */
 131         close(prime_fd);
 132         igt_assert(drm_intel_bo_gem_export_to_prime(test_intel_bo, &prime_fd) == 0);
 133
 134         igt_assert(nouveau_bo_prime_handle_ref(ndev2, prime_fd, &nvbo2) == 0);
 135         close(prime_fd);
 136
 137         igt_assert(nouveau_bo_name_get(nvbo, &flink_name1) == 0);
 138         igt_assert(nouveau_bo_name_get(nvbo2, &flink_name2) == 0);
 139
 140         igt_assert(flink_name1 == flink_name2);
 141
 142         nouveau_bo_ref(NULL, &nvbo2);
 143         nouveau_bo_ref(NULL, &nvbo);
 144         drm_intel_bo_unreference(test_intel_bo);
 145 }
 146
 147 static void test_nv_i915_import_twice_check_flink_name(void)
 148 {
 149         drm_intel_bo *intel_bo = NULL, *intel_bo2 = NULL;
 150         int prime_fd;
 151         struct nouveau_bo *nvbo = NULL;
 152         uint32_t flink_name1, flink_name2;
 153
 154         igt_assert(nouveau_bo_new(ndev, NOUVEAU_BO_GART | NOUVEAU_BO_MAP,
 155                                   0, BO_SIZE, NULL, &nvbo) == 0);
 156
 157         igt_assert(nouveau_bo_set_prime(nvbo, &prime_fd) == 0);
 158
 159         intel_bo = drm_intel_bo_gem_create_from_prime(bufmgr, prime_fd, BO_SIZE);
 160         igt_assert(intel_bo);
 161
 162         intel_bo2 = drm_intel_bo_gem_create_from_prime(bufmgr2, prime_fd, BO_SIZE);
 163         igt_assert(intel_bo2);
 164         close(prime_fd);
 165
 166         igt_assert(drm_intel_bo_flink(intel_bo, &flink_name1) == 0);
 167         igt_assert(drm_intel_bo_flink(intel_bo2, &flink_name2) == 0);
 168
 169         igt_assert(flink_name1 == flink_name2);
 170
 171         nouveau_bo_ref(NULL, &nvbo);
 172         drm_intel_bo_unreference(intel_bo);
 173         drm_intel_bo_unreference(intel_bo2);
 174 }
 175
 176 static void test_nv_i915_reimport_twice_check_flink_name(void)
 177 {
 178         drm_intel_bo *intel_bo = NULL, *intel_bo2 = NULL;
 179         int prime_fd;
 180         struct nouveau_bo *nvbo = NULL;
 181         uint32_t flink_name1, flink_name2;
 182
 183         igt_assert(nouveau_bo_new(ndev, NOUVEAU_BO_GART | NOUVEAU_BO_MAP,
 184                                   0, BO_SIZE, NULL, &nvbo) == 0);
 185
 186         igt_assert(nouveau_bo_set_prime(nvbo, &prime_fd) == 0);
 187
 188         intel_bo = drm_intel_bo_gem_create_from_prime(bufmgr, prime_fd, BO_SIZE);
 189         igt_assert(intel_bo);
 190         close(prime_fd);
 191         igt_assert(nouveau_bo_set_prime(nvbo, &prime_fd) == 0);
 192
 193         intel_bo2 = drm_intel_bo_gem_create_from_prime(bufmgr2, prime_fd, BO_SIZE);
 194         igt_assert(intel_bo2);
 195         close(prime_fd);
 196
 197         igt_assert(drm_intel_bo_flink(intel_bo, &flink_name1) == 0);
 198         igt_assert(drm_intel_bo_flink(intel_bo2, &flink_name2) == 0);
 199
 200         igt_assert(flink_name1 == flink_name2);
 201
 202         nouveau_bo_ref(NULL, &nvbo);
 203         drm_intel_bo_unreference(intel_bo);
 204         drm_intel_bo_unreference(intel_bo2);
 205 }
 206
 207 static void test_i915_nv_import_vs_close(void)
 208 {
 209         drm_intel_bo *test_intel_bo;
 210         int prime_fd;
 211         struct nouveau_bo *nvbo = NULL, *nvbo2 = NULL;
 212
 213         test_intel_bo = drm_intel_bo_alloc(bufmgr, "test bo", BO_SIZE, 4096);
 214         igt_assert(test_intel_bo);
 215
 216         igt_assert(drm_intel_bo_gem_export_to_prime(test_intel_bo, &prime_fd) == 0);
 217
 218         igt_assert(nouveau_bo_prime_handle_ref(ndev, prime_fd, &nvbo) == 0);
 219         close(prime_fd);
 220         igt_assert(nouveau_bo_prime_handle_ref(ndev2, prime_fd, &nvbo2) < 0);
 221
 222         nouveau_bo_ref(NULL, &nvbo2);
 223         nouveau_bo_ref(NULL, &nvbo);
 224         drm_intel_bo_unreference(test_intel_bo);
 225 }
 226
 227 /* import handle twice on one driver */
 228 static void test_i915_nv_double_import(void)
 229 {
 230         drm_intel_bo *test_intel_bo;
 231         int prime_fd;
 232         struct nouveau_bo *nvbo = NULL, *nvbo2 = NULL;
 233
 234         test_intel_bo = drm_intel_bo_alloc(bufmgr, "test bo", BO_SIZE, 4096);
 235         igt_assert(test_intel_bo);
 236
 237         igt_assert(drm_intel_bo_gem_export_to_prime(test_intel_bo, &prime_fd) == 0);
 238
 239         igt_assert(nouveau_bo_prime_handle_ref(ndev, prime_fd, &nvbo) == 0);
 240         igt_assert(nouveau_bo_prime_handle_ref(ndev, prime_fd, &nvbo2) == 0);
 241         close(prime_fd);
 242
 243         igt_assert(nvbo->handle == nvbo2->handle);
 244
 245         nouveau_bo_ref(NULL, &nvbo2);
 246         nouveau_bo_ref(NULL, &nvbo);
 247         drm_intel_bo_unreference(test_intel_bo);
 248 }
 249
 250 /* export handle twice from one driver - import twice
 251    see if we get same object */
 252 static void test_i915_nv_double_export(void)
 253 {
 254         drm_intel_bo *test_intel_bo;
 255         int prime_fd, prime_fd2;
 256         struct nouveau_bo *nvbo = NULL, *nvbo2 = NULL;
 257
 258         test_intel_bo = drm_intel_bo_alloc(bufmgr, "test bo", BO_SIZE, 4096);
 259         igt_assert(test_intel_bo);
 260
 261         drm_intel_bo_gem_export_to_prime(test_intel_bo, &prime_fd);
 262
 263         drm_intel_bo_gem_export_to_prime(test_intel_bo, &prime_fd2);
 264
 265         igt_assert(nouveau_bo_prime_handle_ref(ndev, prime_fd, &nvbo) == 0);
 266         close(prime_fd);
 267         igt_assert(nouveau_bo_prime_handle_ref(ndev, prime_fd2, &nvbo2) == 0);
 268         close(prime_fd2);
 269
 270         igt_assert(nvbo->handle == nvbo2->handle);
 271
 272         nouveau_bo_ref(NULL, &nvbo2);
 273         nouveau_bo_ref(NULL, &nvbo);
 274         drm_intel_bo_unreference(test_intel_bo);
 275 }
 276
 277 /* export handle from intel driver - reimport to intel driver
 278    see if you get same object */
 279 static void test_i915_self_import(void)
 280 {
 281         drm_intel_bo *test_intel_bo, *test_intel_bo2;
 282         int prime_fd;
 283
 284         test_intel_bo = drm_intel_bo_alloc(bufmgr, "test bo", BO_SIZE, 4096);
 285
 286         drm_intel_bo_gem_export_to_prime(test_intel_bo, &prime_fd);
 287
 288         test_intel_bo2 = drm_intel_bo_gem_create_from_prime(bufmgr, prime_fd, BO_SIZE);
 289         close(prime_fd);
 290         igt_assert(test_intel_bo2);
 291
 292         igt_assert(test_intel_bo->handle == test_intel_bo2->handle);
 293
 294         drm_intel_bo_unreference(test_intel_bo);
 295 }
 296
 297 /* nouveau export reimport test */
 298 static void test_nv_self_import(void)
 299 {
 300         int prime_fd;
 301         struct nouveau_bo *nvbo, *nvbo2;
 302
 303         igt_assert(nouveau_bo_new(ndev, NOUVEAU_BO_GART | NOUVEAU_BO_MAP,
 304                                   0, BO_SIZE, NULL, &nvbo) == 0);
 305         igt_assert(nouveau_bo_set_prime(nvbo, &prime_fd) == 0);
 306
 307         igt_assert(nouveau_bo_prime_handle_ref(ndev, prime_fd, &nvbo2) == 0);
 308         close(prime_fd);
 309
 310         igt_assert(nvbo->handle == nvbo2->handle);
 311         nouveau_bo_ref(NULL, &nvbo);
 312         nouveau_bo_ref(NULL, &nvbo2);
 313 }
 314
 315 /* export handle from intel driver - reimport to another intel driver bufmgr
 316    see if you get same object */
 317 static void test_i915_self_import_to_different_fd(void)
 318 {
 319         drm_intel_bo *test_intel_bo, *test_intel_bo2;
 320         int prime_fd;
 321
 322         test_intel_bo = drm_intel_bo_alloc(bufmgr, "test bo", BO_SIZE, 4096);
 323
 324         drm_intel_bo_gem_export_to_prime(test_intel_bo, &prime_fd);
 325
 326         test_intel_bo2 = drm_intel_bo_gem_create_from_prime(bufmgr2, prime_fd, BO_SIZE);
 327         close(prime_fd);
 328         igt_assert(test_intel_bo2);
 329
 330         drm_intel_bo_unreference(test_intel_bo2);
 331         drm_intel_bo_unreference(test_intel_bo);
 332 }
 333
 334 /* nouveau export reimport to other driver test */
 335 static void test_nv_self_import_to_different_fd(void)
 336 {
 337         int prime_fd;
 338         struct nouveau_bo *nvbo, *nvbo2;
 339
 340         igt_assert(nouveau_bo_new(ndev, NOUVEAU_BO_GART | NOUVEAU_BO_MAP,
 341                                   0, BO_SIZE, NULL, &nvbo) == 0);
 342         igt_assert(nouveau_bo_set_prime(nvbo, &prime_fd) == 0);
 343
 344         igt_assert(nouveau_bo_prime_handle_ref(ndev2, prime_fd, &nvbo2) == 0);
 345         close(prime_fd);
 346
 347         /* not sure what to test for, just make sure we don't explode */
 348         nouveau_bo_ref(NULL, &nvbo);
 349         nouveau_bo_ref(NULL, &nvbo2);
 350 }
 351
 352 igt_main
 353 {
 354         igt_fixture {
 355                 find_and_open_devices();
 356
 357                 igt_require(nouveau_fd != -1);
 358                 igt_require(nouveau_fd2 != -1);
 359                 igt_require(intel_fd != -1);
 360                 igt_require(intel_fd2 != -1);
 361
 362                 /* set up intel bufmgr */
 363                 bufmgr = drm_intel_bufmgr_gem_init(intel_fd, 4096);
 364                 igt_assert(bufmgr);
 365                 /* Do not enable reuse, we share (almost) all buffers. */
 366                 //drm_intel_bufmgr_gem_enable_reuse(bufmgr);
 367
 368                 bufmgr2 = drm_intel_bufmgr_gem_init(intel_fd2, 4096);
 369                 igt_assert(bufmgr2);
 370                 drm_intel_bufmgr_gem_enable_reuse(bufmgr2);
 371
 372                 /* set up nouveau bufmgr */
 373                 igt_assert(nouveau_device_wrap(nouveau_fd, 0, &ndev) >= 0);
 374                 igt_assert(nouveau_client_new(ndev, &nclient) >= 0);
 375
 376                 /* set up nouveau bufmgr */
 377                 igt_assert(nouveau_device_wrap(nouveau_fd2, 0, &ndev2) >= 0);
 378
 379                 igt_assert(nouveau_client_new(ndev2, &nclient2) >= 0);;
 380
 381                 /* set up an intel batch buffer */
 382                 devid = intel_get_drm_devid(intel_fd);
 383                 intel_batch = intel_batchbuffer_alloc(bufmgr, devid);
 384                 igt_assert(intel_batch);
 385         }
 386
 387 #define xtest(name) \
 388         igt_subtest(#name) \
 389                 test_##name();
 390
 391         xtest(i915_nv_import_twice);
 392         xtest(i915_nv_import_twice_check_flink_name);
 393         xtest(i915_nv_reimport_twice_check_flink_name);
 394         xtest(nv_i915_import_twice_check_flink_name);
 395         xtest(nv_i915_reimport_twice_check_flink_name);
 396         xtest(i915_nv_import_vs_close);
 397         xtest(i915_nv_double_import);
 398         xtest(i915_nv_double_export);
 399         xtest(i915_self_import);
 400         xtest(nv_self_import);
 401         xtest(i915_self_import_to_different_fd);
 402         xtest(nv_self_import_to_different_fd);
 403
 404         igt_fixture {
 405                 intel_batchbuffer_free(intel_batch);
 406
 407                 nouveau_device_del(&ndev);
 408                 drm_intel_bufmgr_destroy(bufmgr);
 409
 410                 close(intel_fd);
 411                 close(nouveau_fd);
 412         }
 413 }