diff --git a/src/broadcom/vulkan/v3dv_bo.c b/src/broadcom/vulkan/v3dv_bo.c
index 099223b7253..e4e36e1326a 100644
--- a/src/broadcom/vulkan/v3dv_bo.c
+++ b/src/broadcom/vulkan/v3dv_bo.c
@@ -43,9 +43,10 @@ v3dv_bo_alloc(struct v3dv_device *device, uint32_t size)
       .size = size
    };
 
-   int ret = v3dv_ioctl(device->fd, DRM_IOCTL_V3D_CREATE_BO, &create);
-   if (ret != 0)
+   int ret = v3dv_ioctl(device->render_fd, DRM_IOCTL_V3D_CREATE_BO, &create);
+   if (ret != 0) {
       return NULL;
+   }
 
    assert(create.offset % page_align == 0);
    assert((create.offset & 0xffffffff) == create.offset);
@@ -70,7 +71,7 @@ v3dv_bo_free(struct v3dv_device *device, struct v3dv_bo *bo)
    struct drm_gem_close c;
    memset(&c, 0, sizeof(c));
    c.handle = bo->handle;
-   int ret = v3dv_ioctl(device->fd, DRM_IOCTL_GEM_CLOSE, &c);
+   int ret = v3dv_ioctl(device->render_fd, DRM_IOCTL_GEM_CLOSE, &c);
    if (ret != 0)
       fprintf(stderr, "close object %d: %s\n", bo->handle, strerror(errno));
 
@@ -89,14 +90,14 @@ v3dv_bo_map_unsynchronized(struct v3dv_device *device,
    struct drm_v3d_mmap_bo map;
    memset(&map, 0, sizeof(map));
    map.handle = bo->handle;
-   int ret = v3dv_ioctl(device->fd, DRM_IOCTL_V3D_MMAP_BO, &map);
+   int ret = v3dv_ioctl(device->render_fd, DRM_IOCTL_V3D_MMAP_BO, &map);
    if (ret != 0) {
       fprintf(stderr, "map ioctl failure\n");
       return false;
    }
 
    bo->map = mmap(NULL, size, PROT_READ | PROT_WRITE, MAP_SHARED,
-                  device->fd, map.offset);
+                  device->render_fd, map.offset);
    if (bo->map == MAP_FAILED) {
       fprintf(stderr, "mmap of bo %d (offset 0x%016llx, size %d) failed\n",
               bo->handle, (long long)map.offset, (uint32_t)bo->size);
@@ -118,7 +119,7 @@ v3dv_bo_wait(struct v3dv_device *device,
       .handle = bo->handle,
       .timeout_ns = timeout_ns,
    };
-   return v3dv_ioctl(device->fd, DRM_IOCTL_V3D_WAIT_BO, &wait) == 0;
+   return v3dv_ioctl(device->render_fd, DRM_IOCTL_V3D_WAIT_BO, &wait) == 0;
 }
 
 bool
diff --git a/src/broadcom/vulkan/v3dv_device.c b/src/broadcom/vulkan/v3dv_device.c
index 4f782116198..34e504bef50 100644
--- a/src/broadcom/vulkan/v3dv_device.c
+++ b/src/broadcom/vulkan/v3dv_device.c
@@ -225,9 +225,7 @@ v3dv_CreateInstance(const VkInstanceCreateInfo *pCreateInfo,
 static void
 physical_device_finish(struct v3dv_physical_device *device)
 {
-   close(device->local_fd);
-   if (device->master_fd >= 0)
-      close(device->master_fd);
+   close(device->render_fd);
    if (device->display_fd >= 0)
       close(device->display_fd);
 
@@ -327,7 +325,6 @@ physical_device_init(struct v3dv_physical_device *device,
 {
    VkResult result = VK_SUCCESS;
    int32_t display_fd = -1;
-   int32_t master_fd = -1;
 
    device->_loader_data.loaderMagic = ICD_LOADER_MAGIC;
    device->instance = instance;
@@ -337,9 +334,6 @@ physical_device_init(struct v3dv_physical_device *device,
    if (render_fd < 0)
       return vk_error(instance, VK_ERROR_INCOMPATIBLE_DRIVER);
 
-   assert(strlen(path) < ARRAY_SIZE(device->path));
-   snprintf(device->path, ARRAY_SIZE(device->path), "%s", path);
-
    /* If we are running on real hardware we need to open the vc4 display
     * device so we can allocate winsys BOs for the v3d core to render into.
     */
@@ -354,18 +348,17 @@ physical_device_init(struct v3dv_physical_device *device,
    }
 #endif
 
-   device->local_fd = render_fd;       /* The v3d render node  */
+   device->render_fd = render_fd;       /* The v3d render node  */
    device->display_fd = display_fd;    /* The vc4 primary node */
-   device->master_fd = master_fd;      /* For VK_KHR_display */
 
    uint8_t zeroes[VK_UUID_SIZE] = { 0 };
    memcpy(device->pipeline_cache_uuid, zeroes, VK_UUID_SIZE);
 
 #if using_v3d_simulator
-   device->sim_file = v3d_simulator_init(device->local_fd);
+   device->sim_file = v3d_simulator_init(device->render_fd);
 #endif
 
-   if (!v3d_get_device_info(device->local_fd, &device->devinfo, &v3dv_ioctl)) {
+   if (!v3d_get_device_info(device->render_fd, &device->devinfo, &v3dv_ioctl)) {
       result = VK_ERROR_INCOMPATIBLE_DRIVER;
       goto fail;
    }
@@ -414,8 +407,6 @@ fail:
       close(render_fd);
    if (display_fd >= 0)
       close(display_fd);
-   if (master_fd >= 0)
-      close(master_fd);
 
    return result;
 }
@@ -1128,8 +1119,8 @@ v3dv_CreateDevice(VkPhysicalDevice physicalDevice,
    else
       device->alloc = physical_device->instance->alloc;
 
-   device->fd = physical_device->local_fd;
-   if (device->fd == -1) {
+   device->render_fd = physical_device->render_fd;
+   if (device->render_fd == -1) {
       result = VK_ERROR_INITIALIZATION_FAILED;
       goto fail;
    }
@@ -1151,7 +1142,7 @@ v3dv_CreateDevice(VkPhysicalDevice physicalDevice,
    device->devinfo = physical_device->devinfo;
    device->enabled_extensions = enabled_extensions;
 
-   int ret = drmSyncobjCreate(device->fd,
+   int ret = drmSyncobjCreate(device->render_fd,
                               DRM_SYNCOBJ_CREATE_SIGNALED,
                               &device->last_job_sync);
    if (ret) {
@@ -1177,7 +1168,7 @@ v3dv_DestroyDevice(VkDevice _device,
 {
    V3DV_FROM_HANDLE(v3dv_device, device, _device);
 
-   drmSyncobjDestroy(device->fd, device->last_job_sync);
+   drmSyncobjDestroy(device->render_fd, device->last_job_sync);
    queue_finish(&device->queue);
 
    vk_free2(&default_alloc, pAllocator, device);
@@ -1202,8 +1193,8 @@ v3dv_DeviceWaitIdle(VkDevice _device)
 {
    V3DV_FROM_HANDLE(v3dv_device, device, _device);
 
-   int ret =
-      drmSyncobjWait(device->fd, &device->last_job_sync, 1, INT64_MAX, 0, NULL);
+   int ret = drmSyncobjWait(device->render_fd,
+                            &device->last_job_sync, 1, INT64_MAX, 0, NULL);
    if (ret)
       return VK_ERROR_DEVICE_LOST;
 
@@ -1302,7 +1293,7 @@ device_import_bo(struct v3dv_device *device,
 
    int ret;
    uint32_t handle;
-   ret = drmPrimeFDToHandle(device->fd, fd, &handle);
+   ret = drmPrimeFDToHandle(device->render_fd, fd, &handle);
    if (ret) {
       result = VK_ERROR_INVALID_EXTERNAL_HANDLE;
       goto fail;
@@ -1311,7 +1302,7 @@ device_import_bo(struct v3dv_device *device,
    struct drm_v3d_get_bo_offset get_offset = {
       .handle = handle,
    };
-   ret = v3dv_ioctl(device->fd, DRM_IOCTL_V3D_GET_BO_OFFSET, &get_offset);
+   ret = v3dv_ioctl(device->render_fd, DRM_IOCTL_V3D_GET_BO_OFFSET, &get_offset);
    if (ret) {
       result = VK_ERROR_INVALID_EXTERNAL_HANDLE;
       goto fail;
@@ -1807,7 +1798,8 @@ v3dv_GetMemoryFdKHR(VkDevice _device,
           pGetFdInfo->handleType == VK_EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF_BIT_EXT);
 
    int fd, ret;
-   ret = drmPrimeHandleToFD(device->fd, mem->bo->handle, DRM_CLOEXEC, &fd);
+   ret =
+      drmPrimeHandleToFD(device->render_fd, mem->bo->handle, DRM_CLOEXEC, &fd);
    if (ret)
       return vk_error(device->instance, VK_ERROR_OUT_OF_HOST_MEMORY);
 
diff --git a/src/broadcom/vulkan/v3dv_private.h b/src/broadcom/vulkan/v3dv_private.h
index 6d372559a7e..f3fb8f887c6 100644
--- a/src/broadcom/vulkan/v3dv_private.h
+++ b/src/broadcom/vulkan/v3dv_private.h
@@ -133,11 +133,9 @@ struct v3dv_physical_device {
    struct v3dv_device_extension_table supported_extensions;
    struct v3dv_physical_device_dispatch_table dispatch;
 
-   char path[20];
    char *name;
-   int32_t local_fd;
+   int32_t render_fd;
    int32_t display_fd;
-   int32_t master_fd;
    uint8_t pipeline_cache_uuid[VK_UUID_SIZE];
 
    struct wsi_device wsi_device;
@@ -204,7 +202,7 @@ struct v3dv_device {
    struct v3dv_device_extension_table enabled_extensions;
    struct v3dv_device_dispatch_table dispatch;
 
-   int32_t fd;
+   int32_t render_fd;
    int32_t display_fd;
    struct v3d_device_info devinfo;
    struct v3dv_queue queue;
diff --git a/src/broadcom/vulkan/v3dv_queue.c b/src/broadcom/vulkan/v3dv_queue.c
index 1d6e1b5b67d..f40256ecbe8 100644
--- a/src/broadcom/vulkan/v3dv_queue.c
+++ b/src/broadcom/vulkan/v3dv_queue.c
@@ -91,11 +91,11 @@ process_semaphores_to_signal(struct v3dv_device *device,
       sem->fd = -1;
 
       int fd;
-      drmSyncobjExportSyncFile(device->fd, device->last_job_sync, &fd);
+      drmSyncobjExportSyncFile(device->render_fd, device->last_job_sync, &fd);
       if (fd == -1)
          return VK_ERROR_DEVICE_LOST;
 
-      int ret = drmSyncobjImportSyncFile(device->fd, sem->sync, fd);
+      int ret = drmSyncobjImportSyncFile(device->render_fd, sem->sync, fd);
       if (ret)
          return VK_ERROR_DEVICE_LOST;
 
@@ -118,11 +118,11 @@ process_fence_to_signal(struct v3dv_device *device, VkFence _fence)
    fence->fd = -1;
 
    int fd;
-   drmSyncobjExportSyncFile(device->fd, device->last_job_sync, &fd);
+   drmSyncobjExportSyncFile(device->render_fd, device->last_job_sync, &fd);
    if (fd == -1)
       return VK_ERROR_DEVICE_LOST;
 
-   int ret = drmSyncobjImportSyncFile(device->fd, fence->sync, fd);
+   int ret = drmSyncobjImportSyncFile(device->render_fd, fence->sync, fd);
    if (ret)
       return VK_ERROR_DEVICE_LOST;
 
@@ -184,7 +184,7 @@ queue_submit_job(struct v3dv_job *job, bool do_wait)
    struct v3dv_device *device = job->cmd_buffer->device;
    v3dv_clif_dump(device, job, &submit);
 
-   int ret = v3dv_ioctl(device->fd, DRM_IOCTL_V3D_SUBMIT_CL, &submit);
+   int ret = v3dv_ioctl(device->render_fd, DRM_IOCTL_V3D_SUBMIT_CL, &submit);
    static bool warned = false;
    if (ret && !warned) {
       fprintf(stderr, "Draw call returned %s. Expect corruption.\n",
@@ -277,7 +277,7 @@ v3dv_CreateSemaphore(VkDevice _device,
 
    sem->fd = -1;
 
-   int ret = drmSyncobjCreate(device->fd, 0, &sem->sync);
+   int ret = drmSyncobjCreate(device->render_fd, 0, &sem->sync);
    if (ret) {
       vk_free2(&device->alloc, pAllocator, sem);
       return vk_error(device->instance, VK_ERROR_OUT_OF_HOST_MEMORY);
@@ -299,7 +299,7 @@ v3dv_DestroySemaphore(VkDevice _device,
    if (sem == NULL)
       return;
 
-   drmSyncobjDestroy(device->fd, sem->sync);
+   drmSyncobjDestroy(device->render_fd, sem->sync);
 
    if (sem->fd != -1)
       close(sem->fd);
@@ -326,7 +326,7 @@ v3dv_CreateFence(VkDevice _device,
    unsigned flags = 0;
    if (pCreateInfo->flags & VK_FENCE_CREATE_SIGNALED_BIT)
       flags |= DRM_SYNCOBJ_CREATE_SIGNALED;
-   int ret = drmSyncobjCreate(device->fd, flags, &fence->sync);
+   int ret = drmSyncobjCreate(device->render_fd, flags, &fence->sync);
    if (ret) {
       vk_free2(&device->alloc, pAllocator, fence);
       return vk_error(device->instance, VK_ERROR_OUT_OF_HOST_MEMORY);
@@ -350,7 +350,7 @@ v3dv_DestroyFence(VkDevice _device,
    if (fence == NULL)
       return;
 
-   drmSyncobjDestroy(device->fd, fence->sync);
+   drmSyncobjDestroy(device->render_fd, fence->sync);
 
    if (fence->fd != -1)
       close(fence->fd);
@@ -364,7 +364,7 @@ v3dv_GetFenceStatus(VkDevice _device, VkFence _fence)
    V3DV_FROM_HANDLE(v3dv_device, device, _device);
    V3DV_FROM_HANDLE(v3dv_fence, fence, _fence);
 
-   int ret = drmSyncobjWait(device->fd, &fence->sync, 1,
+   int ret = drmSyncobjWait(device->render_fd, &fence->sync, 1,
                             0, DRM_SYNCOBJ_WAIT_FLAGS_WAIT_FOR_SUBMIT, NULL);
    if (ret == -ETIME)
       return VK_NOT_READY;
@@ -389,7 +389,7 @@ v3dv_ResetFences(VkDevice _device, uint32_t fenceCount, const VkFence *pFences)
       syncobjs[i] = fence->sync;
    }
 
-   int ret = drmSyncobjReset(device->fd, syncobjs, fenceCount);
+   int ret = drmSyncobjReset(device->render_fd, syncobjs, fenceCount);
 
    vk_free(&device->alloc, syncobjs);
 
@@ -424,7 +424,7 @@ v3dv_WaitForFences(VkDevice _device,
 
    int ret;
    do {
-      ret = drmSyncobjWait(device->fd, syncobjs, fenceCount,
+      ret = drmSyncobjWait(device->render_fd, syncobjs, fenceCount,
                            timeout, flags, NULL);
    } while (ret == -ETIME && gettime_ns() < abs_timeout);
 
diff --git a/src/broadcom/vulkan/v3dv_wsi.c b/src/broadcom/vulkan/v3dv_wsi.c
index 5716f6adef0..77fe1d35563 100644
--- a/src/broadcom/vulkan/v3dv_wsi.c
+++ b/src/broadcom/vulkan/v3dv_wsi.c
@@ -45,8 +45,7 @@ v3dv_wsi_init(struct v3dv_physical_device *physical_device)
                             v3dv_physical_device_to_handle(physical_device),
                             v3dv_wsi_proc_addr,
                             &physical_device->instance->alloc,
-                            physical_device->master_fd,
-                            NULL, false);
+                            -1, NULL, false);
    if (result != VK_SUCCESS)
       return result;