src/vulkan/runtime/vk_semaphore.c - third_party/mesa - Git at Google

 /*
  * Copyright © 2021 Intel Corporation
  *
  * Permission is hereby granted, free of charge, to any person obtaining a
  * copy of this software and associated documentation files (the "Software"),
  * to deal in the Software without restriction, including without limitation
  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
  * and/or sell copies of the Software, and to permit persons to whom the
  * Software is furnished to do so, subject to the following conditions:
  *
  * The above copyright notice and this permission notice (including the next
  * paragraph) shall be included in all copies or substantial portions of the
  * Software.
  *
  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
  * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
  * IN THE SOFTWARE.
  */

 #include "vk_semaphore.h"

 #include "util/os_time.h"

 #ifndef _WIN32
 #include <unistd.h>
 #endif

 #include "vk_common_entrypoints.h"
 #include "vk_device.h"
 #include "vk_log.h"
 #include "vk_physical_device.h"
 #include "vk_util.h"

 static VkExternalSemaphoreHandleTypeFlags
 vk_sync_semaphore_import_types(const struct vk_sync_type *type,
                                VkSemaphoreType semaphore_type)
 {
    VkExternalSemaphoreHandleTypeFlags handle_types = 0;

    if (type->import_opaque_fd)
       handle_types |= VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT;

    if (type->export_sync_file && semaphore_type == VK_SEMAPHORE_TYPE_BINARY)
       handle_types |= VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD_BIT;

 #if defined(USE_MAGMA)
    if (type->import_magma_handle)
       handle_types |= VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_ZIRCON_EVENT_BIT_FUCHSIA;
 #endif

    return handle_types;
 }

 static VkExternalSemaphoreHandleTypeFlags
 vk_sync_semaphore_export_types(const struct vk_sync_type *type,
                                VkSemaphoreType semaphore_type)
 {
    VkExternalSemaphoreHandleTypeFlags handle_types = 0;

    if (type->export_opaque_fd)
       handle_types |= VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT;

    if (type->export_sync_file && semaphore_type == VK_SEMAPHORE_TYPE_BINARY)
       handle_types |= VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD_BIT;

 #if defined(USE_MAGMA)
    if (type->export_magma_handle)
       handle_types |= VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_ZIRCON_EVENT_BIT_FUCHSIA;
 #endif

    return handle_types;
 }

 static VkExternalSemaphoreHandleTypeFlags
 vk_sync_semaphore_handle_types(const struct vk_sync_type *type,
                                VkSemaphoreType semaphore_type)
 {
    return vk_sync_semaphore_export_types(type, semaphore_type) &
           vk_sync_semaphore_import_types(type, semaphore_type);
 }

 static const struct vk_sync_type *
 get_semaphore_sync_type(struct vk_physical_device *pdevice,
                         VkSemaphoreType semaphore_type,
                         VkExternalSemaphoreHandleTypeFlags handle_types)
 {
    assert(semaphore_type == VK_SEMAPHORE_TYPE_BINARY ||
           semaphore_type == VK_SEMAPHORE_TYPE_TIMELINE);

    enum vk_sync_features req_features = VK_SYNC_FEATURE_GPU_WAIT;
    if (semaphore_type == VK_SEMAPHORE_TYPE_TIMELINE) {
       req_features |= VK_SYNC_FEATURE_TIMELINE |
                       VK_SYNC_FEATURE_CPU_WAIT;
    } else {
       req_features |= VK_SYNC_FEATURE_BINARY;
    }

    for (const struct vk_sync_type *const *t =
         pdevice->supported_sync_types; *t; t++) {
       if (req_features & ~(*t)->features)
          continue;

       if (handle_types & ~vk_sync_semaphore_handle_types(*t, semaphore_type))
          continue;

       return *t;
    }

    return NULL;
 }

 static VkSemaphoreType
 get_semaphore_type(const void *pNext, uint64_t *initial_value)
 {
    const VkSemaphoreTypeCreateInfo *type_info =
       vk_find_struct_const(pNext, SEMAPHORE_TYPE_CREATE_INFO);

    if (!type_info)
       return VK_SEMAPHORE_TYPE_BINARY;

    if (initial_value)
       *initial_value = type_info->initialValue;
    return type_info->semaphoreType;
 }

 VKAPI_ATTR VkResult VKAPI_CALL
 vk_common_CreateSemaphore(VkDevice _device,
                           const VkSemaphoreCreateInfo *pCreateInfo,
                           const VkAllocationCallbacks *pAllocator,
                           VkSemaphore *pSemaphore)
 {
    VK_FROM_HANDLE(vk_device, device, _device);
    struct vk_semaphore *semaphore;

    assert(pCreateInfo->sType == VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO);

    uint64_t initial_value = 0;
    const VkSemaphoreType semaphore_type =
       get_semaphore_type(pCreateInfo->pNext, &initial_value);

    if (semaphore_type == VK_SEMAPHORE_TYPE_TIMELINE)
       assert(device->timeline_mode != VK_DEVICE_TIMELINE_MODE_NONE);

    const VkExportSemaphoreCreateInfo *export =
       vk_find_struct_const(pCreateInfo->pNext, EXPORT_SEMAPHORE_CREATE_INFO);
    VkExternalSemaphoreHandleTypeFlags handle_types =
       export ? export->handleTypes : 0;

    const struct vk_sync_type *sync_type =
       get_semaphore_sync_type(device->physical, semaphore_type, handle_types);
    if (sync_type == NULL) {
       /* We should always be able to get a semaphore type for internal */
       assert(get_semaphore_sync_type(device->physical, semaphore_type, 0) != NULL);
       return vk_errorf(device, VK_ERROR_INVALID_EXTERNAL_HANDLE,
                        "Combination of external handle types is unsupported "
                        "for VkSemaphore creation.");
    }

    /* If the timeline mode is ASSISTED, then any permanent binary semaphore
     * types need to be able to support move.  We don't require this for
     * temporary unless that temporary is also used as a semaphore signal
     * operation which is much trickier to assert early.
     */
    if (semaphore_type == VK_SEMAPHORE_TYPE_BINARY &&
        vk_device_supports_threaded_submit(device))
       assert(sync_type->move);

    /* Allocate a vk_semaphore + vk_sync implementation. Because the permanent
     * field of vk_semaphore is the base field of the vk_sync implementation,
     * we can make the 2 structures overlap.
     */
    size_t size = offsetof(struct vk_semaphore, permanent) + sync_type->size;
    semaphore = vk_object_zalloc(device, pAllocator, size,
                                 VK_OBJECT_TYPE_SEMAPHORE);
    if (semaphore == NULL)
       return vk_error(device, VK_ERROR_OUT_OF_HOST_MEMORY);

    semaphore->type = semaphore_type;

    enum vk_sync_flags sync_flags = 0;
    if (semaphore_type == VK_SEMAPHORE_TYPE_TIMELINE)
       sync_flags |= VK_SYNC_IS_TIMELINE;
    if (handle_types)
       sync_flags |= VK_SYNC_IS_SHAREABLE;

    VkResult result = vk_sync_init(device, &semaphore->permanent,
                                   sync_type, sync_flags, initial_value);
    if (result != VK_SUCCESS) {
       vk_object_free(device, pAllocator, semaphore);
       return result;
    }

    *pSemaphore = vk_semaphore_to_handle(semaphore);

    return VK_SUCCESS;
 }

 void
 vk_semaphore_reset_temporary(struct vk_device *device,
                              struct vk_semaphore *semaphore)
 {
    if (semaphore->temporary == NULL)
       return;

    vk_sync_destroy(device, semaphore->temporary);
    semaphore->temporary = NULL;
 }

 VKAPI_ATTR void VKAPI_CALL
 vk_common_DestroySemaphore(VkDevice _device,
                            VkSemaphore _semaphore,
                            const VkAllocationCallbacks *pAllocator)
 {
    VK_FROM_HANDLE(vk_device, device, _device);
    VK_FROM_HANDLE(vk_semaphore, semaphore, _semaphore);

    if (semaphore == NULL)
       return;

    vk_semaphore_reset_temporary(device, semaphore);
    vk_sync_finish(device, &semaphore->permanent);

    vk_object_free(device, pAllocator, semaphore);
 }

 VKAPI_ATTR void VKAPI_CALL
 vk_common_GetPhysicalDeviceExternalSemaphoreProperties(
    VkPhysicalDevice physicalDevice,
    const VkPhysicalDeviceExternalSemaphoreInfo *pExternalSemaphoreInfo,
    VkExternalSemaphoreProperties *pExternalSemaphoreProperties)
 {
    VK_FROM_HANDLE(vk_physical_device, pdevice, physicalDevice);

    assert(pExternalSemaphoreInfo->sType ==
           VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO);
    const VkExternalSemaphoreHandleTypeFlagBits handle_type =
       pExternalSemaphoreInfo->handleType;

    const VkSemaphoreType semaphore_type =
       get_semaphore_type(pExternalSemaphoreInfo->pNext, NULL);

    const struct vk_sync_type *sync_type =
       get_semaphore_sync_type(pdevice, semaphore_type, handle_type);
    if (sync_type == NULL) {
       pExternalSemaphoreProperties->exportFromImportedHandleTypes = 0;
       pExternalSemaphoreProperties->compatibleHandleTypes = 0;
       pExternalSemaphoreProperties->externalSemaphoreFeatures = 0;
       return;
    }

    VkExternalSemaphoreHandleTypeFlagBits import =
       vk_sync_semaphore_import_types(sync_type, semaphore_type);
    VkExternalSemaphoreHandleTypeFlagBits export =
       vk_sync_semaphore_export_types(sync_type, semaphore_type);

    if (handle_type != VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT) {
       const struct vk_sync_type *opaque_sync_type =
          get_semaphore_sync_type(pdevice, semaphore_type,
                                  VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT);

       /* If we're a different vk_sync_type than the one selected when only
        * OPAQUE_FD is set, then we can't import/export OPAQUE_FD.  Put
        * differently, there can only be one OPAQUE_FD sync type.
        */
       if (sync_type != opaque_sync_type) {
          import &= ~VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT;
          export &= ~VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT;
       }
    }

    VkExternalSemaphoreHandleTypeFlags compatible = import & export;
    VkExternalSemaphoreFeatureFlags features = 0;
    if (handle_type & export)
       features |= VK_EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE_BIT;
    if (handle_type & import)
       features |= VK_EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE_BIT;

    pExternalSemaphoreProperties->exportFromImportedHandleTypes = export;
    pExternalSemaphoreProperties->compatibleHandleTypes = compatible;
    pExternalSemaphoreProperties->externalSemaphoreFeatures = features;
 }

 VKAPI_ATTR VkResult VKAPI_CALL
 vk_common_GetSemaphoreCounterValue(VkDevice _device,
                                    VkSemaphore _semaphore,
                                    uint64_t *pValue)
 {
    VK_FROM_HANDLE(vk_device, device, _device);
    VK_FROM_HANDLE(vk_semaphore, semaphore, _semaphore);

    if (vk_device_is_lost(device))
       return VK_ERROR_DEVICE_LOST;

    struct vk_sync *sync = vk_semaphore_get_active_sync(semaphore);
    return vk_sync_get_value(device, sync, pValue);
 }

 VKAPI_ATTR VkResult VKAPI_CALL
 vk_common_WaitSemaphores(VkDevice _device,
                          const VkSemaphoreWaitInfo *pWaitInfo,
                          uint64_t timeout)
 {
    VK_FROM_HANDLE(vk_device, device, _device);

    if (vk_device_is_lost(device))
       return VK_ERROR_DEVICE_LOST;

    if (pWaitInfo->semaphoreCount == 0)
       return VK_SUCCESS;

    uint64_t abs_timeout_ns = os_time_get_absolute_timeout(timeout);

    const uint32_t wait_count = pWaitInfo->semaphoreCount;
    STACK_ARRAY(struct vk_sync_wait, waits, pWaitInfo->semaphoreCount);

    for (uint32_t i = 0; i < wait_count; i++) {
       VK_FROM_HANDLE(vk_semaphore, semaphore, pWaitInfo->pSemaphores[i]);
       assert(semaphore->type == VK_SEMAPHORE_TYPE_TIMELINE);

       waits[i] = (struct vk_sync_wait) {
          .sync = vk_semaphore_get_active_sync(semaphore),
          .stage_mask = ~(VkPipelineStageFlags2)0,
          .wait_value = pWaitInfo->pValues[i],
       };
    }

    enum vk_sync_wait_flags wait_flags = VK_SYNC_WAIT_COMPLETE;
    if (pWaitInfo->flags & VK_SEMAPHORE_WAIT_ANY_BIT)
       wait_flags |= VK_SYNC_WAIT_ANY;

    VkResult result = vk_sync_wait_many(device, wait_count, waits,
                                        wait_flags, abs_timeout_ns);

    STACK_ARRAY_FINISH(waits);

    VkResult device_status = vk_device_check_status(device);
    if (device_status != VK_SUCCESS)
       return device_status;

    return result;
 }

 VKAPI_ATTR VkResult VKAPI_CALL
 vk_common_SignalSemaphore(VkDevice _device,
                           const VkSemaphoreSignalInfo *pSignalInfo)
 {
    VK_FROM_HANDLE(vk_device, device, _device);
    VK_FROM_HANDLE(vk_semaphore, semaphore, pSignalInfo->semaphore);
    struct vk_sync *sync = vk_semaphore_get_active_sync(semaphore);
    VkResult result;

    /* From the Vulkan 1.2.194 spec:
     *
     *    UID-VkSemaphoreSignalInfo-semaphore-03257
     *
     *    "semaphore must have been created with a VkSemaphoreType of
     *    VK_SEMAPHORE_TYPE_TIMELINE."
     */
    assert(semaphore->type == VK_SEMAPHORE_TYPE_TIMELINE);

    /* From the Vulkan 1.2.194 spec:
     *
     *    VUID-VkSemaphoreSignalInfo-value-03258
     *
     *    "value must have a value greater than the current value of the
     *    semaphore"
     *
     * Since 0 is the lowest possible semaphore timeline value, we can assert
     * that a non-zero signal value is provided.
     */
    if (unlikely(pSignalInfo->value == 0)) {
       return vk_device_set_lost(device,
          "Tried to signal a timeline with value 0");
    }

    result = vk_sync_signal(device, sync, pSignalInfo->value);
    if (unlikely(result != VK_SUCCESS))
       return result;

    if (device->submit_mode == VK_QUEUE_SUBMIT_MODE_DEFERRED) {
       result = vk_device_flush(device);
       if (unlikely(result != VK_SUCCESS))
          return result;
    }

    return VK_SUCCESS;
 }

 #ifndef _WIN32

 VKAPI_ATTR VkResult VKAPI_CALL
 vk_common_ImportSemaphoreFdKHR(VkDevice _device,
                                const VkImportSemaphoreFdInfoKHR *pImportSemaphoreFdInfo)
 {
    VK_FROM_HANDLE(vk_device, device, _device);
    VK_FROM_HANDLE(vk_semaphore, semaphore, pImportSemaphoreFdInfo->semaphore);

    assert(pImportSemaphoreFdInfo->sType ==
           VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_FD_INFO_KHR);

    const int fd = pImportSemaphoreFdInfo->fd;
    const VkExternalSemaphoreHandleTypeFlagBits handle_type =
       pImportSemaphoreFdInfo->handleType;

    struct vk_sync *temporary = NULL, *sync;
    if (pImportSemaphoreFdInfo->flags & VK_SEMAPHORE_IMPORT_TEMPORARY_BIT) {
       /* From the Vulkan 1.2.194 spec:
        *
        *    VUID-VkImportSemaphoreFdInfoKHR-flags-03323
        *
        *    "If flags contains VK_SEMAPHORE_IMPORT_TEMPORARY_BIT, the
        *    VkSemaphoreTypeCreateInfo::semaphoreType field of the semaphore
        *    from which handle or name was exported must not be
        *    VK_SEMAPHORE_TYPE_TIMELINE"
        */
       if (unlikely(semaphore->type == VK_SEMAPHORE_TYPE_TIMELINE)) {
          return vk_errorf(device, VK_ERROR_UNKNOWN,
                           "Cannot temporarily import into a timeline "
                           "semaphore");
       }

       const struct vk_sync_type *sync_type =
          get_semaphore_sync_type(device->physical, semaphore->type, handle_type);

       VkResult result = vk_sync_create(device, sync_type, 0 /* flags */,
                                        0 /* initial_value */, &temporary);
       if (result != VK_SUCCESS)
          return result;

       sync = temporary;
    } else {
       sync = &semaphore->permanent;
    }
    assert(handle_type &
           vk_sync_semaphore_handle_types(sync->type, semaphore->type));

    VkResult result;
    switch (pImportSemaphoreFdInfo->handleType) {
    case VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT:
       result = vk_sync_import_opaque_fd(device, sync, fd);
       break;

    case VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD_BIT:
       result = vk_sync_import_sync_file(device, sync, fd);
       break;

    default:
       result = vk_error(semaphore, VK_ERROR_INVALID_EXTERNAL_HANDLE);
    }

    if (result != VK_SUCCESS) {
       if (temporary != NULL)
          vk_sync_destroy(device, temporary);
       return result;
    }

    /* From the Vulkan 1.2.194 spec:
     *
     *    "Importing a semaphore payload from a file descriptor transfers
     *    ownership of the file descriptor from the application to the Vulkan
     *    implementation. The application must not perform any operations on
     *    the file descriptor after a successful import."
     *
     * If the import fails, we leave the file descriptor open.
     */
    if (fd != -1)
       close(fd);

    /* From a spec correctness point of view, we could probably replace the
     * semaphore's temporary payload with the new vk_sync at the top.  However,
     * we choose to be nice to applications and only replace the semaphore if
     * the import succeeded.
     */
    if (temporary) {
       vk_semaphore_reset_temporary(device, semaphore);
       semaphore->temporary = temporary;
    }

    return VK_SUCCESS;
 }

 VKAPI_ATTR VkResult VKAPI_CALL
 vk_common_GetSemaphoreFdKHR(VkDevice _device,
                             const VkSemaphoreGetFdInfoKHR *pGetFdInfo,
                             int *pFd)
 {
    VK_FROM_HANDLE(vk_device, device, _device);
    VK_FROM_HANDLE(vk_semaphore, semaphore, pGetFdInfo->semaphore);

    assert(pGetFdInfo->sType == VK_STRUCTURE_TYPE_SEMAPHORE_GET_FD_INFO_KHR);

    struct vk_sync *sync = vk_semaphore_get_active_sync(semaphore);

    VkResult result;
    switch (pGetFdInfo->handleType) {
    case VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT:
       result = vk_sync_export_opaque_fd(device, sync, pFd);
       if (result != VK_SUCCESS)
          return result;
       break;

    case VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD_BIT:
       /* From the Vulkan 1.2.194 spec:
        *
        *    VUID-VkSemaphoreGetFdInfoKHR-handleType-03253
        *
        *    "If handleType refers to a handle type with copy payload
        *    transference semantics, semaphore must have been created with a
        *    VkSemaphoreType of VK_SEMAPHORE_TYPE_BINARY."
        */
       if (unlikely(semaphore->type != VK_SEMAPHORE_TYPE_BINARY)) {
          return vk_errorf(device, VK_ERROR_INVALID_EXTERNAL_HANDLE,
                           "Cannot export a timeline semaphore as SYNC_FD");
       }

       /* From the Vulkan 1.2.194 spec:
        *    VUID-VkSemaphoreGetFdInfoKHR-handleType-03254
        *
        *    "If handleType refers to a handle type with copy payload
        *    transference semantics, semaphore must have an associated
        *    semaphore signal operation that has been submitted for execution
        *    and any semaphore signal operations on which it depends (if any)
        *    must have also been submitted for execution."
        *
        * If we have real timelines, it's possible that the time point doesn't
        * exist yet and is waiting for one of our submit threads to trigger.
        * However, thanks to the above bit of spec text, that wait should never
        * block for long.
        */
       if (vk_device_supports_threaded_submit(device)) {
          result = vk_sync_wait(device, sync, 0,
                                VK_SYNC_WAIT_PENDING,
                                UINT64_MAX);
          if (unlikely(result != VK_SUCCESS))
             return result;
       }

       result = vk_sync_export_sync_file(device, sync, pFd);
       if (unlikely(result != VK_SUCCESS))
          return result;

       /* From the Vulkan 1.2.194 spec:
        *
        *    "Export operations have the same transference as the specified
        *    handle type’s import operations. Additionally, exporting a
        *    semaphore payload to a handle with copy transference has the same
        *    side effects on the source semaphore’s payload as executing a
        *    semaphore wait operation."
        *
        * In other words, exporting a sync file also resets the semaphore.  We
        * only care about this for the permanent payload because the temporary
        * payload will be destroyed below.
        */
       if (sync == &semaphore->permanent) {
          result = vk_sync_reset(device, sync);
          if (unlikely(result != VK_SUCCESS))
             return result;
       }
       break;

    default:
       unreachable("Invalid semaphore export handle type");
    }

    /* From the Vulkan 1.2.194 spec:
     *
     *    "Export operations have the same transference as the specified
     *    handle type’s import operations. [...] If the semaphore was using
     *    a temporarily imported payload, the semaphore’s prior permanent
     *    payload will be restored."
     */
    vk_semaphore_reset_temporary(device, semaphore);

    return VK_SUCCESS;
 }

 #endif /* !defined(_WIN32) */

 #if defined(__Fuchsia__)
 #if defined(USE_MAGMA)

 VkResult
 vk_common_ImportSemaphoreZirconHandleFUCHSIA(VkDevice vk_device,
                                              const VkImportSemaphoreZirconHandleInfoFUCHSIA* info)
 {
    assert(info->sType == VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_ZIRCON_HANDLE_INFO_FUCHSIA);
    assert(info->handleType == VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_ZIRCON_EVENT_BIT_FUCHSIA);

    VK_FROM_HANDLE(vk_device, device, vk_device);
    VK_FROM_HANDLE(vk_semaphore, semaphore, info->semaphore);

    VkResult result;

    if (info->flags & VK_SEMAPHORE_IMPORT_TEMPORARY_BIT_KHR) {
       if (semaphore->temporary) {
          result = vk_sync_import_magma_handle(device, semaphore->temporary, info->zirconHandle);
       } else {
          const struct vk_sync_type *sync_type =
             get_semaphore_sync_type(device->physical, semaphore->type, info->handleType);

          result = vk_sync_create(device, sync_type, /*flags=*/ 0,
                                  info->zirconHandle, &semaphore->temporary);
          if (result != VK_SUCCESS)
             return result;

          semaphore->temporary->flags |= VK_SYNC_IS_SHAREABLE | VK_SYNC_IS_SHARED;
       }
    } else {
       result = vk_sync_import_magma_handle(device, &semaphore->permanent, info->zirconHandle);
    }

    return result;
 }

 VkResult
 vk_common_GetSemaphoreZirconHandleFUCHSIA(VkDevice vk_device,
                                           const VkSemaphoreGetZirconHandleInfoFUCHSIA* info,
                                           uint32_t* pZirconHandle)
 {
    VK_FROM_HANDLE(vk_device, device, vk_device);
    VK_FROM_HANDLE(vk_semaphore, semaphore, info->semaphore);

    assert(info->sType == VK_STRUCTURE_TYPE_SEMAPHORE_GET_ZIRCON_HANDLE_INFO_FUCHSIA);

    if (info->handleType != VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_ZIRCON_EVENT_BIT_FUCHSIA)
       return VK_SUCCESS;

    struct vk_sync *sync = vk_semaphore_get_active_sync(semaphore);

    VkResult result = vk_sync_export_magma_handle(device, sync, pZirconHandle);
    if (result != VK_SUCCESS)
       return result;

    /* From the Vulkan 1.2.194 spec:
     *
     *    "Export operations have the same transference as the specified
     *    handle type’s import operations. [...] If the semaphore was using
     *    a temporarily imported payload, the semaphore’s prior permanent
     *    payload will be restored."
     */
    vk_semaphore_reset_temporary(device, semaphore);

    return VK_SUCCESS;
 }

 #else  /* Zircon */
 #endif  /* defined(USE_MAGMA) */
 #endif  /* defined(__Fuchsia__) */
	/*
	* Copyright © 2021 Intel Corporation
	*
	* Permission is hereby granted, free of charge, to any person obtaining a
	* copy of this software and associated documentation files (the "Software"),
	* to deal in the Software without restriction, including without limitation
	* the rights to use, copy, modify, merge, publish, distribute, sublicense,
	* and/or sell copies of the Software, and to permit persons to whom the
	* Software is furnished to do so, subject to the following conditions:
	*
	* The above copyright notice and this permission notice (including the next
	* paragraph) shall be included in all copies or substantial portions of the
	* Software.
	*
	* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
	* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
	* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
	* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
	* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
	* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
	* IN THE SOFTWARE.
	*/

	#include "vk_semaphore.h"

	#include "util/os_time.h"

	#ifndef _WIN32
	#include <unistd.h>
	#endif

	#include "vk_common_entrypoints.h"
	#include "vk_device.h"
	#include "vk_log.h"
	#include "vk_physical_device.h"
	#include "vk_util.h"

	static VkExternalSemaphoreHandleTypeFlags
	vk_sync_semaphore_import_types(const struct vk_sync_type *type,
	VkSemaphoreType semaphore_type)
	{
	VkExternalSemaphoreHandleTypeFlags handle_types = 0;

	if (type->import_opaque_fd)
	handle_types \|= VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT;

	if (type->export_sync_file && semaphore_type == VK_SEMAPHORE_TYPE_BINARY)
	handle_types \|= VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD_BIT;

	#if defined(USE_MAGMA)
	if (type->import_magma_handle)
	handle_types \|= VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_ZIRCON_EVENT_BIT_FUCHSIA;
	#endif

	return handle_types;
	}

	static VkExternalSemaphoreHandleTypeFlags
	vk_sync_semaphore_export_types(const struct vk_sync_type *type,
	VkSemaphoreType semaphore_type)
	{
	VkExternalSemaphoreHandleTypeFlags handle_types = 0;

	if (type->export_opaque_fd)
	handle_types \|= VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT;

	if (type->export_sync_file && semaphore_type == VK_SEMAPHORE_TYPE_BINARY)
	handle_types \|= VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD_BIT;

	#if defined(USE_MAGMA)
	if (type->export_magma_handle)
	handle_types \|= VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_ZIRCON_EVENT_BIT_FUCHSIA;
	#endif

	return handle_types;
	}

	static VkExternalSemaphoreHandleTypeFlags
	vk_sync_semaphore_handle_types(const struct vk_sync_type *type,
	VkSemaphoreType semaphore_type)
	{
	return vk_sync_semaphore_export_types(type, semaphore_type) &
	vk_sync_semaphore_import_types(type, semaphore_type);
	}

	static const struct vk_sync_type *
	get_semaphore_sync_type(struct vk_physical_device *pdevice,
	VkSemaphoreType semaphore_type,
	VkExternalSemaphoreHandleTypeFlags handle_types)
	{
	assert(semaphore_type == VK_SEMAPHORE_TYPE_BINARY \|\|
	semaphore_type == VK_SEMAPHORE_TYPE_TIMELINE);

	enum vk_sync_features req_features = VK_SYNC_FEATURE_GPU_WAIT;
	if (semaphore_type == VK_SEMAPHORE_TYPE_TIMELINE) {
	req_features \|= VK_SYNC_FEATURE_TIMELINE \|
	VK_SYNC_FEATURE_CPU_WAIT;
	} else {
	req_features \|= VK_SYNC_FEATURE_BINARY;
	}

	for (const struct vk_sync_type const t =
	pdevice->supported_sync_types; *t; t++) {
	if (req_features & ~(*t)->features)
	continue;

	if (handle_types & ~vk_sync_semaphore_handle_types(*t, semaphore_type))
	continue;

	return *t;
	}

	return NULL;
	}

	static VkSemaphoreType
	get_semaphore_type(const void pNext, uint64_t initial_value)
	{
	const VkSemaphoreTypeCreateInfo *type_info =
	vk_find_struct_const(pNext, SEMAPHORE_TYPE_CREATE_INFO);

	if (!type_info)
	return VK_SEMAPHORE_TYPE_BINARY;

	if (initial_value)
	*initial_value = type_info->initialValue;
	return type_info->semaphoreType;
	}

	VKAPI_ATTR VkResult VKAPI_CALL
	vk_common_CreateSemaphore(VkDevice _device,
	const VkSemaphoreCreateInfo *pCreateInfo,
	const VkAllocationCallbacks *pAllocator,
	VkSemaphore *pSemaphore)
	{
	VK_FROM_HANDLE(vk_device, device, _device);
	struct vk_semaphore *semaphore;

	assert(pCreateInfo->sType == VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO);

	uint64_t initial_value = 0;
	const VkSemaphoreType semaphore_type =
	get_semaphore_type(pCreateInfo->pNext, &initial_value);

	if (semaphore_type == VK_SEMAPHORE_TYPE_TIMELINE)
	assert(device->timeline_mode != VK_DEVICE_TIMELINE_MODE_NONE);

	const VkExportSemaphoreCreateInfo *export =
	vk_find_struct_const(pCreateInfo->pNext, EXPORT_SEMAPHORE_CREATE_INFO);
	VkExternalSemaphoreHandleTypeFlags handle_types =
	export ? export->handleTypes : 0;

	const struct vk_sync_type *sync_type =
	get_semaphore_sync_type(device->physical, semaphore_type, handle_types);
	if (sync_type == NULL) {
	/* We should always be able to get a semaphore type for internal */
	assert(get_semaphore_sync_type(device->physical, semaphore_type, 0) != NULL);
	return vk_errorf(device, VK_ERROR_INVALID_EXTERNAL_HANDLE,
	"Combination of external handle types is unsupported "
	"for VkSemaphore creation.");
	}

	/* If the timeline mode is ASSISTED, then any permanent binary semaphore
	* types need to be able to support move. We don't require this for
	* temporary unless that temporary is also used as a semaphore signal
	* operation which is much trickier to assert early.
	*/
	if (semaphore_type == VK_SEMAPHORE_TYPE_BINARY &&
	vk_device_supports_threaded_submit(device))
	assert(sync_type->move);

	/* Allocate a vk_semaphore + vk_sync implementation. Because the permanent
	* field of vk_semaphore is the base field of the vk_sync implementation,
	* we can make the 2 structures overlap.
	*/
	size_t size = offsetof(struct vk_semaphore, permanent) + sync_type->size;
	semaphore = vk_object_zalloc(device, pAllocator, size,
	VK_OBJECT_TYPE_SEMAPHORE);
	if (semaphore == NULL)
	return vk_error(device, VK_ERROR_OUT_OF_HOST_MEMORY);

	semaphore->type = semaphore_type;

	enum vk_sync_flags sync_flags = 0;
	if (semaphore_type == VK_SEMAPHORE_TYPE_TIMELINE)
	sync_flags \|= VK_SYNC_IS_TIMELINE;
	if (handle_types)
	sync_flags \|= VK_SYNC_IS_SHAREABLE;

	VkResult result = vk_sync_init(device, &semaphore->permanent,
	sync_type, sync_flags, initial_value);
	if (result != VK_SUCCESS) {
	vk_object_free(device, pAllocator, semaphore);
	return result;
	}

	*pSemaphore = vk_semaphore_to_handle(semaphore);

	return VK_SUCCESS;
	}

	void
	vk_semaphore_reset_temporary(struct vk_device *device,
	struct vk_semaphore *semaphore)
	{
	if (semaphore->temporary == NULL)
	return;

	vk_sync_destroy(device, semaphore->temporary);
	semaphore->temporary = NULL;
	}

	VKAPI_ATTR void VKAPI_CALL
	vk_common_DestroySemaphore(VkDevice _device,
	VkSemaphore _semaphore,
	const VkAllocationCallbacks *pAllocator)
	{
	VK_FROM_HANDLE(vk_device, device, _device);
	VK_FROM_HANDLE(vk_semaphore, semaphore, _semaphore);

	if (semaphore == NULL)
	return;

	vk_semaphore_reset_temporary(device, semaphore);
	vk_sync_finish(device, &semaphore->permanent);

	vk_object_free(device, pAllocator, semaphore);
	}

	VKAPI_ATTR void VKAPI_CALL
	vk_common_GetPhysicalDeviceExternalSemaphoreProperties(
	VkPhysicalDevice physicalDevice,
	const VkPhysicalDeviceExternalSemaphoreInfo *pExternalSemaphoreInfo,
	VkExternalSemaphoreProperties *pExternalSemaphoreProperties)
	{
	VK_FROM_HANDLE(vk_physical_device, pdevice, physicalDevice);

	assert(pExternalSemaphoreInfo->sType ==
	VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO);
	const VkExternalSemaphoreHandleTypeFlagBits handle_type =
	pExternalSemaphoreInfo->handleType;

	const VkSemaphoreType semaphore_type =
	get_semaphore_type(pExternalSemaphoreInfo->pNext, NULL);

	const struct vk_sync_type *sync_type =
	get_semaphore_sync_type(pdevice, semaphore_type, handle_type);
	if (sync_type == NULL) {
	pExternalSemaphoreProperties->exportFromImportedHandleTypes = 0;
	pExternalSemaphoreProperties->compatibleHandleTypes = 0;
	pExternalSemaphoreProperties->externalSemaphoreFeatures = 0;
	return;
	}

	VkExternalSemaphoreHandleTypeFlagBits import =
	vk_sync_semaphore_import_types(sync_type, semaphore_type);
	VkExternalSemaphoreHandleTypeFlagBits export =
	vk_sync_semaphore_export_types(sync_type, semaphore_type);

	if (handle_type != VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT) {
	const struct vk_sync_type *opaque_sync_type =
	get_semaphore_sync_type(pdevice, semaphore_type,
	VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT);

	/* If we're a different vk_sync_type than the one selected when only
	* OPAQUE_FD is set, then we can't import/export OPAQUE_FD. Put
	* differently, there can only be one OPAQUE_FD sync type.
	*/
	if (sync_type != opaque_sync_type) {
	import &= ~VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT;
	export &= ~VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT;
	}
	}

	VkExternalSemaphoreHandleTypeFlags compatible = import & export;
	VkExternalSemaphoreFeatureFlags features = 0;
	if (handle_type & export)
	features \|= VK_EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE_BIT;
	if (handle_type & import)
	features \|= VK_EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE_BIT;

	pExternalSemaphoreProperties->exportFromImportedHandleTypes = export;
	pExternalSemaphoreProperties->compatibleHandleTypes = compatible;
	pExternalSemaphoreProperties->externalSemaphoreFeatures = features;
	}

	VKAPI_ATTR VkResult VKAPI_CALL
	vk_common_GetSemaphoreCounterValue(VkDevice _device,
	VkSemaphore _semaphore,
	uint64_t *pValue)
	{
	VK_FROM_HANDLE(vk_device, device, _device);
	VK_FROM_HANDLE(vk_semaphore, semaphore, _semaphore);

	if (vk_device_is_lost(device))
	return VK_ERROR_DEVICE_LOST;

	struct vk_sync *sync = vk_semaphore_get_active_sync(semaphore);
	return vk_sync_get_value(device, sync, pValue);
	}

	VKAPI_ATTR VkResult VKAPI_CALL
	vk_common_WaitSemaphores(VkDevice _device,
	const VkSemaphoreWaitInfo *pWaitInfo,
	uint64_t timeout)
	{
	VK_FROM_HANDLE(vk_device, device, _device);

	if (vk_device_is_lost(device))
	return VK_ERROR_DEVICE_LOST;

	if (pWaitInfo->semaphoreCount == 0)
	return VK_SUCCESS;

	uint64_t abs_timeout_ns = os_time_get_absolute_timeout(timeout);

	const uint32_t wait_count = pWaitInfo->semaphoreCount;
	STACK_ARRAY(struct vk_sync_wait, waits, pWaitInfo->semaphoreCount);

	for (uint32_t i = 0; i < wait_count; i++) {
	VK_FROM_HANDLE(vk_semaphore, semaphore, pWaitInfo->pSemaphores[i]);
	assert(semaphore->type == VK_SEMAPHORE_TYPE_TIMELINE);

	waits[i] = (struct vk_sync_wait) {
	.sync = vk_semaphore_get_active_sync(semaphore),
	.stage_mask = ~(VkPipelineStageFlags2)0,
	.wait_value = pWaitInfo->pValues[i],
	};
	}

	enum vk_sync_wait_flags wait_flags = VK_SYNC_WAIT_COMPLETE;
	if (pWaitInfo->flags & VK_SEMAPHORE_WAIT_ANY_BIT)
	wait_flags \|= VK_SYNC_WAIT_ANY;

	VkResult result = vk_sync_wait_many(device, wait_count, waits,
	wait_flags, abs_timeout_ns);

	STACK_ARRAY_FINISH(waits);

	VkResult device_status = vk_device_check_status(device);
	if (device_status != VK_SUCCESS)
	return device_status;

	return result;
	}

	VKAPI_ATTR VkResult VKAPI_CALL
	vk_common_SignalSemaphore(VkDevice _device,
	const VkSemaphoreSignalInfo *pSignalInfo)
	{
	VK_FROM_HANDLE(vk_device, device, _device);
	VK_FROM_HANDLE(vk_semaphore, semaphore, pSignalInfo->semaphore);
	struct vk_sync *sync = vk_semaphore_get_active_sync(semaphore);
	VkResult result;

	/* From the Vulkan 1.2.194 spec:
	*
	* UID-VkSemaphoreSignalInfo-semaphore-03257
	*
	* "semaphore must have been created with a VkSemaphoreType of
	* VK_SEMAPHORE_TYPE_TIMELINE."
	*/
	assert(semaphore->type == VK_SEMAPHORE_TYPE_TIMELINE);

	/* From the Vulkan 1.2.194 spec:
	*
	* VUID-VkSemaphoreSignalInfo-value-03258
	*
	* "value must have a value greater than the current value of the
	* semaphore"
	*
	* Since 0 is the lowest possible semaphore timeline value, we can assert
	* that a non-zero signal value is provided.
	*/
	if (unlikely(pSignalInfo->value == 0)) {
	return vk_device_set_lost(device,
	"Tried to signal a timeline with value 0");
	}

	result = vk_sync_signal(device, sync, pSignalInfo->value);
	if (unlikely(result != VK_SUCCESS))
	return result;

	if (device->submit_mode == VK_QUEUE_SUBMIT_MODE_DEFERRED) {
	result = vk_device_flush(device);
	if (unlikely(result != VK_SUCCESS))
	return result;
	}

	return VK_SUCCESS;
	}

	#ifndef _WIN32

	VKAPI_ATTR VkResult VKAPI_CALL
	vk_common_ImportSemaphoreFdKHR(VkDevice _device,
	const VkImportSemaphoreFdInfoKHR *pImportSemaphoreFdInfo)
	{
	VK_FROM_HANDLE(vk_device, device, _device);
	VK_FROM_HANDLE(vk_semaphore, semaphore, pImportSemaphoreFdInfo->semaphore);

	assert(pImportSemaphoreFdInfo->sType ==
	VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_FD_INFO_KHR);

	const int fd = pImportSemaphoreFdInfo->fd;
	const VkExternalSemaphoreHandleTypeFlagBits handle_type =
	pImportSemaphoreFdInfo->handleType;

	struct vk_sync temporary = NULL, sync;
	if (pImportSemaphoreFdInfo->flags & VK_SEMAPHORE_IMPORT_TEMPORARY_BIT) {
	/* From the Vulkan 1.2.194 spec:
	*
	* VUID-VkImportSemaphoreFdInfoKHR-flags-03323
	*
	* "If flags contains VK_SEMAPHORE_IMPORT_TEMPORARY_BIT, the
	* VkSemaphoreTypeCreateInfo::semaphoreType field of the semaphore
	* from which handle or name was exported must not be
	* VK_SEMAPHORE_TYPE_TIMELINE"
	*/
	if (unlikely(semaphore->type == VK_SEMAPHORE_TYPE_TIMELINE)) {
	return vk_errorf(device, VK_ERROR_UNKNOWN,
	"Cannot temporarily import into a timeline "
	"semaphore");
	}

	const struct vk_sync_type *sync_type =
	get_semaphore_sync_type(device->physical, semaphore->type, handle_type);

	VkResult result = vk_sync_create(device, sync_type, 0 /* flags */,
	0 /* initial_value */, &temporary);
	if (result != VK_SUCCESS)
	return result;

	sync = temporary;
	} else {
	sync = &semaphore->permanent;
	}
	assert(handle_type &
	vk_sync_semaphore_handle_types(sync->type, semaphore->type));

	VkResult result;
	switch (pImportSemaphoreFdInfo->handleType) {
	case VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT:
	result = vk_sync_import_opaque_fd(device, sync, fd);
	break;

	case VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD_BIT:
	result = vk_sync_import_sync_file(device, sync, fd);
	break;

	default:
	result = vk_error(semaphore, VK_ERROR_INVALID_EXTERNAL_HANDLE);
	}

	if (result != VK_SUCCESS) {
	if (temporary != NULL)
	vk_sync_destroy(device, temporary);
	return result;
	}

	/* From the Vulkan 1.2.194 spec:
	*
	* "Importing a semaphore payload from a file descriptor transfers
	* ownership of the file descriptor from the application to the Vulkan
	* implementation. The application must not perform any operations on
	* the file descriptor after a successful import."
	*
	* If the import fails, we leave the file descriptor open.
	*/
	if (fd != -1)
	close(fd);

	/* From a spec correctness point of view, we could probably replace the
	* semaphore's temporary payload with the new vk_sync at the top. However,
	* we choose to be nice to applications and only replace the semaphore if
	* the import succeeded.
	*/
	if (temporary) {
	vk_semaphore_reset_temporary(device, semaphore);
	semaphore->temporary = temporary;
	}

	return VK_SUCCESS;
	}

	VKAPI_ATTR VkResult VKAPI_CALL
	vk_common_GetSemaphoreFdKHR(VkDevice _device,
	const VkSemaphoreGetFdInfoKHR *pGetFdInfo,
	int *pFd)
	{
	VK_FROM_HANDLE(vk_device, device, _device);
	VK_FROM_HANDLE(vk_semaphore, semaphore, pGetFdInfo->semaphore);

	assert(pGetFdInfo->sType == VK_STRUCTURE_TYPE_SEMAPHORE_GET_FD_INFO_KHR);

	struct vk_sync *sync = vk_semaphore_get_active_sync(semaphore);

	VkResult result;
	switch (pGetFdInfo->handleType) {
	case VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT:
	result = vk_sync_export_opaque_fd(device, sync, pFd);
	if (result != VK_SUCCESS)
	return result;
	break;

	case VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD_BIT:
	/* From the Vulkan 1.2.194 spec:
	*
	* VUID-VkSemaphoreGetFdInfoKHR-handleType-03253
	*
	* "If handleType refers to a handle type with copy payload
	* transference semantics, semaphore must have been created with a
	* VkSemaphoreType of VK_SEMAPHORE_TYPE_BINARY."
	*/
	if (unlikely(semaphore->type != VK_SEMAPHORE_TYPE_BINARY)) {
	return vk_errorf(device, VK_ERROR_INVALID_EXTERNAL_HANDLE,
	"Cannot export a timeline semaphore as SYNC_FD");
	}

	/* From the Vulkan 1.2.194 spec:
	* VUID-VkSemaphoreGetFdInfoKHR-handleType-03254
	*
	* "If handleType refers to a handle type with copy payload
	* transference semantics, semaphore must have an associated
	* semaphore signal operation that has been submitted for execution
	* and any semaphore signal operations on which it depends (if any)
	* must have also been submitted for execution."
	*
	* If we have real timelines, it's possible that the time point doesn't
	* exist yet and is waiting for one of our submit threads to trigger.
	* However, thanks to the above bit of spec text, that wait should never
	* block for long.
	*/
	if (vk_device_supports_threaded_submit(device)) {
	result = vk_sync_wait(device, sync, 0,
	VK_SYNC_WAIT_PENDING,
	UINT64_MAX);
	if (unlikely(result != VK_SUCCESS))
	return result;
	}

	result = vk_sync_export_sync_file(device, sync, pFd);
	if (unlikely(result != VK_SUCCESS))
	return result;

	/* From the Vulkan 1.2.194 spec:
	*
	* "Export operations have the same transference as the specified
	* handle type’s import operations. Additionally, exporting a
	* semaphore payload to a handle with copy transference has the same
	* side effects on the source semaphore’s payload as executing a
	* semaphore wait operation."
	*
	* In other words, exporting a sync file also resets the semaphore. We
	* only care about this for the permanent payload because the temporary
	* payload will be destroyed below.
	*/
	if (sync == &semaphore->permanent) {
	result = vk_sync_reset(device, sync);
	if (unlikely(result != VK_SUCCESS))
	return result;
	}
	break;

	default:
	unreachable("Invalid semaphore export handle type");
	}

	/* From the Vulkan 1.2.194 spec:
	*
	* "Export operations have the same transference as the specified
	* handle type’s import operations. [...] If the semaphore was using
	* a temporarily imported payload, the semaphore’s prior permanent
	* payload will be restored."
	*/
	vk_semaphore_reset_temporary(device, semaphore);

	return VK_SUCCESS;
	}

	#endif /* !defined(_WIN32) */

	#if defined(__Fuchsia__)
	#if defined(USE_MAGMA)

	VkResult
	vk_common_ImportSemaphoreZirconHandleFUCHSIA(VkDevice vk_device,
	const VkImportSemaphoreZirconHandleInfoFUCHSIA* info)
	{
	assert(info->sType == VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_ZIRCON_HANDLE_INFO_FUCHSIA);
	assert(info->handleType == VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_ZIRCON_EVENT_BIT_FUCHSIA);

	VK_FROM_HANDLE(vk_device, device, vk_device);
	VK_FROM_HANDLE(vk_semaphore, semaphore, info->semaphore);

	VkResult result;

	if (info->flags & VK_SEMAPHORE_IMPORT_TEMPORARY_BIT_KHR) {
	if (semaphore->temporary) {
	result = vk_sync_import_magma_handle(device, semaphore->temporary, info->zirconHandle);
	} else {
	const struct vk_sync_type *sync_type =
	get_semaphore_sync_type(device->physical, semaphore->type, info->handleType);

	result = vk_sync_create(device, sync_type, /flags=/ 0,
	info->zirconHandle, &semaphore->temporary);
	if (result != VK_SUCCESS)
	return result;

	semaphore->temporary->flags \|= VK_SYNC_IS_SHAREABLE \| VK_SYNC_IS_SHARED;
	}
	} else {
	result = vk_sync_import_magma_handle(device, &semaphore->permanent, info->zirconHandle);
	}

	return result;
	}

	VkResult
	vk_common_GetSemaphoreZirconHandleFUCHSIA(VkDevice vk_device,
	const VkSemaphoreGetZirconHandleInfoFUCHSIA* info,
	uint32_t* pZirconHandle)
	{
	VK_FROM_HANDLE(vk_device, device, vk_device);
	VK_FROM_HANDLE(vk_semaphore, semaphore, info->semaphore);

	assert(info->sType == VK_STRUCTURE_TYPE_SEMAPHORE_GET_ZIRCON_HANDLE_INFO_FUCHSIA);

	if (info->handleType != VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_ZIRCON_EVENT_BIT_FUCHSIA)
	return VK_SUCCESS;

	struct vk_sync *sync = vk_semaphore_get_active_sync(semaphore);

	VkResult result = vk_sync_export_magma_handle(device, sync, pZirconHandle);
	if (result != VK_SUCCESS)
	return result;

	/* From the Vulkan 1.2.194 spec:
	*
	* "Export operations have the same transference as the specified
	* handle type’s import operations. [...] If the semaphore was using
	* a temporarily imported payload, the semaphore’s prior permanent
	* payload will be restored."
	*/
	vk_semaphore_reset_temporary(device, semaphore);

	return VK_SUCCESS;
	}

	#else /* Zircon */
	#endif /* defined(USE_MAGMA) */
	#endif /* defined(__Fuchsia__) */