tools/testing/selftests/iommu/iommufd_utils.h

   1 /* SPDX-License-Identifier: GPL-2.0-only */
   2 /* Copyright (c) 2021-2022, NVIDIA CORPORATION & AFFILIATES */
   3 #ifndef __SELFTEST_IOMMUFD_UTILS
   4 #define __SELFTEST_IOMMUFD_UTILS
   5
   6 #include <unistd.h>
   7 #include <stddef.h>
   8 #include <sys/fcntl.h>
   9 #include <sys/ioctl.h>
  10 #include <stdint.h>
  11 #include <assert.h>
  12
  13 #include "../kselftest_harness.h"
  14 #include "../../../../drivers/iommu/iommufd/iommufd_test.h"
  15
  16 /* Hack to make assertions more readable */
  17 #define _IOMMU_TEST_CMD(x) IOMMU_TEST_CMD
  18
  19 /* Imported from include/asm-generic/bitops/generic-non-atomic.h */
  20 #define BITS_PER_BYTE 8
  21 #define BITS_PER_LONG __BITS_PER_LONG
  22 #define BIT_MASK(nr) (1UL << ((nr) % __BITS_PER_LONG))
  23 #define BIT_WORD(nr) ((nr) / __BITS_PER_LONG)
  24
  25 static inline void set_bit(unsigned int nr, unsigned long *addr)
  26 {
  27         unsigned long mask = BIT_MASK(nr);
  28         unsigned long *p = ((unsigned long *)addr) + BIT_WORD(nr);
  29
  30         *p |= mask;
  31 }
  32
  33 static inline bool test_bit(unsigned int nr, unsigned long *addr)
  34 {
  35         return 1UL & (addr[BIT_WORD(nr)] >> (nr & (BITS_PER_LONG - 1)));
  36 }
  37
  38 static void *buffer;
  39 static unsigned long BUFFER_SIZE;
  40
  41 static unsigned long PAGE_SIZE;
  42
  43 #define sizeof_field(TYPE, MEMBER) sizeof((((TYPE *)0)->MEMBER))
  44 #define offsetofend(TYPE, MEMBER) \
  45         (offsetof(TYPE, MEMBER) + sizeof_field(TYPE, MEMBER))
  46
  47 /*
  48  * Have the kernel check the refcount on pages. I don't know why a freshly
  49  * mmap'd anon non-compound page starts out with a ref of 3
  50  */
  51 #define check_refs(_ptr, _length, _refs)                                      \
  52         ({                                                                    \
  53                 struct iommu_test_cmd test_cmd = {                            \
  54                         .size = sizeof(test_cmd),                             \
  55                         .op = IOMMU_TEST_OP_MD_CHECK_REFS,                    \
  56                         .check_refs = { .length = _length,                    \
  57                                         .uptr = (uintptr_t)(_ptr),            \
  58                                         .refs = _refs },                      \
  59                 };                                                            \
  60                 ASSERT_EQ(0,                                                  \
  61                           ioctl(self->fd,                                     \
  62                                 _IOMMU_TEST_CMD(IOMMU_TEST_OP_MD_CHECK_REFS), \
  63                                 &test_cmd));                                  \
  64         })
  65
  66 static int _test_cmd_mock_domain(int fd, unsigned int ioas_id, __u32 *stdev_id,
  67                                  __u32 *hwpt_id, __u32 *idev_id)
  68 {
  69         struct iommu_test_cmd cmd = {
  70                 .size = sizeof(cmd),
  71                 .op = IOMMU_TEST_OP_MOCK_DOMAIN,
  72                 .id = ioas_id,
  73                 .mock_domain = {},
  74         };
  75         int ret;
  76
  77         ret = ioctl(fd, IOMMU_TEST_CMD, &cmd);
  78         if (ret)
  79                 return ret;
  80         if (stdev_id)
  81                 *stdev_id = cmd.mock_domain.out_stdev_id;
  82         assert(cmd.id != 0);
  83         if (hwpt_id)
  84                 *hwpt_id = cmd.mock_domain.out_hwpt_id;
  85         if (idev_id)
  86                 *idev_id = cmd.mock_domain.out_idev_id;
  87         return 0;
  88 }
  89 #define test_cmd_mock_domain(ioas_id, stdev_id, hwpt_id, idev_id)       \
  90         ASSERT_EQ(0, _test_cmd_mock_domain(self->fd, ioas_id, stdev_id, \
  91                                            hwpt_id, idev_id))
  92 #define test_err_mock_domain(_errno, ioas_id, stdev_id, hwpt_id)      \
  93         EXPECT_ERRNO(_errno, _test_cmd_mock_domain(self->fd, ioas_id, \
  94                                                    stdev_id, hwpt_id, NULL))
  95
  96 static int _test_cmd_mock_domain_flags(int fd, unsigned int ioas_id,
  97                                        __u32 stdev_flags, __u32 *stdev_id,
  98                                        __u32 *hwpt_id, __u32 *idev_id)
  99 {
 100         struct iommu_test_cmd cmd = {
 101                 .size = sizeof(cmd),
 102                 .op = IOMMU_TEST_OP_MOCK_DOMAIN_FLAGS,
 103                 .id = ioas_id,
 104                 .mock_domain_flags = { .dev_flags = stdev_flags },
 105         };
 106         int ret;
 107
 108         ret = ioctl(fd, IOMMU_TEST_CMD, &cmd);
 109         if (ret)
 110                 return ret;
 111         if (stdev_id)
 112                 *stdev_id = cmd.mock_domain_flags.out_stdev_id;
 113         assert(cmd.id != 0);
 114         if (hwpt_id)
 115                 *hwpt_id = cmd.mock_domain_flags.out_hwpt_id;
 116         if (idev_id)
 117                 *idev_id = cmd.mock_domain_flags.out_idev_id;
 118         return 0;
 119 }
 120 #define test_cmd_mock_domain_flags(ioas_id, flags, stdev_id, hwpt_id, idev_id) \
 121         ASSERT_EQ(0, _test_cmd_mock_domain_flags(self->fd, ioas_id, flags,     \
 122                                                  stdev_id, hwpt_id, idev_id))
 123 #define test_err_mock_domain_flags(_errno, ioas_id, flags, stdev_id, hwpt_id) \
 124         EXPECT_ERRNO(_errno,                                                  \
 125                      _test_cmd_mock_domain_flags(self->fd, ioas_id, flags,    \
 126                                                  stdev_id, hwpt_id, NULL))
 127
 128 static int _test_cmd_mock_domain_replace(int fd, __u32 stdev_id, __u32 pt_id,
 129                                          __u32 *hwpt_id)
 130 {
 131         struct iommu_test_cmd cmd = {
 132                 .size = sizeof(cmd),
 133                 .op = IOMMU_TEST_OP_MOCK_DOMAIN_REPLACE,
 134                 .id = stdev_id,
 135                 .mock_domain_replace = {
 136                         .pt_id = pt_id,
 137                 },
 138         };
 139         int ret;
 140
 141         ret = ioctl(fd, IOMMU_TEST_CMD, &cmd);
 142         if (ret)
 143                 return ret;
 144         if (hwpt_id)
 145                 *hwpt_id = cmd.mock_domain_replace.pt_id;
 146         return 0;
 147 }
 148
 149 #define test_cmd_mock_domain_replace(stdev_id, pt_id)                         \
 150         ASSERT_EQ(0, _test_cmd_mock_domain_replace(self->fd, stdev_id, pt_id, \
 151                                                    NULL))
 152 #define test_err_mock_domain_replace(_errno, stdev_id, pt_id)                  \
 153         EXPECT_ERRNO(_errno, _test_cmd_mock_domain_replace(self->fd, stdev_id, \
 154                                                            pt_id, NULL))
 155
 156 static int _test_cmd_hwpt_alloc(int fd, __u32 device_id, __u32 pt_id,
 157                                 __u32 flags, __u32 *hwpt_id, __u32 data_type,
 158                                 void *data, size_t data_len)
 159 {
 160         struct iommu_hwpt_alloc cmd = {
 161                 .size = sizeof(cmd),
 162                 .flags = flags,
 163                 .dev_id = device_id,
 164                 .pt_id = pt_id,
 165                 .data_type = data_type,
 166                 .data_len = data_len,
 167                 .data_uptr = (uint64_t)data,
 168         };
 169         int ret;
 170
 171         ret = ioctl(fd, IOMMU_HWPT_ALLOC, &cmd);
 172         if (ret)
 173                 return ret;
 174         if (hwpt_id)
 175                 *hwpt_id = cmd.out_hwpt_id;
 176         return 0;
 177 }
 178
 179 #define test_cmd_hwpt_alloc(device_id, pt_id, flags, hwpt_id)                  \
 180         ASSERT_EQ(0, _test_cmd_hwpt_alloc(self->fd, device_id, pt_id, flags,   \
 181                                           hwpt_id, IOMMU_HWPT_DATA_NONE, NULL, \
 182                                           0))
 183 #define test_err_hwpt_alloc(_errno, device_id, pt_id, flags, hwpt_id)   \
 184         EXPECT_ERRNO(_errno, _test_cmd_hwpt_alloc(                      \
 185                                      self->fd, device_id, pt_id, flags, \
 186                                      hwpt_id, IOMMU_HWPT_DATA_NONE, NULL, 0))
 187
 188 #define test_cmd_hwpt_alloc_nested(device_id, pt_id, flags, hwpt_id,         \
 189                                    data_type, data, data_len)                \
 190         ASSERT_EQ(0, _test_cmd_hwpt_alloc(self->fd, device_id, pt_id, flags, \
 191                                           hwpt_id, data_type, data, data_len))
 192 #define test_err_hwpt_alloc_nested(_errno, device_id, pt_id, flags, hwpt_id, \
 193                                    data_type, data, data_len)                \
 194         EXPECT_ERRNO(_errno,                                                 \
 195                      _test_cmd_hwpt_alloc(self->fd, device_id, pt_id, flags, \
 196                                           hwpt_id, data_type, data, data_len))
 197
 198 static int _test_cmd_access_replace_ioas(int fd, __u32 access_id,
 199                                          unsigned int ioas_id)
 200 {
 201         struct iommu_test_cmd cmd = {
 202                 .size = sizeof(cmd),
 203                 .op = IOMMU_TEST_OP_ACCESS_REPLACE_IOAS,
 204                 .id = access_id,
 205                 .access_replace_ioas = { .ioas_id = ioas_id },
 206         };
 207         int ret;
 208
 209         ret = ioctl(fd, IOMMU_TEST_CMD, &cmd);
 210         if (ret)
 211                 return ret;
 212         return 0;
 213 }
 214 #define test_cmd_access_replace_ioas(access_id, ioas_id) \
 215         ASSERT_EQ(0, _test_cmd_access_replace_ioas(self->fd, access_id, ioas_id))
 216
 217 static int _test_cmd_set_dirty_tracking(int fd, __u32 hwpt_id, bool enabled)
 218 {
 219         struct iommu_hwpt_set_dirty_tracking cmd = {
 220                 .size = sizeof(cmd),
 221                 .flags = enabled ? IOMMU_HWPT_DIRTY_TRACKING_ENABLE : 0,
 222                 .hwpt_id = hwpt_id,
 223         };
 224         int ret;
 225
 226         ret = ioctl(fd, IOMMU_HWPT_SET_DIRTY_TRACKING, &cmd);
 227         if (ret)
 228                 return -errno;
 229         return 0;
 230 }
 231 #define test_cmd_set_dirty_tracking(hwpt_id, enabled) \
 232         ASSERT_EQ(0, _test_cmd_set_dirty_tracking(self->fd, hwpt_id, enabled))
 233
 234 static int _test_cmd_get_dirty_bitmap(int fd, __u32 hwpt_id, size_t length,
 235                                       __u64 iova, size_t page_size,
 236                                       __u64 *bitmap, __u32 flags)
 237 {
 238         struct iommu_hwpt_get_dirty_bitmap cmd = {
 239                 .size = sizeof(cmd),
 240                 .hwpt_id = hwpt_id,
 241                 .flags = flags,
 242                 .iova = iova,
 243                 .length = length,
 244                 .page_size = page_size,
 245                 .data = (uintptr_t)bitmap,
 246         };
 247         int ret;
 248
 249         ret = ioctl(fd, IOMMU_HWPT_GET_DIRTY_BITMAP, &cmd);
 250         if (ret)
 251                 return ret;
 252         return 0;
 253 }
 254
 255 #define test_cmd_get_dirty_bitmap(fd, hwpt_id, length, iova, page_size,    \
 256                                   bitmap, flags)                           \
 257         ASSERT_EQ(0, _test_cmd_get_dirty_bitmap(fd, hwpt_id, length, iova, \
 258                                                 page_size, bitmap, flags))
 259
 260 static int _test_cmd_mock_domain_set_dirty(int fd, __u32 hwpt_id, size_t length,
 261                                            __u64 iova, size_t page_size,
 262                                            __u64 *bitmap, __u64 *dirty)
 263 {
 264         struct iommu_test_cmd cmd = {
 265                 .size = sizeof(cmd),
 266                 .op = IOMMU_TEST_OP_DIRTY,
 267                 .id = hwpt_id,
 268                 .dirty = {
 269                         .iova = iova,
 270                         .length = length,
 271                         .page_size = page_size,
 272                         .uptr = (uintptr_t)bitmap,
 273                 }
 274         };
 275         int ret;
 276
 277         ret = ioctl(fd, _IOMMU_TEST_CMD(IOMMU_TEST_OP_DIRTY), &cmd);
 278         if (ret)
 279                 return -ret;
 280         if (dirty)
 281                 *dirty = cmd.dirty.out_nr_dirty;
 282         return 0;
 283 }
 284
 285 #define test_cmd_mock_domain_set_dirty(fd, hwpt_id, length, iova, page_size, \
 286                                        bitmap, nr)                           \
 287         ASSERT_EQ(0,                                                         \
 288                   _test_cmd_mock_domain_set_dirty(fd, hwpt_id, length, iova, \
 289                                                   page_size, bitmap, nr))
 290
 291 static int _test_mock_dirty_bitmaps(int fd, __u32 hwpt_id, size_t length,
 292                                     __u64 iova, size_t page_size, __u64 *bitmap,
 293                                     __u64 bitmap_size, __u32 flags,
 294                                     struct __test_metadata *_metadata)
 295 {
 296         unsigned long i, nbits = bitmap_size * BITS_PER_BYTE;
 297         unsigned long nr = nbits / 2;
 298         __u64 out_dirty = 0;
 299
 300         /* Mark all even bits as dirty in the mock domain */
 301         for (i = 0; i < nbits; i += 2)
 302                 set_bit(i, (unsigned long *)bitmap);
 303
 304         test_cmd_mock_domain_set_dirty(fd, hwpt_id, length, iova, page_size,
 305                                        bitmap, &out_dirty);
 306         ASSERT_EQ(nr, out_dirty);
 307
 308         /* Expect all even bits as dirty in the user bitmap */
 309         memset(bitmap, 0, bitmap_size);
 310         test_cmd_get_dirty_bitmap(fd, hwpt_id, length, iova, page_size, bitmap,
 311                                   flags);
 312         /* Beware ASSERT_EQ() is two statements -- braces are not redundant! */
 313         for (i = 0; i < nbits; i++) {
 314                 ASSERT_EQ(!(i % 2), test_bit(i, (unsigned long *)bitmap));
 315         }
 316
 317         memset(bitmap, 0, bitmap_size);
 318         test_cmd_get_dirty_bitmap(fd, hwpt_id, length, iova, page_size, bitmap,
 319                                   flags);
 320
 321         /* It as read already -- expect all zeroes */
 322         for (i = 0; i < nbits; i++) {
 323                 ASSERT_EQ(!(i % 2) && (flags &
 324                                        IOMMU_HWPT_GET_DIRTY_BITMAP_NO_CLEAR),
 325                           test_bit(i, (unsigned long *)bitmap));
 326         }
 327
 328         return 0;
 329 }
 330 #define test_mock_dirty_bitmaps(hwpt_id, length, iova, page_size, bitmap,      \
 331                                 bitmap_size, flags, _metadata)                 \
 332         ASSERT_EQ(0, _test_mock_dirty_bitmaps(self->fd, hwpt_id, length, iova, \
 333                                               page_size, bitmap, bitmap_size,  \
 334                                               flags, _metadata))
 335
 336 static int _test_cmd_create_access(int fd, unsigned int ioas_id,
 337                                    __u32 *access_id, unsigned int flags)
 338 {
 339         struct iommu_test_cmd cmd = {
 340                 .size = sizeof(cmd),
 341                 .op = IOMMU_TEST_OP_CREATE_ACCESS,
 342                 .id = ioas_id,
 343                 .create_access = { .flags = flags },
 344         };
 345         int ret;
 346
 347         ret = ioctl(fd, IOMMU_TEST_CMD, &cmd);
 348         if (ret)
 349                 return ret;
 350         *access_id = cmd.create_access.out_access_fd;
 351         return 0;
 352 }
 353 #define test_cmd_create_access(ioas_id, access_id, flags)                  \
 354         ASSERT_EQ(0, _test_cmd_create_access(self->fd, ioas_id, access_id, \
 355                                              flags))
 356
 357 static int _test_cmd_destroy_access(unsigned int access_id)
 358 {
 359         return close(access_id);
 360 }
 361 #define test_cmd_destroy_access(access_id) \
 362         ASSERT_EQ(0, _test_cmd_destroy_access(access_id))
 363
 364 static int _test_cmd_destroy_access_pages(int fd, unsigned int access_id,
 365                                           unsigned int access_pages_id)
 366 {
 367         struct iommu_test_cmd cmd = {
 368                 .size = sizeof(cmd),
 369                 .op = IOMMU_TEST_OP_DESTROY_ACCESS_PAGES,
 370                 .id = access_id,
 371                 .destroy_access_pages = { .access_pages_id = access_pages_id },
 372         };
 373         return ioctl(fd, IOMMU_TEST_CMD, &cmd);
 374 }
 375 #define test_cmd_destroy_access_pages(access_id, access_pages_id)        \
 376         ASSERT_EQ(0, _test_cmd_destroy_access_pages(self->fd, access_id, \
 377                                                     access_pages_id))
 378 #define test_err_destroy_access_pages(_errno, access_id, access_pages_id) \
 379         EXPECT_ERRNO(_errno, _test_cmd_destroy_access_pages(              \
 380                                      self->fd, access_id, access_pages_id))
 381
 382 static int _test_ioctl_destroy(int fd, unsigned int id)
 383 {
 384         struct iommu_destroy cmd = {
 385                 .size = sizeof(cmd),
 386                 .id = id,
 387         };
 388         return ioctl(fd, IOMMU_DESTROY, &cmd);
 389 }
 390 #define test_ioctl_destroy(id) ASSERT_EQ(0, _test_ioctl_destroy(self->fd, id))
 391
 392 static int _test_ioctl_ioas_alloc(int fd, __u32 *id)
 393 {
 394         struct iommu_ioas_alloc cmd = {
 395                 .size = sizeof(cmd),
 396         };
 397         int ret;
 398
 399         ret = ioctl(fd, IOMMU_IOAS_ALLOC, &cmd);
 400         if (ret)
 401                 return ret;
 402         *id = cmd.out_ioas_id;
 403         return 0;
 404 }
 405 #define test_ioctl_ioas_alloc(id)                                   \
 406         ({                                                          \
 407                 ASSERT_EQ(0, _test_ioctl_ioas_alloc(self->fd, id)); \
 408                 ASSERT_NE(0, *(id));                                \
 409         })
 410
 411 static int _test_ioctl_ioas_map(int fd, unsigned int ioas_id, void *buffer,
 412                                 size_t length, __u64 *iova, unsigned int flags)
 413 {
 414         struct iommu_ioas_map cmd = {
 415                 .size = sizeof(cmd),
 416                 .flags = flags,
 417                 .ioas_id = ioas_id,
 418                 .user_va = (uintptr_t)buffer,
 419                 .length = length,
 420         };
 421         int ret;
 422
 423         if (flags & IOMMU_IOAS_MAP_FIXED_IOVA)
 424                 cmd.iova = *iova;
 425
 426         ret = ioctl(fd, IOMMU_IOAS_MAP, &cmd);
 427         *iova = cmd.iova;
 428         return ret;
 429 }
 430 #define test_ioctl_ioas_map(buffer, length, iova_p)                        \
 431         ASSERT_EQ(0, _test_ioctl_ioas_map(self->fd, self->ioas_id, buffer, \
 432                                           length, iova_p,                  \
 433                                           IOMMU_IOAS_MAP_WRITEABLE |       \
 434                                                   IOMMU_IOAS_MAP_READABLE))
 435
 436 #define test_err_ioctl_ioas_map(_errno, buffer, length, iova_p)            \
 437         EXPECT_ERRNO(_errno,                                               \
 438                      _test_ioctl_ioas_map(self->fd, self->ioas_id, buffer, \
 439                                           length, iova_p,                  \
 440                                           IOMMU_IOAS_MAP_WRITEABLE |       \
 441                                                   IOMMU_IOAS_MAP_READABLE))
 442
 443 #define test_ioctl_ioas_map_id(ioas_id, buffer, length, iova_p)              \
 444         ASSERT_EQ(0, _test_ioctl_ioas_map(self->fd, ioas_id, buffer, length, \
 445                                           iova_p,                            \
 446                                           IOMMU_IOAS_MAP_WRITEABLE |         \
 447                                                   IOMMU_IOAS_MAP_READABLE))
 448
 449 #define test_ioctl_ioas_map_fixed(buffer, length, iova)                       \
 450         ({                                                                    \
 451                 __u64 __iova = iova;                                          \
 452                 ASSERT_EQ(0, _test_ioctl_ioas_map(                            \
 453                                      self->fd, self->ioas_id, buffer, length, \
 454                                      &__iova,                                 \
 455                                      IOMMU_IOAS_MAP_FIXED_IOVA |              \
 456                                              IOMMU_IOAS_MAP_WRITEABLE |       \
 457                                              IOMMU_IOAS_MAP_READABLE));       \
 458         })
 459
 460 #define test_ioctl_ioas_map_fixed_id(ioas_id, buffer, length, iova)           \
 461         ({                                                                    \
 462                 __u64 __iova = iova;                                          \
 463                 ASSERT_EQ(0,                                                  \
 464                           _test_ioctl_ioas_map(                               \
 465                                   self->fd, ioas_id, buffer, length, &__iova, \
 466                                   IOMMU_IOAS_MAP_FIXED_IOVA |                 \
 467                                           IOMMU_IOAS_MAP_WRITEABLE |          \
 468                                           IOMMU_IOAS_MAP_READABLE));          \
 469         })
 470
 471 #define test_err_ioctl_ioas_map_fixed(_errno, buffer, length, iova)           \
 472         ({                                                                    \
 473                 __u64 __iova = iova;                                          \
 474                 EXPECT_ERRNO(_errno,                                          \
 475                              _test_ioctl_ioas_map(                            \
 476                                      self->fd, self->ioas_id, buffer, length, \
 477                                      &__iova,                                 \
 478                                      IOMMU_IOAS_MAP_FIXED_IOVA |              \
 479                                              IOMMU_IOAS_MAP_WRITEABLE |       \
 480                                              IOMMU_IOAS_MAP_READABLE));       \
 481         })
 482
 483 static int _test_ioctl_ioas_unmap(int fd, unsigned int ioas_id, uint64_t iova,
 484                                   size_t length, uint64_t *out_len)
 485 {
 486         struct iommu_ioas_unmap cmd = {
 487                 .size = sizeof(cmd),
 488                 .ioas_id = ioas_id,
 489                 .iova = iova,
 490                 .length = length,
 491         };
 492         int ret;
 493
 494         ret = ioctl(fd, IOMMU_IOAS_UNMAP, &cmd);
 495         if (out_len)
 496                 *out_len = cmd.length;
 497         return ret;
 498 }
 499 #define test_ioctl_ioas_unmap(iova, length)                                \
 500         ASSERT_EQ(0, _test_ioctl_ioas_unmap(self->fd, self->ioas_id, iova, \
 501                                             length, NULL))
 502
 503 #define test_ioctl_ioas_unmap_id(ioas_id, iova, length)                      \
 504         ASSERT_EQ(0, _test_ioctl_ioas_unmap(self->fd, ioas_id, iova, length, \
 505                                             NULL))
 506
 507 #define test_err_ioctl_ioas_unmap(_errno, iova, length)                      \
 508         EXPECT_ERRNO(_errno, _test_ioctl_ioas_unmap(self->fd, self->ioas_id, \
 509                                                     iova, length, NULL))
 510
 511 static int _test_ioctl_set_temp_memory_limit(int fd, unsigned int limit)
 512 {
 513         struct iommu_test_cmd memlimit_cmd = {
 514                 .size = sizeof(memlimit_cmd),
 515                 .op = IOMMU_TEST_OP_SET_TEMP_MEMORY_LIMIT,
 516                 .memory_limit = { .limit = limit },
 517         };
 518
 519         return ioctl(fd, _IOMMU_TEST_CMD(IOMMU_TEST_OP_SET_TEMP_MEMORY_LIMIT),
 520                      &memlimit_cmd);
 521 }
 522
 523 #define test_ioctl_set_temp_memory_limit(limit) \
 524         ASSERT_EQ(0, _test_ioctl_set_temp_memory_limit(self->fd, limit))
 525
 526 #define test_ioctl_set_default_memory_limit() \
 527         test_ioctl_set_temp_memory_limit(65536)
 528
 529 static void teardown_iommufd(int fd, struct __test_metadata *_metadata)
 530 {
 531         struct iommu_test_cmd test_cmd = {
 532                 .size = sizeof(test_cmd),
 533                 .op = IOMMU_TEST_OP_MD_CHECK_REFS,
 534                 .check_refs = { .length = BUFFER_SIZE,
 535                                 .uptr = (uintptr_t)buffer },
 536         };
 537
 538         if (fd == -1)
 539                 return;
 540
 541         EXPECT_EQ(0, close(fd));
 542
 543         fd = open("/dev/iommu", O_RDWR);
 544         EXPECT_NE(-1, fd);
 545         EXPECT_EQ(0, ioctl(fd, _IOMMU_TEST_CMD(IOMMU_TEST_OP_MD_CHECK_REFS),
 546                            &test_cmd));
 547         EXPECT_EQ(0, close(fd));
 548 }
 549
 550 #define EXPECT_ERRNO(expected_errno, cmd)         \
 551         ({                                        \
 552                 ASSERT_EQ(-1, cmd);               \
 553                 EXPECT_EQ(expected_errno, errno); \
 554         })
 555
 556 #endif
 557
 558 /* @data can be NULL */
 559 static int _test_cmd_get_hw_info(int fd, __u32 device_id, void *data,
 560                                  size_t data_len, uint32_t *capabilities)
 561 {
 562         struct iommu_test_hw_info *info = (struct iommu_test_hw_info *)data;
 563         struct iommu_hw_info cmd = {
 564                 .size = sizeof(cmd),
 565                 .dev_id = device_id,
 566                 .data_len = data_len,
 567                 .data_uptr = (uint64_t)data,
 568                 .out_capabilities = 0,
 569         };
 570         int ret;
 571
 572         ret = ioctl(fd, IOMMU_GET_HW_INFO, &cmd);
 573         if (ret)
 574                 return ret;
 575
 576         assert(cmd.out_data_type == IOMMU_HW_INFO_TYPE_SELFTEST);
 577
 578         /*
 579          * The struct iommu_test_hw_info should be the one defined
 580          * by the current kernel.
 581          */
 582         assert(cmd.data_len == sizeof(struct iommu_test_hw_info));
 583
 584         /*
 585          * Trailing bytes should be 0 if user buffer is larger than
 586          * the data that kernel reports.
 587          */
 588         if (data_len > cmd.data_len) {
 589                 char *ptr = (char *)(data + cmd.data_len);
 590                 int idx = 0;
 591
 592                 while (idx < data_len - cmd.data_len) {
 593                         assert(!*(ptr + idx));
 594                         idx++;
 595                 }
 596         }
 597
 598         if (info) {
 599                 if (data_len >= offsetofend(struct iommu_test_hw_info, test_reg))
 600                         assert(info->test_reg == IOMMU_HW_INFO_SELFTEST_REGVAL);
 601                 if (data_len >= offsetofend(struct iommu_test_hw_info, flags))
 602                         assert(!info->flags);
 603         }
 604
 605         if (capabilities)
 606                 *capabilities = cmd.out_capabilities;
 607
 608         return 0;
 609 }
 610
 611 #define test_cmd_get_hw_info(device_id, data, data_len)               \
 612         ASSERT_EQ(0, _test_cmd_get_hw_info(self->fd, device_id, data, \
 613                                            data_len, NULL))
 614
 615 #define test_err_get_hw_info(_errno, device_id, data, data_len)               \
 616         EXPECT_ERRNO(_errno, _test_cmd_get_hw_info(self->fd, device_id, data, \
 617                                                    data_len, NULL))
 618
 619 #define test_cmd_get_hw_capabilities(device_id, caps, mask) \
 620         ASSERT_EQ(0, _test_cmd_get_hw_info(self->fd, device_id, NULL, 0, &caps))