[vulkan] Implement VK_FUCHSIA_external_memory extension.

src/Vulkan/VkDeviceMemory.cpp

@@ -51,6 +51,13 @@ public:
 	}
 #endif
 
+#if VK_USE_PLATFORM_FUCHSIA
+	virtual VkResult exportHandle(zx_handle_t *pHandle) const
+	{
+		return VK_ERROR_INVALID_EXTERNAL_HANDLE;
+	}
+#endif
+
 protected:
 	ExternalBase() = default;
 };
@@ -219,6 +226,10 @@ private:
 #	endif
 #endif
 
+#if VK_USE_PLATFORM_FUCHSIA
+#	include "VkDeviceMemoryExternalFuchsia.hpp"
+#endif
+
 namespace vk {
 
 static void findTraits(const VkMemoryAllocateInfo *pAllocateInfo,
@@ -236,6 +247,12 @@ static void findTraits(const VkMemoryAllocateInfo *pAllocateInfo,
 		return;
 	}
 #endif
+#if VK_USE_PLATFORM_FUCHSIA
+	if(parseCreateInfo<zircon::VmoExternalMemory>(pAllocateInfo, pTraits))
+	{
+		return;
+	}
+#endif
 	if(parseCreateInfo<ExternalMemoryHost>(pAllocateInfo, pTraits))
 	{
 		return;
@@ -348,4 +365,11 @@ VkResult DeviceMemory::getAhbProperties(const struct AHardwareBuffer *buffer, Vk
 }
 #endif
 
+#if VK_USE_PLATFORM_FUCHSIA
+VkResult DeviceMemory::exportHandle(zx_handle_t *pHandle) const
+{
+	return external->exportHandle(pHandle);
+}
+#endif
+
 }  // namespace vk

src/Vulkan/VkDeviceMemory.hpp

@@ -36,6 +36,10 @@ public:
 	static VkResult getAhbProperties(const struct AHardwareBuffer *buffer, VkAndroidHardwareBufferPropertiesANDROID *pProperties);
 #endif
 
+#if VK_USE_PLATFORM_FUCHSIA
+	VkResult exportHandle(zx_handle_t *pHandle) const;
+#endif
+
 	void destroy(const VkAllocationCallbacks *pAllocator);
 	VkResult allocate();
 	VkResult map(VkDeviceSize offset, VkDeviceSize size, void **ppData);

src/Vulkan/VkDeviceMemoryExternalFuchsia.hpp

+// Copyright 2019 The SwiftShader Authors. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//    http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "VkStringify.hpp"
+
+#include "System/Debug.hpp"
+
+#include <zircon/process.h>
+#include <zircon/syscalls.h>
+
+namespace zircon {
+
+class VmoExternalMemory : public vk::DeviceMemory::ExternalBase
+{
+public:
+	// Helper struct to parse the VkMemoryAllocateInfo.pNext chain and
+	// extract relevant information related to the handle type supported
+	// by this DeviceMemory::ExternalBase subclass.
+	struct AllocateInfo
+	{
+		bool importHandle = false;
+		bool exportHandle = false;
+		zx_handle_t handle = ZX_HANDLE_INVALID;
+
+		AllocateInfo() = default;
+
+		// Parse the VkMemoryAllocateInfo->pNext chain to initialize a AllocateInfo.
+		AllocateInfo(const VkMemoryAllocateInfo *pAllocateInfo)
+		{
+			const auto *extInfo = reinterpret_cast<const VkBaseInStructure *>(pAllocateInfo->pNext);
+			while(extInfo)
+			{
+				switch(extInfo->sType)
+				{
+					case VK_STRUCTURE_TYPE_TEMP_IMPORT_MEMORY_ZIRCON_HANDLE_INFO_FUCHSIA:
+					{
+						const auto *importInfo = reinterpret_cast<const VkImportMemoryZirconHandleInfoFUCHSIA *>(extInfo);
+
+						if(importInfo->handleType != VK_EXTERNAL_MEMORY_HANDLE_TYPE_TEMP_ZIRCON_VMO_BIT_FUCHSIA)
+						{
+							UNSUPPORTED("importInfo->handleType");
+						}
+						importHandle = true;
+						handle = importInfo->handle;
+						break;
+					}
+					case VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO:
+					{
+						const auto *exportInfo = reinterpret_cast<const VkExportMemoryAllocateInfo *>(extInfo);
+
+						if(exportInfo->handleTypes != VK_EXTERNAL_MEMORY_HANDLE_TYPE_TEMP_ZIRCON_VMO_BIT_FUCHSIA)
+						{
+							UNSUPPORTED("exportInfo->handleTypes");
+						}
+						exportHandle = true;
+						break;
+					}
+
+					default:
+						WARN("VkMemoryAllocateInfo->pNext sType = %s", vk::Stringify(extInfo->sType).c_str());
+				}
+				extInfo = extInfo->pNext;
+			}
+		}
+	};
+
+	static const VkExternalMemoryHandleTypeFlagBits typeFlagBit = VK_EXTERNAL_MEMORY_HANDLE_TYPE_TEMP_ZIRCON_VMO_BIT_FUCHSIA;
+
+	static bool supportsAllocateInfo(const VkMemoryAllocateInfo *pAllocateInfo)
+	{
+		AllocateInfo info(pAllocateInfo);
+		return info.importHandle || info.exportHandle;
+	}
+
+	explicit VmoExternalMemory(const VkMemoryAllocateInfo *pAllocateInfo)
+	    : allocateInfo(pAllocateInfo)
+	{
+	}
+
+	~VmoExternalMemory()
+	{
+		closeVmo();
+	}
+
+	VkResult allocate(size_t size, void **pBuffer) override
+	{
+		if(allocateInfo.importHandle)
+		{
+			// NOTE: handle ownership is passed to the VkDeviceMemory.
+			vmoHandle = allocateInfo.handle;
+		}
+		else
+		{
+			ASSERT(allocateInfo.exportHandle);
+			zx_status_t status = zx_vmo_create(size, 0, &vmoHandle);
+			if(status != ZX_OK)
+			{
+				TRACE("zx_vmo_create() returned %d", status);
+				return VK_ERROR_OUT_OF_DEVICE_MEMORY;
+			}
+		}
+
+		// Now map it directly.
+		zx_vaddr_t addr = 0;
+		zx_status_t status = zx_vmar_map(zx_vmar_root_self(),
+		                                 ZX_VM_PERM_READ | ZX_VM_PERM_WRITE,
+		                                 0,  // vmar_offset
+		                                 vmoHandle,
+		                                 0,  // vmo_offset
+		                                 size,
+		                                 &addr);
+		if(status != ZX_OK)
+		{
+			TRACE("zx_vmar_map() failed with %d", status);
+			return VK_ERROR_MEMORY_MAP_FAILED;
+		}
+		*pBuffer = reinterpret_cast<void *>(addr);
+		return VK_SUCCESS;
+	}
+
+	void deallocate(void *buffer, size_t size) override
+	{
+		zx_status_t status = zx_vmar_unmap(zx_vmar_root_self(),
+		                                   reinterpret_cast<zx_vaddr_t>(buffer),
+		                                   size);
+		if(status != ZX_OK)
+		{
+			TRACE("zx_vmar_unmap() failed with %d", status);
+		}
+		closeVmo();
+	}
+
+	VkExternalMemoryHandleTypeFlagBits getFlagBit() const override
+	{
+		return typeFlagBit;
+	}
+
+	VkResult exportHandle(zx_handle_t *pHandle) const override
+	{
+		if(vmoHandle == ZX_HANDLE_INVALID)
+		{
+			return VK_ERROR_INVALID_EXTERNAL_HANDLE;
+		}
+		zx_status_t status = zx_handle_duplicate(vmoHandle, ZX_RIGHT_SAME_RIGHTS, pHandle);
+		if(status != ZX_OK)
+		{
+			TRACE("zx_handle_duplicate() returned %d", status);
+			return VK_ERROR_INVALID_EXTERNAL_HANDLE;
+		}
+		return VK_SUCCESS;
+	}
+
+private:
+	void closeVmo()
+	{
+		if(vmoHandle != ZX_HANDLE_INVALID)
+		{
+			zx_handle_close(vmoHandle);
+			vmoHandle = ZX_HANDLE_INVALID;
+		}
+	}
+
+	zx_handle_t vmoHandle = ZX_HANDLE_INVALID;
+	AllocateInfo allocateInfo;
+};
+
+}  // namespace zircon

src/Vulkan/VkGetProcAddress.cpp

@@ -397,6 +397,16 @@ static const std::vector<std::pair<const char *, std::unordered_map<std::string,
 	        MAKE_VULKAN_DEVICE_ENTRY(vkGetMemoryAndroidHardwareBufferANDROID),
 	    } },
 #endif
+
+#if VK_USE_PLATFORM_FUCHSIA
+	// VK_FUCHSIA_external_memory
+	{
+	    VK_FUCHSIA_EXTERNAL_MEMORY_EXTENSION_NAME,
+	    {
+	        MAKE_VULKAN_DEVICE_ENTRY(vkGetMemoryZirconHandleFUCHSIA),
+	        MAKE_VULKAN_DEVICE_ENTRY(vkGetMemoryZirconHandlePropertiesFUCHSIA),
+	    } },
+#endif
 };
 
 #undef MAKE_VULKAN_DEVICE_ENTRY

src/Vulkan/VkPhysicalDevice.cpp

@@ -43,6 +43,15 @@ static void setExternalMemoryProperties(VkExternalMemoryHandleTypeFlagBits handl
 		return;
 	}
 #endif
+#if VK_USE_PLATFORM_FUCHSIA
+	if(handleType == VK_EXTERNAL_MEMORY_HANDLE_TYPE_TEMP_ZIRCON_VMO_BIT_FUCHSIA)
+	{
+		properties->compatibleHandleTypes = VK_EXTERNAL_MEMORY_HANDLE_TYPE_TEMP_ZIRCON_VMO_BIT_FUCHSIA;
+		properties->exportFromImportedHandleTypes = VK_EXTERNAL_MEMORY_HANDLE_TYPE_TEMP_ZIRCON_VMO_BIT_FUCHSIA;
+		properties->externalMemoryFeatures = VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT | VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT;
+		return;
+	}
+#endif
 	properties->compatibleHandleTypes = 0;
 	properties->exportFromImportedHandleTypes = 0;
 	properties->externalMemoryFeatures = 0;

src/Vulkan/libVulkan.cpp

@@ -348,6 +348,7 @@ static const VkExtensionProperties deviceExtensionProperties[] = {
 
 #if VK_USE_PLATFORM_FUCHSIA
 	{ VK_FUCHSIA_EXTERNAL_SEMAPHORE_EXTENSION_NAME, VK_FUCHSIA_EXTERNAL_SEMAPHORE_SPEC_VERSION },
+	{ VK_FUCHSIA_EXTERNAL_MEMORY_EXTENSION_NAME, VK_FUCHSIA_EXTERNAL_MEMORY_SPEC_VERSION },
 #endif
 	{ VK_EXT_PROVOKING_VERTEX_EXTENSION_NAME, VK_EXT_PROVOKING_VERTEX_SPEC_VERSION },
 };
@@ -946,6 +947,10 @@ VKAPI_ATTR VkResult VKAPI_CALL vkAllocateMemory(VkDevice device, const VkMemoryA
 					case VK_EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_BIT_ANDROID:
 						break;
 #endif
+#if VK_USE_PLATFORM_FUCHSIA
+					case VK_EXTERNAL_MEMORY_HANDLE_TYPE_TEMP_ZIRCON_VMO_BIT_FUCHSIA:
+						break;
+#endif
 					default:
 						UNSUPPORTED("exportInfo->handleTypes %u", exportInfo->handleTypes);
 						return VK_ERROR_INVALID_EXTERNAL_HANDLE;
@@ -967,6 +972,18 @@ VKAPI_ATTR VkResult VKAPI_CALL vkAllocateMemory(VkDevice device, const VkMemoryA
 				}
 				break;
 			}
+#if VK_USE_PLATFORM_FUCHSIA
+			case VK_STRUCTURE_TYPE_TEMP_IMPORT_MEMORY_ZIRCON_HANDLE_INFO_FUCHSIA:
+			{
+				auto *importInfo = reinterpret_cast<const VkImportMemoryZirconHandleInfoFUCHSIA *>(allocationInfo);
+				if(importInfo->handleType != VK_EXTERNAL_MEMORY_HANDLE_TYPE_TEMP_ZIRCON_VMO_BIT_FUCHSIA)
+				{
+					UNSUPPORTED("importInfo->handleType %u", importInfo->handleType);
+					return VK_ERROR_INVALID_EXTERNAL_HANDLE;
+				}
+				break;
+			}
+#endif  // VK_USE_PLATFORM_FUCHSIA
 			default:
 				LOG_TRAP("pAllocateInfo->pNext sType = %s", vk::Stringify(allocationInfo->sType).c_str());
 				break;
@@ -1039,6 +1056,45 @@ VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryFdPropertiesKHR(VkDevice device, VkExt
 	return VK_SUCCESS;
 }
 #endif  // SWIFTSHADER_EXTERNAL_MEMORY_OPAQUE_FD
+#if VK_USE_PLATFORM_FUCHSIA
+VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryZirconHandleFUCHSIA(VkDevice device, const VkMemoryGetZirconHandleInfoFUCHSIA *pGetHandleInfo, zx_handle_t *pHandle)
+{
+	TRACE("(VkDevice device = %p, const VkMemoryGetZirconHandleInfoFUCHSIA* pGetHandleInfo = %p, zx_handle_t* pHandle = %p",
+	      device, pGetHandleInfo, pHandle);
+
+	if(pGetHandleInfo->handleType != VK_EXTERNAL_MEMORY_HANDLE_TYPE_TEMP_ZIRCON_VMO_BIT_FUCHSIA)
+	{
+		UNSUPPORTED("pGetHandleInfo->handleType %u", pGetHandleInfo->handleType);
+		return VK_ERROR_INVALID_EXTERNAL_HANDLE;
+	}
+	return vk::Cast(pGetHandleInfo->memory)->exportHandle(pHandle);
+}
+
+VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryZirconHandlePropertiesFUCHSIA(VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType, zx_handle_t handle, VkMemoryZirconHandlePropertiesFUCHSIA *pMemoryZirconHandleProperties)
+{
+	TRACE("(VkDevice device = %p, VkExternalMemoryHandleTypeFlagBits handleType = %x, zx_handle_t handle = %d, VkMemoryZirconHandlePropertiesFUCHSIA* pMemoryZirconHandleProperties = %p)",
+	      device, handleType, handle, pMemoryZirconHandleProperties);
+
+	if(handleType != VK_EXTERNAL_MEMORY_HANDLE_TYPE_TEMP_ZIRCON_VMO_BIT_FUCHSIA)
+	{
+		UNSUPPORTED("handleType %u", handleType);
+		return VK_ERROR_INVALID_EXTERNAL_HANDLE;
+	}
+
+	if(handle == ZX_HANDLE_INVALID)
+	{
+		return VK_ERROR_INVALID_EXTERNAL_HANDLE;
+	}
+
+	const VkPhysicalDeviceMemoryProperties &memoryProperties =
+	    vk::Cast(device)->getPhysicalDevice()->getMemoryProperties();
+
+	// All SwiftShader memory types support this!
+	pMemoryZirconHandleProperties->memoryTypeBits = (1U << memoryProperties.memoryTypeCount) - 1U;
+
+	return VK_SUCCESS;
+}
+#endif  // VK_USE_PLATFORM_FUCHSIA
 
 VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryHostPointerPropertiesEXT(VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType, const void *pHostPointer, VkMemoryHostPointerPropertiesEXT *pMemoryHostPointerProperties)
 {