radeonsi: remove redundant si_shader_info:*(clip|cull)* fields
[mesa.git] / src / drm-shim / device.c
1 /*
2 * Copyright © 2018 Broadcom
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
21 * DEALINGS IN THE SOFTWARE.
22 */
23
24 /** @file
25 *
26 * Implements core GEM support (particularly ioctls) underneath the libc ioctl
27 * wrappers, and calls into the driver-specific code as necessary.
28 */
29
30 #include <c11/threads.h>
31 #include <errno.h>
32 #include <linux/memfd.h>
33 #include <stdbool.h>
34 #include <stdio.h>
35 #include <stdlib.h>
36 #include <string.h>
37 #include <sys/ioctl.h>
38 #include <sys/mman.h>
39 #include <unistd.h>
40 #include "drm-uapi/drm.h"
41 #include "drm_shim.h"
42 #include "util/hash_table.h"
43 #include "util/u_atomic.h"
44
45 #define SHIM_MEM_SIZE (4ull * 1024 * 1024 * 1024)
46
47 #ifndef HAVE_MEMFD_CREATE
48 #include <sys/syscall.h>
49
50 static inline int
51 memfd_create(const char *name, unsigned int flags)
52 {
53 return syscall(SYS_memfd_create, name, flags);
54 }
55 #endif
56
57 /* Global state for the shim shared between libc, core, and driver. */
58 struct shim_device shim_device;
59
60 static uint32_t
61 uint_key_hash(const void *key)
62 {
63 return (uintptr_t)key;
64 }
65
66 static bool
67 uint_key_compare(const void *a, const void *b)
68 {
69 return a == b;
70 }
71
72 /**
73 * Called when the first libc shim is called, to initialize GEM simulation
74 * state (other than the shims themselves).
75 */
76 void
77 drm_shim_device_init(void)
78 {
79 shim_device.fd_map = _mesa_hash_table_create(NULL,
80 uint_key_hash,
81 uint_key_compare);
82
83 mtx_init(&shim_device.mem_lock, mtx_plain);
84
85 shim_device.mem_fd = memfd_create("shim mem", MFD_CLOEXEC);
86 assert(shim_device.mem_fd != -1);
87
88 ASSERTED int ret = ftruncate(shim_device.mem_fd, SHIM_MEM_SIZE);
89 assert(ret == 0);
90
91 util_vma_heap_init(&shim_device.mem_heap, 4096, SHIM_MEM_SIZE - 4096);
92
93 drm_shim_driver_init();
94 }
95
96 static struct shim_fd *
97 drm_shim_file_create(int fd)
98 {
99 struct shim_fd *shim_fd = calloc(1, sizeof(*shim_fd));
100
101 shim_fd->fd = fd;
102 mtx_init(&shim_fd->handle_lock, mtx_plain);
103 shim_fd->handles = _mesa_hash_table_create(NULL,
104 uint_key_hash,
105 uint_key_compare);
106
107 return shim_fd;
108 }
109
110 /**
111 * Called when the libc shims have interposed an open or dup of our simulated
112 * DRM device.
113 */
114 void drm_shim_fd_register(int fd, struct shim_fd *shim_fd)
115 {
116 if (!shim_fd)
117 shim_fd = drm_shim_file_create(fd);
118
119 _mesa_hash_table_insert(shim_device.fd_map, (void *)(uintptr_t)(fd + 1), shim_fd);
120 }
121
122 struct shim_fd *
123 drm_shim_fd_lookup(int fd)
124 {
125 if (fd == -1)
126 return NULL;
127
128 struct hash_entry *entry =
129 _mesa_hash_table_search(shim_device.fd_map, (void *)(uintptr_t)(fd + 1));
130
131 if (!entry)
132 return NULL;
133 return entry->data;
134 }
135
136 /* ioctl used by drmGetVersion() */
137 static int
138 drm_shim_ioctl_version(int fd, unsigned long request, void *arg)
139 {
140 struct drm_version *args = arg;
141 const char *date = "20190320";
142 const char *desc = "shim";
143
144 args->version_major = shim_device.version_major;
145 args->version_minor = shim_device.version_minor;
146 args->version_patchlevel = shim_device.version_patchlevel;
147
148 if (args->name)
149 strncpy(args->name, shim_device.driver_name, args->name_len);
150 if (args->date)
151 strncpy(args->date, date, args->date_len);
152 if (args->desc)
153 strncpy(args->desc, desc, args->desc_len);
154 args->name_len = strlen(shim_device.driver_name);
155 args->date_len = strlen(date);
156 args->desc_len = strlen(desc);
157
158 return 0;
159 }
160
161 static int
162 drm_shim_ioctl_get_cap(int fd, unsigned long request, void *arg)
163 {
164 struct drm_get_cap *gc = arg;
165
166 switch (gc->capability) {
167 case DRM_CAP_PRIME:
168 case DRM_CAP_SYNCOBJ:
169 gc->value = 1;
170 return 0;
171
172 default:
173 fprintf(stderr, "DRM_IOCTL_GET_CAP: unhandled 0x%x\n",
174 (int)gc->capability);
175 return -1;
176 }
177 }
178
179 static int
180 drm_shim_ioctl_gem_close(int fd, unsigned long request, void *arg)
181 {
182 struct shim_fd *shim_fd = drm_shim_fd_lookup(fd);
183 struct drm_gem_close *c = arg;
184
185 if (!c->handle)
186 return 0;
187
188 mtx_lock(&shim_fd->handle_lock);
189 struct hash_entry *entry =
190 _mesa_hash_table_search(shim_fd->handles, (void *)(uintptr_t)c->handle);
191 if (!entry) {
192 mtx_unlock(&shim_fd->handle_lock);
193 return -EINVAL;
194 }
195
196 struct shim_bo *bo = entry->data;
197 _mesa_hash_table_remove(shim_fd->handles, entry);
198 drm_shim_bo_put(bo);
199 mtx_unlock(&shim_fd->handle_lock);
200 return 0;
201 }
202
203 static int
204 drm_shim_ioctl_syncobj_create(int fd, unsigned long request, void *arg)
205 {
206 struct drm_syncobj_create *create = arg;
207
208 create->handle = 1; /* 0 is invalid */
209
210 return 0;
211 }
212
213 static int
214 drm_shim_ioctl_stub(int fd, unsigned long request, void *arg)
215 {
216 return 0;
217 }
218
219 ioctl_fn_t core_ioctls[] = {
220 [_IOC_NR(DRM_IOCTL_VERSION)] = drm_shim_ioctl_version,
221 [_IOC_NR(DRM_IOCTL_GET_CAP)] = drm_shim_ioctl_get_cap,
222 [_IOC_NR(DRM_IOCTL_GEM_CLOSE)] = drm_shim_ioctl_gem_close,
223 [_IOC_NR(DRM_IOCTL_SYNCOBJ_CREATE)] = drm_shim_ioctl_syncobj_create,
224 [_IOC_NR(DRM_IOCTL_SYNCOBJ_DESTROY)] = drm_shim_ioctl_stub,
225 [_IOC_NR(DRM_IOCTL_SYNCOBJ_HANDLE_TO_FD)] = drm_shim_ioctl_stub,
226 [_IOC_NR(DRM_IOCTL_SYNCOBJ_FD_TO_HANDLE)] = drm_shim_ioctl_stub,
227 [_IOC_NR(DRM_IOCTL_SYNCOBJ_WAIT)] = drm_shim_ioctl_stub,
228 };
229
230 /**
231 * Implements the GEM core ioctls, and calls into driver-specific ioctls.
232 */
233 int
234 drm_shim_ioctl(int fd, unsigned long request, void *arg)
235 {
236 ASSERTED int type = _IOC_TYPE(request);
237 int nr = _IOC_NR(request);
238
239 assert(type == DRM_IOCTL_BASE);
240
241 if (nr >= DRM_COMMAND_BASE && nr < DRM_COMMAND_END) {
242 int driver_nr = nr - DRM_COMMAND_BASE;
243
244 if (driver_nr < shim_device.driver_ioctl_count &&
245 shim_device.driver_ioctls[driver_nr]) {
246 return shim_device.driver_ioctls[driver_nr](fd, request, arg);
247 }
248 } else {
249 if (nr < ARRAY_SIZE(core_ioctls) && core_ioctls[nr]) {
250 return core_ioctls[nr](fd, request, arg);
251 }
252 }
253
254 if (nr >= DRM_COMMAND_BASE && nr < DRM_COMMAND_END) {
255 fprintf(stderr,
256 "DRM_SHIM: unhandled driver DRM ioctl %d (0x%08lx)\n",
257 nr - DRM_COMMAND_BASE, request);
258 } else {
259 fprintf(stderr,
260 "DRM_SHIM: unhandled core DRM ioctl 0x%X (0x%08lx)\n",
261 nr, request);
262 }
263
264 return -EINVAL;
265 }
266
267 void
268 drm_shim_bo_init(struct shim_bo *bo, size_t size)
269 {
270
271 mtx_lock(&shim_device.mem_lock);
272 bo->mem_addr = util_vma_heap_alloc(&shim_device.mem_heap, size, 4096);
273 mtx_unlock(&shim_device.mem_lock);
274 assert(bo->mem_addr);
275
276 bo->size = size;
277 }
278
279 struct shim_bo *
280 drm_shim_bo_lookup(struct shim_fd *shim_fd, int handle)
281 {
282 if (!handle)
283 return NULL;
284
285 mtx_lock(&shim_fd->handle_lock);
286 struct hash_entry *entry =
287 _mesa_hash_table_search(shim_fd->handles, (void *)(uintptr_t)handle);
288 struct shim_bo *bo = entry ? entry->data : NULL;
289 mtx_unlock(&shim_fd->handle_lock);
290
291 if (bo)
292 p_atomic_inc(&bo->refcount);
293
294 return bo;
295 }
296
297 void
298 drm_shim_bo_get(struct shim_bo *bo)
299 {
300 p_atomic_inc(&bo->refcount);
301 }
302
303 void
304 drm_shim_bo_put(struct shim_bo *bo)
305 {
306 if (p_atomic_dec_return(&bo->refcount) == 0)
307 return;
308
309 if (shim_device.driver_bo_free)
310 shim_device.driver_bo_free(bo);
311
312 mtx_lock(&shim_device.mem_lock);
313 util_vma_heap_free(&shim_device.mem_heap, bo->mem_addr, bo->size);
314 mtx_unlock(&shim_device.mem_lock);
315 free(bo);
316 }
317
318 int
319 drm_shim_bo_get_handle(struct shim_fd *shim_fd, struct shim_bo *bo)
320 {
321 /* We should probably have some real datastructure for finding the free
322 * number.
323 */
324 mtx_lock(&shim_fd->handle_lock);
325 for (int new_handle = 1; ; new_handle++) {
326 void *key = (void *)(uintptr_t)new_handle;
327 if (!_mesa_hash_table_search(shim_fd->handles, key)) {
328 drm_shim_bo_get(bo);
329 _mesa_hash_table_insert(shim_fd->handles, key, bo);
330 mtx_unlock(&shim_fd->handle_lock);
331 return new_handle;
332 }
333 }
334 mtx_unlock(&shim_fd->handle_lock);
335
336 return 0;
337 }
338
339 /* Creates an mmap offset for the BO in the DRM fd.
340 *
341 * XXX: We should be maintaining a u_mm allocator where the mmap offsets
342 * allocate the size of the BO and it can be used to look the BO back up.
343 * Instead, we just stuff the shim's pointer as the return value, and treat
344 * the incoming mmap offset on the DRM fd as a BO pointer. This doesn't work
345 * if someone tries to map a subset of the BO, but it's enough to get V3D
346 * working for now.
347 */
348 uint64_t
349 drm_shim_bo_get_mmap_offset(struct shim_fd *shim_fd, struct shim_bo *bo)
350 {
351 return (uintptr_t)bo;
352 }
353
354 /* For mmap() on the DRM fd, look up the BO from the "offset" and map the BO's
355 * fd.
356 */
357 void *
358 drm_shim_mmap(struct shim_fd *shim_fd, size_t length, int prot, int flags,
359 int fd, off_t offset)
360 {
361 struct shim_bo *bo = (void *)(uintptr_t)offset;
362
363 return mmap(NULL, length, prot, flags, shim_device.mem_fd, bo->mem_addr);
364 }