1 // SPDX-License-Identifier: GPL-2.0 2 3 #include <dirent.h> 4 #include <errno.h> 5 #include <fcntl.h> 6 #include <stdio.h> 7 #include <stdlib.h> 8 #include <stdint.h> 9 #include <string.h> 10 #include <unistd.h> 11 #include <sys/ioctl.h> 12 #include <sys/mman.h> 13 #include <sys/types.h> 14 15 #include <linux/dma-buf.h> 16 #include <drm/drm.h> 17 18 #include "../../../../include/uapi/linux/dma-heap.h" 19 20 #define DEVPATH "/dev/dma_heap" 21 22 static int check_vgem(int fd) 23 { 24 drm_version_t version = { 0 }; 25 char name[5]; 26 int ret; 27 28 version.name_len = 4; 29 version.name = name; 30 31 ret = ioctl(fd, DRM_IOCTL_VERSION, &version); 32 if (ret) 33 return 0; 34 35 return !strcmp(name, "vgem"); 36 } 37 38 static int open_vgem(void) 39 { 40 int i, fd; 41 const char *drmstr = "/dev/dri/card"; 42 43 fd = -1; 44 for (i = 0; i < 16; i++) { 45 char name[80]; 46 47 snprintf(name, 80, "%s%u", drmstr, i); 48 49 fd = open(name, O_RDWR); 50 if (fd < 0) 51 continue; 52 53 if (!check_vgem(fd)) { 54 close(fd); 55 fd = -1; 56 continue; 57 } else { 58 break; 59 } 60 } 61 return fd; 62 } 63 64 static int import_vgem_fd(int vgem_fd, int dma_buf_fd, uint32_t *handle) 65 { 66 struct drm_prime_handle import_handle = { 67 .fd = dma_buf_fd, 68 .flags = 0, 69 .handle = 0, 70 }; 71 int ret; 72 73 ret = ioctl(vgem_fd, DRM_IOCTL_PRIME_FD_TO_HANDLE, &import_handle); 74 if (ret == 0) 75 *handle = import_handle.handle; 76 return ret; 77 } 78 79 static void close_handle(int vgem_fd, uint32_t handle) 80 { 81 struct drm_gem_close close = { 82 .handle = handle, 83 }; 84 85 ioctl(vgem_fd, DRM_IOCTL_GEM_CLOSE, &close); 86 } 87 88 static int dmabuf_heap_open(char *name) 89 { 90 int ret, fd; 91 char buf[256]; 92 93 ret = snprintf(buf, 256, "%s/%s", DEVPATH, name); 94 if (ret < 0) { 95 printf("snprintf failed!\n"); 96 return ret; 97 } 98 99 fd = open(buf, O_RDWR); 100 if (fd < 0) 101 printf("open %s failed!\n", buf); 102 return fd; 103 } 104 105 static int dmabuf_heap_alloc_fdflags(int fd, size_t len, unsigned int fd_flags, 106 unsigned int heap_flags, int *dmabuf_fd) 107 { 108 struct dma_heap_allocation_data data = { 109 .len = len, 110 .fd = 0, 111 .fd_flags = fd_flags, 112 .heap_flags = heap_flags, 113 }; 114 int ret; 115 116 if (!dmabuf_fd) 117 return -EINVAL; 118 119 ret = ioctl(fd, DMA_HEAP_IOCTL_ALLOC, &data); 120 if (ret < 0) 121 return ret; 122 *dmabuf_fd = (int)data.fd; 123 return ret; 124 } 125 126 static int dmabuf_heap_alloc(int fd, size_t len, unsigned int flags, 127 int *dmabuf_fd) 128 { 129 return dmabuf_heap_alloc_fdflags(fd, len, O_RDWR | O_CLOEXEC, flags, 130 dmabuf_fd); 131 } 132 133 static int dmabuf_sync(int fd, int start_stop) 134 { 135 struct dma_buf_sync sync = { 136 .flags = start_stop | DMA_BUF_SYNC_RW, 137 }; 138 139 return ioctl(fd, DMA_BUF_IOCTL_SYNC, &sync); 140 } 141 142 #define ONE_MEG (1024 * 1024) 143 144 static int test_alloc_and_import(char *heap_name) 145 { 146 int heap_fd = -1, dmabuf_fd = -1, importer_fd = -1; 147 uint32_t handle = 0; 148 void *p = NULL; 149 int ret; 150 151 heap_fd = dmabuf_heap_open(heap_name); 152 if (heap_fd < 0) 153 return -1; 154 155 printf(" Testing allocation and importing: "); 156 ret = dmabuf_heap_alloc(heap_fd, ONE_MEG, 0, &dmabuf_fd); 157 if (ret) { 158 printf("FAIL (Allocation Failed!)\n"); 159 ret = -1; 160 goto out; 161 } 162 /* mmap and write a simple pattern */ 163 p = mmap(NULL, 164 ONE_MEG, 165 PROT_READ | PROT_WRITE, 166 MAP_SHARED, 167 dmabuf_fd, 168 0); 169 if (p == MAP_FAILED) { 170 printf("FAIL (mmap() failed)\n"); 171 ret = -1; 172 goto out; 173 } 174 175 dmabuf_sync(dmabuf_fd, DMA_BUF_SYNC_START); 176 memset(p, 1, ONE_MEG / 2); 177 memset((char *)p + ONE_MEG / 2, 0, ONE_MEG / 2); 178 dmabuf_sync(dmabuf_fd, DMA_BUF_SYNC_END); 179 180 importer_fd = open_vgem(); 181 if (importer_fd < 0) { 182 ret = importer_fd; 183 printf("(Could not open vgem - skipping): "); 184 } else { 185 ret = import_vgem_fd(importer_fd, dmabuf_fd, &handle); 186 if (ret < 0) { 187 printf("FAIL (Failed to import buffer)\n"); 188 goto out; 189 } 190 } 191 192 ret = dmabuf_sync(dmabuf_fd, DMA_BUF_SYNC_START); 193 if (ret < 0) { 194 printf("FAIL (DMA_BUF_SYNC_START failed!)\n"); 195 goto out; 196 } 197 198 memset(p, 0xff, ONE_MEG); 199 ret = dmabuf_sync(dmabuf_fd, DMA_BUF_SYNC_END); 200 if (ret < 0) { 201 printf("FAIL (DMA_BUF_SYNC_END failed!)\n"); 202 goto out; 203 } 204 205 close_handle(importer_fd, handle); 206 ret = 0; 207 printf(" OK\n"); 208 out: 209 if (p) 210 munmap(p, ONE_MEG); 211 if (importer_fd >= 0) 212 close(importer_fd); 213 if (dmabuf_fd >= 0) 214 close(dmabuf_fd); 215 if (heap_fd >= 0) 216 close(heap_fd); 217 218 return ret; 219 } 220 221 /* Test the ioctl version compatibility w/ a smaller structure then expected */ 222 static int dmabuf_heap_alloc_older(int fd, size_t len, unsigned int flags, 223 int *dmabuf_fd) 224 { 225 int ret; 226 unsigned int older_alloc_ioctl; 227 struct dma_heap_allocation_data_smaller { 228 __u64 len; 229 __u32 fd; 230 __u32 fd_flags; 231 } data = { 232 .len = len, 233 .fd = 0, 234 .fd_flags = O_RDWR | O_CLOEXEC, 235 }; 236 237 older_alloc_ioctl = _IOWR(DMA_HEAP_IOC_MAGIC, 0x0, 238 struct dma_heap_allocation_data_smaller); 239 if (!dmabuf_fd) 240 return -EINVAL; 241 242 ret = ioctl(fd, older_alloc_ioctl, &data); 243 if (ret < 0) 244 return ret; 245 *dmabuf_fd = (int)data.fd; 246 return ret; 247 } 248 249 /* Test the ioctl version compatibility w/ a larger structure then expected */ 250 static int dmabuf_heap_alloc_newer(int fd, size_t len, unsigned int flags, 251 int *dmabuf_fd) 252 { 253 int ret; 254 unsigned int newer_alloc_ioctl; 255 struct dma_heap_allocation_data_bigger { 256 __u64 len; 257 __u32 fd; 258 __u32 fd_flags; 259 __u64 heap_flags; 260 __u64 garbage1; 261 __u64 garbage2; 262 __u64 garbage3; 263 } data = { 264 .len = len, 265 .fd = 0, 266 .fd_flags = O_RDWR | O_CLOEXEC, 267 .heap_flags = flags, 268 .garbage1 = 0xffffffff, 269 .garbage2 = 0x88888888, 270 .garbage3 = 0x11111111, 271 }; 272 273 newer_alloc_ioctl = _IOWR(DMA_HEAP_IOC_MAGIC, 0x0, 274 struct dma_heap_allocation_data_bigger); 275 if (!dmabuf_fd) 276 return -EINVAL; 277 278 ret = ioctl(fd, newer_alloc_ioctl, &data); 279 if (ret < 0) 280 return ret; 281 282 *dmabuf_fd = (int)data.fd; 283 return ret; 284 } 285 286 static int test_alloc_compat(char *heap_name) 287 { 288 int heap_fd = -1, dmabuf_fd = -1; 289 int ret; 290 291 heap_fd = dmabuf_heap_open(heap_name); 292 if (heap_fd < 0) 293 return -1; 294 295 printf(" Testing (theoretical)older alloc compat: "); 296 ret = dmabuf_heap_alloc_older(heap_fd, ONE_MEG, 0, &dmabuf_fd); 297 if (ret) { 298 printf("FAIL (Older compat allocation failed!)\n"); 299 ret = -1; 300 goto out; 301 } 302 close(dmabuf_fd); 303 printf("OK\n"); 304 305 printf(" Testing (theoretical)newer alloc compat: "); 306 ret = dmabuf_heap_alloc_newer(heap_fd, ONE_MEG, 0, &dmabuf_fd); 307 if (ret) { 308 printf("FAIL (Newer compat allocation failed!)\n"); 309 ret = -1; 310 goto out; 311 } 312 printf("OK\n"); 313 out: 314 if (dmabuf_fd >= 0) 315 close(dmabuf_fd); 316 if (heap_fd >= 0) 317 close(heap_fd); 318 319 return ret; 320 } 321 322 static int test_alloc_errors(char *heap_name) 323 { 324 int heap_fd = -1, dmabuf_fd = -1; 325 int ret; 326 327 heap_fd = dmabuf_heap_open(heap_name); 328 if (heap_fd < 0) 329 return -1; 330 331 printf(" Testing expected error cases: "); 332 ret = dmabuf_heap_alloc(0, ONE_MEG, 0x111111, &dmabuf_fd); 333 if (!ret) { 334 printf("FAIL (Did not see expected error (invalid fd)!)\n"); 335 ret = -1; 336 goto out; 337 } 338 339 ret = dmabuf_heap_alloc(heap_fd, ONE_MEG, 0x111111, &dmabuf_fd); 340 if (!ret) { 341 printf("FAIL (Did not see expected error (invalid heap flags)!)\n"); 342 ret = -1; 343 goto out; 344 } 345 346 ret = dmabuf_heap_alloc_fdflags(heap_fd, ONE_MEG, 347 ~(O_RDWR | O_CLOEXEC), 0, &dmabuf_fd); 348 if (!ret) { 349 printf("FAIL (Did not see expected error (invalid fd flags)!)\n"); 350 ret = -1; 351 goto out; 352 } 353 354 printf("OK\n"); 355 ret = 0; 356 out: 357 if (dmabuf_fd >= 0) 358 close(dmabuf_fd); 359 if (heap_fd >= 0) 360 close(heap_fd); 361 362 return ret; 363 } 364 365 int main(void) 366 { 367 DIR *d; 368 struct dirent *dir; 369 int ret = -1; 370 371 d = opendir(DEVPATH); 372 if (!d) { 373 printf("No %s directory?\n", DEVPATH); 374 return -1; 375 } 376 377 while ((dir = readdir(d)) != NULL) { 378 if (!strncmp(dir->d_name, ".", 2)) 379 continue; 380 if (!strncmp(dir->d_name, "..", 3)) 381 continue; 382 383 printf("Testing heap: %s\n", dir->d_name); 384 printf("=======================================\n"); 385 ret = test_alloc_and_import(dir->d_name); 386 if (ret) 387 break; 388 389 ret = test_alloc_compat(dir->d_name); 390 if (ret) 391 break; 392 393 ret = test_alloc_errors(dir->d_name); 394 if (ret) 395 break; 396 } 397 closedir(d); 398 399 return ret; 400 } 401