amdgpu/amdgpu_bo.c

   1 /*
   2  * Copyright © 2014 Advanced Micro Devices, Inc.
   3  * All Rights Reserved.
   4  *
   5  * Permission is hereby granted, free of charge, to any person obtaining a
   6  * copy of this software and associated documentation files (the "Software"),
   7  * to deal in the Software without restriction, including without limitation
   8  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
   9  * and/or sell copies of the Software, and to permit persons to whom the
  10  * Software is furnished to do so, subject to the following conditions:
  11  *
  12  * The above copyright notice and this permission notice shall be included in
  13  * all copies or substantial portions of the 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 COPYRIGHT HOLDER(S) OR AUTHOR(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR
  19  * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
  20  * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
  21  * OTHER DEALINGS IN THE SOFTWARE.
  22  *
  23  */
  24
  25 #ifdef HAVE_CONFIG_H
  26 #include "config.h"
  27 #endif
  28
  29 #include <stdlib.h>
  30 #include <stdio.h>
  31 #include <stdint.h>
  32 #include <string.h>
  33 #include <errno.h>
  34 #include <fcntl.h>
  35 #include <unistd.h>
  36 #include <sys/ioctl.h>
  37 #include <sys/mman.h>
  38 #include <sys/time.h>
  39
  40 #include "libdrm_macros.h"
  41 #include "xf86drm.h"
  42 #include "amdgpu_drm.h"
  43 #include "amdgpu_internal.h"
  44 #include "util_hash_table.h"
  45 #include "util_math.h"
  46
  47 static void amdgpu_close_kms_handle(amdgpu_device_handle dev,
  48                                      uint32_t handle)
  49 {
  50         struct drm_gem_close args = {};
  51
  52         args.handle = handle;
  53         drmIoctl(dev->fd, DRM_IOCTL_GEM_CLOSE, &args);
  54 }
  55
  56 drm_private void amdgpu_bo_free_internal(amdgpu_bo_handle bo)
  57 {
  58         /* Remove the buffer from the hash tables. */
  59         pthread_mutex_lock(&bo->dev->bo_table_mutex);
  60         util_hash_table_remove(bo->dev->bo_handles,
  61                                (void*)(uintptr_t)bo->handle);
  62         if (bo->flink_name) {
  63                 util_hash_table_remove(bo->dev->bo_flink_names,
  64                                        (void*)(uintptr_t)bo->flink_name);
  65         }
  66         pthread_mutex_unlock(&bo->dev->bo_table_mutex);
  67
  68         /* Release CPU access. */
  69         if (bo->cpu_map_count > 0) {
  70                 bo->cpu_map_count = 1;
  71                 amdgpu_bo_cpu_unmap(bo);
  72         }
  73
  74         amdgpu_close_kms_handle(bo->dev, bo->handle);
  75         pthread_mutex_destroy(&bo->cpu_access_mutex);
  76         free(bo);
  77 }
  78
  79 int amdgpu_bo_alloc(amdgpu_device_handle dev,
  80                     struct amdgpu_bo_alloc_request *alloc_buffer,
  81                     amdgpu_bo_handle *buf_handle)
  82 {
  83         struct amdgpu_bo *bo;
  84         union drm_amdgpu_gem_create args;
  85         unsigned heap = alloc_buffer->preferred_heap;
  86         int r = 0;
  87
  88         /* It's an error if the heap is not specified */
  89         if (!(heap & (AMDGPU_GEM_DOMAIN_GTT | AMDGPU_GEM_DOMAIN_VRAM)))
  90                 return -EINVAL;
  91
  92         bo = calloc(1, sizeof(struct amdgpu_bo));
  93         if (!bo)
  94                 return -ENOMEM;
  95
  96         atomic_set(&bo->refcount, 1);
  97         bo->dev = dev;
  98         bo->alloc_size = alloc_buffer->alloc_size;
  99
 100         memset(&args, 0, sizeof(args));
 101         args.in.bo_size = alloc_buffer->alloc_size;
 102         args.in.alignment = alloc_buffer->phys_alignment;
 103
 104         /* Set the placement. */
 105         args.in.domains = heap;
 106         args.in.domain_flags = alloc_buffer->flags;
 107
 108         /* Allocate the buffer with the preferred heap. */
 109         r = drmCommandWriteRead(dev->fd, DRM_AMDGPU_GEM_CREATE,
 110                                 &args, sizeof(args));
 111         if (r) {
 112                 free(bo);
 113                 return r;
 114         }
 115
 116         bo->handle = args.out.handle;
 117
 118         pthread_mutex_init(&bo->cpu_access_mutex, NULL);
 119
 120         *buf_handle = bo;
 121         return 0;
 122 }
 123
 124 int amdgpu_bo_set_metadata(amdgpu_bo_handle bo,
 125                            struct amdgpu_bo_metadata *info)
 126 {
 127         struct drm_amdgpu_gem_metadata args = {};
 128
 129         args.handle = bo->handle;
 130         args.op = AMDGPU_GEM_METADATA_OP_SET_METADATA;
 131         args.data.flags = info->flags;
 132         args.data.tiling_info = info->tiling_info;
 133
 134         if (info->size_metadata > sizeof(args.data.data))
 135                 return -EINVAL;
 136
 137         if (info->size_metadata) {
 138                 args.data.data_size_bytes = info->size_metadata;
 139                 memcpy(args.data.data, info->umd_metadata, info->size_metadata);
 140         }
 141
 142         return drmCommandWriteRead(bo->dev->fd,
 143                                    DRM_AMDGPU_GEM_METADATA,
 144                                    &args, sizeof(args));
 145 }
 146
 147 int amdgpu_bo_query_info(amdgpu_bo_handle bo,
 148                          struct amdgpu_bo_info *info)
 149 {
 150         struct drm_amdgpu_gem_metadata metadata = {};
 151         struct drm_amdgpu_gem_create_in bo_info = {};
 152         struct drm_amdgpu_gem_op gem_op = {};
 153         int r;
 154
 155         /* Validate the BO passed in */
 156         if (!bo->handle)
 157                 return -EINVAL;
 158
 159         /* Query metadata. */
 160         metadata.handle = bo->handle;
 161         metadata.op = AMDGPU_GEM_METADATA_OP_GET_METADATA;
 162
 163         r = drmCommandWriteRead(bo->dev->fd, DRM_AMDGPU_GEM_METADATA,
 164                                 &metadata, sizeof(metadata));
 165         if (r)
 166                 return r;
 167
 168         if (metadata.data.data_size_bytes >
 169             sizeof(info->metadata.umd_metadata))
 170                 return -EINVAL;
 171
 172         /* Query buffer info. */
 173         gem_op.handle = bo->handle;
 174         gem_op.op = AMDGPU_GEM_OP_GET_GEM_CREATE_INFO;
 175         gem_op.value = (uintptr_t)&bo_info;
 176
 177         r = drmCommandWriteRead(bo->dev->fd, DRM_AMDGPU_GEM_OP,
 178                                 &gem_op, sizeof(gem_op));
 179         if (r)
 180                 return r;
 181
 182         memset(info, 0, sizeof(*info));
 183         info->alloc_size = bo_info.bo_size;
 184         info->phys_alignment = bo_info.alignment;
 185         info->preferred_heap = bo_info.domains;
 186         info->alloc_flags = bo_info.domain_flags;
 187         info->metadata.flags = metadata.data.flags;
 188         info->metadata.tiling_info = metadata.data.tiling_info;
 189
 190         info->metadata.size_metadata = metadata.data.data_size_bytes;
 191         if (metadata.data.data_size_bytes > 0)
 192                 memcpy(info->metadata.umd_metadata, metadata.data.data,
 193                        metadata.data.data_size_bytes);
 194
 195         return 0;
 196 }
 197
 198 static void amdgpu_add_handle_to_table(amdgpu_bo_handle bo)
 199 {
 200         pthread_mutex_lock(&bo->dev->bo_table_mutex);
 201         util_hash_table_set(bo->dev->bo_handles,
 202                             (void*)(uintptr_t)bo->handle, bo);
 203         pthread_mutex_unlock(&bo->dev->bo_table_mutex);
 204 }
 205
 206 static int amdgpu_bo_export_flink(amdgpu_bo_handle bo)
 207 {
 208         struct drm_gem_flink flink;
 209         int fd, dma_fd;
 210         uint32_t handle;
 211         int r;
 212
 213         fd = bo->dev->fd;
 214         handle = bo->handle;
 215         if (bo->flink_name)
 216                 return 0;
 217
 218
 219         if (bo->dev->flink_fd != bo->dev->fd) {
 220                 r = drmPrimeHandleToFD(bo->dev->fd, bo->handle, DRM_CLOEXEC,
 221                                        &dma_fd);
 222                 if (!r) {
 223                         r = drmPrimeFDToHandle(bo->dev->flink_fd, dma_fd, &handle);
 224                         close(dma_fd);
 225                 }
 226                 if (r)
 227                         return r;
 228                 fd = bo->dev->flink_fd;
 229         }
 230         memset(&flink, 0, sizeof(flink));
 231         flink.handle = handle;
 232
 233         r = drmIoctl(fd, DRM_IOCTL_GEM_FLINK, &flink);
 234         if (r)
 235                 return r;
 236
 237         bo->flink_name = flink.name;
 238
 239         if (bo->dev->flink_fd != bo->dev->fd) {
 240                 struct drm_gem_close args = {};
 241                 args.handle = handle;
 242                 drmIoctl(bo->dev->flink_fd, DRM_IOCTL_GEM_CLOSE, &args);
 243         }
 244
 245         pthread_mutex_lock(&bo->dev->bo_table_mutex);
 246         util_hash_table_set(bo->dev->bo_flink_names,
 247                             (void*)(uintptr_t)bo->flink_name,
 248                             bo);
 249         pthread_mutex_unlock(&bo->dev->bo_table_mutex);
 250
 251         return 0;
 252 }
 253
 254 int amdgpu_bo_export(amdgpu_bo_handle bo,
 255                      enum amdgpu_bo_handle_type type,
 256                      uint32_t *shared_handle)
 257 {
 258         int r;
 259
 260         switch (type) {
 261         case amdgpu_bo_handle_type_gem_flink_name:
 262                 r = amdgpu_bo_export_flink(bo);
 263                 if (r)
 264                         return r;
 265
 266                 *shared_handle = bo->flink_name;
 267                 return 0;
 268
 269         case amdgpu_bo_handle_type_kms:
 270                 amdgpu_add_handle_to_table(bo);
 271                 *shared_handle = bo->handle;
 272                 return 0;
 273
 274         case amdgpu_bo_handle_type_dma_buf_fd:
 275                 amdgpu_add_handle_to_table(bo);
 276                 return drmPrimeHandleToFD(bo->dev->fd, bo->handle, DRM_CLOEXEC,
 277                                        (int*)shared_handle);
 278         }
 279         return -EINVAL;
 280 }
 281
 282 int amdgpu_bo_import(amdgpu_device_handle dev,
 283                      enum amdgpu_bo_handle_type type,
 284                      uint32_t shared_handle,
 285                      struct amdgpu_bo_import_result *output)
 286 {
 287         struct drm_gem_open open_arg = {};
 288         struct amdgpu_bo *bo = NULL;
 289         int r;
 290         int dma_fd;
 291         uint64_t dma_buf_size = 0;
 292
 293         /* Convert a DMA buf handle to a KMS handle now. */
 294         if (type == amdgpu_bo_handle_type_dma_buf_fd) {
 295                 uint32_t handle;
 296                 off_t size;
 297
 298                 /* Get a KMS handle. */
 299                 r = drmPrimeFDToHandle(dev->fd, shared_handle, &handle);
 300                 if (r) {
 301                         return r;
 302                 }
 303
 304                 /* Query the buffer size. */
 305                 size = lseek(shared_handle, 0, SEEK_END);
 306                 if (size == (off_t)-1) {
 307                         amdgpu_close_kms_handle(dev, handle);
 308                         return -errno;
 309                 }
 310                 lseek(shared_handle, 0, SEEK_SET);
 311
 312                 dma_buf_size = size;
 313                 shared_handle = handle;
 314         }
 315
 316         /* We must maintain a list of pairs <handle, bo>, so that we always
 317          * return the same amdgpu_bo instance for the same handle. */
 318         pthread_mutex_lock(&dev->bo_table_mutex);
 319
 320         /* If we have already created a buffer with this handle, find it. */
 321         switch (type) {
 322         case amdgpu_bo_handle_type_gem_flink_name:
 323                 bo = util_hash_table_get(dev->bo_flink_names,
 324                                          (void*)(uintptr_t)shared_handle);
 325                 break;
 326
 327         case amdgpu_bo_handle_type_dma_buf_fd:
 328                 bo = util_hash_table_get(dev->bo_handles,
 329                                          (void*)(uintptr_t)shared_handle);
 330                 break;
 331
 332         case amdgpu_bo_handle_type_kms:
 333                 /* Importing a KMS handle in not allowed. */
 334                 pthread_mutex_unlock(&dev->bo_table_mutex);
 335                 return -EPERM;
 336
 337         default:
 338                 pthread_mutex_unlock(&dev->bo_table_mutex);
 339                 return -EINVAL;
 340         }
 341
 342         if (bo) {
 343                 pthread_mutex_unlock(&dev->bo_table_mutex);
 344
 345                 /* The buffer already exists, just bump the refcount. */
 346                 atomic_inc(&bo->refcount);
 347
 348                 output->buf_handle = bo;
 349                 output->alloc_size = bo->alloc_size;
 350                 return 0;
 351         }
 352
 353         bo = calloc(1, sizeof(struct amdgpu_bo));
 354         if (!bo) {
 355                 pthread_mutex_unlock(&dev->bo_table_mutex);
 356                 if (type == amdgpu_bo_handle_type_dma_buf_fd) {
 357                         amdgpu_close_kms_handle(dev, shared_handle);
 358                 }
 359                 return -ENOMEM;
 360         }
 361
 362         /* Open the handle. */
 363         switch (type) {
 364         case amdgpu_bo_handle_type_gem_flink_name:
 365                 open_arg.name = shared_handle;
 366                 r = drmIoctl(dev->flink_fd, DRM_IOCTL_GEM_OPEN, &open_arg);
 367                 if (r) {
 368                         free(bo);
 369                         pthread_mutex_unlock(&dev->bo_table_mutex);
 370                         return r;
 371                 }
 372
 373                 bo->handle = open_arg.handle;
 374                 if (dev->flink_fd != dev->fd) {
 375                         r = drmPrimeHandleToFD(dev->flink_fd, bo->handle, DRM_CLOEXEC, &dma_fd);
 376                         if (r) {
 377                                 free(bo);
 378                                 pthread_mutex_unlock(&dev->bo_table_mutex);
 379                                 return r;
 380                         }
 381                         r = drmPrimeFDToHandle(dev->fd, dma_fd, &bo->handle );
 382
 383                         close(dma_fd);
 384
 385                         if (r) {
 386                                 free(bo);
 387                                 pthread_mutex_unlock(&dev->bo_table_mutex);
 388                                 return r;
 389                         }
 390                 }
 391                 bo->flink_name = shared_handle;
 392                 bo->alloc_size = open_arg.size;
 393                 util_hash_table_set(dev->bo_flink_names,
 394                                     (void*)(uintptr_t)bo->flink_name, bo);
 395                 break;
 396
 397         case amdgpu_bo_handle_type_dma_buf_fd:
 398                 bo->handle = shared_handle;
 399                 bo->alloc_size = dma_buf_size;
 400                 break;
 401
 402         case amdgpu_bo_handle_type_kms:
 403                 assert(0); /* unreachable */
 404         }
 405
 406         /* Initialize it. */
 407         atomic_set(&bo->refcount, 1);
 408         bo->dev = dev;
 409         pthread_mutex_init(&bo->cpu_access_mutex, NULL);
 410
 411         util_hash_table_set(dev->bo_handles, (void*)(uintptr_t)bo->handle, bo);
 412         pthread_mutex_unlock(&dev->bo_table_mutex);
 413
 414         output->buf_handle = bo;
 415         output->alloc_size = bo->alloc_size;
 416         return 0;
 417 }
 418
 419 int amdgpu_bo_free(amdgpu_bo_handle buf_handle)
 420 {
 421         /* Just drop the reference. */
 422         amdgpu_bo_reference(&buf_handle, NULL);
 423         return 0;
 424 }
 425
 426 int amdgpu_bo_cpu_map(amdgpu_bo_handle bo, void **cpu)
 427 {
 428         union drm_amdgpu_gem_mmap args;
 429         void *ptr;
 430         int r;
 431
 432         pthread_mutex_lock(&bo->cpu_access_mutex);
 433
 434         if (bo->cpu_ptr) {
 435                 /* already mapped */
 436                 assert(bo->cpu_map_count > 0);
 437                 bo->cpu_map_count++;
 438                 *cpu = bo->cpu_ptr;
 439                 pthread_mutex_unlock(&bo->cpu_access_mutex);
 440                 return 0;
 441         }
 442
 443         assert(bo->cpu_map_count == 0);
 444
 445         memset(&args, 0, sizeof(args));
 446
 447         /* Query the buffer address (args.addr_ptr).
 448          * The kernel driver ignores the offset and size parameters. */
 449         args.in.handle = bo->handle;
 450
 451         r = drmCommandWriteRead(bo->dev->fd, DRM_AMDGPU_GEM_MMAP, &args,
 452                                 sizeof(args));
 453         if (r) {
 454                 pthread_mutex_unlock(&bo->cpu_access_mutex);
 455                 return r;
 456         }
 457
 458         /* Map the buffer. */
 459         ptr = drm_mmap(NULL, bo->alloc_size, PROT_READ | PROT_WRITE, MAP_SHARED,
 460                        bo->dev->fd, args.out.addr_ptr);
 461         if (ptr == MAP_FAILED) {
 462                 pthread_mutex_unlock(&bo->cpu_access_mutex);
 463                 return -errno;
 464         }
 465
 466         bo->cpu_ptr = ptr;
 467         bo->cpu_map_count = 1;
 468         pthread_mutex_unlock(&bo->cpu_access_mutex);
 469
 470         *cpu = ptr;
 471         return 0;
 472 }
 473
 474 int amdgpu_bo_cpu_unmap(amdgpu_bo_handle bo)
 475 {
 476         int r;
 477
 478         pthread_mutex_lock(&bo->cpu_access_mutex);
 479         assert(bo->cpu_map_count >= 0);
 480
 481         if (bo->cpu_map_count == 0) {
 482                 /* not mapped */
 483                 pthread_mutex_unlock(&bo->cpu_access_mutex);
 484                 return -EBADMSG;
 485         }
 486
 487         bo->cpu_map_count--;
 488         if (bo->cpu_map_count > 0) {
 489                 /* mapped multiple times */
 490                 pthread_mutex_unlock(&bo->cpu_access_mutex);
 491                 return 0;
 492         }
 493
 494         r = drm_munmap(bo->cpu_ptr, bo->alloc_size) == 0 ? 0 : -errno;
 495         bo->cpu_ptr = NULL;
 496         pthread_mutex_unlock(&bo->cpu_access_mutex);
 497         return r;
 498 }
 499
 500 int amdgpu_query_buffer_size_alignment(amdgpu_device_handle dev,
 501                                 struct amdgpu_buffer_size_alignments *info)
 502 {
 503         info->size_local = dev->dev_info.pte_fragment_size;
 504         info->size_remote = dev->dev_info.gart_page_size;
 505         return 0;
 506 }
 507
 508 int amdgpu_bo_wait_for_idle(amdgpu_bo_handle bo,
 509                             uint64_t timeout_ns,
 510                             bool *busy)
 511 {
 512         union drm_amdgpu_gem_wait_idle args;
 513         int r;
 514
 515         memset(&args, 0, sizeof(args));
 516         args.in.handle = bo->handle;
 517         args.in.timeout = amdgpu_cs_calculate_timeout(timeout_ns);
 518
 519         r = drmCommandWriteRead(bo->dev->fd, DRM_AMDGPU_GEM_WAIT_IDLE,
 520                                 &args, sizeof(args));
 521
 522         if (r == 0) {
 523                 *busy = args.out.status;
 524                 return 0;
 525         } else {
 526                 fprintf(stderr, "amdgpu: GEM_WAIT_IDLE failed with %i\n", r);
 527                 return r;
 528         }
 529 }
 530
 531 int amdgpu_create_bo_from_user_mem(amdgpu_device_handle dev,
 532                                     void *cpu,
 533                                     uint64_t size,
 534                                     amdgpu_bo_handle *buf_handle)
 535 {
 536         int r;
 537         struct amdgpu_bo *bo;
 538         struct drm_amdgpu_gem_userptr args;
 539         uintptr_t cpu0;
 540         uint32_t ps, off;
 541
 542         memset(&args, 0, sizeof(args));
 543         ps = getpagesize();
 544
 545         cpu0 = ROUND_DOWN((uintptr_t)cpu, ps);
 546         off = (uintptr_t)cpu - cpu0;
 547         size = ROUND_UP(size + off, ps);
 548
 549         args.addr = cpu0;
 550         args.flags = AMDGPU_GEM_USERPTR_ANONONLY | AMDGPU_GEM_USERPTR_REGISTER;
 551         args.size = size;
 552         r = drmCommandWriteRead(dev->fd, DRM_AMDGPU_GEM_USERPTR,
 553                                 &args, sizeof(args));
 554         if (r)
 555                 return r;
 556
 557         bo = calloc(1, sizeof(struct amdgpu_bo));
 558         if (!bo)
 559                 return -ENOMEM;
 560
 561         atomic_set(&bo->refcount, 1);
 562         bo->dev = dev;
 563         bo->alloc_size = size;
 564         bo->handle = args.handle;
 565
 566         *buf_handle = bo;
 567
 568         return r;
 569 }
 570
 571 int amdgpu_bo_list_create(amdgpu_device_handle dev,
 572                           uint32_t number_of_resources,
 573                           amdgpu_bo_handle *resources,
 574                           uint8_t *resource_prios,
 575                           amdgpu_bo_list_handle *result)
 576 {
 577         struct drm_amdgpu_bo_list_entry *list;
 578         union drm_amdgpu_bo_list args;
 579         unsigned i;
 580         int r;
 581
 582         if (!number_of_resources)
 583                 return -EINVAL;
 584
 585         /* overflow check for multiplication */
 586         if (number_of_resources > UINT32_MAX / sizeof(struct drm_amdgpu_bo_list_entry))
 587                 return -EINVAL;
 588
 589         list = malloc(number_of_resources * sizeof(struct drm_amdgpu_bo_list_entry));
 590         if (!list)
 591                 return -ENOMEM;
 592
 593         memset(&args, 0, sizeof(args));
 594         args.in.operation = AMDGPU_BO_LIST_OP_CREATE;
 595         args.in.bo_number = number_of_resources;
 596         args.in.bo_info_size = sizeof(struct drm_amdgpu_bo_list_entry);
 597         args.in.bo_info_ptr = (uint64_t)(uintptr_t)list;
 598
 599         for (i = 0; i < number_of_resources; i++) {
 600                 list[i].bo_handle = resources[i]->handle;
 601                 if (resource_prios)
 602                         list[i].bo_priority = resource_prios[i];
 603                 else
 604                         list[i].bo_priority = 0;
 605         }
 606
 607         r = drmCommandWriteRead(dev->fd, DRM_AMDGPU_BO_LIST,
 608                                 &args, sizeof(args));
 609         free(list);
 610         if (r)
 611                 return r;
 612
 613         *result = malloc(sizeof(struct amdgpu_bo_list));
 614         (*result)->dev = dev;
 615         (*result)->handle = args.out.list_handle;
 616         return 0;
 617 }
 618
 619 int amdgpu_bo_list_destroy(amdgpu_bo_list_handle list)
 620 {
 621         union drm_amdgpu_bo_list args;
 622         int r;
 623
 624         memset(&args, 0, sizeof(args));
 625         args.in.operation = AMDGPU_BO_LIST_OP_DESTROY;
 626         args.in.list_handle = list->handle;
 627
 628         r = drmCommandWriteRead(list->dev->fd, DRM_AMDGPU_BO_LIST,
 629                                 &args, sizeof(args));
 630
 631         if (!r)
 632                 free(list);
 633
 634         return r;
 635 }
 636
 637 int amdgpu_bo_list_update(amdgpu_bo_list_handle handle,
 638                           uint32_t number_of_resources,
 639                           amdgpu_bo_handle *resources,
 640                           uint8_t *resource_prios)
 641 {
 642         struct drm_amdgpu_bo_list_entry *list;
 643         union drm_amdgpu_bo_list args;
 644         unsigned i;
 645         int r;
 646
 647         if (!number_of_resources)
 648                 return -EINVAL;
 649
 650         /* overflow check for multiplication */
 651         if (number_of_resources > UINT32_MAX / sizeof(struct drm_amdgpu_bo_list_entry))
 652                 return -EINVAL;
 653
 654         list = malloc(number_of_resources * sizeof(struct drm_amdgpu_bo_list_entry));
 655         if (list == NULL)
 656                 return -ENOMEM;
 657
 658         args.in.operation = AMDGPU_BO_LIST_OP_UPDATE;
 659         args.in.list_handle = handle->handle;
 660         args.in.bo_number = number_of_resources;
 661         args.in.bo_info_size = sizeof(struct drm_amdgpu_bo_list_entry);
 662         args.in.bo_info_ptr = (uintptr_t)list;
 663
 664         for (i = 0; i < number_of_resources; i++) {
 665                 list[i].bo_handle = resources[i]->handle;
 666                 if (resource_prios)
 667                         list[i].bo_priority = resource_prios[i];
 668                 else
 669                         list[i].bo_priority = 0;
 670         }
 671
 672         r = drmCommandWriteRead(handle->dev->fd, DRM_AMDGPU_BO_LIST,
 673                                 &args, sizeof(args));
 674         free(list);
 675         return r;
 676 }
 677
 678 int amdgpu_bo_va_op(amdgpu_bo_handle bo,
 679                      uint64_t offset,
 680                      uint64_t size,
 681                      uint64_t addr,
 682                      uint64_t flags,
 683                      uint32_t ops)
 684 {
 685         amdgpu_device_handle dev = bo->dev;
 686         struct drm_amdgpu_gem_va va;
 687         int r;
 688
 689         if (ops != AMDGPU_VA_OP_MAP && ops != AMDGPU_VA_OP_UNMAP)
 690                 return -EINVAL;
 691
 692         memset(&va, 0, sizeof(va));
 693         va.handle = bo->handle;
 694         va.operation = ops;
 695         va.flags = AMDGPU_VM_PAGE_READABLE |
 696                    AMDGPU_VM_PAGE_WRITEABLE |
 697                    AMDGPU_VM_PAGE_EXECUTABLE;
 698         va.va_address = addr;
 699         va.offset_in_bo = offset;
 700         va.map_size = ALIGN(size, getpagesize());
 701
 702         r = drmCommandWriteRead(dev->fd, DRM_AMDGPU_GEM_VA, &va, sizeof(va));
 703
 704         return r;
 705 }