diff --git a/host/vulkan/VkDecoder.cpp b/host/vulkan/VkDecoder.cpp
index a41c2e7..d052848 100644
--- a/host/vulkan/VkDecoder.cpp
+++ b/host/vulkan/VkDecoder.cpp
@@ -15,9 +15,9 @@
 
 // Autogenerated module VkDecoder
 //
-// (impl) generated by codegen/vulkan/vulkan-docs/scripts/genvk.py -registry
-// codegen/vulkan/vulkan-docs/xml/vk.xml -registryGfxstream
-// codegen/vulkan/vulkan-docs/xml/vk_gfxstream.xml cereal -o host/vulkan/cereal
+// (impl) generated by codegen/vulkan/vulkan-docs-next/scripts/genvk.py -registry
+// codegen/vulkan/vulkan-docs-next/xml/vk.xml -registryGfxstream
+// codegen/vulkan/vulkan-docs-next/xml/vk_gfxstream.xml cereal -o host/vulkan/cereal
 //
 // Please do not modify directly;
 // re-run gfxstream-protocols/scripts/generate-vulkan-sources.sh,
@@ -17365,6 +17365,245 @@
                 break;
             }
 #endif
+#ifdef VK_KHR_maintenance5
+            case OP_vkCmdBindIndexBuffer2KHR: {
+                android::base::beginTrace("vkCmdBindIndexBuffer2KHR decode");
+                VkCommandBuffer commandBuffer;
+                VkBuffer buffer;
+                VkDeviceSize offset;
+                VkDeviceSize size;
+                VkIndexType indexType;
+                // Begin non wrapped dispatchable handle unboxing for commandBuffer;
+                uint64_t cgen_var_0;
+                memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
+                *readStreamPtrPtr += 1 * 8;
+                *(VkCommandBuffer*)&commandBuffer =
+                    (VkCommandBuffer)(VkCommandBuffer)((VkCommandBuffer)(*&cgen_var_0));
+                auto unboxed_commandBuffer = unbox_VkCommandBuffer(commandBuffer);
+                auto vk = dispatch_VkCommandBuffer(commandBuffer);
+                // End manual dispatchable handle unboxing for commandBuffer;
+                uint64_t cgen_var_1;
+                memcpy((uint64_t*)&cgen_var_1, *readStreamPtrPtr, 1 * 8);
+                *readStreamPtrPtr += 1 * 8;
+                *(VkBuffer*)&buffer = (VkBuffer)unbox_VkBuffer((VkBuffer)(*&cgen_var_1));
+                memcpy((VkDeviceSize*)&offset, *readStreamPtrPtr, sizeof(VkDeviceSize));
+                *readStreamPtrPtr += sizeof(VkDeviceSize);
+                memcpy((VkDeviceSize*)&size, *readStreamPtrPtr, sizeof(VkDeviceSize));
+                *readStreamPtrPtr += sizeof(VkDeviceSize);
+                memcpy((VkIndexType*)&indexType, *readStreamPtrPtr, sizeof(VkIndexType));
+                *readStreamPtrPtr += sizeof(VkIndexType);
+                if (m_logCalls) {
+                    fprintf(stderr,
+                            "stream %p: call vkCmdBindIndexBuffer2KHR 0x%llx 0x%llx 0x%llx 0x%llx "
+                            "0x%llx \n",
+                            ioStream, (unsigned long long)commandBuffer, (unsigned long long)buffer,
+                            (unsigned long long)offset, (unsigned long long)size,
+                            (unsigned long long)indexType);
+                }
+                vk->vkCmdBindIndexBuffer2KHR(unboxed_commandBuffer, buffer, offset, size,
+                                             indexType);
+                vkStream->unsetHandleMapping();
+                vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
+                                         (uintptr_t)snapshotTraceBegin);
+                size_t snapshotTraceBytes = vkReadStream->endTrace();
+                if (m_state->snapshotsEnabled()) {
+                    m_state->snapshot()->vkCmdBindIndexBuffer2KHR(
+                        snapshotTraceBegin, snapshotTraceBytes, &m_pool, commandBuffer, buffer,
+                        offset, size, indexType);
+                }
+                vkReadStream->clearPool();
+                if (queueSubmitWithCommandsEnabled)
+                    seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
+                android::base::endTrace();
+                break;
+            }
+            case OP_vkGetRenderingAreaGranularityKHR: {
+                android::base::beginTrace("vkGetRenderingAreaGranularityKHR decode");
+                VkDevice device;
+                const VkRenderingAreaInfoKHR* pRenderingAreaInfo;
+                VkExtent2D* pGranularity;
+                // Begin non wrapped dispatchable handle unboxing for device;
+                uint64_t cgen_var_0;
+                memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
+                *readStreamPtrPtr += 1 * 8;
+                *(VkDevice*)&device = (VkDevice)(VkDevice)((VkDevice)(*&cgen_var_0));
+                auto unboxed_device = unbox_VkDevice(device);
+                auto vk = dispatch_VkDevice(device);
+                // End manual dispatchable handle unboxing for device;
+                vkReadStream->alloc((void**)&pRenderingAreaInfo,
+                                    sizeof(const VkRenderingAreaInfoKHR));
+                reservedunmarshal_VkRenderingAreaInfoKHR(
+                    vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
+                    (VkRenderingAreaInfoKHR*)(pRenderingAreaInfo), readStreamPtrPtr);
+                // Begin manual dispatchable handle unboxing for pGranularity;
+                vkReadStream->unsetHandleMapping();
+                vkReadStream->alloc((void**)&pGranularity, sizeof(VkExtent2D));
+                reservedunmarshal_VkExtent2D(vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
+                                             (VkExtent2D*)(pGranularity), readStreamPtrPtr);
+                if (pRenderingAreaInfo) {
+                    transform_tohost_VkRenderingAreaInfoKHR(
+                        m_state, (VkRenderingAreaInfoKHR*)(pRenderingAreaInfo));
+                }
+                if (pGranularity) {
+                    transform_tohost_VkExtent2D(m_state, (VkExtent2D*)(pGranularity));
+                }
+                if (m_logCalls) {
+                    fprintf(
+                        stderr,
+                        "stream %p: call vkGetRenderingAreaGranularityKHR 0x%llx 0x%llx 0x%llx \n",
+                        ioStream, (unsigned long long)device,
+                        (unsigned long long)pRenderingAreaInfo, (unsigned long long)pGranularity);
+                }
+                vk->vkGetRenderingAreaGranularityKHR(unboxed_device, pRenderingAreaInfo,
+                                                     pGranularity);
+                vkStream->unsetHandleMapping();
+                if (pGranularity) {
+                    transform_fromhost_VkExtent2D(m_state, (VkExtent2D*)(pGranularity));
+                }
+                marshal_VkExtent2D(vkStream, VK_STRUCTURE_TYPE_MAX_ENUM,
+                                   (VkExtent2D*)(pGranularity));
+                vkStream->commitWrite();
+                vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
+                                         (uintptr_t)snapshotTraceBegin);
+                size_t snapshotTraceBytes = vkReadStream->endTrace();
+                if (m_state->snapshotsEnabled()) {
+                    m_state->snapshot()->vkGetRenderingAreaGranularityKHR(
+                        snapshotTraceBegin, snapshotTraceBytes, &m_pool, device, pRenderingAreaInfo,
+                        pGranularity);
+                }
+                vkReadStream->clearPool();
+                if (queueSubmitWithCommandsEnabled)
+                    seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
+                android::base::endTrace();
+                break;
+            }
+            case OP_vkGetDeviceImageSubresourceLayoutKHR: {
+                android::base::beginTrace("vkGetDeviceImageSubresourceLayoutKHR decode");
+                VkDevice device;
+                const VkDeviceImageSubresourceInfoKHR* pInfo;
+                VkSubresourceLayout2KHR* pLayout;
+                // Begin non wrapped dispatchable handle unboxing for device;
+                uint64_t cgen_var_0;
+                memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
+                *readStreamPtrPtr += 1 * 8;
+                *(VkDevice*)&device = (VkDevice)(VkDevice)((VkDevice)(*&cgen_var_0));
+                auto unboxed_device = unbox_VkDevice(device);
+                auto vk = dispatch_VkDevice(device);
+                // End manual dispatchable handle unboxing for device;
+                vkReadStream->alloc((void**)&pInfo, sizeof(const VkDeviceImageSubresourceInfoKHR));
+                reservedunmarshal_VkDeviceImageSubresourceInfoKHR(
+                    vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
+                    (VkDeviceImageSubresourceInfoKHR*)(pInfo), readStreamPtrPtr);
+                // Begin manual dispatchable handle unboxing for pLayout;
+                vkReadStream->unsetHandleMapping();
+                vkReadStream->alloc((void**)&pLayout, sizeof(VkSubresourceLayout2KHR));
+                reservedunmarshal_VkSubresourceLayout2KHR(vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
+                                                          (VkSubresourceLayout2KHR*)(pLayout),
+                                                          readStreamPtrPtr);
+                if (pInfo) {
+                    transform_tohost_VkDeviceImageSubresourceInfoKHR(
+                        m_state, (VkDeviceImageSubresourceInfoKHR*)(pInfo));
+                }
+                if (pLayout) {
+                    transform_tohost_VkSubresourceLayout2KHR(m_state,
+                                                             (VkSubresourceLayout2KHR*)(pLayout));
+                }
+                if (m_logCalls) {
+                    fprintf(stderr,
+                            "stream %p: call vkGetDeviceImageSubresourceLayoutKHR 0x%llx 0x%llx "
+                            "0x%llx \n",
+                            ioStream, (unsigned long long)device, (unsigned long long)pInfo,
+                            (unsigned long long)pLayout);
+                }
+                vk->vkGetDeviceImageSubresourceLayoutKHR(unboxed_device, pInfo, pLayout);
+                vkStream->unsetHandleMapping();
+                if (pLayout) {
+                    transform_fromhost_VkSubresourceLayout2KHR(m_state,
+                                                               (VkSubresourceLayout2KHR*)(pLayout));
+                }
+                marshal_VkSubresourceLayout2KHR(vkStream, VK_STRUCTURE_TYPE_MAX_ENUM,
+                                                (VkSubresourceLayout2KHR*)(pLayout));
+                vkStream->commitWrite();
+                vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
+                                         (uintptr_t)snapshotTraceBegin);
+                size_t snapshotTraceBytes = vkReadStream->endTrace();
+                if (m_state->snapshotsEnabled()) {
+                    m_state->snapshot()->vkGetDeviceImageSubresourceLayoutKHR(
+                        snapshotTraceBegin, snapshotTraceBytes, &m_pool, device, pInfo, pLayout);
+                }
+                vkReadStream->clearPool();
+                if (queueSubmitWithCommandsEnabled)
+                    seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
+                android::base::endTrace();
+                break;
+            }
+            case OP_vkGetImageSubresourceLayout2KHR: {
+                android::base::beginTrace("vkGetImageSubresourceLayout2KHR decode");
+                VkDevice device;
+                VkImage image;
+                const VkImageSubresource2KHR* pSubresource;
+                VkSubresourceLayout2KHR* pLayout;
+                // Begin non wrapped dispatchable handle unboxing for device;
+                uint64_t cgen_var_0;
+                memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
+                *readStreamPtrPtr += 1 * 8;
+                *(VkDevice*)&device = (VkDevice)(VkDevice)((VkDevice)(*&cgen_var_0));
+                auto unboxed_device = unbox_VkDevice(device);
+                auto vk = dispatch_VkDevice(device);
+                // End manual dispatchable handle unboxing for device;
+                uint64_t cgen_var_1;
+                memcpy((uint64_t*)&cgen_var_1, *readStreamPtrPtr, 1 * 8);
+                *readStreamPtrPtr += 1 * 8;
+                *(VkImage*)&image = (VkImage)unbox_VkImage((VkImage)(*&cgen_var_1));
+                vkReadStream->alloc((void**)&pSubresource, sizeof(const VkImageSubresource2KHR));
+                reservedunmarshal_VkImageSubresource2KHR(vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
+                                                         (VkImageSubresource2KHR*)(pSubresource),
+                                                         readStreamPtrPtr);
+                // Begin manual dispatchable handle unboxing for pLayout;
+                vkReadStream->unsetHandleMapping();
+                vkReadStream->alloc((void**)&pLayout, sizeof(VkSubresourceLayout2KHR));
+                reservedunmarshal_VkSubresourceLayout2KHR(vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
+                                                          (VkSubresourceLayout2KHR*)(pLayout),
+                                                          readStreamPtrPtr);
+                if (pSubresource) {
+                    transform_tohost_VkImageSubresource2KHR(
+                        m_state, (VkImageSubresource2KHR*)(pSubresource));
+                }
+                if (pLayout) {
+                    transform_tohost_VkSubresourceLayout2KHR(m_state,
+                                                             (VkSubresourceLayout2KHR*)(pLayout));
+                }
+                if (m_logCalls) {
+                    fprintf(stderr,
+                            "stream %p: call vkGetImageSubresourceLayout2KHR 0x%llx 0x%llx 0x%llx "
+                            "0x%llx \n",
+                            ioStream, (unsigned long long)device, (unsigned long long)image,
+                            (unsigned long long)pSubresource, (unsigned long long)pLayout);
+                }
+                vk->vkGetImageSubresourceLayout2KHR(unboxed_device, image, pSubresource, pLayout);
+                vkStream->unsetHandleMapping();
+                if (pLayout) {
+                    transform_fromhost_VkSubresourceLayout2KHR(m_state,
+                                                               (VkSubresourceLayout2KHR*)(pLayout));
+                }
+                marshal_VkSubresourceLayout2KHR(vkStream, VK_STRUCTURE_TYPE_MAX_ENUM,
+                                                (VkSubresourceLayout2KHR*)(pLayout));
+                vkStream->commitWrite();
+                vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
+                                         (uintptr_t)snapshotTraceBegin);
+                size_t snapshotTraceBytes = vkReadStream->endTrace();
+                if (m_state->snapshotsEnabled()) {
+                    m_state->snapshot()->vkGetImageSubresourceLayout2KHR(
+                        snapshotTraceBegin, snapshotTraceBytes, &m_pool, device, image,
+                        pSubresource, pLayout);
+                }
+                vkReadStream->clearPool();
+                if (queueSubmitWithCommandsEnabled)
+                    seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
+                android::base::endTrace();
+                break;
+            }
+#endif
 #ifdef VK_ANDROID_native_buffer
             case OP_vkGetSwapchainGrallocUsageANDROID: {
                 android::base::beginTrace("vkGetSwapchainGrallocUsageANDROID decode");
@@ -18736,6 +18975,284 @@
                 break;
             }
 #endif
+#ifdef VK_EXT_host_image_copy
+            case OP_vkCopyMemoryToImageEXT: {
+                android::base::beginTrace("vkCopyMemoryToImageEXT decode");
+                VkDevice device;
+                const VkCopyMemoryToImageInfoEXT* pCopyMemoryToImageInfo;
+                // Begin non wrapped dispatchable handle unboxing for device;
+                uint64_t cgen_var_0;
+                memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
+                *readStreamPtrPtr += 1 * 8;
+                *(VkDevice*)&device = (VkDevice)(VkDevice)((VkDevice)(*&cgen_var_0));
+                auto unboxed_device = unbox_VkDevice(device);
+                auto vk = dispatch_VkDevice(device);
+                // End manual dispatchable handle unboxing for device;
+                vkReadStream->alloc((void**)&pCopyMemoryToImageInfo,
+                                    sizeof(const VkCopyMemoryToImageInfoEXT));
+                reservedunmarshal_VkCopyMemoryToImageInfoEXT(
+                    vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
+                    (VkCopyMemoryToImageInfoEXT*)(pCopyMemoryToImageInfo), readStreamPtrPtr);
+                if (pCopyMemoryToImageInfo) {
+                    transform_tohost_VkCopyMemoryToImageInfoEXT(
+                        m_state, (VkCopyMemoryToImageInfoEXT*)(pCopyMemoryToImageInfo));
+                }
+                if (m_logCalls) {
+                    fprintf(stderr, "stream %p: call vkCopyMemoryToImageEXT 0x%llx 0x%llx \n",
+                            ioStream, (unsigned long long)device,
+                            (unsigned long long)pCopyMemoryToImageInfo);
+                }
+                VkResult vkCopyMemoryToImageEXT_VkResult_return = (VkResult)0;
+                vkCopyMemoryToImageEXT_VkResult_return =
+                    vk->vkCopyMemoryToImageEXT(unboxed_device, pCopyMemoryToImageInfo);
+                if ((vkCopyMemoryToImageEXT_VkResult_return) == VK_ERROR_DEVICE_LOST)
+                    m_state->on_DeviceLost();
+                m_state->on_CheckOutOfMemory(vkCopyMemoryToImageEXT_VkResult_return, opcode,
+                                             context);
+                vkStream->unsetHandleMapping();
+                vkStream->write(&vkCopyMemoryToImageEXT_VkResult_return, sizeof(VkResult));
+                vkStream->commitWrite();
+                vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
+                                         (uintptr_t)snapshotTraceBegin);
+                size_t snapshotTraceBytes = vkReadStream->endTrace();
+                if (m_state->snapshotsEnabled()) {
+                    m_state->snapshot()->vkCopyMemoryToImageEXT(
+                        snapshotTraceBegin, snapshotTraceBytes, &m_pool,
+                        vkCopyMemoryToImageEXT_VkResult_return, device, pCopyMemoryToImageInfo);
+                }
+                vkReadStream->clearPool();
+                if (queueSubmitWithCommandsEnabled)
+                    seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
+                android::base::endTrace();
+                break;
+            }
+            case OP_vkCopyImageToMemoryEXT: {
+                android::base::beginTrace("vkCopyImageToMemoryEXT decode");
+                VkDevice device;
+                const VkCopyImageToMemoryInfoEXT* pCopyImageToMemoryInfo;
+                // Begin non wrapped dispatchable handle unboxing for device;
+                uint64_t cgen_var_0;
+                memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
+                *readStreamPtrPtr += 1 * 8;
+                *(VkDevice*)&device = (VkDevice)(VkDevice)((VkDevice)(*&cgen_var_0));
+                auto unboxed_device = unbox_VkDevice(device);
+                auto vk = dispatch_VkDevice(device);
+                // End manual dispatchable handle unboxing for device;
+                vkReadStream->alloc((void**)&pCopyImageToMemoryInfo,
+                                    sizeof(const VkCopyImageToMemoryInfoEXT));
+                reservedunmarshal_VkCopyImageToMemoryInfoEXT(
+                    vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
+                    (VkCopyImageToMemoryInfoEXT*)(pCopyImageToMemoryInfo), readStreamPtrPtr);
+                if (pCopyImageToMemoryInfo) {
+                    transform_tohost_VkCopyImageToMemoryInfoEXT(
+                        m_state, (VkCopyImageToMemoryInfoEXT*)(pCopyImageToMemoryInfo));
+                }
+                if (m_logCalls) {
+                    fprintf(stderr, "stream %p: call vkCopyImageToMemoryEXT 0x%llx 0x%llx \n",
+                            ioStream, (unsigned long long)device,
+                            (unsigned long long)pCopyImageToMemoryInfo);
+                }
+                VkResult vkCopyImageToMemoryEXT_VkResult_return = (VkResult)0;
+                vkCopyImageToMemoryEXT_VkResult_return =
+                    vk->vkCopyImageToMemoryEXT(unboxed_device, pCopyImageToMemoryInfo);
+                if ((vkCopyImageToMemoryEXT_VkResult_return) == VK_ERROR_DEVICE_LOST)
+                    m_state->on_DeviceLost();
+                m_state->on_CheckOutOfMemory(vkCopyImageToMemoryEXT_VkResult_return, opcode,
+                                             context);
+                vkStream->unsetHandleMapping();
+                vkStream->write(&vkCopyImageToMemoryEXT_VkResult_return, sizeof(VkResult));
+                vkStream->commitWrite();
+                vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
+                                         (uintptr_t)snapshotTraceBegin);
+                size_t snapshotTraceBytes = vkReadStream->endTrace();
+                if (m_state->snapshotsEnabled()) {
+                    m_state->snapshot()->vkCopyImageToMemoryEXT(
+                        snapshotTraceBegin, snapshotTraceBytes, &m_pool,
+                        vkCopyImageToMemoryEXT_VkResult_return, device, pCopyImageToMemoryInfo);
+                }
+                vkReadStream->clearPool();
+                if (queueSubmitWithCommandsEnabled)
+                    seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
+                android::base::endTrace();
+                break;
+            }
+            case OP_vkCopyImageToImageEXT: {
+                android::base::beginTrace("vkCopyImageToImageEXT decode");
+                VkDevice device;
+                const VkCopyImageToImageInfoEXT* pCopyImageToImageInfo;
+                // Begin non wrapped dispatchable handle unboxing for device;
+                uint64_t cgen_var_0;
+                memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
+                *readStreamPtrPtr += 1 * 8;
+                *(VkDevice*)&device = (VkDevice)(VkDevice)((VkDevice)(*&cgen_var_0));
+                auto unboxed_device = unbox_VkDevice(device);
+                auto vk = dispatch_VkDevice(device);
+                // End manual dispatchable handle unboxing for device;
+                vkReadStream->alloc((void**)&pCopyImageToImageInfo,
+                                    sizeof(const VkCopyImageToImageInfoEXT));
+                reservedunmarshal_VkCopyImageToImageInfoEXT(
+                    vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
+                    (VkCopyImageToImageInfoEXT*)(pCopyImageToImageInfo), readStreamPtrPtr);
+                if (pCopyImageToImageInfo) {
+                    transform_tohost_VkCopyImageToImageInfoEXT(
+                        m_state, (VkCopyImageToImageInfoEXT*)(pCopyImageToImageInfo));
+                }
+                if (m_logCalls) {
+                    fprintf(stderr, "stream %p: call vkCopyImageToImageEXT 0x%llx 0x%llx \n",
+                            ioStream, (unsigned long long)device,
+                            (unsigned long long)pCopyImageToImageInfo);
+                }
+                VkResult vkCopyImageToImageEXT_VkResult_return = (VkResult)0;
+                vkCopyImageToImageEXT_VkResult_return =
+                    vk->vkCopyImageToImageEXT(unboxed_device, pCopyImageToImageInfo);
+                if ((vkCopyImageToImageEXT_VkResult_return) == VK_ERROR_DEVICE_LOST)
+                    m_state->on_DeviceLost();
+                m_state->on_CheckOutOfMemory(vkCopyImageToImageEXT_VkResult_return, opcode,
+                                             context);
+                vkStream->unsetHandleMapping();
+                vkStream->write(&vkCopyImageToImageEXT_VkResult_return, sizeof(VkResult));
+                vkStream->commitWrite();
+                vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
+                                         (uintptr_t)snapshotTraceBegin);
+                size_t snapshotTraceBytes = vkReadStream->endTrace();
+                if (m_state->snapshotsEnabled()) {
+                    m_state->snapshot()->vkCopyImageToImageEXT(
+                        snapshotTraceBegin, snapshotTraceBytes, &m_pool,
+                        vkCopyImageToImageEXT_VkResult_return, device, pCopyImageToImageInfo);
+                }
+                vkReadStream->clearPool();
+                if (queueSubmitWithCommandsEnabled)
+                    seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
+                android::base::endTrace();
+                break;
+            }
+            case OP_vkTransitionImageLayoutEXT: {
+                android::base::beginTrace("vkTransitionImageLayoutEXT decode");
+                VkDevice device;
+                uint32_t transitionCount;
+                const VkHostImageLayoutTransitionInfoEXT* pTransitions;
+                // Begin non wrapped dispatchable handle unboxing for device;
+                uint64_t cgen_var_0;
+                memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
+                *readStreamPtrPtr += 1 * 8;
+                *(VkDevice*)&device = (VkDevice)(VkDevice)((VkDevice)(*&cgen_var_0));
+                auto unboxed_device = unbox_VkDevice(device);
+                auto vk = dispatch_VkDevice(device);
+                // End manual dispatchable handle unboxing for device;
+                memcpy((uint32_t*)&transitionCount, *readStreamPtrPtr, sizeof(uint32_t));
+                *readStreamPtrPtr += sizeof(uint32_t);
+                vkReadStream->alloc(
+                    (void**)&pTransitions,
+                    ((transitionCount)) * sizeof(const VkHostImageLayoutTransitionInfoEXT));
+                for (uint32_t i = 0; i < (uint32_t)((transitionCount)); ++i) {
+                    reservedunmarshal_VkHostImageLayoutTransitionInfoEXT(
+                        vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
+                        (VkHostImageLayoutTransitionInfoEXT*)(pTransitions + i), readStreamPtrPtr);
+                }
+                if (pTransitions) {
+                    for (uint32_t i = 0; i < (uint32_t)((transitionCount)); ++i) {
+                        transform_tohost_VkHostImageLayoutTransitionInfoEXT(
+                            m_state, (VkHostImageLayoutTransitionInfoEXT*)(pTransitions + i));
+                    }
+                }
+                if (m_logCalls) {
+                    fprintf(stderr,
+                            "stream %p: call vkTransitionImageLayoutEXT 0x%llx 0x%llx 0x%llx \n",
+                            ioStream, (unsigned long long)device,
+                            (unsigned long long)transitionCount, (unsigned long long)pTransitions);
+                }
+                VkResult vkTransitionImageLayoutEXT_VkResult_return = (VkResult)0;
+                vkTransitionImageLayoutEXT_VkResult_return =
+                    vk->vkTransitionImageLayoutEXT(unboxed_device, transitionCount, pTransitions);
+                if ((vkTransitionImageLayoutEXT_VkResult_return) == VK_ERROR_DEVICE_LOST)
+                    m_state->on_DeviceLost();
+                m_state->on_CheckOutOfMemory(vkTransitionImageLayoutEXT_VkResult_return, opcode,
+                                             context);
+                vkStream->unsetHandleMapping();
+                vkStream->write(&vkTransitionImageLayoutEXT_VkResult_return, sizeof(VkResult));
+                vkStream->commitWrite();
+                vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
+                                         (uintptr_t)snapshotTraceBegin);
+                size_t snapshotTraceBytes = vkReadStream->endTrace();
+                if (m_state->snapshotsEnabled()) {
+                    m_state->snapshot()->vkTransitionImageLayoutEXT(
+                        snapshotTraceBegin, snapshotTraceBytes, &m_pool,
+                        vkTransitionImageLayoutEXT_VkResult_return, device, transitionCount,
+                        pTransitions);
+                }
+                vkReadStream->clearPool();
+                if (queueSubmitWithCommandsEnabled)
+                    seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
+                android::base::endTrace();
+                break;
+            }
+            case OP_vkGetImageSubresourceLayout2EXT: {
+                android::base::beginTrace("vkGetImageSubresourceLayout2EXT decode");
+                VkDevice device;
+                VkImage image;
+                const VkImageSubresource2KHR* pSubresource;
+                VkSubresourceLayout2KHR* pLayout;
+                // Begin non wrapped dispatchable handle unboxing for device;
+                uint64_t cgen_var_0;
+                memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
+                *readStreamPtrPtr += 1 * 8;
+                *(VkDevice*)&device = (VkDevice)(VkDevice)((VkDevice)(*&cgen_var_0));
+                auto unboxed_device = unbox_VkDevice(device);
+                auto vk = dispatch_VkDevice(device);
+                // End manual dispatchable handle unboxing for device;
+                uint64_t cgen_var_1;
+                memcpy((uint64_t*)&cgen_var_1, *readStreamPtrPtr, 1 * 8);
+                *readStreamPtrPtr += 1 * 8;
+                *(VkImage*)&image = (VkImage)unbox_VkImage((VkImage)(*&cgen_var_1));
+                vkReadStream->alloc((void**)&pSubresource, sizeof(const VkImageSubresource2KHR));
+                reservedunmarshal_VkImageSubresource2KHR(vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
+                                                         (VkImageSubresource2KHR*)(pSubresource),
+                                                         readStreamPtrPtr);
+                // Begin manual dispatchable handle unboxing for pLayout;
+                vkReadStream->unsetHandleMapping();
+                vkReadStream->alloc((void**)&pLayout, sizeof(VkSubresourceLayout2KHR));
+                reservedunmarshal_VkSubresourceLayout2KHR(vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
+                                                          (VkSubresourceLayout2KHR*)(pLayout),
+                                                          readStreamPtrPtr);
+                if (pSubresource) {
+                    transform_tohost_VkImageSubresource2KHR(
+                        m_state, (VkImageSubresource2KHR*)(pSubresource));
+                }
+                if (pLayout) {
+                    transform_tohost_VkSubresourceLayout2KHR(m_state,
+                                                             (VkSubresourceLayout2KHR*)(pLayout));
+                }
+                if (m_logCalls) {
+                    fprintf(stderr,
+                            "stream %p: call vkGetImageSubresourceLayout2EXT 0x%llx 0x%llx 0x%llx "
+                            "0x%llx \n",
+                            ioStream, (unsigned long long)device, (unsigned long long)image,
+                            (unsigned long long)pSubresource, (unsigned long long)pLayout);
+                }
+                vk->vkGetImageSubresourceLayout2EXT(unboxed_device, image, pSubresource, pLayout);
+                vkStream->unsetHandleMapping();
+                if (pLayout) {
+                    transform_fromhost_VkSubresourceLayout2KHR(m_state,
+                                                               (VkSubresourceLayout2KHR*)(pLayout));
+                }
+                marshal_VkSubresourceLayout2KHR(vkStream, VK_STRUCTURE_TYPE_MAX_ENUM,
+                                                (VkSubresourceLayout2KHR*)(pLayout));
+                vkStream->commitWrite();
+                vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
+                                         (uintptr_t)snapshotTraceBegin);
+                size_t snapshotTraceBytes = vkReadStream->endTrace();
+                if (m_state->snapshotsEnabled()) {
+                    m_state->snapshot()->vkGetImageSubresourceLayout2EXT(
+                        snapshotTraceBegin, snapshotTraceBytes, &m_pool, device, image,
+                        pSubresource, pLayout);
+                }
+                vkReadStream->clearPool();
+                if (queueSubmitWithCommandsEnabled)
+                    seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
+                android::base::endTrace();
+                break;
+            }
+#endif
 #ifdef VK_EXT_swapchain_maintenance1
             case OP_vkReleaseSwapchainImagesEXT: {
                 android::base::beginTrace("vkReleaseSwapchainImagesEXT decode");
@@ -19045,72 +19562,6 @@
 #ifdef VK_EXT_image_robustness
 #endif
 #ifdef VK_EXT_image_compression_control
-            case OP_vkGetImageSubresourceLayout2EXT: {
-                android::base::beginTrace("vkGetImageSubresourceLayout2EXT decode");
-                VkDevice device;
-                VkImage image;
-                const VkImageSubresource2EXT* pSubresource;
-                VkSubresourceLayout2EXT* pLayout;
-                // Begin non wrapped dispatchable handle unboxing for device;
-                uint64_t cgen_var_0;
-                memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
-                *readStreamPtrPtr += 1 * 8;
-                *(VkDevice*)&device = (VkDevice)(VkDevice)((VkDevice)(*&cgen_var_0));
-                auto unboxed_device = unbox_VkDevice(device);
-                auto vk = dispatch_VkDevice(device);
-                // End manual dispatchable handle unboxing for device;
-                uint64_t cgen_var_1;
-                memcpy((uint64_t*)&cgen_var_1, *readStreamPtrPtr, 1 * 8);
-                *readStreamPtrPtr += 1 * 8;
-                *(VkImage*)&image = (VkImage)unbox_VkImage((VkImage)(*&cgen_var_1));
-                vkReadStream->alloc((void**)&pSubresource, sizeof(const VkImageSubresource2EXT));
-                reservedunmarshal_VkImageSubresource2EXT(vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
-                                                         (VkImageSubresource2EXT*)(pSubresource),
-                                                         readStreamPtrPtr);
-                // Begin manual dispatchable handle unboxing for pLayout;
-                vkReadStream->unsetHandleMapping();
-                vkReadStream->alloc((void**)&pLayout, sizeof(VkSubresourceLayout2EXT));
-                reservedunmarshal_VkSubresourceLayout2EXT(vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
-                                                          (VkSubresourceLayout2EXT*)(pLayout),
-                                                          readStreamPtrPtr);
-                if (pSubresource) {
-                    transform_tohost_VkImageSubresource2EXT(
-                        m_state, (VkImageSubresource2EXT*)(pSubresource));
-                }
-                if (pLayout) {
-                    transform_tohost_VkSubresourceLayout2EXT(m_state,
-                                                             (VkSubresourceLayout2EXT*)(pLayout));
-                }
-                if (m_logCalls) {
-                    fprintf(stderr,
-                            "stream %p: call vkGetImageSubresourceLayout2EXT 0x%llx 0x%llx 0x%llx "
-                            "0x%llx \n",
-                            ioStream, (unsigned long long)device, (unsigned long long)image,
-                            (unsigned long long)pSubresource, (unsigned long long)pLayout);
-                }
-                vk->vkGetImageSubresourceLayout2EXT(unboxed_device, image, pSubresource, pLayout);
-                vkStream->unsetHandleMapping();
-                if (pLayout) {
-                    transform_fromhost_VkSubresourceLayout2EXT(m_state,
-                                                               (VkSubresourceLayout2EXT*)(pLayout));
-                }
-                marshal_VkSubresourceLayout2EXT(vkStream, VK_STRUCTURE_TYPE_MAX_ENUM,
-                                                (VkSubresourceLayout2EXT*)(pLayout));
-                vkStream->commitWrite();
-                vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
-                                         (uintptr_t)snapshotTraceBegin);
-                size_t snapshotTraceBytes = vkReadStream->endTrace();
-                if (m_state->snapshotsEnabled()) {
-                    m_state->snapshot()->vkGetImageSubresourceLayout2EXT(
-                        snapshotTraceBegin, snapshotTraceBytes, &m_pool, device, image,
-                        pSubresource, pLayout);
-                }
-                vkReadStream->clearPool();
-                if (queueSubmitWithCommandsEnabled)
-                    seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
-                android::base::endTrace();
-                break;
-            }
 #endif
 #ifdef VK_EXT_4444_formats
 #endif
diff --git a/host/vulkan/VkDecoder.h b/host/vulkan/VkDecoder.h
index 2f0f592..7512e3f 100644
--- a/host/vulkan/VkDecoder.h
+++ b/host/vulkan/VkDecoder.h
@@ -15,9 +15,9 @@
 
 // Autogenerated module VkDecoder
 //
-// (header) generated by codegen/vulkan/vulkan-docs/scripts/genvk.py -registry
-// codegen/vulkan/vulkan-docs/xml/vk.xml -registryGfxstream
-// codegen/vulkan/vulkan-docs/xml/vk_gfxstream.xml cereal -o host/vulkan/cereal
+// (header) generated by codegen/vulkan/vulkan-docs-next/scripts/genvk.py -registry
+// codegen/vulkan/vulkan-docs-next/xml/vk.xml -registryGfxstream
+// codegen/vulkan/vulkan-docs-next/xml/vk_gfxstream.xml cereal -o host/vulkan/cereal
 //
 // Please do not modify directly;
 // re-run gfxstream-protocols/scripts/generate-vulkan-sources.sh,
@@ -35,7 +35,7 @@
 #include <memory>
 
 #include "VkDecoderContext.h"
-#include "vk_android_native_buffer.h"
+#include "vk_android_native_buffer_gfxstream.h"
 #include "vulkan_gfxstream.h"
 
 namespace android {
@@ -164,6 +164,8 @@
 #endif
 #ifdef VK_KHR_maintenance4
 #endif
+#ifdef VK_KHR_maintenance5
+#endif
 #ifdef VK_ANDROID_native_buffer
 #endif
 #ifdef VK_EXT_transform_feedback
@@ -202,6 +204,8 @@
 #endif
 #ifdef VK_EXT_extended_dynamic_state
 #endif
+#ifdef VK_EXT_host_image_copy
+#endif
 #ifdef VK_EXT_swapchain_maintenance1
 #endif
 #ifdef VK_EXT_shader_demote_to_helper_invocation
diff --git a/host/vulkan/VkDecoderSnapshot.cpp b/host/vulkan/VkDecoderSnapshot.cpp
index 39c168f..c0e12da 100644
--- a/host/vulkan/VkDecoderSnapshot.cpp
+++ b/host/vulkan/VkDecoderSnapshot.cpp
@@ -15,9 +15,9 @@
 
 // Autogenerated module VkDecoderSnapshot
 //
-// (impl) generated by codegen/vulkan/vulkan-docs/scripts/genvk.py -registry
-// codegen/vulkan/vulkan-docs/xml/vk.xml -registryGfxstream
-// codegen/vulkan/vulkan-docs/xml/vk_gfxstream.xml cereal -o host/vulkan/cereal
+// (impl) generated by codegen/vulkan/vulkan-docs-next/scripts/genvk.py -registry
+// codegen/vulkan/vulkan-docs-next/xml/vk.xml -registryGfxstream
+// codegen/vulkan/vulkan-docs-next/xml/vk_gfxstream.xml cereal -o host/vulkan/cereal
 //
 // Please do not modify directly;
 // re-run gfxstream-protocols/scripts/generate-vulkan-sources.sh,
@@ -2305,6 +2305,35 @@
         // TODO: Implement
     }
 #endif
+#ifdef VK_KHR_maintenance5
+    void vkCmdBindIndexBuffer2KHR(const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes,
+                                  android::base::BumpPool* pool, VkCommandBuffer commandBuffer,
+                                  VkBuffer buffer, VkDeviceSize offset, VkDeviceSize size,
+                                  VkIndexType indexType) {
+        // TODO: Implement
+    }
+    void vkGetRenderingAreaGranularityKHR(const uint8_t* snapshotTraceBegin,
+                                          size_t snapshotTraceBytes, android::base::BumpPool* pool,
+                                          VkDevice device,
+                                          const VkRenderingAreaInfoKHR* pRenderingAreaInfo,
+                                          VkExtent2D* pGranularity) {
+        // TODO: Implement
+    }
+    void vkGetDeviceImageSubresourceLayoutKHR(const uint8_t* snapshotTraceBegin,
+                                              size_t snapshotTraceBytes,
+                                              android::base::BumpPool* pool, VkDevice device,
+                                              const VkDeviceImageSubresourceInfoKHR* pInfo,
+                                              VkSubresourceLayout2KHR* pLayout) {
+        // TODO: Implement
+    }
+    void vkGetImageSubresourceLayout2KHR(const uint8_t* snapshotTraceBegin,
+                                         size_t snapshotTraceBytes, android::base::BumpPool* pool,
+                                         VkDevice device, VkImage image,
+                                         const VkImageSubresource2KHR* pSubresource,
+                                         VkSubresourceLayout2KHR* pLayout) {
+        // TODO: Implement
+    }
+#endif
 #ifdef VK_ANDROID_native_buffer
     void vkGetSwapchainGrallocUsageANDROID(const uint8_t* snapshotTraceBegin,
                                            size_t snapshotTraceBytes, android::base::BumpPool* pool,
@@ -2485,6 +2514,39 @@
         // TODO: Implement
     }
 #endif
+#ifdef VK_EXT_host_image_copy
+    void vkCopyMemoryToImageEXT(const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes,
+                                android::base::BumpPool* pool, VkResult input_result,
+                                VkDevice device,
+                                const VkCopyMemoryToImageInfoEXT* pCopyMemoryToImageInfo) {
+        // TODO: Implement
+    }
+    void vkCopyImageToMemoryEXT(const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes,
+                                android::base::BumpPool* pool, VkResult input_result,
+                                VkDevice device,
+                                const VkCopyImageToMemoryInfoEXT* pCopyImageToMemoryInfo) {
+        // TODO: Implement
+    }
+    void vkCopyImageToImageEXT(const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes,
+                               android::base::BumpPool* pool, VkResult input_result,
+                               VkDevice device,
+                               const VkCopyImageToImageInfoEXT* pCopyImageToImageInfo) {
+        // TODO: Implement
+    }
+    void vkTransitionImageLayoutEXT(const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes,
+                                    android::base::BumpPool* pool, VkResult input_result,
+                                    VkDevice device, uint32_t transitionCount,
+                                    const VkHostImageLayoutTransitionInfoEXT* pTransitions) {
+        // TODO: Implement
+    }
+    void vkGetImageSubresourceLayout2EXT(const uint8_t* snapshotTraceBegin,
+                                         size_t snapshotTraceBytes, android::base::BumpPool* pool,
+                                         VkDevice device, VkImage image,
+                                         const VkImageSubresource2KHR* pSubresource,
+                                         VkSubresourceLayout2KHR* pLayout) {
+        // TODO: Implement
+    }
+#endif
 #ifdef VK_EXT_swapchain_maintenance1
     void vkReleaseSwapchainImagesEXT(const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes,
                                      android::base::BumpPool* pool, VkResult input_result,
@@ -2537,13 +2599,6 @@
 #ifdef VK_EXT_image_robustness
 #endif
 #ifdef VK_EXT_image_compression_control
-    void vkGetImageSubresourceLayout2EXT(const uint8_t* snapshotTraceBegin,
-                                         size_t snapshotTraceBytes, android::base::BumpPool* pool,
-                                         VkDevice device, VkImage image,
-                                         const VkImageSubresource2EXT* pSubresource,
-                                         VkSubresourceLayout2EXT* pLayout) {
-        // TODO: Implement
-    }
 #endif
 #ifdef VK_EXT_4444_formats
 #endif
@@ -5488,6 +5543,45 @@
                                                        pSparseMemoryRequirements);
 }
 #endif
+#ifdef VK_KHR_maintenance5
+void VkDecoderSnapshot::vkCmdBindIndexBuffer2KHR(const uint8_t* snapshotTraceBegin,
+                                                 size_t snapshotTraceBytes,
+                                                 android::base::BumpPool* pool,
+                                                 VkCommandBuffer commandBuffer, VkBuffer buffer,
+                                                 VkDeviceSize offset, VkDeviceSize size,
+                                                 VkIndexType indexType) {
+    mImpl->vkCmdBindIndexBuffer2KHR(snapshotTraceBegin, snapshotTraceBytes, pool, commandBuffer,
+                                    buffer, offset, size, indexType);
+}
+#endif
+#ifdef VK_KHR_maintenance5
+void VkDecoderSnapshot::vkGetRenderingAreaGranularityKHR(
+    const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes, android::base::BumpPool* pool,
+    VkDevice device, const VkRenderingAreaInfoKHR* pRenderingAreaInfo, VkExtent2D* pGranularity) {
+    mImpl->vkGetRenderingAreaGranularityKHR(snapshotTraceBegin, snapshotTraceBytes, pool, device,
+                                            pRenderingAreaInfo, pGranularity);
+}
+#endif
+#ifdef VK_KHR_maintenance5
+void VkDecoderSnapshot::vkGetDeviceImageSubresourceLayoutKHR(
+    const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes, android::base::BumpPool* pool,
+    VkDevice device, const VkDeviceImageSubresourceInfoKHR* pInfo,
+    VkSubresourceLayout2KHR* pLayout) {
+    mImpl->vkGetDeviceImageSubresourceLayoutKHR(snapshotTraceBegin, snapshotTraceBytes, pool,
+                                                device, pInfo, pLayout);
+}
+#endif
+#ifdef VK_KHR_maintenance5
+void VkDecoderSnapshot::vkGetImageSubresourceLayout2KHR(const uint8_t* snapshotTraceBegin,
+                                                        size_t snapshotTraceBytes,
+                                                        android::base::BumpPool* pool,
+                                                        VkDevice device, VkImage image,
+                                                        const VkImageSubresource2KHR* pSubresource,
+                                                        VkSubresourceLayout2KHR* pLayout) {
+    mImpl->vkGetImageSubresourceLayout2KHR(snapshotTraceBegin, snapshotTraceBytes, pool, device,
+                                           image, pSubresource, pLayout);
+}
+#endif
 #ifdef VK_ANDROID_native_buffer
 void VkDecoderSnapshot::vkGetSwapchainGrallocUsageANDROID(
     const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes, android::base::BumpPool* pool,
@@ -5722,6 +5816,53 @@
                                 faceMask, failOp, passOp, depthFailOp, compareOp);
 }
 #endif
+#ifdef VK_EXT_host_image_copy
+void VkDecoderSnapshot::vkCopyMemoryToImageEXT(
+    const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes, android::base::BumpPool* pool,
+    VkResult input_result, VkDevice device,
+    const VkCopyMemoryToImageInfoEXT* pCopyMemoryToImageInfo) {
+    mImpl->vkCopyMemoryToImageEXT(snapshotTraceBegin, snapshotTraceBytes, pool, input_result,
+                                  device, pCopyMemoryToImageInfo);
+}
+#endif
+#ifdef VK_EXT_host_image_copy
+void VkDecoderSnapshot::vkCopyImageToMemoryEXT(
+    const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes, android::base::BumpPool* pool,
+    VkResult input_result, VkDevice device,
+    const VkCopyImageToMemoryInfoEXT* pCopyImageToMemoryInfo) {
+    mImpl->vkCopyImageToMemoryEXT(snapshotTraceBegin, snapshotTraceBytes, pool, input_result,
+                                  device, pCopyImageToMemoryInfo);
+}
+#endif
+#ifdef VK_EXT_host_image_copy
+void VkDecoderSnapshot::vkCopyImageToImageEXT(
+    const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes, android::base::BumpPool* pool,
+    VkResult input_result, VkDevice device,
+    const VkCopyImageToImageInfoEXT* pCopyImageToImageInfo) {
+    mImpl->vkCopyImageToImageEXT(snapshotTraceBegin, snapshotTraceBytes, pool, input_result, device,
+                                 pCopyImageToImageInfo);
+}
+#endif
+#ifdef VK_EXT_host_image_copy
+void VkDecoderSnapshot::vkTransitionImageLayoutEXT(
+    const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes, android::base::BumpPool* pool,
+    VkResult input_result, VkDevice device, uint32_t transitionCount,
+    const VkHostImageLayoutTransitionInfoEXT* pTransitions) {
+    mImpl->vkTransitionImageLayoutEXT(snapshotTraceBegin, snapshotTraceBytes, pool, input_result,
+                                      device, transitionCount, pTransitions);
+}
+#endif
+#ifdef VK_EXT_host_image_copy
+void VkDecoderSnapshot::vkGetImageSubresourceLayout2EXT(const uint8_t* snapshotTraceBegin,
+                                                        size_t snapshotTraceBytes,
+                                                        android::base::BumpPool* pool,
+                                                        VkDevice device, VkImage image,
+                                                        const VkImageSubresource2KHR* pSubresource,
+                                                        VkSubresourceLayout2KHR* pLayout) {
+    mImpl->vkGetImageSubresourceLayout2EXT(snapshotTraceBegin, snapshotTraceBytes, pool, device,
+                                           image, pSubresource, pLayout);
+}
+#endif
 #ifdef VK_EXT_swapchain_maintenance1
 void VkDecoderSnapshot::vkReleaseSwapchainImagesEXT(
     const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes, android::base::BumpPool* pool,
@@ -5770,17 +5911,6 @@
                                objectHandle, privateDataSlot, pData);
 }
 #endif
-#ifdef VK_EXT_image_compression_control
-void VkDecoderSnapshot::vkGetImageSubresourceLayout2EXT(const uint8_t* snapshotTraceBegin,
-                                                        size_t snapshotTraceBytes,
-                                                        android::base::BumpPool* pool,
-                                                        VkDevice device, VkImage image,
-                                                        const VkImageSubresource2EXT* pSubresource,
-                                                        VkSubresourceLayout2EXT* pLayout) {
-    mImpl->vkGetImageSubresourceLayout2EXT(snapshotTraceBegin, snapshotTraceBytes, pool, device,
-                                           image, pSubresource, pLayout);
-}
-#endif
 #ifdef VK_EXT_extended_dynamic_state2
 void VkDecoderSnapshot::vkCmdSetPatchControlPointsEXT(const uint8_t* snapshotTraceBegin,
                                                       size_t snapshotTraceBytes,
diff --git a/host/vulkan/VkDecoderSnapshot.h b/host/vulkan/VkDecoderSnapshot.h
index ba0d550..28611ff 100644
--- a/host/vulkan/VkDecoderSnapshot.h
+++ b/host/vulkan/VkDecoderSnapshot.h
@@ -15,9 +15,9 @@
 
 // Autogenerated module VkDecoderSnapshot
 //
-// (header) generated by codegen/vulkan/vulkan-docs/scripts/genvk.py -registry
-// codegen/vulkan/vulkan-docs/xml/vk.xml -registryGfxstream
-// codegen/vulkan/vulkan-docs/xml/vk_gfxstream.xml cereal -o host/vulkan/cereal
+// (header) generated by codegen/vulkan/vulkan-docs-next/scripts/genvk.py -registry
+// codegen/vulkan/vulkan-docs-next/xml/vk.xml -registryGfxstream
+// codegen/vulkan/vulkan-docs-next/xml/vk_gfxstream.xml cereal -o host/vulkan/cereal
 //
 // Please do not modify directly;
 // re-run gfxstream-protocols/scripts/generate-vulkan-sources.sh,
@@ -37,7 +37,7 @@
 #include "aemu/base/HealthMonitor.h"
 #include "common/goldfish_vk_private_defs.h"
 #include "utils/GfxApiLogger.h"
-#include "vk_android_native_buffer.h"
+#include "vk_android_native_buffer_gfxstream.h"
 #include "vulkan_gfxstream.h"
 
 namespace android {
@@ -1240,6 +1240,27 @@
         uint32_t* pSparseMemoryRequirementCount,
         VkSparseImageMemoryRequirements2* pSparseMemoryRequirements);
 #endif
+#ifdef VK_KHR_maintenance5
+    void vkCmdBindIndexBuffer2KHR(const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes,
+                                  android::base::BumpPool* pool, VkCommandBuffer commandBuffer,
+                                  VkBuffer buffer, VkDeviceSize offset, VkDeviceSize size,
+                                  VkIndexType indexType);
+    void vkGetRenderingAreaGranularityKHR(const uint8_t* snapshotTraceBegin,
+                                          size_t snapshotTraceBytes, android::base::BumpPool* pool,
+                                          VkDevice device,
+                                          const VkRenderingAreaInfoKHR* pRenderingAreaInfo,
+                                          VkExtent2D* pGranularity);
+    void vkGetDeviceImageSubresourceLayoutKHR(const uint8_t* snapshotTraceBegin,
+                                              size_t snapshotTraceBytes,
+                                              android::base::BumpPool* pool, VkDevice device,
+                                              const VkDeviceImageSubresourceInfoKHR* pInfo,
+                                              VkSubresourceLayout2KHR* pLayout);
+    void vkGetImageSubresourceLayout2KHR(const uint8_t* snapshotTraceBegin,
+                                         size_t snapshotTraceBytes, android::base::BumpPool* pool,
+                                         VkDevice device, VkImage image,
+                                         const VkImageSubresource2KHR* pSubresource,
+                                         VkSubresourceLayout2KHR* pLayout);
+#endif
 #ifdef VK_ANDROID_native_buffer
     void vkGetSwapchainGrallocUsageANDROID(const uint8_t* snapshotTraceBegin,
                                            size_t snapshotTraceBytes, android::base::BumpPool* pool,
@@ -1372,6 +1393,29 @@
                               VkStencilFaceFlags faceMask, VkStencilOp failOp, VkStencilOp passOp,
                               VkStencilOp depthFailOp, VkCompareOp compareOp);
 #endif
+#ifdef VK_EXT_host_image_copy
+    void vkCopyMemoryToImageEXT(const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes,
+                                android::base::BumpPool* pool, VkResult input_result,
+                                VkDevice device,
+                                const VkCopyMemoryToImageInfoEXT* pCopyMemoryToImageInfo);
+    void vkCopyImageToMemoryEXT(const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes,
+                                android::base::BumpPool* pool, VkResult input_result,
+                                VkDevice device,
+                                const VkCopyImageToMemoryInfoEXT* pCopyImageToMemoryInfo);
+    void vkCopyImageToImageEXT(const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes,
+                               android::base::BumpPool* pool, VkResult input_result,
+                               VkDevice device,
+                               const VkCopyImageToImageInfoEXT* pCopyImageToImageInfo);
+    void vkTransitionImageLayoutEXT(const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes,
+                                    android::base::BumpPool* pool, VkResult input_result,
+                                    VkDevice device, uint32_t transitionCount,
+                                    const VkHostImageLayoutTransitionInfoEXT* pTransitions);
+    void vkGetImageSubresourceLayout2EXT(const uint8_t* snapshotTraceBegin,
+                                         size_t snapshotTraceBytes, android::base::BumpPool* pool,
+                                         VkDevice device, VkImage image,
+                                         const VkImageSubresource2KHR* pSubresource,
+                                         VkSubresourceLayout2KHR* pLayout);
+#endif
 #ifdef VK_EXT_swapchain_maintenance1
     void vkReleaseSwapchainImagesEXT(const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes,
                                      android::base::BumpPool* pool, VkResult input_result,
@@ -1414,11 +1458,6 @@
 #ifdef VK_EXT_image_robustness
 #endif
 #ifdef VK_EXT_image_compression_control
-    void vkGetImageSubresourceLayout2EXT(const uint8_t* snapshotTraceBegin,
-                                         size_t snapshotTraceBytes, android::base::BumpPool* pool,
-                                         VkDevice device, VkImage image,
-                                         const VkImageSubresource2EXT* pSubresource,
-                                         VkSubresourceLayout2EXT* pLayout);
 #endif
 #ifdef VK_EXT_4444_formats
 #endif
diff --git a/host/vulkan/VkSubDecoder.cpp b/host/vulkan/VkSubDecoder.cpp
index b18596e..69eab14 100644
--- a/host/vulkan/VkSubDecoder.cpp
+++ b/host/vulkan/VkSubDecoder.cpp
@@ -15,9 +15,9 @@
 
 // Autogenerated module VkSubDecoder
 //
-// (impl) generated by codegen/vulkan/vulkan-docs/scripts/genvk.py -registry
-// codegen/vulkan/vulkan-docs/xml/vk.xml -registryGfxstream
-// codegen/vulkan/vulkan-docs/xml/vk_gfxstream.xml cereal -o host/vulkan/cereal
+// (impl) generated by codegen/vulkan/vulkan-docs-next/scripts/genvk.py -registry
+// codegen/vulkan/vulkan-docs-next/xml/vk.xml -registryGfxstream
+// codegen/vulkan/vulkan-docs-next/xml/vk_gfxstream.xml cereal -o host/vulkan/cereal
 //
 // Please do not modify directly;
 // re-run gfxstream-protocols/scripts/generate-vulkan-sources.sh,
@@ -2454,6 +2454,29 @@
 #endif
 #ifdef VK_KHR_maintenance4
 #endif
+#ifdef VK_KHR_maintenance5
+            case OP_vkCmdBindIndexBuffer2KHR: {
+                android::base::beginTrace("vkCmdBindIndexBuffer2KHR subdecode");
+                VkBuffer buffer;
+                VkDeviceSize offset;
+                VkDeviceSize size;
+                VkIndexType indexType;
+                uint64_t cgen_var_0;
+                memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
+                *readStreamPtrPtr += 1 * 8;
+                *(VkBuffer*)&buffer = (VkBuffer)unbox_VkBuffer((VkBuffer)(*&cgen_var_0));
+                memcpy((VkDeviceSize*)&offset, *readStreamPtrPtr, sizeof(VkDeviceSize));
+                *readStreamPtrPtr += sizeof(VkDeviceSize);
+                memcpy((VkDeviceSize*)&size, *readStreamPtrPtr, sizeof(VkDeviceSize));
+                *readStreamPtrPtr += sizeof(VkDeviceSize);
+                memcpy((VkIndexType*)&indexType, *readStreamPtrPtr, sizeof(VkIndexType));
+                *readStreamPtrPtr += sizeof(VkIndexType);
+                vk->vkCmdBindIndexBuffer2KHR((VkCommandBuffer)dispatchHandle, buffer, offset, size,
+                                             indexType);
+                android::base::endTrace();
+                break;
+            }
+#endif
 #ifdef VK_ANDROID_native_buffer
 #endif
 #ifdef VK_EXT_transform_feedback
@@ -2979,6 +3002,8 @@
                 break;
             }
 #endif
+#ifdef VK_EXT_host_image_copy
+#endif
 #ifdef VK_EXT_swapchain_maintenance1
 #endif
 #ifdef VK_EXT_shader_demote_to_helper_invocation
diff --git a/host/vulkan/cereal/CMakeLists.txt b/host/vulkan/cereal/CMakeLists.txt
index b3a8815..0231ac9 100644
--- a/host/vulkan/cereal/CMakeLists.txt
+++ b/host/vulkan/cereal/CMakeLists.txt
@@ -1,6 +1,6 @@
 
 # Autogenerated makefile
-# codegen/vulkan/vulkan-docs/scripts/genvk.py -registry codegen/vulkan/vulkan-docs/xml/vk.xml -registryGfxstream codegen/vulkan/vulkan-docs/xml/vk_gfxstream.xml cereal -o host/vulkan/cereal
+# codegen/vulkan/vulkan-docs-next/scripts/genvk.py -registry codegen/vulkan/vulkan-docs-next/xml/vk.xml -registryGfxstream codegen/vulkan/vulkan-docs-next/xml/vk_gfxstream.xml cereal -o host/vulkan/cereal
 # Please do not modify directly;
 # re-run gfxstream-protocols/scripts/generate-vulkan-sources.sh,
 # or directly from Python by defining:
diff --git a/host/vulkan/cereal/common/goldfish_vk_deepcopy.cpp b/host/vulkan/cereal/common/goldfish_vk_deepcopy.cpp
index c69010e..65eb18e 100644
--- a/host/vulkan/cereal/common/goldfish_vk_deepcopy.cpp
+++ b/host/vulkan/cereal/common/goldfish_vk_deepcopy.cpp
@@ -15,9 +15,9 @@
 
 // Autogenerated module goldfish_vk_deepcopy
 //
-// (impl) generated by codegen/vulkan/vulkan-docs/scripts/genvk.py -registry
-// codegen/vulkan/vulkan-docs/xml/vk.xml -registryGfxstream
-// codegen/vulkan/vulkan-docs/xml/vk_gfxstream.xml cereal -o host/vulkan/cereal
+// (impl) generated by codegen/vulkan/vulkan-docs-next/scripts/genvk.py -registry
+// codegen/vulkan/vulkan-docs-next/xml/vk.xml -registryGfxstream
+// codegen/vulkan/vulkan-docs-next/xml/vk_gfxstream.xml cereal -o host/vulkan/cereal
 //
 // Please do not modify directly;
 // re-run gfxstream-protocols/scripts/generate-vulkan-sources.sh,
@@ -7244,6 +7244,207 @@
 #endif
 #ifdef VK_KHR_maintenance4
 #endif
+#ifdef VK_KHR_maintenance5
+void deepcopy_VkPhysicalDeviceMaintenance5FeaturesKHR(
+    Allocator* alloc, VkStructureType rootType, const VkPhysicalDeviceMaintenance5FeaturesKHR* from,
+    VkPhysicalDeviceMaintenance5FeaturesKHR* to) {
+    (void)alloc;
+    (void)rootType;
+    *to = *from;
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = from->sType;
+    }
+    const void* from_pNext = from;
+    size_t pNext_size = 0u;
+    while (!pNext_size && from_pNext) {
+        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+        pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
+    }
+    to->pNext = nullptr;
+    if (pNext_size) {
+        to->pNext = (void*)alloc->alloc(pNext_size);
+        deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
+    }
+}
+
+void deepcopy_VkPhysicalDeviceMaintenance5PropertiesKHR(
+    Allocator* alloc, VkStructureType rootType,
+    const VkPhysicalDeviceMaintenance5PropertiesKHR* from,
+    VkPhysicalDeviceMaintenance5PropertiesKHR* to) {
+    (void)alloc;
+    (void)rootType;
+    *to = *from;
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = from->sType;
+    }
+    const void* from_pNext = from;
+    size_t pNext_size = 0u;
+    while (!pNext_size && from_pNext) {
+        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+        pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
+    }
+    to->pNext = nullptr;
+    if (pNext_size) {
+        to->pNext = (void*)alloc->alloc(pNext_size);
+        deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
+    }
+}
+
+void deepcopy_VkRenderingAreaInfoKHR(Allocator* alloc, VkStructureType rootType,
+                                     const VkRenderingAreaInfoKHR* from,
+                                     VkRenderingAreaInfoKHR* to) {
+    (void)alloc;
+    (void)rootType;
+    *to = *from;
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = from->sType;
+    }
+    const void* from_pNext = from;
+    size_t pNext_size = 0u;
+    while (!pNext_size && from_pNext) {
+        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+        pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
+    }
+    to->pNext = nullptr;
+    if (pNext_size) {
+        to->pNext = (void*)alloc->alloc(pNext_size);
+        deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
+    }
+    to->pColorAttachmentFormats = nullptr;
+    if (from->pColorAttachmentFormats) {
+        to->pColorAttachmentFormats = (VkFormat*)alloc->dupArray(
+            from->pColorAttachmentFormats, from->colorAttachmentCount * sizeof(const VkFormat));
+    }
+}
+
+void deepcopy_VkImageSubresource2KHR(Allocator* alloc, VkStructureType rootType,
+                                     const VkImageSubresource2KHR* from,
+                                     VkImageSubresource2KHR* to) {
+    (void)alloc;
+    (void)rootType;
+    *to = *from;
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = from->sType;
+    }
+    const void* from_pNext = from;
+    size_t pNext_size = 0u;
+    while (!pNext_size && from_pNext) {
+        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+        pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
+    }
+    to->pNext = nullptr;
+    if (pNext_size) {
+        to->pNext = (void*)alloc->alloc(pNext_size);
+        deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
+    }
+    deepcopy_VkImageSubresource(alloc, rootType, &from->imageSubresource,
+                                (VkImageSubresource*)(&to->imageSubresource));
+}
+
+void deepcopy_VkDeviceImageSubresourceInfoKHR(Allocator* alloc, VkStructureType rootType,
+                                              const VkDeviceImageSubresourceInfoKHR* from,
+                                              VkDeviceImageSubresourceInfoKHR* to) {
+    (void)alloc;
+    (void)rootType;
+    *to = *from;
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = from->sType;
+    }
+    const void* from_pNext = from;
+    size_t pNext_size = 0u;
+    while (!pNext_size && from_pNext) {
+        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+        pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
+    }
+    to->pNext = nullptr;
+    if (pNext_size) {
+        to->pNext = (void*)alloc->alloc(pNext_size);
+        deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
+    }
+    to->pCreateInfo = nullptr;
+    if (from->pCreateInfo) {
+        to->pCreateInfo = (VkImageCreateInfo*)alloc->alloc(sizeof(const VkImageCreateInfo));
+        deepcopy_VkImageCreateInfo(alloc, rootType, from->pCreateInfo,
+                                   (VkImageCreateInfo*)(to->pCreateInfo));
+    }
+    to->pSubresource = nullptr;
+    if (from->pSubresource) {
+        to->pSubresource =
+            (VkImageSubresource2KHR*)alloc->alloc(sizeof(const VkImageSubresource2KHR));
+        deepcopy_VkImageSubresource2KHR(alloc, rootType, from->pSubresource,
+                                        (VkImageSubresource2KHR*)(to->pSubresource));
+    }
+}
+
+void deepcopy_VkSubresourceLayout2KHR(Allocator* alloc, VkStructureType rootType,
+                                      const VkSubresourceLayout2KHR* from,
+                                      VkSubresourceLayout2KHR* to) {
+    (void)alloc;
+    (void)rootType;
+    *to = *from;
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = from->sType;
+    }
+    const void* from_pNext = from;
+    size_t pNext_size = 0u;
+    while (!pNext_size && from_pNext) {
+        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+        pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
+    }
+    to->pNext = nullptr;
+    if (pNext_size) {
+        to->pNext = (void*)alloc->alloc(pNext_size);
+        deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
+    }
+    deepcopy_VkSubresourceLayout(alloc, rootType, &from->subresourceLayout,
+                                 (VkSubresourceLayout*)(&to->subresourceLayout));
+}
+
+void deepcopy_VkPipelineCreateFlags2CreateInfoKHR(Allocator* alloc, VkStructureType rootType,
+                                                  const VkPipelineCreateFlags2CreateInfoKHR* from,
+                                                  VkPipelineCreateFlags2CreateInfoKHR* to) {
+    (void)alloc;
+    (void)rootType;
+    *to = *from;
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = from->sType;
+    }
+    const void* from_pNext = from;
+    size_t pNext_size = 0u;
+    while (!pNext_size && from_pNext) {
+        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+        pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
+    }
+    to->pNext = nullptr;
+    if (pNext_size) {
+        to->pNext = (void*)alloc->alloc(pNext_size);
+        deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
+    }
+}
+
+void deepcopy_VkBufferUsageFlags2CreateInfoKHR(Allocator* alloc, VkStructureType rootType,
+                                               const VkBufferUsageFlags2CreateInfoKHR* from,
+                                               VkBufferUsageFlags2CreateInfoKHR* to) {
+    (void)alloc;
+    (void)rootType;
+    *to = *from;
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = from->sType;
+    }
+    const void* from_pNext = from;
+    size_t pNext_size = 0u;
+    while (!pNext_size && from_pNext) {
+        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+        pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
+    }
+    to->pNext = nullptr;
+    if (pNext_size) {
+        to->pNext = (void*)alloc->alloc(pNext_size);
+        deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
+    }
+}
+
+#endif
 #ifdef VK_ANDROID_native_buffer
 void deepcopy_VkNativeBufferUsage2ANDROID(Allocator* alloc, VkStructureType rootType,
                                           const VkNativeBufferUsage2ANDROID* from,
@@ -7615,6 +7816,297 @@
 }
 
 #endif
+#ifdef VK_EXT_host_image_copy
+void deepcopy_VkPhysicalDeviceHostImageCopyFeaturesEXT(
+    Allocator* alloc, VkStructureType rootType,
+    const VkPhysicalDeviceHostImageCopyFeaturesEXT* from,
+    VkPhysicalDeviceHostImageCopyFeaturesEXT* to) {
+    (void)alloc;
+    (void)rootType;
+    *to = *from;
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = from->sType;
+    }
+    const void* from_pNext = from;
+    size_t pNext_size = 0u;
+    while (!pNext_size && from_pNext) {
+        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+        pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
+    }
+    to->pNext = nullptr;
+    if (pNext_size) {
+        to->pNext = (void*)alloc->alloc(pNext_size);
+        deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
+    }
+}
+
+void deepcopy_VkPhysicalDeviceHostImageCopyPropertiesEXT(
+    Allocator* alloc, VkStructureType rootType,
+    const VkPhysicalDeviceHostImageCopyPropertiesEXT* from,
+    VkPhysicalDeviceHostImageCopyPropertiesEXT* to) {
+    (void)alloc;
+    (void)rootType;
+    *to = *from;
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = from->sType;
+    }
+    const void* from_pNext = from;
+    size_t pNext_size = 0u;
+    while (!pNext_size && from_pNext) {
+        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+        pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
+    }
+    to->pNext = nullptr;
+    if (pNext_size) {
+        to->pNext = (void*)alloc->alloc(pNext_size);
+        deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
+    }
+    to->pCopySrcLayouts = nullptr;
+    if (from->pCopySrcLayouts) {
+        to->pCopySrcLayouts = (VkImageLayout*)alloc->dupArray(
+            from->pCopySrcLayouts, from->copySrcLayoutCount * sizeof(VkImageLayout));
+    }
+    to->pCopyDstLayouts = nullptr;
+    if (from->pCopyDstLayouts) {
+        to->pCopyDstLayouts = (VkImageLayout*)alloc->dupArray(
+            from->pCopyDstLayouts, from->copyDstLayoutCount * sizeof(VkImageLayout));
+    }
+    memcpy(to->optimalTilingLayoutUUID, from->optimalTilingLayoutUUID,
+           VK_UUID_SIZE * sizeof(uint8_t));
+}
+
+void deepcopy_VkMemoryToImageCopyEXT(Allocator* alloc, VkStructureType rootType,
+                                     const VkMemoryToImageCopyEXT* from,
+                                     VkMemoryToImageCopyEXT* to) {
+    (void)alloc;
+    (void)rootType;
+    *to = *from;
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = from->sType;
+    }
+    const void* from_pNext = from;
+    size_t pNext_size = 0u;
+    while (!pNext_size && from_pNext) {
+        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+        pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
+    }
+    to->pNext = nullptr;
+    if (pNext_size) {
+        to->pNext = (void*)alloc->alloc(pNext_size);
+        deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
+    }
+    to->pHostPointer = nullptr;
+    if (from->pHostPointer) {
+        to->pHostPointer = (void*)alloc->dupArray(from->pHostPointer, sizeof(const uint8_t));
+    }
+    deepcopy_VkImageSubresourceLayers(alloc, rootType, &from->imageSubresource,
+                                      (VkImageSubresourceLayers*)(&to->imageSubresource));
+    deepcopy_VkOffset3D(alloc, rootType, &from->imageOffset, (VkOffset3D*)(&to->imageOffset));
+    deepcopy_VkExtent3D(alloc, rootType, &from->imageExtent, (VkExtent3D*)(&to->imageExtent));
+}
+
+void deepcopy_VkImageToMemoryCopyEXT(Allocator* alloc, VkStructureType rootType,
+                                     const VkImageToMemoryCopyEXT* from,
+                                     VkImageToMemoryCopyEXT* to) {
+    (void)alloc;
+    (void)rootType;
+    *to = *from;
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = from->sType;
+    }
+    const void* from_pNext = from;
+    size_t pNext_size = 0u;
+    while (!pNext_size && from_pNext) {
+        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+        pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
+    }
+    to->pNext = nullptr;
+    if (pNext_size) {
+        to->pNext = (void*)alloc->alloc(pNext_size);
+        deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
+    }
+    to->pHostPointer = nullptr;
+    if (from->pHostPointer) {
+        to->pHostPointer = (void*)alloc->dupArray(from->pHostPointer, sizeof(uint8_t));
+    }
+    deepcopy_VkImageSubresourceLayers(alloc, rootType, &from->imageSubresource,
+                                      (VkImageSubresourceLayers*)(&to->imageSubresource));
+    deepcopy_VkOffset3D(alloc, rootType, &from->imageOffset, (VkOffset3D*)(&to->imageOffset));
+    deepcopy_VkExtent3D(alloc, rootType, &from->imageExtent, (VkExtent3D*)(&to->imageExtent));
+}
+
+void deepcopy_VkCopyMemoryToImageInfoEXT(Allocator* alloc, VkStructureType rootType,
+                                         const VkCopyMemoryToImageInfoEXT* from,
+                                         VkCopyMemoryToImageInfoEXT* to) {
+    (void)alloc;
+    (void)rootType;
+    *to = *from;
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = from->sType;
+    }
+    const void* from_pNext = from;
+    size_t pNext_size = 0u;
+    while (!pNext_size && from_pNext) {
+        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+        pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
+    }
+    to->pNext = nullptr;
+    if (pNext_size) {
+        to->pNext = (void*)alloc->alloc(pNext_size);
+        deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
+    }
+    if (from) {
+        to->pRegions = nullptr;
+        if (from->pRegions) {
+            to->pRegions = (VkMemoryToImageCopyEXT*)alloc->alloc(
+                from->regionCount * sizeof(const VkMemoryToImageCopyEXT));
+            to->regionCount = from->regionCount;
+            for (uint32_t i = 0; i < (uint32_t)from->regionCount; ++i) {
+                deepcopy_VkMemoryToImageCopyEXT(alloc, rootType, from->pRegions + i,
+                                                (VkMemoryToImageCopyEXT*)(to->pRegions + i));
+            }
+        }
+    }
+}
+
+void deepcopy_VkCopyImageToMemoryInfoEXT(Allocator* alloc, VkStructureType rootType,
+                                         const VkCopyImageToMemoryInfoEXT* from,
+                                         VkCopyImageToMemoryInfoEXT* to) {
+    (void)alloc;
+    (void)rootType;
+    *to = *from;
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = from->sType;
+    }
+    const void* from_pNext = from;
+    size_t pNext_size = 0u;
+    while (!pNext_size && from_pNext) {
+        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+        pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
+    }
+    to->pNext = nullptr;
+    if (pNext_size) {
+        to->pNext = (void*)alloc->alloc(pNext_size);
+        deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
+    }
+    if (from) {
+        to->pRegions = nullptr;
+        if (from->pRegions) {
+            to->pRegions = (VkImageToMemoryCopyEXT*)alloc->alloc(
+                from->regionCount * sizeof(const VkImageToMemoryCopyEXT));
+            to->regionCount = from->regionCount;
+            for (uint32_t i = 0; i < (uint32_t)from->regionCount; ++i) {
+                deepcopy_VkImageToMemoryCopyEXT(alloc, rootType, from->pRegions + i,
+                                                (VkImageToMemoryCopyEXT*)(to->pRegions + i));
+            }
+        }
+    }
+}
+
+void deepcopy_VkCopyImageToImageInfoEXT(Allocator* alloc, VkStructureType rootType,
+                                        const VkCopyImageToImageInfoEXT* from,
+                                        VkCopyImageToImageInfoEXT* to) {
+    (void)alloc;
+    (void)rootType;
+    *to = *from;
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = from->sType;
+    }
+    const void* from_pNext = from;
+    size_t pNext_size = 0u;
+    while (!pNext_size && from_pNext) {
+        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+        pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
+    }
+    to->pNext = nullptr;
+    if (pNext_size) {
+        to->pNext = (void*)alloc->alloc(pNext_size);
+        deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
+    }
+    if (from) {
+        to->pRegions = nullptr;
+        if (from->pRegions) {
+            to->pRegions =
+                (VkImageCopy2*)alloc->alloc(from->regionCount * sizeof(const VkImageCopy2));
+            to->regionCount = from->regionCount;
+            for (uint32_t i = 0; i < (uint32_t)from->regionCount; ++i) {
+                deepcopy_VkImageCopy2(alloc, rootType, from->pRegions + i,
+                                      (VkImageCopy2*)(to->pRegions + i));
+            }
+        }
+    }
+}
+
+void deepcopy_VkHostImageLayoutTransitionInfoEXT(Allocator* alloc, VkStructureType rootType,
+                                                 const VkHostImageLayoutTransitionInfoEXT* from,
+                                                 VkHostImageLayoutTransitionInfoEXT* to) {
+    (void)alloc;
+    (void)rootType;
+    *to = *from;
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = from->sType;
+    }
+    const void* from_pNext = from;
+    size_t pNext_size = 0u;
+    while (!pNext_size && from_pNext) {
+        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+        pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
+    }
+    to->pNext = nullptr;
+    if (pNext_size) {
+        to->pNext = (void*)alloc->alloc(pNext_size);
+        deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
+    }
+    deepcopy_VkImageSubresourceRange(alloc, rootType, &from->subresourceRange,
+                                     (VkImageSubresourceRange*)(&to->subresourceRange));
+}
+
+void deepcopy_VkSubresourceHostMemcpySizeEXT(Allocator* alloc, VkStructureType rootType,
+                                             const VkSubresourceHostMemcpySizeEXT* from,
+                                             VkSubresourceHostMemcpySizeEXT* to) {
+    (void)alloc;
+    (void)rootType;
+    *to = *from;
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = from->sType;
+    }
+    const void* from_pNext = from;
+    size_t pNext_size = 0u;
+    while (!pNext_size && from_pNext) {
+        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+        pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
+    }
+    to->pNext = nullptr;
+    if (pNext_size) {
+        to->pNext = (void*)alloc->alloc(pNext_size);
+        deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
+    }
+}
+
+void deepcopy_VkHostImageCopyDevicePerformanceQueryEXT(
+    Allocator* alloc, VkStructureType rootType,
+    const VkHostImageCopyDevicePerformanceQueryEXT* from,
+    VkHostImageCopyDevicePerformanceQueryEXT* to) {
+    (void)alloc;
+    (void)rootType;
+    *to = *from;
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = from->sType;
+    }
+    const void* from_pNext = from;
+    size_t pNext_size = 0u;
+    while (!pNext_size && from_pNext) {
+        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+        pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
+    }
+    to->pNext = nullptr;
+    if (pNext_size) {
+        to->pNext = (void*)alloc->alloc(pNext_size);
+        deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
+    }
+}
+
+#endif
 #ifdef VK_EXT_swapchain_maintenance1
 void deepcopy_VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT(
     Allocator* alloc, VkStructureType rootType,
@@ -8095,54 +8587,6 @@
     }
 }
 
-void deepcopy_VkSubresourceLayout2EXT(Allocator* alloc, VkStructureType rootType,
-                                      const VkSubresourceLayout2EXT* from,
-                                      VkSubresourceLayout2EXT* to) {
-    (void)alloc;
-    (void)rootType;
-    *to = *from;
-    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
-        rootType = from->sType;
-    }
-    const void* from_pNext = from;
-    size_t pNext_size = 0u;
-    while (!pNext_size && from_pNext) {
-        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
-        pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
-    }
-    to->pNext = nullptr;
-    if (pNext_size) {
-        to->pNext = (void*)alloc->alloc(pNext_size);
-        deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
-    }
-    deepcopy_VkSubresourceLayout(alloc, rootType, &from->subresourceLayout,
-                                 (VkSubresourceLayout*)(&to->subresourceLayout));
-}
-
-void deepcopy_VkImageSubresource2EXT(Allocator* alloc, VkStructureType rootType,
-                                     const VkImageSubresource2EXT* from,
-                                     VkImageSubresource2EXT* to) {
-    (void)alloc;
-    (void)rootType;
-    *to = *from;
-    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
-        rootType = from->sType;
-    }
-    const void* from_pNext = from;
-    size_t pNext_size = 0u;
-    while (!pNext_size && from_pNext) {
-        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
-        pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
-    }
-    to->pNext = nullptr;
-    if (pNext_size) {
-        to->pNext = (void*)alloc->alloc(pNext_size);
-        deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
-    }
-    deepcopy_VkImageSubresource(alloc, rootType, &from->imageSubresource,
-                                (VkImageSubresource*)(&to->imageSubresource));
-}
-
 void deepcopy_VkImageCompressionPropertiesEXT(Allocator* alloc, VkStructureType rootType,
                                               const VkImageCompressionPropertiesEXT* from,
                                               VkImageCompressionPropertiesEXT* to) {
@@ -9245,6 +9689,36 @@
             break;
         }
 #endif
+#ifdef VK_KHR_maintenance5
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_FEATURES_KHR: {
+            deepcopy_VkPhysicalDeviceMaintenance5FeaturesKHR(
+                alloc, rootType,
+                reinterpret_cast<const VkPhysicalDeviceMaintenance5FeaturesKHR*>(structExtension),
+                reinterpret_cast<VkPhysicalDeviceMaintenance5FeaturesKHR*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_PROPERTIES_KHR: {
+            deepcopy_VkPhysicalDeviceMaintenance5PropertiesKHR(
+                alloc, rootType,
+                reinterpret_cast<const VkPhysicalDeviceMaintenance5PropertiesKHR*>(structExtension),
+                reinterpret_cast<VkPhysicalDeviceMaintenance5PropertiesKHR*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PIPELINE_CREATE_FLAGS_2_CREATE_INFO_KHR: {
+            deepcopy_VkPipelineCreateFlags2CreateInfoKHR(
+                alloc, rootType,
+                reinterpret_cast<const VkPipelineCreateFlags2CreateInfoKHR*>(structExtension),
+                reinterpret_cast<VkPipelineCreateFlags2CreateInfoKHR*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_BUFFER_USAGE_FLAGS_2_CREATE_INFO_KHR: {
+            deepcopy_VkBufferUsageFlags2CreateInfoKHR(
+                alloc, rootType,
+                reinterpret_cast<const VkBufferUsageFlags2CreateInfoKHR*>(structExtension),
+                reinterpret_cast<VkBufferUsageFlags2CreateInfoKHR*>(structExtension_out));
+            break;
+        }
+#endif
 #ifdef VK_ANDROID_native_buffer
         case VK_STRUCTURE_TYPE_NATIVE_BUFFER_ANDROID: {
             deepcopy_VkNativeBufferANDROID(
@@ -9359,6 +9833,37 @@
             break;
         }
 #endif
+#ifdef VK_EXT_host_image_copy
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_FEATURES_EXT: {
+            deepcopy_VkPhysicalDeviceHostImageCopyFeaturesEXT(
+                alloc, rootType,
+                reinterpret_cast<const VkPhysicalDeviceHostImageCopyFeaturesEXT*>(structExtension),
+                reinterpret_cast<VkPhysicalDeviceHostImageCopyFeaturesEXT*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_PROPERTIES_EXT: {
+            deepcopy_VkPhysicalDeviceHostImageCopyPropertiesEXT(
+                alloc, rootType,
+                reinterpret_cast<const VkPhysicalDeviceHostImageCopyPropertiesEXT*>(
+                    structExtension),
+                reinterpret_cast<VkPhysicalDeviceHostImageCopyPropertiesEXT*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_SUBRESOURCE_HOST_MEMCPY_SIZE_EXT: {
+            deepcopy_VkSubresourceHostMemcpySizeEXT(
+                alloc, rootType,
+                reinterpret_cast<const VkSubresourceHostMemcpySizeEXT*>(structExtension),
+                reinterpret_cast<VkSubresourceHostMemcpySizeEXT*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_HOST_IMAGE_COPY_DEVICE_PERFORMANCE_QUERY_EXT: {
+            deepcopy_VkHostImageCopyDevicePerformanceQueryEXT(
+                alloc, rootType,
+                reinterpret_cast<const VkHostImageCopyDevicePerformanceQueryEXT*>(structExtension),
+                reinterpret_cast<VkHostImageCopyDevicePerformanceQueryEXT*>(structExtension_out));
+            break;
+        }
+#endif
 #ifdef VK_EXT_swapchain_maintenance1
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SWAPCHAIN_MAINTENANCE_1_FEATURES_EXT: {
             deepcopy_VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT(
diff --git a/host/vulkan/cereal/common/goldfish_vk_deepcopy.h b/host/vulkan/cereal/common/goldfish_vk_deepcopy.h
index 51ccb2d..62b7c7a 100644
--- a/host/vulkan/cereal/common/goldfish_vk_deepcopy.h
+++ b/host/vulkan/cereal/common/goldfish_vk_deepcopy.h
@@ -15,9 +15,9 @@
 
 // Autogenerated module goldfish_vk_deepcopy
 //
-// (header) generated by codegen/vulkan/vulkan-docs/scripts/genvk.py -registry
-// codegen/vulkan/vulkan-docs/xml/vk.xml -registryGfxstream
-// codegen/vulkan/vulkan-docs/xml/vk_gfxstream.xml cereal -o host/vulkan/cereal
+// (header) generated by codegen/vulkan/vulkan-docs-next/scripts/genvk.py -registry
+// codegen/vulkan/vulkan-docs-next/xml/vk.xml -registryGfxstream
+// codegen/vulkan/vulkan-docs-next/xml/vk_gfxstream.xml cereal -o host/vulkan/cereal
 //
 // Please do not modify directly;
 // re-run gfxstream-protocols/scripts/generate-vulkan-sources.sh,
@@ -34,7 +34,7 @@
 
 #include "aemu/base/BumpPool.h"
 #include "goldfish_vk_private_defs.h"
-#include "vk_android_native_buffer.h"
+#include "vk_android_native_buffer_gfxstream.h"
 #include "vulkan_gfxstream.h"
 using android::base::Allocator;
 using android::base::BumpPool;
@@ -1600,6 +1600,41 @@
                       deepcopy_VkDeviceImageMemoryRequirementsKHR)
 
 #endif
+#ifdef VK_KHR_maintenance5
+void deepcopy_VkPhysicalDeviceMaintenance5FeaturesKHR(
+    Allocator* alloc, VkStructureType rootType, const VkPhysicalDeviceMaintenance5FeaturesKHR* from,
+    VkPhysicalDeviceMaintenance5FeaturesKHR* to);
+
+void deepcopy_VkPhysicalDeviceMaintenance5PropertiesKHR(
+    Allocator* alloc, VkStructureType rootType,
+    const VkPhysicalDeviceMaintenance5PropertiesKHR* from,
+    VkPhysicalDeviceMaintenance5PropertiesKHR* to);
+
+void deepcopy_VkRenderingAreaInfoKHR(Allocator* alloc, VkStructureType rootType,
+                                     const VkRenderingAreaInfoKHR* from,
+                                     VkRenderingAreaInfoKHR* to);
+
+void deepcopy_VkImageSubresource2KHR(Allocator* alloc, VkStructureType rootType,
+                                     const VkImageSubresource2KHR* from,
+                                     VkImageSubresource2KHR* to);
+
+void deepcopy_VkDeviceImageSubresourceInfoKHR(Allocator* alloc, VkStructureType rootType,
+                                              const VkDeviceImageSubresourceInfoKHR* from,
+                                              VkDeviceImageSubresourceInfoKHR* to);
+
+void deepcopy_VkSubresourceLayout2KHR(Allocator* alloc, VkStructureType rootType,
+                                      const VkSubresourceLayout2KHR* from,
+                                      VkSubresourceLayout2KHR* to);
+
+void deepcopy_VkPipelineCreateFlags2CreateInfoKHR(Allocator* alloc, VkStructureType rootType,
+                                                  const VkPipelineCreateFlags2CreateInfoKHR* from,
+                                                  VkPipelineCreateFlags2CreateInfoKHR* to);
+
+void deepcopy_VkBufferUsageFlags2CreateInfoKHR(Allocator* alloc, VkStructureType rootType,
+                                               const VkBufferUsageFlags2CreateInfoKHR* from,
+                                               VkBufferUsageFlags2CreateInfoKHR* to);
+
+#endif
 #ifdef VK_ANDROID_native_buffer
 void deepcopy_VkNativeBufferUsage2ANDROID(Allocator* alloc, VkStructureType rootType,
                                           const VkNativeBufferUsage2ANDROID* from,
@@ -1741,6 +1776,55 @@
     VkPhysicalDeviceExtendedDynamicStateFeaturesEXT* to);
 
 #endif
+#ifdef VK_EXT_host_image_copy
+void deepcopy_VkPhysicalDeviceHostImageCopyFeaturesEXT(
+    Allocator* alloc, VkStructureType rootType,
+    const VkPhysicalDeviceHostImageCopyFeaturesEXT* from,
+    VkPhysicalDeviceHostImageCopyFeaturesEXT* to);
+
+void deepcopy_VkPhysicalDeviceHostImageCopyPropertiesEXT(
+    Allocator* alloc, VkStructureType rootType,
+    const VkPhysicalDeviceHostImageCopyPropertiesEXT* from,
+    VkPhysicalDeviceHostImageCopyPropertiesEXT* to);
+
+void deepcopy_VkMemoryToImageCopyEXT(Allocator* alloc, VkStructureType rootType,
+                                     const VkMemoryToImageCopyEXT* from,
+                                     VkMemoryToImageCopyEXT* to);
+
+void deepcopy_VkImageToMemoryCopyEXT(Allocator* alloc, VkStructureType rootType,
+                                     const VkImageToMemoryCopyEXT* from,
+                                     VkImageToMemoryCopyEXT* to);
+
+void deepcopy_VkCopyMemoryToImageInfoEXT(Allocator* alloc, VkStructureType rootType,
+                                         const VkCopyMemoryToImageInfoEXT* from,
+                                         VkCopyMemoryToImageInfoEXT* to);
+
+void deepcopy_VkCopyImageToMemoryInfoEXT(Allocator* alloc, VkStructureType rootType,
+                                         const VkCopyImageToMemoryInfoEXT* from,
+                                         VkCopyImageToMemoryInfoEXT* to);
+
+void deepcopy_VkCopyImageToImageInfoEXT(Allocator* alloc, VkStructureType rootType,
+                                        const VkCopyImageToImageInfoEXT* from,
+                                        VkCopyImageToImageInfoEXT* to);
+
+void deepcopy_VkHostImageLayoutTransitionInfoEXT(Allocator* alloc, VkStructureType rootType,
+                                                 const VkHostImageLayoutTransitionInfoEXT* from,
+                                                 VkHostImageLayoutTransitionInfoEXT* to);
+
+void deepcopy_VkSubresourceHostMemcpySizeEXT(Allocator* alloc, VkStructureType rootType,
+                                             const VkSubresourceHostMemcpySizeEXT* from,
+                                             VkSubresourceHostMemcpySizeEXT* to);
+
+void deepcopy_VkHostImageCopyDevicePerformanceQueryEXT(
+    Allocator* alloc, VkStructureType rootType,
+    const VkHostImageCopyDevicePerformanceQueryEXT* from,
+    VkHostImageCopyDevicePerformanceQueryEXT* to);
+
+DEFINE_ALIAS_FUNCTION(deepcopy_VkSubresourceLayout2KHR, deepcopy_VkSubresourceLayout2EXT)
+
+DEFINE_ALIAS_FUNCTION(deepcopy_VkImageSubresource2KHR, deepcopy_VkImageSubresource2EXT)
+
+#endif
 #ifdef VK_EXT_swapchain_maintenance1
 void deepcopy_VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT(
     Allocator* alloc, VkStructureType rootType,
@@ -1867,14 +1951,6 @@
                                            const VkImageCompressionControlEXT* from,
                                            VkImageCompressionControlEXT* to);
 
-void deepcopy_VkSubresourceLayout2EXT(Allocator* alloc, VkStructureType rootType,
-                                      const VkSubresourceLayout2EXT* from,
-                                      VkSubresourceLayout2EXT* to);
-
-void deepcopy_VkImageSubresource2EXT(Allocator* alloc, VkStructureType rootType,
-                                     const VkImageSubresource2EXT* from,
-                                     VkImageSubresource2EXT* to);
-
 void deepcopy_VkImageCompressionPropertiesEXT(Allocator* alloc, VkStructureType rootType,
                                               const VkImageCompressionPropertiesEXT* from,
                                               VkImageCompressionPropertiesEXT* to);
diff --git a/host/vulkan/cereal/common/goldfish_vk_dispatch.cpp b/host/vulkan/cereal/common/goldfish_vk_dispatch.cpp
index 011d41d..e94cc42 100644
--- a/host/vulkan/cereal/common/goldfish_vk_dispatch.cpp
+++ b/host/vulkan/cereal/common/goldfish_vk_dispatch.cpp
@@ -15,9 +15,9 @@
 
 // Autogenerated module goldfish_vk_dispatch
 //
-// (impl) generated by codegen/vulkan/vulkan-docs/scripts/genvk.py -registry
-// codegen/vulkan/vulkan-docs/xml/vk.xml -registryGfxstream
-// codegen/vulkan/vulkan-docs/xml/vk_gfxstream.xml cereal -o host/vulkan/cereal
+// (impl) generated by codegen/vulkan/vulkan-docs-next/scripts/genvk.py -registry
+// codegen/vulkan/vulkan-docs-next/xml/vk.xml -registryGfxstream
+// codegen/vulkan/vulkan-docs-next/xml/vk_gfxstream.xml cereal -o host/vulkan/cereal
 //
 // Please do not modify directly;
 // re-run gfxstream-protocols/scripts/generate-vulkan-sources.sh,
@@ -135,6 +135,8 @@
 #endif
 #ifdef VK_KHR_maintenance4
 #endif
+#ifdef VK_KHR_maintenance5
+#endif
 #ifdef VK_ANDROID_native_buffer
 #endif
 #ifdef VK_EXT_transform_feedback
@@ -173,6 +175,8 @@
 #endif
 #ifdef VK_EXT_extended_dynamic_state
 #endif
+#ifdef VK_EXT_host_image_copy
+#endif
 #ifdef VK_EXT_swapchain_maintenance1
 #endif
 #ifdef VK_EXT_shader_demote_to_helper_invocation
@@ -769,6 +773,16 @@
         (PFN_vkGetDeviceImageSparseMemoryRequirementsKHR)dlSymFunc(
             lib, "vkGetDeviceImageSparseMemoryRequirementsKHR");
 #endif
+#ifdef VK_KHR_maintenance5
+    out->vkCmdBindIndexBuffer2KHR =
+        (PFN_vkCmdBindIndexBuffer2KHR)dlSymFunc(lib, "vkCmdBindIndexBuffer2KHR");
+    out->vkGetRenderingAreaGranularityKHR =
+        (PFN_vkGetRenderingAreaGranularityKHR)dlSymFunc(lib, "vkGetRenderingAreaGranularityKHR");
+    out->vkGetDeviceImageSubresourceLayoutKHR = (PFN_vkGetDeviceImageSubresourceLayoutKHR)dlSymFunc(
+        lib, "vkGetDeviceImageSubresourceLayoutKHR");
+    out->vkGetImageSubresourceLayout2KHR =
+        (PFN_vkGetImageSubresourceLayout2KHR)dlSymFunc(lib, "vkGetImageSubresourceLayout2KHR");
+#endif
 #ifdef VK_ANDROID_native_buffer
     out->vkGetSwapchainGrallocUsageANDROID =
         (PFN_vkGetSwapchainGrallocUsageANDROID)dlSymFunc(lib, "vkGetSwapchainGrallocUsageANDROID");
@@ -841,6 +855,17 @@
         (PFN_vkCmdSetStencilTestEnableEXT)dlSymFunc(lib, "vkCmdSetStencilTestEnableEXT");
     out->vkCmdSetStencilOpEXT = (PFN_vkCmdSetStencilOpEXT)dlSymFunc(lib, "vkCmdSetStencilOpEXT");
 #endif
+#ifdef VK_EXT_host_image_copy
+    out->vkCopyMemoryToImageEXT =
+        (PFN_vkCopyMemoryToImageEXT)dlSymFunc(lib, "vkCopyMemoryToImageEXT");
+    out->vkCopyImageToMemoryEXT =
+        (PFN_vkCopyImageToMemoryEXT)dlSymFunc(lib, "vkCopyImageToMemoryEXT");
+    out->vkCopyImageToImageEXT = (PFN_vkCopyImageToImageEXT)dlSymFunc(lib, "vkCopyImageToImageEXT");
+    out->vkTransitionImageLayoutEXT =
+        (PFN_vkTransitionImageLayoutEXT)dlSymFunc(lib, "vkTransitionImageLayoutEXT");
+    out->vkGetImageSubresourceLayout2EXT =
+        (PFN_vkGetImageSubresourceLayout2EXT)dlSymFunc(lib, "vkGetImageSubresourceLayout2EXT");
+#endif
 #ifdef VK_EXT_swapchain_maintenance1
     out->vkReleaseSwapchainImagesEXT =
         (PFN_vkReleaseSwapchainImagesEXT)dlSymFunc(lib, "vkReleaseSwapchainImagesEXT");
@@ -853,10 +878,6 @@
     out->vkSetPrivateDataEXT = (PFN_vkSetPrivateDataEXT)dlSymFunc(lib, "vkSetPrivateDataEXT");
     out->vkGetPrivateDataEXT = (PFN_vkGetPrivateDataEXT)dlSymFunc(lib, "vkGetPrivateDataEXT");
 #endif
-#ifdef VK_EXT_image_compression_control
-    out->vkGetImageSubresourceLayout2EXT =
-        (PFN_vkGetImageSubresourceLayout2EXT)dlSymFunc(lib, "vkGetImageSubresourceLayout2EXT");
-#endif
 #ifdef VK_EXT_extended_dynamic_state2
     out->vkCmdSetPatchControlPointsEXT =
         (PFN_vkCmdSetPatchControlPointsEXT)dlSymFunc(lib, "vkCmdSetPatchControlPointsEXT");
@@ -1654,6 +1675,19 @@
         (PFN_vkGetDeviceImageSparseMemoryRequirementsKHR)vk->vkGetInstanceProcAddr(
             instance, "vkGetDeviceImageSparseMemoryRequirementsKHR");
 #endif
+#ifdef VK_KHR_maintenance5
+    out->vkCmdBindIndexBuffer2KHR = (PFN_vkCmdBindIndexBuffer2KHR)vk->vkGetInstanceProcAddr(
+        instance, "vkCmdBindIndexBuffer2KHR");
+    out->vkGetRenderingAreaGranularityKHR =
+        (PFN_vkGetRenderingAreaGranularityKHR)vk->vkGetInstanceProcAddr(
+            instance, "vkGetRenderingAreaGranularityKHR");
+    out->vkGetDeviceImageSubresourceLayoutKHR =
+        (PFN_vkGetDeviceImageSubresourceLayoutKHR)vk->vkGetInstanceProcAddr(
+            instance, "vkGetDeviceImageSubresourceLayoutKHR");
+    out->vkGetImageSubresourceLayout2KHR =
+        (PFN_vkGetImageSubresourceLayout2KHR)vk->vkGetInstanceProcAddr(
+            instance, "vkGetImageSubresourceLayout2KHR");
+#endif
 #ifdef VK_ANDROID_native_buffer
     out->vkGetSwapchainGrallocUsageANDROID =
         (PFN_vkGetSwapchainGrallocUsageANDROID)vk->vkGetInstanceProcAddr(
@@ -1741,6 +1775,19 @@
     out->vkCmdSetStencilOpEXT =
         (PFN_vkCmdSetStencilOpEXT)vk->vkGetInstanceProcAddr(instance, "vkCmdSetStencilOpEXT");
 #endif
+#ifdef VK_EXT_host_image_copy
+    out->vkCopyMemoryToImageEXT =
+        (PFN_vkCopyMemoryToImageEXT)vk->vkGetInstanceProcAddr(instance, "vkCopyMemoryToImageEXT");
+    out->vkCopyImageToMemoryEXT =
+        (PFN_vkCopyImageToMemoryEXT)vk->vkGetInstanceProcAddr(instance, "vkCopyImageToMemoryEXT");
+    out->vkCopyImageToImageEXT =
+        (PFN_vkCopyImageToImageEXT)vk->vkGetInstanceProcAddr(instance, "vkCopyImageToImageEXT");
+    out->vkTransitionImageLayoutEXT = (PFN_vkTransitionImageLayoutEXT)vk->vkGetInstanceProcAddr(
+        instance, "vkTransitionImageLayoutEXT");
+    out->vkGetImageSubresourceLayout2EXT =
+        (PFN_vkGetImageSubresourceLayout2EXT)vk->vkGetInstanceProcAddr(
+            instance, "vkGetImageSubresourceLayout2EXT");
+#endif
 #ifdef VK_EXT_swapchain_maintenance1
     out->vkReleaseSwapchainImagesEXT = (PFN_vkReleaseSwapchainImagesEXT)vk->vkGetInstanceProcAddr(
         instance, "vkReleaseSwapchainImagesEXT");
@@ -1755,11 +1802,6 @@
     out->vkGetPrivateDataEXT =
         (PFN_vkGetPrivateDataEXT)vk->vkGetInstanceProcAddr(instance, "vkGetPrivateDataEXT");
 #endif
-#ifdef VK_EXT_image_compression_control
-    out->vkGetImageSubresourceLayout2EXT =
-        (PFN_vkGetImageSubresourceLayout2EXT)vk->vkGetInstanceProcAddr(
-            instance, "vkGetImageSubresourceLayout2EXT");
-#endif
 #ifdef VK_EXT_extended_dynamic_state2
     out->vkCmdSetPatchControlPointsEXT =
         (PFN_vkCmdSetPatchControlPointsEXT)vk->vkGetInstanceProcAddr(
@@ -2553,6 +2595,19 @@
         (PFN_vkGetDeviceImageSparseMemoryRequirementsKHR)vk->vkGetDeviceProcAddr(
             device, "vkGetDeviceImageSparseMemoryRequirementsKHR");
 #endif
+#ifdef VK_KHR_maintenance5
+    out->vkCmdBindIndexBuffer2KHR =
+        (PFN_vkCmdBindIndexBuffer2KHR)vk->vkGetDeviceProcAddr(device, "vkCmdBindIndexBuffer2KHR");
+    out->vkGetRenderingAreaGranularityKHR =
+        (PFN_vkGetRenderingAreaGranularityKHR)vk->vkGetDeviceProcAddr(
+            device, "vkGetRenderingAreaGranularityKHR");
+    out->vkGetDeviceImageSubresourceLayoutKHR =
+        (PFN_vkGetDeviceImageSubresourceLayoutKHR)vk->vkGetDeviceProcAddr(
+            device, "vkGetDeviceImageSubresourceLayoutKHR");
+    out->vkGetImageSubresourceLayout2KHR =
+        (PFN_vkGetImageSubresourceLayout2KHR)vk->vkGetDeviceProcAddr(
+            device, "vkGetImageSubresourceLayout2KHR");
+#endif
 #ifdef VK_ANDROID_native_buffer
     out->vkGetSwapchainGrallocUsageANDROID =
         (PFN_vkGetSwapchainGrallocUsageANDROID)vk->vkGetDeviceProcAddr(
@@ -2638,6 +2693,19 @@
     out->vkCmdSetStencilOpEXT =
         (PFN_vkCmdSetStencilOpEXT)vk->vkGetDeviceProcAddr(device, "vkCmdSetStencilOpEXT");
 #endif
+#ifdef VK_EXT_host_image_copy
+    out->vkCopyMemoryToImageEXT =
+        (PFN_vkCopyMemoryToImageEXT)vk->vkGetDeviceProcAddr(device, "vkCopyMemoryToImageEXT");
+    out->vkCopyImageToMemoryEXT =
+        (PFN_vkCopyImageToMemoryEXT)vk->vkGetDeviceProcAddr(device, "vkCopyImageToMemoryEXT");
+    out->vkCopyImageToImageEXT =
+        (PFN_vkCopyImageToImageEXT)vk->vkGetDeviceProcAddr(device, "vkCopyImageToImageEXT");
+    out->vkTransitionImageLayoutEXT = (PFN_vkTransitionImageLayoutEXT)vk->vkGetDeviceProcAddr(
+        device, "vkTransitionImageLayoutEXT");
+    out->vkGetImageSubresourceLayout2EXT =
+        (PFN_vkGetImageSubresourceLayout2EXT)vk->vkGetDeviceProcAddr(
+            device, "vkGetImageSubresourceLayout2EXT");
+#endif
 #ifdef VK_EXT_swapchain_maintenance1
     out->vkReleaseSwapchainImagesEXT = (PFN_vkReleaseSwapchainImagesEXT)vk->vkGetDeviceProcAddr(
         device, "vkReleaseSwapchainImagesEXT");
@@ -2652,11 +2720,6 @@
     out->vkGetPrivateDataEXT =
         (PFN_vkGetPrivateDataEXT)vk->vkGetDeviceProcAddr(device, "vkGetPrivateDataEXT");
 #endif
-#ifdef VK_EXT_image_compression_control
-    out->vkGetImageSubresourceLayout2EXT =
-        (PFN_vkGetImageSubresourceLayout2EXT)vk->vkGetDeviceProcAddr(
-            device, "vkGetImageSubresourceLayout2EXT");
-#endif
 #ifdef VK_EXT_extended_dynamic_state2
     out->vkCmdSetPatchControlPointsEXT = (PFN_vkCmdSetPatchControlPointsEXT)vk->vkGetDeviceProcAddr(
         device, "vkCmdSetPatchControlPointsEXT");
diff --git a/host/vulkan/cereal/common/goldfish_vk_dispatch.h b/host/vulkan/cereal/common/goldfish_vk_dispatch.h
index 516bbd7..3865e42 100644
--- a/host/vulkan/cereal/common/goldfish_vk_dispatch.h
+++ b/host/vulkan/cereal/common/goldfish_vk_dispatch.h
@@ -15,9 +15,9 @@
 
 // Autogenerated module goldfish_vk_dispatch
 //
-// (header) generated by codegen/vulkan/vulkan-docs/scripts/genvk.py -registry
-// codegen/vulkan/vulkan-docs/xml/vk.xml -registryGfxstream
-// codegen/vulkan/vulkan-docs/xml/vk_gfxstream.xml cereal -o host/vulkan/cereal
+// (header) generated by codegen/vulkan/vulkan-docs-next/scripts/genvk.py -registry
+// codegen/vulkan/vulkan-docs-next/xml/vk.xml -registryGfxstream
+// codegen/vulkan/vulkan-docs-next/xml/vk_gfxstream.xml cereal -o host/vulkan/cereal
 //
 // Please do not modify directly;
 // re-run gfxstream-protocols/scripts/generate-vulkan-sources.sh,
@@ -33,7 +33,7 @@
 #include <vulkan/vulkan.h>
 
 #include "goldfish_vk_private_defs.h"
-#include "vk_android_native_buffer.h"
+#include "vk_android_native_buffer_gfxstream.h"
 #include "vulkan_gfxstream.h"
 namespace gfxstream {
 namespace vk {
@@ -464,6 +464,12 @@
     PFN_vkGetDeviceImageMemoryRequirementsKHR vkGetDeviceImageMemoryRequirementsKHR;
     PFN_vkGetDeviceImageSparseMemoryRequirementsKHR vkGetDeviceImageSparseMemoryRequirementsKHR;
 #endif
+#ifdef VK_KHR_maintenance5
+    PFN_vkCmdBindIndexBuffer2KHR vkCmdBindIndexBuffer2KHR;
+    PFN_vkGetRenderingAreaGranularityKHR vkGetRenderingAreaGranularityKHR;
+    PFN_vkGetDeviceImageSubresourceLayoutKHR vkGetDeviceImageSubresourceLayoutKHR;
+    PFN_vkGetImageSubresourceLayout2KHR vkGetImageSubresourceLayout2KHR;
+#endif
 #ifdef VK_ANDROID_native_buffer
     PFN_vkGetSwapchainGrallocUsageANDROID vkGetSwapchainGrallocUsageANDROID;
     PFN_vkAcquireImageANDROID vkAcquireImageANDROID;
@@ -538,6 +544,13 @@
     PFN_vkCmdSetStencilTestEnableEXT vkCmdSetStencilTestEnableEXT;
     PFN_vkCmdSetStencilOpEXT vkCmdSetStencilOpEXT;
 #endif
+#ifdef VK_EXT_host_image_copy
+    PFN_vkCopyMemoryToImageEXT vkCopyMemoryToImageEXT;
+    PFN_vkCopyImageToMemoryEXT vkCopyImageToMemoryEXT;
+    PFN_vkCopyImageToImageEXT vkCopyImageToImageEXT;
+    PFN_vkTransitionImageLayoutEXT vkTransitionImageLayoutEXT;
+    PFN_vkGetImageSubresourceLayout2EXT vkGetImageSubresourceLayout2EXT;
+#endif
 #ifdef VK_EXT_swapchain_maintenance1
     PFN_vkReleaseSwapchainImagesEXT vkReleaseSwapchainImagesEXT;
 #endif
@@ -564,7 +577,6 @@
 #ifdef VK_EXT_image_robustness
 #endif
 #ifdef VK_EXT_image_compression_control
-    PFN_vkGetImageSubresourceLayout2EXT vkGetImageSubresourceLayout2EXT;
 #endif
 #ifdef VK_EXT_4444_formats
 #endif
diff --git a/host/vulkan/cereal/common/goldfish_vk_extension_structs.cpp b/host/vulkan/cereal/common/goldfish_vk_extension_structs.cpp
index d2f2559..758d350 100644
--- a/host/vulkan/cereal/common/goldfish_vk_extension_structs.cpp
+++ b/host/vulkan/cereal/common/goldfish_vk_extension_structs.cpp
@@ -15,9 +15,9 @@
 
 // Autogenerated module goldfish_vk_extension_structs
 //
-// (impl) generated by codegen/vulkan/vulkan-docs/scripts/genvk.py -registry
-// codegen/vulkan/vulkan-docs/xml/vk.xml -registryGfxstream
-// codegen/vulkan/vulkan-docs/xml/vk_gfxstream.xml cereal -o host/vulkan/cereal
+// (impl) generated by codegen/vulkan/vulkan-docs-next/scripts/genvk.py -registry
+// codegen/vulkan/vulkan-docs-next/xml/vk.xml -registryGfxstream
+// codegen/vulkan/vulkan-docs-next/xml/vk_gfxstream.xml cereal -o host/vulkan/cereal
 //
 // Please do not modify directly;
 // re-run gfxstream-protocols/scripts/generate-vulkan-sources.sh,
@@ -130,6 +130,8 @@
 #endif
 #ifdef VK_KHR_maintenance4
 #endif
+#ifdef VK_KHR_maintenance5
+#endif
 #ifdef VK_ANDROID_native_buffer
 #endif
 #ifdef VK_EXT_transform_feedback
@@ -168,6 +170,8 @@
 #endif
 #ifdef VK_EXT_extended_dynamic_state
 #endif
+#ifdef VK_EXT_host_image_copy
+#endif
 #ifdef VK_EXT_swapchain_maintenance1
 #endif
 #ifdef VK_EXT_shader_demote_to_helper_invocation
@@ -585,6 +589,20 @@
             return sizeof(VkQueueFamilyCheckpointProperties2NV);
         }
 #endif
+#ifdef VK_KHR_maintenance5
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_FEATURES_KHR: {
+            return sizeof(VkPhysicalDeviceMaintenance5FeaturesKHR);
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_PROPERTIES_KHR: {
+            return sizeof(VkPhysicalDeviceMaintenance5PropertiesKHR);
+        }
+        case VK_STRUCTURE_TYPE_PIPELINE_CREATE_FLAGS_2_CREATE_INFO_KHR: {
+            return sizeof(VkPipelineCreateFlags2CreateInfoKHR);
+        }
+        case VK_STRUCTURE_TYPE_BUFFER_USAGE_FLAGS_2_CREATE_INFO_KHR: {
+            return sizeof(VkBufferUsageFlags2CreateInfoKHR);
+        }
+#endif
 #ifdef VK_ANDROID_native_buffer
         case VK_STRUCTURE_TYPE_NATIVE_BUFFER_ANDROID: {
             return sizeof(VkNativeBufferANDROID);
@@ -633,6 +651,20 @@
             return sizeof(VkPhysicalDeviceExtendedDynamicStateFeaturesEXT);
         }
 #endif
+#ifdef VK_EXT_host_image_copy
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_FEATURES_EXT: {
+            return sizeof(VkPhysicalDeviceHostImageCopyFeaturesEXT);
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_PROPERTIES_EXT: {
+            return sizeof(VkPhysicalDeviceHostImageCopyPropertiesEXT);
+        }
+        case VK_STRUCTURE_TYPE_SUBRESOURCE_HOST_MEMCPY_SIZE_EXT: {
+            return sizeof(VkSubresourceHostMemcpySizeEXT);
+        }
+        case VK_STRUCTURE_TYPE_HOST_IMAGE_COPY_DEVICE_PERFORMANCE_QUERY_EXT: {
+            return sizeof(VkHostImageCopyDevicePerformanceQueryEXT);
+        }
+#endif
 #ifdef VK_EXT_swapchain_maintenance1
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SWAPCHAIN_MAINTENANCE_1_FEATURES_EXT: {
             return sizeof(VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT);
@@ -1122,6 +1154,20 @@
             return sizeof(VkQueueFamilyCheckpointProperties2NV);
         }
 #endif
+#ifdef VK_KHR_maintenance5
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_FEATURES_KHR: {
+            return sizeof(VkPhysicalDeviceMaintenance5FeaturesKHR);
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_PROPERTIES_KHR: {
+            return sizeof(VkPhysicalDeviceMaintenance5PropertiesKHR);
+        }
+        case VK_STRUCTURE_TYPE_PIPELINE_CREATE_FLAGS_2_CREATE_INFO_KHR: {
+            return sizeof(VkPipelineCreateFlags2CreateInfoKHR);
+        }
+        case VK_STRUCTURE_TYPE_BUFFER_USAGE_FLAGS_2_CREATE_INFO_KHR: {
+            return sizeof(VkBufferUsageFlags2CreateInfoKHR);
+        }
+#endif
 #ifdef VK_ANDROID_native_buffer
         case VK_STRUCTURE_TYPE_NATIVE_BUFFER_ANDROID: {
             return sizeof(VkNativeBufferANDROID);
@@ -1170,6 +1216,20 @@
             return sizeof(VkPhysicalDeviceExtendedDynamicStateFeaturesEXT);
         }
 #endif
+#ifdef VK_EXT_host_image_copy
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_FEATURES_EXT: {
+            return sizeof(VkPhysicalDeviceHostImageCopyFeaturesEXT);
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_PROPERTIES_EXT: {
+            return sizeof(VkPhysicalDeviceHostImageCopyPropertiesEXT);
+        }
+        case VK_STRUCTURE_TYPE_SUBRESOURCE_HOST_MEMCPY_SIZE_EXT: {
+            return sizeof(VkSubresourceHostMemcpySizeEXT);
+        }
+        case VK_STRUCTURE_TYPE_HOST_IMAGE_COPY_DEVICE_PERFORMANCE_QUERY_EXT: {
+            return sizeof(VkHostImageCopyDevicePerformanceQueryEXT);
+        }
+#endif
 #ifdef VK_EXT_swapchain_maintenance1
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SWAPCHAIN_MAINTENANCE_1_FEATURES_EXT: {
             return sizeof(VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT);
diff --git a/host/vulkan/cereal/common/goldfish_vk_extension_structs.h b/host/vulkan/cereal/common/goldfish_vk_extension_structs.h
index 72bfb7b..ff2aa18 100644
--- a/host/vulkan/cereal/common/goldfish_vk_extension_structs.h
+++ b/host/vulkan/cereal/common/goldfish_vk_extension_structs.h
@@ -15,9 +15,9 @@
 
 // Autogenerated module goldfish_vk_extension_structs
 //
-// (header) generated by codegen/vulkan/vulkan-docs/scripts/genvk.py -registry
-// codegen/vulkan/vulkan-docs/xml/vk.xml -registryGfxstream
-// codegen/vulkan/vulkan-docs/xml/vk_gfxstream.xml cereal -o host/vulkan/cereal
+// (header) generated by codegen/vulkan/vulkan-docs-next/scripts/genvk.py -registry
+// codegen/vulkan/vulkan-docs-next/xml/vk.xml -registryGfxstream
+// codegen/vulkan/vulkan-docs-next/xml/vk_gfxstream.xml cereal -o host/vulkan/cereal
 //
 // Please do not modify directly;
 // re-run gfxstream-protocols/scripts/generate-vulkan-sources.sh,
@@ -33,7 +33,7 @@
 #include <vulkan/vulkan.h>
 
 #include "goldfish_vk_private_defs.h"
-#include "vk_android_native_buffer.h"
+#include "vk_android_native_buffer_gfxstream.h"
 #include "vulkan_gfxstream.h"
 
 namespace gfxstream {
@@ -143,6 +143,8 @@
 #endif
 #ifdef VK_KHR_maintenance4
 #endif
+#ifdef VK_KHR_maintenance5
+#endif
 #ifdef VK_ANDROID_native_buffer
 #endif
 #ifdef VK_EXT_transform_feedback
@@ -181,6 +183,8 @@
 #endif
 #ifdef VK_EXT_extended_dynamic_state
 #endif
+#ifdef VK_EXT_host_image_copy
+#endif
 #ifdef VK_EXT_swapchain_maintenance1
 #endif
 #ifdef VK_EXT_shader_demote_to_helper_invocation
diff --git a/host/vulkan/cereal/common/goldfish_vk_handlemap.cpp b/host/vulkan/cereal/common/goldfish_vk_handlemap.cpp
index 5e68477..e8be9c4 100644
--- a/host/vulkan/cereal/common/goldfish_vk_handlemap.cpp
+++ b/host/vulkan/cereal/common/goldfish_vk_handlemap.cpp
@@ -15,9 +15,9 @@
 
 // Autogenerated module goldfish_vk_handlemap
 //
-// (impl) generated by codegen/vulkan/vulkan-docs/scripts/genvk.py -registry
-// codegen/vulkan/vulkan-docs/xml/vk.xml -registryGfxstream
-// codegen/vulkan/vulkan-docs/xml/vk_gfxstream.xml cereal -o host/vulkan/cereal
+// (impl) generated by codegen/vulkan/vulkan-docs-next/scripts/genvk.py -registry
+// codegen/vulkan/vulkan-docs-next/xml/vk.xml -registryGfxstream
+// codegen/vulkan/vulkan-docs-next/xml/vk_gfxstream.xml cereal -o host/vulkan/cereal
 //
 // Please do not modify directly;
 // re-run gfxstream-protocols/scripts/generate-vulkan-sources.sh,
@@ -3386,6 +3386,88 @@
 #endif
 #ifdef VK_KHR_maintenance4
 #endif
+#ifdef VK_KHR_maintenance5
+void handlemap_VkPhysicalDeviceMaintenance5FeaturesKHR(
+    VulkanHandleMapping* handlemap, VkPhysicalDeviceMaintenance5FeaturesKHR* toMap) {
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext) {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+}
+
+void handlemap_VkPhysicalDeviceMaintenance5PropertiesKHR(
+    VulkanHandleMapping* handlemap, VkPhysicalDeviceMaintenance5PropertiesKHR* toMap) {
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext) {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+}
+
+void handlemap_VkRenderingAreaInfoKHR(VulkanHandleMapping* handlemap,
+                                      VkRenderingAreaInfoKHR* toMap) {
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext) {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+}
+
+void handlemap_VkImageSubresource2KHR(VulkanHandleMapping* handlemap,
+                                      VkImageSubresource2KHR* toMap) {
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext) {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+    handlemap_VkImageSubresource(handlemap, (VkImageSubresource*)(&toMap->imageSubresource));
+}
+
+void handlemap_VkDeviceImageSubresourceInfoKHR(VulkanHandleMapping* handlemap,
+                                               VkDeviceImageSubresourceInfoKHR* toMap) {
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext) {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+    if (toMap->pCreateInfo) {
+        handlemap_VkImageCreateInfo(handlemap, (VkImageCreateInfo*)(toMap->pCreateInfo));
+    }
+    if (toMap->pSubresource) {
+        handlemap_VkImageSubresource2KHR(handlemap, (VkImageSubresource2KHR*)(toMap->pSubresource));
+    }
+}
+
+void handlemap_VkSubresourceLayout2KHR(VulkanHandleMapping* handlemap,
+                                       VkSubresourceLayout2KHR* toMap) {
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext) {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+    handlemap_VkSubresourceLayout(handlemap, (VkSubresourceLayout*)(&toMap->subresourceLayout));
+}
+
+void handlemap_VkPipelineCreateFlags2CreateInfoKHR(VulkanHandleMapping* handlemap,
+                                                   VkPipelineCreateFlags2CreateInfoKHR* toMap) {
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext) {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+}
+
+void handlemap_VkBufferUsageFlags2CreateInfoKHR(VulkanHandleMapping* handlemap,
+                                                VkBufferUsageFlags2CreateInfoKHR* toMap) {
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext) {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+}
+
+#endif
 #ifdef VK_ANDROID_native_buffer
 void handlemap_VkNativeBufferUsage2ANDROID(VulkanHandleMapping* handlemap,
                                            VkNativeBufferUsage2ANDROID* toMap) {
@@ -3558,6 +3640,136 @@
 }
 
 #endif
+#ifdef VK_EXT_host_image_copy
+void handlemap_VkPhysicalDeviceHostImageCopyFeaturesEXT(
+    VulkanHandleMapping* handlemap, VkPhysicalDeviceHostImageCopyFeaturesEXT* toMap) {
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext) {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+}
+
+void handlemap_VkPhysicalDeviceHostImageCopyPropertiesEXT(
+    VulkanHandleMapping* handlemap, VkPhysicalDeviceHostImageCopyPropertiesEXT* toMap) {
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext) {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+}
+
+void handlemap_VkMemoryToImageCopyEXT(VulkanHandleMapping* handlemap,
+                                      VkMemoryToImageCopyEXT* toMap) {
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext) {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+    handlemap_VkImageSubresourceLayers(handlemap,
+                                       (VkImageSubresourceLayers*)(&toMap->imageSubresource));
+    handlemap_VkOffset3D(handlemap, (VkOffset3D*)(&toMap->imageOffset));
+    handlemap_VkExtent3D(handlemap, (VkExtent3D*)(&toMap->imageExtent));
+}
+
+void handlemap_VkImageToMemoryCopyEXT(VulkanHandleMapping* handlemap,
+                                      VkImageToMemoryCopyEXT* toMap) {
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext) {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+    handlemap_VkImageSubresourceLayers(handlemap,
+                                       (VkImageSubresourceLayers*)(&toMap->imageSubresource));
+    handlemap_VkOffset3D(handlemap, (VkOffset3D*)(&toMap->imageOffset));
+    handlemap_VkExtent3D(handlemap, (VkExtent3D*)(&toMap->imageExtent));
+}
+
+void handlemap_VkCopyMemoryToImageInfoEXT(VulkanHandleMapping* handlemap,
+                                          VkCopyMemoryToImageInfoEXT* toMap) {
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext) {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+    handlemap->mapHandles_VkImage((VkImage*)&toMap->dstImage);
+    if (toMap) {
+        if (toMap->pRegions) {
+            for (uint32_t i = 0; i < (uint32_t)toMap->regionCount; ++i) {
+                handlemap_VkMemoryToImageCopyEXT(handlemap,
+                                                 (VkMemoryToImageCopyEXT*)(toMap->pRegions + i));
+            }
+        }
+    }
+}
+
+void handlemap_VkCopyImageToMemoryInfoEXT(VulkanHandleMapping* handlemap,
+                                          VkCopyImageToMemoryInfoEXT* toMap) {
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext) {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+    handlemap->mapHandles_VkImage((VkImage*)&toMap->srcImage);
+    if (toMap) {
+        if (toMap->pRegions) {
+            for (uint32_t i = 0; i < (uint32_t)toMap->regionCount; ++i) {
+                handlemap_VkImageToMemoryCopyEXT(handlemap,
+                                                 (VkImageToMemoryCopyEXT*)(toMap->pRegions + i));
+            }
+        }
+    }
+}
+
+void handlemap_VkCopyImageToImageInfoEXT(VulkanHandleMapping* handlemap,
+                                         VkCopyImageToImageInfoEXT* toMap) {
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext) {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+    handlemap->mapHandles_VkImage((VkImage*)&toMap->srcImage);
+    handlemap->mapHandles_VkImage((VkImage*)&toMap->dstImage);
+    if (toMap) {
+        if (toMap->pRegions) {
+            for (uint32_t i = 0; i < (uint32_t)toMap->regionCount; ++i) {
+                handlemap_VkImageCopy2(handlemap, (VkImageCopy2*)(toMap->pRegions + i));
+            }
+        }
+    }
+}
+
+void handlemap_VkHostImageLayoutTransitionInfoEXT(VulkanHandleMapping* handlemap,
+                                                  VkHostImageLayoutTransitionInfoEXT* toMap) {
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext) {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+    handlemap->mapHandles_VkImage((VkImage*)&toMap->image);
+    handlemap_VkImageSubresourceRange(handlemap,
+                                      (VkImageSubresourceRange*)(&toMap->subresourceRange));
+}
+
+void handlemap_VkSubresourceHostMemcpySizeEXT(VulkanHandleMapping* handlemap,
+                                              VkSubresourceHostMemcpySizeEXT* toMap) {
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext) {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+}
+
+void handlemap_VkHostImageCopyDevicePerformanceQueryEXT(
+    VulkanHandleMapping* handlemap, VkHostImageCopyDevicePerformanceQueryEXT* toMap) {
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext) {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+}
+
+#endif
 #ifdef VK_EXT_swapchain_maintenance1
 void handlemap_VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT(
     VulkanHandleMapping* handlemap, VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT* toMap) {
@@ -3755,26 +3967,6 @@
     }
 }
 
-void handlemap_VkSubresourceLayout2EXT(VulkanHandleMapping* handlemap,
-                                       VkSubresourceLayout2EXT* toMap) {
-    (void)handlemap;
-    (void)toMap;
-    if (toMap->pNext) {
-        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
-    }
-    handlemap_VkSubresourceLayout(handlemap, (VkSubresourceLayout*)(&toMap->subresourceLayout));
-}
-
-void handlemap_VkImageSubresource2EXT(VulkanHandleMapping* handlemap,
-                                      VkImageSubresource2EXT* toMap) {
-    (void)handlemap;
-    (void)toMap;
-    if (toMap->pNext) {
-        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
-    }
-    handlemap_VkImageSubresource(handlemap, (VkImageSubresource*)(&toMap->imageSubresource));
-}
-
 void handlemap_VkImageCompressionPropertiesEXT(VulkanHandleMapping* handlemap,
                                                VkImageCompressionPropertiesEXT* toMap) {
     (void)handlemap;
@@ -4562,6 +4754,32 @@
             break;
         }
 #endif
+#ifdef VK_KHR_maintenance5
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_FEATURES_KHR: {
+            handlemap_VkPhysicalDeviceMaintenance5FeaturesKHR(
+                handlemap,
+                reinterpret_cast<VkPhysicalDeviceMaintenance5FeaturesKHR*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_PROPERTIES_KHR: {
+            handlemap_VkPhysicalDeviceMaintenance5PropertiesKHR(
+                handlemap,
+                reinterpret_cast<VkPhysicalDeviceMaintenance5PropertiesKHR*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PIPELINE_CREATE_FLAGS_2_CREATE_INFO_KHR: {
+            handlemap_VkPipelineCreateFlags2CreateInfoKHR(
+                handlemap,
+                reinterpret_cast<VkPipelineCreateFlags2CreateInfoKHR*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_BUFFER_USAGE_FLAGS_2_CREATE_INFO_KHR: {
+            handlemap_VkBufferUsageFlags2CreateInfoKHR(
+                handlemap,
+                reinterpret_cast<VkBufferUsageFlags2CreateInfoKHR*>(structExtension_out));
+            break;
+        }
+#endif
 #ifdef VK_ANDROID_native_buffer
         case VK_STRUCTURE_TYPE_NATIVE_BUFFER_ANDROID: {
             handlemap_VkNativeBufferANDROID(
@@ -4646,6 +4864,31 @@
             break;
         }
 #endif
+#ifdef VK_EXT_host_image_copy
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_FEATURES_EXT: {
+            handlemap_VkPhysicalDeviceHostImageCopyFeaturesEXT(
+                handlemap,
+                reinterpret_cast<VkPhysicalDeviceHostImageCopyFeaturesEXT*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_PROPERTIES_EXT: {
+            handlemap_VkPhysicalDeviceHostImageCopyPropertiesEXT(
+                handlemap,
+                reinterpret_cast<VkPhysicalDeviceHostImageCopyPropertiesEXT*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_SUBRESOURCE_HOST_MEMCPY_SIZE_EXT: {
+            handlemap_VkSubresourceHostMemcpySizeEXT(
+                handlemap, reinterpret_cast<VkSubresourceHostMemcpySizeEXT*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_HOST_IMAGE_COPY_DEVICE_PERFORMANCE_QUERY_EXT: {
+            handlemap_VkHostImageCopyDevicePerformanceQueryEXT(
+                handlemap,
+                reinterpret_cast<VkHostImageCopyDevicePerformanceQueryEXT*>(structExtension_out));
+            break;
+        }
+#endif
 #ifdef VK_EXT_swapchain_maintenance1
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SWAPCHAIN_MAINTENANCE_1_FEATURES_EXT: {
             handlemap_VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT(
diff --git a/host/vulkan/cereal/common/goldfish_vk_handlemap.h b/host/vulkan/cereal/common/goldfish_vk_handlemap.h
index bf82449..6421d20 100644
--- a/host/vulkan/cereal/common/goldfish_vk_handlemap.h
+++ b/host/vulkan/cereal/common/goldfish_vk_handlemap.h
@@ -15,9 +15,9 @@
 
 // Autogenerated module goldfish_vk_handlemap
 //
-// (header) generated by codegen/vulkan/vulkan-docs/scripts/genvk.py -registry
-// codegen/vulkan/vulkan-docs/xml/vk.xml -registryGfxstream
-// codegen/vulkan/vulkan-docs/xml/vk_gfxstream.xml cereal -o host/vulkan/cereal
+// (header) generated by codegen/vulkan/vulkan-docs-next/scripts/genvk.py -registry
+// codegen/vulkan/vulkan-docs-next/xml/vk.xml -registryGfxstream
+// codegen/vulkan/vulkan-docs-next/xml/vk_gfxstream.xml cereal -o host/vulkan/cereal
 //
 // Please do not modify directly;
 // re-run gfxstream-protocols/scripts/generate-vulkan-sources.sh,
@@ -34,7 +34,7 @@
 
 #include "VulkanHandleMapping.h"
 #include "goldfish_vk_private_defs.h"
-#include "vk_android_native_buffer.h"
+#include "vk_android_native_buffer_gfxstream.h"
 #include "vulkan_gfxstream.h"
 
 namespace gfxstream {
@@ -1245,6 +1245,32 @@
                       handlemap_VkDeviceImageMemoryRequirementsKHR)
 
 #endif
+#ifdef VK_KHR_maintenance5
+void handlemap_VkPhysicalDeviceMaintenance5FeaturesKHR(
+    VulkanHandleMapping* handlemap, VkPhysicalDeviceMaintenance5FeaturesKHR* toMap);
+
+void handlemap_VkPhysicalDeviceMaintenance5PropertiesKHR(
+    VulkanHandleMapping* handlemap, VkPhysicalDeviceMaintenance5PropertiesKHR* toMap);
+
+void handlemap_VkRenderingAreaInfoKHR(VulkanHandleMapping* handlemap,
+                                      VkRenderingAreaInfoKHR* toMap);
+
+void handlemap_VkImageSubresource2KHR(VulkanHandleMapping* handlemap,
+                                      VkImageSubresource2KHR* toMap);
+
+void handlemap_VkDeviceImageSubresourceInfoKHR(VulkanHandleMapping* handlemap,
+                                               VkDeviceImageSubresourceInfoKHR* toMap);
+
+void handlemap_VkSubresourceLayout2KHR(VulkanHandleMapping* handlemap,
+                                       VkSubresourceLayout2KHR* toMap);
+
+void handlemap_VkPipelineCreateFlags2CreateInfoKHR(VulkanHandleMapping* handlemap,
+                                                   VkPipelineCreateFlags2CreateInfoKHR* toMap);
+
+void handlemap_VkBufferUsageFlags2CreateInfoKHR(VulkanHandleMapping* handlemap,
+                                                VkBufferUsageFlags2CreateInfoKHR* toMap);
+
+#endif
 #ifdef VK_ANDROID_native_buffer
 void handlemap_VkNativeBufferUsage2ANDROID(VulkanHandleMapping* handlemap,
                                            VkNativeBufferUsage2ANDROID* toMap);
@@ -1360,6 +1386,42 @@
     VulkanHandleMapping* handlemap, VkPhysicalDeviceExtendedDynamicStateFeaturesEXT* toMap);
 
 #endif
+#ifdef VK_EXT_host_image_copy
+void handlemap_VkPhysicalDeviceHostImageCopyFeaturesEXT(
+    VulkanHandleMapping* handlemap, VkPhysicalDeviceHostImageCopyFeaturesEXT* toMap);
+
+void handlemap_VkPhysicalDeviceHostImageCopyPropertiesEXT(
+    VulkanHandleMapping* handlemap, VkPhysicalDeviceHostImageCopyPropertiesEXT* toMap);
+
+void handlemap_VkMemoryToImageCopyEXT(VulkanHandleMapping* handlemap,
+                                      VkMemoryToImageCopyEXT* toMap);
+
+void handlemap_VkImageToMemoryCopyEXT(VulkanHandleMapping* handlemap,
+                                      VkImageToMemoryCopyEXT* toMap);
+
+void handlemap_VkCopyMemoryToImageInfoEXT(VulkanHandleMapping* handlemap,
+                                          VkCopyMemoryToImageInfoEXT* toMap);
+
+void handlemap_VkCopyImageToMemoryInfoEXT(VulkanHandleMapping* handlemap,
+                                          VkCopyImageToMemoryInfoEXT* toMap);
+
+void handlemap_VkCopyImageToImageInfoEXT(VulkanHandleMapping* handlemap,
+                                         VkCopyImageToImageInfoEXT* toMap);
+
+void handlemap_VkHostImageLayoutTransitionInfoEXT(VulkanHandleMapping* handlemap,
+                                                  VkHostImageLayoutTransitionInfoEXT* toMap);
+
+void handlemap_VkSubresourceHostMemcpySizeEXT(VulkanHandleMapping* handlemap,
+                                              VkSubresourceHostMemcpySizeEXT* toMap);
+
+void handlemap_VkHostImageCopyDevicePerformanceQueryEXT(
+    VulkanHandleMapping* handlemap, VkHostImageCopyDevicePerformanceQueryEXT* toMap);
+
+DEFINE_ALIAS_FUNCTION(handlemap_VkSubresourceLayout2KHR, handlemap_VkSubresourceLayout2EXT)
+
+DEFINE_ALIAS_FUNCTION(handlemap_VkImageSubresource2KHR, handlemap_VkImageSubresource2EXT)
+
+#endif
 #ifdef VK_EXT_swapchain_maintenance1
 void handlemap_VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT(
     VulkanHandleMapping* handlemap, VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT* toMap);
@@ -1459,12 +1521,6 @@
 void handlemap_VkImageCompressionControlEXT(VulkanHandleMapping* handlemap,
                                             VkImageCompressionControlEXT* toMap);
 
-void handlemap_VkSubresourceLayout2EXT(VulkanHandleMapping* handlemap,
-                                       VkSubresourceLayout2EXT* toMap);
-
-void handlemap_VkImageSubresource2EXT(VulkanHandleMapping* handlemap,
-                                      VkImageSubresource2EXT* toMap);
-
 void handlemap_VkImageCompressionPropertiesEXT(VulkanHandleMapping* handlemap,
                                                VkImageCompressionPropertiesEXT* toMap);
 
diff --git a/host/vulkan/cereal/common/goldfish_vk_marshaling.cpp b/host/vulkan/cereal/common/goldfish_vk_marshaling.cpp
index f0cefba..734b309 100644
--- a/host/vulkan/cereal/common/goldfish_vk_marshaling.cpp
+++ b/host/vulkan/cereal/common/goldfish_vk_marshaling.cpp
@@ -15,9 +15,9 @@
 
 // Autogenerated module goldfish_vk_marshaling
 //
-// (impl) generated by codegen/vulkan/vulkan-docs/scripts/genvk.py -registry
-// codegen/vulkan/vulkan-docs/xml/vk.xml -registryGfxstream
-// codegen/vulkan/vulkan-docs/xml/vk_gfxstream.xml cereal -o host/vulkan/cereal
+// (impl) generated by codegen/vulkan/vulkan-docs-next/scripts/genvk.py -registry
+// codegen/vulkan/vulkan-docs-next/xml/vk.xml -registryGfxstream
+// codegen/vulkan/vulkan-docs-next/xml/vk_gfxstream.xml cereal -o host/vulkan/cereal
 //
 // Please do not modify directly;
 // re-run gfxstream-protocols/scripts/generate-vulkan-sources.sh,
@@ -14803,6 +14803,341 @@
 #endif
 #ifdef VK_KHR_maintenance4
 #endif
+#ifdef VK_KHR_maintenance5
+void marshal_VkPhysicalDeviceMaintenance5FeaturesKHR(
+    VulkanStream* vkStream, VkStructureType rootType,
+    const VkPhysicalDeviceMaintenance5FeaturesKHR* forMarshaling) {
+    (void)rootType;
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forMarshaling->sType;
+    }
+    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
+    vkStream->write((VkBool32*)&forMarshaling->maintenance5, sizeof(VkBool32));
+}
+
+void unmarshal_VkPhysicalDeviceMaintenance5FeaturesKHR(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPhysicalDeviceMaintenance5FeaturesKHR* forUnmarshaling) {
+    (void)rootType;
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->read((VkBool32*)&forUnmarshaling->maintenance5, sizeof(VkBool32));
+}
+
+void marshal_VkPhysicalDeviceMaintenance5PropertiesKHR(
+    VulkanStream* vkStream, VkStructureType rootType,
+    const VkPhysicalDeviceMaintenance5PropertiesKHR* forMarshaling) {
+    (void)rootType;
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forMarshaling->sType;
+    }
+    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
+    vkStream->write((VkBool32*)&forMarshaling->earlyFragmentMultisampleCoverageAfterSampleCounting,
+                    sizeof(VkBool32));
+    vkStream->write((VkBool32*)&forMarshaling->earlyFragmentSampleMaskTestBeforeSampleCounting,
+                    sizeof(VkBool32));
+    vkStream->write((VkBool32*)&forMarshaling->depthStencilSwizzleOneSupport, sizeof(VkBool32));
+    vkStream->write((VkBool32*)&forMarshaling->polygonModePointSize, sizeof(VkBool32));
+    vkStream->write((VkBool32*)&forMarshaling->nonStrictSinglePixelWideLinesUseParallelogram,
+                    sizeof(VkBool32));
+    vkStream->write((VkBool32*)&forMarshaling->nonStrictWideLinesUseParallelogram,
+                    sizeof(VkBool32));
+}
+
+void unmarshal_VkPhysicalDeviceMaintenance5PropertiesKHR(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPhysicalDeviceMaintenance5PropertiesKHR* forUnmarshaling) {
+    (void)rootType;
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->read((VkBool32*)&forUnmarshaling->earlyFragmentMultisampleCoverageAfterSampleCounting,
+                   sizeof(VkBool32));
+    vkStream->read((VkBool32*)&forUnmarshaling->earlyFragmentSampleMaskTestBeforeSampleCounting,
+                   sizeof(VkBool32));
+    vkStream->read((VkBool32*)&forUnmarshaling->depthStencilSwizzleOneSupport, sizeof(VkBool32));
+    vkStream->read((VkBool32*)&forUnmarshaling->polygonModePointSize, sizeof(VkBool32));
+    vkStream->read((VkBool32*)&forUnmarshaling->nonStrictSinglePixelWideLinesUseParallelogram,
+                   sizeof(VkBool32));
+    vkStream->read((VkBool32*)&forUnmarshaling->nonStrictWideLinesUseParallelogram,
+                   sizeof(VkBool32));
+}
+
+void marshal_VkRenderingAreaInfoKHR(VulkanStream* vkStream, VkStructureType rootType,
+                                    const VkRenderingAreaInfoKHR* forMarshaling) {
+    (void)rootType;
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forMarshaling->sType;
+    }
+    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
+    vkStream->write((uint32_t*)&forMarshaling->viewMask, sizeof(uint32_t));
+    vkStream->write((uint32_t*)&forMarshaling->colorAttachmentCount, sizeof(uint32_t));
+    // WARNING PTR CHECK
+    uint64_t cgen_var_0 = (uint64_t)(uintptr_t)forMarshaling->pColorAttachmentFormats;
+    vkStream->putBe64(cgen_var_0);
+    if (forMarshaling->pColorAttachmentFormats) {
+        vkStream->write((const VkFormat*)forMarshaling->pColorAttachmentFormats,
+                        forMarshaling->colorAttachmentCount * sizeof(const VkFormat));
+    }
+    vkStream->write((VkFormat*)&forMarshaling->depthAttachmentFormat, sizeof(VkFormat));
+    vkStream->write((VkFormat*)&forMarshaling->stencilAttachmentFormat, sizeof(VkFormat));
+}
+
+void unmarshal_VkRenderingAreaInfoKHR(VulkanStream* vkStream, VkStructureType rootType,
+                                      VkRenderingAreaInfoKHR* forUnmarshaling) {
+    (void)rootType;
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->read((uint32_t*)&forUnmarshaling->viewMask, sizeof(uint32_t));
+    vkStream->read((uint32_t*)&forUnmarshaling->colorAttachmentCount, sizeof(uint32_t));
+    // WARNING PTR CHECK
+    forUnmarshaling->pColorAttachmentFormats = (const VkFormat*)(uintptr_t)vkStream->getBe64();
+    if (forUnmarshaling->pColorAttachmentFormats) {
+        vkStream->alloc((void**)&forUnmarshaling->pColorAttachmentFormats,
+                        forUnmarshaling->colorAttachmentCount * sizeof(const VkFormat));
+        vkStream->read((VkFormat*)forUnmarshaling->pColorAttachmentFormats,
+                       forUnmarshaling->colorAttachmentCount * sizeof(const VkFormat));
+    }
+    vkStream->read((VkFormat*)&forUnmarshaling->depthAttachmentFormat, sizeof(VkFormat));
+    vkStream->read((VkFormat*)&forUnmarshaling->stencilAttachmentFormat, sizeof(VkFormat));
+}
+
+void marshal_VkImageSubresource2KHR(VulkanStream* vkStream, VkStructureType rootType,
+                                    const VkImageSubresource2KHR* forMarshaling) {
+    (void)rootType;
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forMarshaling->sType;
+    }
+    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
+    marshal_VkImageSubresource(vkStream, rootType,
+                               (VkImageSubresource*)(&forMarshaling->imageSubresource));
+}
+
+void unmarshal_VkImageSubresource2KHR(VulkanStream* vkStream, VkStructureType rootType,
+                                      VkImageSubresource2KHR* forUnmarshaling) {
+    (void)rootType;
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
+    }
+    unmarshal_VkImageSubresource(vkStream, rootType,
+                                 (VkImageSubresource*)(&forUnmarshaling->imageSubresource));
+}
+
+void marshal_VkDeviceImageSubresourceInfoKHR(VulkanStream* vkStream, VkStructureType rootType,
+                                             const VkDeviceImageSubresourceInfoKHR* forMarshaling) {
+    (void)rootType;
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forMarshaling->sType;
+    }
+    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
+    marshal_VkImageCreateInfo(vkStream, rootType,
+                              (const VkImageCreateInfo*)(forMarshaling->pCreateInfo));
+    marshal_VkImageSubresource2KHR(vkStream, rootType,
+                                   (const VkImageSubresource2KHR*)(forMarshaling->pSubresource));
+}
+
+void unmarshal_VkDeviceImageSubresourceInfoKHR(VulkanStream* vkStream, VkStructureType rootType,
+                                               VkDeviceImageSubresourceInfoKHR* forUnmarshaling) {
+    (void)rootType;
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->alloc((void**)&forUnmarshaling->pCreateInfo, sizeof(const VkImageCreateInfo));
+    unmarshal_VkImageCreateInfo(vkStream, rootType,
+                                (VkImageCreateInfo*)(forUnmarshaling->pCreateInfo));
+    vkStream->alloc((void**)&forUnmarshaling->pSubresource, sizeof(const VkImageSubresource2KHR));
+    unmarshal_VkImageSubresource2KHR(vkStream, rootType,
+                                     (VkImageSubresource2KHR*)(forUnmarshaling->pSubresource));
+}
+
+void marshal_VkSubresourceLayout2KHR(VulkanStream* vkStream, VkStructureType rootType,
+                                     const VkSubresourceLayout2KHR* forMarshaling) {
+    (void)rootType;
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forMarshaling->sType;
+    }
+    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
+    marshal_VkSubresourceLayout(vkStream, rootType,
+                                (VkSubresourceLayout*)(&forMarshaling->subresourceLayout));
+}
+
+void unmarshal_VkSubresourceLayout2KHR(VulkanStream* vkStream, VkStructureType rootType,
+                                       VkSubresourceLayout2KHR* forUnmarshaling) {
+    (void)rootType;
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
+    }
+    unmarshal_VkSubresourceLayout(vkStream, rootType,
+                                  (VkSubresourceLayout*)(&forUnmarshaling->subresourceLayout));
+}
+
+void marshal_VkPipelineCreateFlags2CreateInfoKHR(
+    VulkanStream* vkStream, VkStructureType rootType,
+    const VkPipelineCreateFlags2CreateInfoKHR* forMarshaling) {
+    (void)rootType;
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forMarshaling->sType;
+    }
+    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
+    vkStream->write((VkPipelineCreateFlags2KHR*)&forMarshaling->flags,
+                    sizeof(VkPipelineCreateFlags2KHR));
+}
+
+void unmarshal_VkPipelineCreateFlags2CreateInfoKHR(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPipelineCreateFlags2CreateInfoKHR* forUnmarshaling) {
+    (void)rootType;
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->read((VkPipelineCreateFlags2KHR*)&forUnmarshaling->flags,
+                   sizeof(VkPipelineCreateFlags2KHR));
+}
+
+void marshal_VkBufferUsageFlags2CreateInfoKHR(
+    VulkanStream* vkStream, VkStructureType rootType,
+    const VkBufferUsageFlags2CreateInfoKHR* forMarshaling) {
+    (void)rootType;
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forMarshaling->sType;
+    }
+    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
+    vkStream->write((VkBufferUsageFlags2KHR*)&forMarshaling->usage, sizeof(VkBufferUsageFlags2KHR));
+}
+
+void unmarshal_VkBufferUsageFlags2CreateInfoKHR(VulkanStream* vkStream, VkStructureType rootType,
+                                                VkBufferUsageFlags2CreateInfoKHR* forUnmarshaling) {
+    (void)rootType;
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->read((VkBufferUsageFlags2KHR*)&forUnmarshaling->usage,
+                   sizeof(VkBufferUsageFlags2KHR));
+}
+
+#endif
 #ifdef VK_ANDROID_native_buffer
 void marshal_VkNativeBufferUsage2ANDROID(VulkanStream* vkStream, VkStructureType rootType,
                                          const VkNativeBufferUsage2ANDROID* forMarshaling) {
@@ -15444,6 +15779,525 @@
 }
 
 #endif
+#ifdef VK_EXT_host_image_copy
+void marshal_VkPhysicalDeviceHostImageCopyFeaturesEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    const VkPhysicalDeviceHostImageCopyFeaturesEXT* forMarshaling) {
+    (void)rootType;
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forMarshaling->sType;
+    }
+    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
+    vkStream->write((VkBool32*)&forMarshaling->hostImageCopy, sizeof(VkBool32));
+}
+
+void unmarshal_VkPhysicalDeviceHostImageCopyFeaturesEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPhysicalDeviceHostImageCopyFeaturesEXT* forUnmarshaling) {
+    (void)rootType;
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->read((VkBool32*)&forUnmarshaling->hostImageCopy, sizeof(VkBool32));
+}
+
+void marshal_VkPhysicalDeviceHostImageCopyPropertiesEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    const VkPhysicalDeviceHostImageCopyPropertiesEXT* forMarshaling) {
+    (void)rootType;
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forMarshaling->sType;
+    }
+    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
+    vkStream->write((uint32_t*)&forMarshaling->copySrcLayoutCount, sizeof(uint32_t));
+    // WARNING PTR CHECK
+    uint64_t cgen_var_0 = (uint64_t)(uintptr_t)forMarshaling->pCopySrcLayouts;
+    vkStream->putBe64(cgen_var_0);
+    if (forMarshaling->pCopySrcLayouts) {
+        vkStream->write((VkImageLayout*)forMarshaling->pCopySrcLayouts,
+                        forMarshaling->copySrcLayoutCount * sizeof(VkImageLayout));
+    }
+    vkStream->write((uint32_t*)&forMarshaling->copyDstLayoutCount, sizeof(uint32_t));
+    // WARNING PTR CHECK
+    uint64_t cgen_var_1 = (uint64_t)(uintptr_t)forMarshaling->pCopyDstLayouts;
+    vkStream->putBe64(cgen_var_1);
+    if (forMarshaling->pCopyDstLayouts) {
+        vkStream->write((VkImageLayout*)forMarshaling->pCopyDstLayouts,
+                        forMarshaling->copyDstLayoutCount * sizeof(VkImageLayout));
+    }
+    vkStream->write((uint8_t*)forMarshaling->optimalTilingLayoutUUID,
+                    VK_UUID_SIZE * sizeof(uint8_t));
+    vkStream->write((VkBool32*)&forMarshaling->identicalMemoryTypeRequirements, sizeof(VkBool32));
+}
+
+void unmarshal_VkPhysicalDeviceHostImageCopyPropertiesEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPhysicalDeviceHostImageCopyPropertiesEXT* forUnmarshaling) {
+    (void)rootType;
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->read((uint32_t*)&forUnmarshaling->copySrcLayoutCount, sizeof(uint32_t));
+    // WARNING PTR CHECK
+    forUnmarshaling->pCopySrcLayouts = (VkImageLayout*)(uintptr_t)vkStream->getBe64();
+    if (forUnmarshaling->pCopySrcLayouts) {
+        vkStream->alloc((void**)&forUnmarshaling->pCopySrcLayouts,
+                        forUnmarshaling->copySrcLayoutCount * sizeof(VkImageLayout));
+        vkStream->read((VkImageLayout*)forUnmarshaling->pCopySrcLayouts,
+                       forUnmarshaling->copySrcLayoutCount * sizeof(VkImageLayout));
+    }
+    vkStream->read((uint32_t*)&forUnmarshaling->copyDstLayoutCount, sizeof(uint32_t));
+    // WARNING PTR CHECK
+    forUnmarshaling->pCopyDstLayouts = (VkImageLayout*)(uintptr_t)vkStream->getBe64();
+    if (forUnmarshaling->pCopyDstLayouts) {
+        vkStream->alloc((void**)&forUnmarshaling->pCopyDstLayouts,
+                        forUnmarshaling->copyDstLayoutCount * sizeof(VkImageLayout));
+        vkStream->read((VkImageLayout*)forUnmarshaling->pCopyDstLayouts,
+                       forUnmarshaling->copyDstLayoutCount * sizeof(VkImageLayout));
+    }
+    vkStream->read((uint8_t*)forUnmarshaling->optimalTilingLayoutUUID,
+                   VK_UUID_SIZE * sizeof(uint8_t));
+    vkStream->read((VkBool32*)&forUnmarshaling->identicalMemoryTypeRequirements, sizeof(VkBool32));
+}
+
+void marshal_VkMemoryToImageCopyEXT(VulkanStream* vkStream, VkStructureType rootType,
+                                    const VkMemoryToImageCopyEXT* forMarshaling) {
+    (void)rootType;
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forMarshaling->sType;
+    }
+    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
+    vkStream->write((const void*)forMarshaling->pHostPointer, sizeof(const uint8_t));
+    vkStream->write((uint32_t*)&forMarshaling->memoryRowLength, sizeof(uint32_t));
+    vkStream->write((uint32_t*)&forMarshaling->memoryImageHeight, sizeof(uint32_t));
+    marshal_VkImageSubresourceLayers(vkStream, rootType,
+                                     (VkImageSubresourceLayers*)(&forMarshaling->imageSubresource));
+    marshal_VkOffset3D(vkStream, rootType, (VkOffset3D*)(&forMarshaling->imageOffset));
+    marshal_VkExtent3D(vkStream, rootType, (VkExtent3D*)(&forMarshaling->imageExtent));
+}
+
+void unmarshal_VkMemoryToImageCopyEXT(VulkanStream* vkStream, VkStructureType rootType,
+                                      VkMemoryToImageCopyEXT* forUnmarshaling) {
+    (void)rootType;
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->alloc((void**)&forUnmarshaling->pHostPointer, sizeof(const uint8_t));
+    vkStream->read((void*)forUnmarshaling->pHostPointer, sizeof(const uint8_t));
+    vkStream->read((uint32_t*)&forUnmarshaling->memoryRowLength, sizeof(uint32_t));
+    vkStream->read((uint32_t*)&forUnmarshaling->memoryImageHeight, sizeof(uint32_t));
+    unmarshal_VkImageSubresourceLayers(
+        vkStream, rootType, (VkImageSubresourceLayers*)(&forUnmarshaling->imageSubresource));
+    unmarshal_VkOffset3D(vkStream, rootType, (VkOffset3D*)(&forUnmarshaling->imageOffset));
+    unmarshal_VkExtent3D(vkStream, rootType, (VkExtent3D*)(&forUnmarshaling->imageExtent));
+}
+
+void marshal_VkImageToMemoryCopyEXT(VulkanStream* vkStream, VkStructureType rootType,
+                                    const VkImageToMemoryCopyEXT* forMarshaling) {
+    (void)rootType;
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forMarshaling->sType;
+    }
+    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
+    vkStream->write((void*)forMarshaling->pHostPointer, sizeof(uint8_t));
+    vkStream->write((uint32_t*)&forMarshaling->memoryRowLength, sizeof(uint32_t));
+    vkStream->write((uint32_t*)&forMarshaling->memoryImageHeight, sizeof(uint32_t));
+    marshal_VkImageSubresourceLayers(vkStream, rootType,
+                                     (VkImageSubresourceLayers*)(&forMarshaling->imageSubresource));
+    marshal_VkOffset3D(vkStream, rootType, (VkOffset3D*)(&forMarshaling->imageOffset));
+    marshal_VkExtent3D(vkStream, rootType, (VkExtent3D*)(&forMarshaling->imageExtent));
+}
+
+void unmarshal_VkImageToMemoryCopyEXT(VulkanStream* vkStream, VkStructureType rootType,
+                                      VkImageToMemoryCopyEXT* forUnmarshaling) {
+    (void)rootType;
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->alloc((void**)&forUnmarshaling->pHostPointer, sizeof(uint8_t));
+    vkStream->read((void*)forUnmarshaling->pHostPointer, sizeof(uint8_t));
+    vkStream->read((uint32_t*)&forUnmarshaling->memoryRowLength, sizeof(uint32_t));
+    vkStream->read((uint32_t*)&forUnmarshaling->memoryImageHeight, sizeof(uint32_t));
+    unmarshal_VkImageSubresourceLayers(
+        vkStream, rootType, (VkImageSubresourceLayers*)(&forUnmarshaling->imageSubresource));
+    unmarshal_VkOffset3D(vkStream, rootType, (VkOffset3D*)(&forUnmarshaling->imageOffset));
+    unmarshal_VkExtent3D(vkStream, rootType, (VkExtent3D*)(&forUnmarshaling->imageExtent));
+}
+
+void marshal_VkCopyMemoryToImageInfoEXT(VulkanStream* vkStream, VkStructureType rootType,
+                                        const VkCopyMemoryToImageInfoEXT* forMarshaling) {
+    (void)rootType;
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forMarshaling->sType;
+    }
+    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
+    vkStream->write((VkHostImageCopyFlagsEXT*)&forMarshaling->flags,
+                    sizeof(VkHostImageCopyFlagsEXT));
+    uint64_t cgen_var_0;
+    vkStream->handleMapping()->mapHandles_VkImage_u64(&forMarshaling->dstImage, &cgen_var_0, 1);
+    vkStream->write((uint64_t*)&cgen_var_0, 1 * 8);
+    vkStream->write((VkImageLayout*)&forMarshaling->dstImageLayout, sizeof(VkImageLayout));
+    vkStream->write((uint32_t*)&forMarshaling->regionCount, sizeof(uint32_t));
+    if (forMarshaling) {
+        for (uint32_t i = 0; i < (uint32_t)forMarshaling->regionCount; ++i) {
+            marshal_VkMemoryToImageCopyEXT(
+                vkStream, rootType, (const VkMemoryToImageCopyEXT*)(forMarshaling->pRegions + i));
+        }
+    }
+}
+
+void unmarshal_VkCopyMemoryToImageInfoEXT(VulkanStream* vkStream, VkStructureType rootType,
+                                          VkCopyMemoryToImageInfoEXT* forUnmarshaling) {
+    (void)rootType;
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->read((VkHostImageCopyFlagsEXT*)&forUnmarshaling->flags,
+                   sizeof(VkHostImageCopyFlagsEXT));
+    uint64_t cgen_var_0;
+    vkStream->read((uint64_t*)&cgen_var_0, 1 * 8);
+    vkStream->handleMapping()->mapHandles_u64_VkImage(&cgen_var_0,
+                                                      (VkImage*)&forUnmarshaling->dstImage, 1);
+    vkStream->read((VkImageLayout*)&forUnmarshaling->dstImageLayout, sizeof(VkImageLayout));
+    vkStream->read((uint32_t*)&forUnmarshaling->regionCount, sizeof(uint32_t));
+    vkStream->alloc((void**)&forUnmarshaling->pRegions,
+                    forUnmarshaling->regionCount * sizeof(const VkMemoryToImageCopyEXT));
+    if (forUnmarshaling) {
+        for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->regionCount; ++i) {
+            unmarshal_VkMemoryToImageCopyEXT(
+                vkStream, rootType, (VkMemoryToImageCopyEXT*)(forUnmarshaling->pRegions + i));
+        }
+    }
+}
+
+void marshal_VkCopyImageToMemoryInfoEXT(VulkanStream* vkStream, VkStructureType rootType,
+                                        const VkCopyImageToMemoryInfoEXT* forMarshaling) {
+    (void)rootType;
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forMarshaling->sType;
+    }
+    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
+    vkStream->write((VkHostImageCopyFlagsEXT*)&forMarshaling->flags,
+                    sizeof(VkHostImageCopyFlagsEXT));
+    uint64_t cgen_var_0;
+    vkStream->handleMapping()->mapHandles_VkImage_u64(&forMarshaling->srcImage, &cgen_var_0, 1);
+    vkStream->write((uint64_t*)&cgen_var_0, 1 * 8);
+    vkStream->write((VkImageLayout*)&forMarshaling->srcImageLayout, sizeof(VkImageLayout));
+    vkStream->write((uint32_t*)&forMarshaling->regionCount, sizeof(uint32_t));
+    if (forMarshaling) {
+        for (uint32_t i = 0; i < (uint32_t)forMarshaling->regionCount; ++i) {
+            marshal_VkImageToMemoryCopyEXT(
+                vkStream, rootType, (const VkImageToMemoryCopyEXT*)(forMarshaling->pRegions + i));
+        }
+    }
+}
+
+void unmarshal_VkCopyImageToMemoryInfoEXT(VulkanStream* vkStream, VkStructureType rootType,
+                                          VkCopyImageToMemoryInfoEXT* forUnmarshaling) {
+    (void)rootType;
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->read((VkHostImageCopyFlagsEXT*)&forUnmarshaling->flags,
+                   sizeof(VkHostImageCopyFlagsEXT));
+    uint64_t cgen_var_0;
+    vkStream->read((uint64_t*)&cgen_var_0, 1 * 8);
+    vkStream->handleMapping()->mapHandles_u64_VkImage(&cgen_var_0,
+                                                      (VkImage*)&forUnmarshaling->srcImage, 1);
+    vkStream->read((VkImageLayout*)&forUnmarshaling->srcImageLayout, sizeof(VkImageLayout));
+    vkStream->read((uint32_t*)&forUnmarshaling->regionCount, sizeof(uint32_t));
+    vkStream->alloc((void**)&forUnmarshaling->pRegions,
+                    forUnmarshaling->regionCount * sizeof(const VkImageToMemoryCopyEXT));
+    if (forUnmarshaling) {
+        for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->regionCount; ++i) {
+            unmarshal_VkImageToMemoryCopyEXT(
+                vkStream, rootType, (VkImageToMemoryCopyEXT*)(forUnmarshaling->pRegions + i));
+        }
+    }
+}
+
+void marshal_VkCopyImageToImageInfoEXT(VulkanStream* vkStream, VkStructureType rootType,
+                                       const VkCopyImageToImageInfoEXT* forMarshaling) {
+    (void)rootType;
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forMarshaling->sType;
+    }
+    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
+    vkStream->write((VkHostImageCopyFlagsEXT*)&forMarshaling->flags,
+                    sizeof(VkHostImageCopyFlagsEXT));
+    uint64_t cgen_var_0;
+    vkStream->handleMapping()->mapHandles_VkImage_u64(&forMarshaling->srcImage, &cgen_var_0, 1);
+    vkStream->write((uint64_t*)&cgen_var_0, 1 * 8);
+    vkStream->write((VkImageLayout*)&forMarshaling->srcImageLayout, sizeof(VkImageLayout));
+    uint64_t cgen_var_1;
+    vkStream->handleMapping()->mapHandles_VkImage_u64(&forMarshaling->dstImage, &cgen_var_1, 1);
+    vkStream->write((uint64_t*)&cgen_var_1, 1 * 8);
+    vkStream->write((VkImageLayout*)&forMarshaling->dstImageLayout, sizeof(VkImageLayout));
+    vkStream->write((uint32_t*)&forMarshaling->regionCount, sizeof(uint32_t));
+    if (forMarshaling) {
+        for (uint32_t i = 0; i < (uint32_t)forMarshaling->regionCount; ++i) {
+            marshal_VkImageCopy2(vkStream, rootType,
+                                 (const VkImageCopy2*)(forMarshaling->pRegions + i));
+        }
+    }
+}
+
+void unmarshal_VkCopyImageToImageInfoEXT(VulkanStream* vkStream, VkStructureType rootType,
+                                         VkCopyImageToImageInfoEXT* forUnmarshaling) {
+    (void)rootType;
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->read((VkHostImageCopyFlagsEXT*)&forUnmarshaling->flags,
+                   sizeof(VkHostImageCopyFlagsEXT));
+    uint64_t cgen_var_0;
+    vkStream->read((uint64_t*)&cgen_var_0, 1 * 8);
+    vkStream->handleMapping()->mapHandles_u64_VkImage(&cgen_var_0,
+                                                      (VkImage*)&forUnmarshaling->srcImage, 1);
+    vkStream->read((VkImageLayout*)&forUnmarshaling->srcImageLayout, sizeof(VkImageLayout));
+    uint64_t cgen_var_1;
+    vkStream->read((uint64_t*)&cgen_var_1, 1 * 8);
+    vkStream->handleMapping()->mapHandles_u64_VkImage(&cgen_var_1,
+                                                      (VkImage*)&forUnmarshaling->dstImage, 1);
+    vkStream->read((VkImageLayout*)&forUnmarshaling->dstImageLayout, sizeof(VkImageLayout));
+    vkStream->read((uint32_t*)&forUnmarshaling->regionCount, sizeof(uint32_t));
+    vkStream->alloc((void**)&forUnmarshaling->pRegions,
+                    forUnmarshaling->regionCount * sizeof(const VkImageCopy2));
+    if (forUnmarshaling) {
+        for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->regionCount; ++i) {
+            unmarshal_VkImageCopy2(vkStream, rootType,
+                                   (VkImageCopy2*)(forUnmarshaling->pRegions + i));
+        }
+    }
+}
+
+void marshal_VkHostImageLayoutTransitionInfoEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    const VkHostImageLayoutTransitionInfoEXT* forMarshaling) {
+    (void)rootType;
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forMarshaling->sType;
+    }
+    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
+    uint64_t cgen_var_0;
+    vkStream->handleMapping()->mapHandles_VkImage_u64(&forMarshaling->image, &cgen_var_0, 1);
+    vkStream->write((uint64_t*)&cgen_var_0, 1 * 8);
+    vkStream->write((VkImageLayout*)&forMarshaling->oldLayout, sizeof(VkImageLayout));
+    vkStream->write((VkImageLayout*)&forMarshaling->newLayout, sizeof(VkImageLayout));
+    marshal_VkImageSubresourceRange(vkStream, rootType,
+                                    (VkImageSubresourceRange*)(&forMarshaling->subresourceRange));
+}
+
+void unmarshal_VkHostImageLayoutTransitionInfoEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkHostImageLayoutTransitionInfoEXT* forUnmarshaling) {
+    (void)rootType;
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
+    }
+    uint64_t cgen_var_0;
+    vkStream->read((uint64_t*)&cgen_var_0, 1 * 8);
+    vkStream->handleMapping()->mapHandles_u64_VkImage(&cgen_var_0,
+                                                      (VkImage*)&forUnmarshaling->image, 1);
+    vkStream->read((VkImageLayout*)&forUnmarshaling->oldLayout, sizeof(VkImageLayout));
+    vkStream->read((VkImageLayout*)&forUnmarshaling->newLayout, sizeof(VkImageLayout));
+    unmarshal_VkImageSubresourceRange(
+        vkStream, rootType, (VkImageSubresourceRange*)(&forUnmarshaling->subresourceRange));
+}
+
+void marshal_VkSubresourceHostMemcpySizeEXT(VulkanStream* vkStream, VkStructureType rootType,
+                                            const VkSubresourceHostMemcpySizeEXT* forMarshaling) {
+    (void)rootType;
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forMarshaling->sType;
+    }
+    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
+    vkStream->write((VkDeviceSize*)&forMarshaling->size, sizeof(VkDeviceSize));
+}
+
+void unmarshal_VkSubresourceHostMemcpySizeEXT(VulkanStream* vkStream, VkStructureType rootType,
+                                              VkSubresourceHostMemcpySizeEXT* forUnmarshaling) {
+    (void)rootType;
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->read((VkDeviceSize*)&forUnmarshaling->size, sizeof(VkDeviceSize));
+}
+
+void marshal_VkHostImageCopyDevicePerformanceQueryEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    const VkHostImageCopyDevicePerformanceQueryEXT* forMarshaling) {
+    (void)rootType;
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forMarshaling->sType;
+    }
+    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
+    vkStream->write((VkBool32*)&forMarshaling->optimalDeviceAccess, sizeof(VkBool32));
+    vkStream->write((VkBool32*)&forMarshaling->identicalMemoryLayout, sizeof(VkBool32));
+}
+
+void unmarshal_VkHostImageCopyDevicePerformanceQueryEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkHostImageCopyDevicePerformanceQueryEXT* forUnmarshaling) {
+    (void)rootType;
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->read((VkBool32*)&forUnmarshaling->optimalDeviceAccess, sizeof(VkBool32));
+    vkStream->read((VkBool32*)&forUnmarshaling->identicalMemoryLayout, sizeof(VkBool32));
+}
+
+#endif
 #ifdef VK_EXT_swapchain_maintenance1
 void marshal_VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT(
     VulkanStream* vkStream, VkStructureType rootType,
@@ -16256,78 +17110,6 @@
     }
 }
 
-void marshal_VkSubresourceLayout2EXT(VulkanStream* vkStream, VkStructureType rootType,
-                                     const VkSubresourceLayout2EXT* forMarshaling) {
-    (void)rootType;
-    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
-    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
-        rootType = forMarshaling->sType;
-    }
-    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
-    marshal_VkSubresourceLayout(vkStream, rootType,
-                                (VkSubresourceLayout*)(&forMarshaling->subresourceLayout));
-}
-
-void unmarshal_VkSubresourceLayout2EXT(VulkanStream* vkStream, VkStructureType rootType,
-                                       VkSubresourceLayout2EXT* forUnmarshaling) {
-    (void)rootType;
-    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
-    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
-        rootType = forUnmarshaling->sType;
-    }
-    size_t pNext_size;
-    pNext_size = vkStream->getBe32();
-    forUnmarshaling->pNext = nullptr;
-    if (pNext_size) {
-        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
-        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
-        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
-        vkStream->alloc((void**)&forUnmarshaling->pNext,
-                        goldfish_vk_extension_struct_size_with_stream_features(
-                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
-        *(VkStructureType*)forUnmarshaling->pNext = extType;
-        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
-    }
-    unmarshal_VkSubresourceLayout(vkStream, rootType,
-                                  (VkSubresourceLayout*)(&forUnmarshaling->subresourceLayout));
-}
-
-void marshal_VkImageSubresource2EXT(VulkanStream* vkStream, VkStructureType rootType,
-                                    const VkImageSubresource2EXT* forMarshaling) {
-    (void)rootType;
-    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
-    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
-        rootType = forMarshaling->sType;
-    }
-    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
-    marshal_VkImageSubresource(vkStream, rootType,
-                               (VkImageSubresource*)(&forMarshaling->imageSubresource));
-}
-
-void unmarshal_VkImageSubresource2EXT(VulkanStream* vkStream, VkStructureType rootType,
-                                      VkImageSubresource2EXT* forUnmarshaling) {
-    (void)rootType;
-    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
-    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
-        rootType = forUnmarshaling->sType;
-    }
-    size_t pNext_size;
-    pNext_size = vkStream->getBe32();
-    forUnmarshaling->pNext = nullptr;
-    if (pNext_size) {
-        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
-        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
-        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
-        vkStream->alloc((void**)&forUnmarshaling->pNext,
-                        goldfish_vk_extension_struct_size_with_stream_features(
-                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
-        *(VkStructureType*)forUnmarshaling->pNext = extType;
-        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
-    }
-    unmarshal_VkImageSubresource(vkStream, rootType,
-                                 (VkImageSubresource*)(&forUnmarshaling->imageSubresource));
-}
-
 void marshal_VkImageCompressionPropertiesEXT(VulkanStream* vkStream, VkStructureType rootType,
                                              const VkImageCompressionPropertiesEXT* forMarshaling) {
     (void)rootType;
@@ -17434,6 +18216,33 @@
             break;
         }
 #endif
+#ifdef VK_KHR_maintenance5
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_FEATURES_KHR: {
+            marshal_VkPhysicalDeviceMaintenance5FeaturesKHR(
+                vkStream, rootType,
+                reinterpret_cast<const VkPhysicalDeviceMaintenance5FeaturesKHR*>(structExtension));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_PROPERTIES_KHR: {
+            marshal_VkPhysicalDeviceMaintenance5PropertiesKHR(
+                vkStream, rootType,
+                reinterpret_cast<const VkPhysicalDeviceMaintenance5PropertiesKHR*>(
+                    structExtension));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PIPELINE_CREATE_FLAGS_2_CREATE_INFO_KHR: {
+            marshal_VkPipelineCreateFlags2CreateInfoKHR(
+                vkStream, rootType,
+                reinterpret_cast<const VkPipelineCreateFlags2CreateInfoKHR*>(structExtension));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_BUFFER_USAGE_FLAGS_2_CREATE_INFO_KHR: {
+            marshal_VkBufferUsageFlags2CreateInfoKHR(
+                vkStream, rootType,
+                reinterpret_cast<const VkBufferUsageFlags2CreateInfoKHR*>(structExtension));
+            break;
+        }
+#endif
 #ifdef VK_ANDROID_native_buffer
         case VK_STRUCTURE_TYPE_NATIVE_BUFFER_ANDROID: {
             marshal_VkNativeBufferANDROID(
@@ -17529,6 +18338,33 @@
             break;
         }
 #endif
+#ifdef VK_EXT_host_image_copy
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_FEATURES_EXT: {
+            marshal_VkPhysicalDeviceHostImageCopyFeaturesEXT(
+                vkStream, rootType,
+                reinterpret_cast<const VkPhysicalDeviceHostImageCopyFeaturesEXT*>(structExtension));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_PROPERTIES_EXT: {
+            marshal_VkPhysicalDeviceHostImageCopyPropertiesEXT(
+                vkStream, rootType,
+                reinterpret_cast<const VkPhysicalDeviceHostImageCopyPropertiesEXT*>(
+                    structExtension));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_SUBRESOURCE_HOST_MEMCPY_SIZE_EXT: {
+            marshal_VkSubresourceHostMemcpySizeEXT(
+                vkStream, rootType,
+                reinterpret_cast<const VkSubresourceHostMemcpySizeEXT*>(structExtension));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_HOST_IMAGE_COPY_DEVICE_PERFORMANCE_QUERY_EXT: {
+            marshal_VkHostImageCopyDevicePerformanceQueryEXT(
+                vkStream, rootType,
+                reinterpret_cast<const VkHostImageCopyDevicePerformanceQueryEXT*>(structExtension));
+            break;
+        }
+#endif
 #ifdef VK_EXT_swapchain_maintenance1
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SWAPCHAIN_MAINTENANCE_1_FEATURES_EXT: {
             marshal_VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT(
@@ -18497,6 +19333,32 @@
             break;
         }
 #endif
+#ifdef VK_KHR_maintenance5
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_FEATURES_KHR: {
+            unmarshal_VkPhysicalDeviceMaintenance5FeaturesKHR(
+                vkStream, rootType,
+                reinterpret_cast<VkPhysicalDeviceMaintenance5FeaturesKHR*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_PROPERTIES_KHR: {
+            unmarshal_VkPhysicalDeviceMaintenance5PropertiesKHR(
+                vkStream, rootType,
+                reinterpret_cast<VkPhysicalDeviceMaintenance5PropertiesKHR*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PIPELINE_CREATE_FLAGS_2_CREATE_INFO_KHR: {
+            unmarshal_VkPipelineCreateFlags2CreateInfoKHR(
+                vkStream, rootType,
+                reinterpret_cast<VkPipelineCreateFlags2CreateInfoKHR*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_BUFFER_USAGE_FLAGS_2_CREATE_INFO_KHR: {
+            unmarshal_VkBufferUsageFlags2CreateInfoKHR(
+                vkStream, rootType,
+                reinterpret_cast<VkBufferUsageFlags2CreateInfoKHR*>(structExtension_out));
+            break;
+        }
+#endif
 #ifdef VK_ANDROID_native_buffer
         case VK_STRUCTURE_TYPE_NATIVE_BUFFER_ANDROID: {
             unmarshal_VkNativeBufferANDROID(
@@ -18589,6 +19451,32 @@
             break;
         }
 #endif
+#ifdef VK_EXT_host_image_copy
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_FEATURES_EXT: {
+            unmarshal_VkPhysicalDeviceHostImageCopyFeaturesEXT(
+                vkStream, rootType,
+                reinterpret_cast<VkPhysicalDeviceHostImageCopyFeaturesEXT*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_PROPERTIES_EXT: {
+            unmarshal_VkPhysicalDeviceHostImageCopyPropertiesEXT(
+                vkStream, rootType,
+                reinterpret_cast<VkPhysicalDeviceHostImageCopyPropertiesEXT*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_SUBRESOURCE_HOST_MEMCPY_SIZE_EXT: {
+            unmarshal_VkSubresourceHostMemcpySizeEXT(
+                vkStream, rootType,
+                reinterpret_cast<VkSubresourceHostMemcpySizeEXT*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_HOST_IMAGE_COPY_DEVICE_PERFORMANCE_QUERY_EXT: {
+            unmarshal_VkHostImageCopyDevicePerformanceQueryEXT(
+                vkStream, rootType,
+                reinterpret_cast<VkHostImageCopyDevicePerformanceQueryEXT*>(structExtension_out));
+            break;
+        }
+#endif
 #ifdef VK_EXT_swapchain_maintenance1
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SWAPCHAIN_MAINTENANCE_1_FEATURES_EXT: {
             unmarshal_VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT(
@@ -19505,11 +20393,21 @@
             return "OP_vkGetDeviceBufferMemoryRequirementsKHR";
         }
 #endif
+#ifdef VK_KHR_maintenance5
+        case OP_vkCmdBindIndexBuffer2KHR: {
+            return "OP_vkCmdBindIndexBuffer2KHR";
+        }
+#endif
 #ifdef VK_EXT_extended_dynamic_state
         case OP_vkCmdSetScissorWithCountEXT: {
             return "OP_vkCmdSetScissorWithCountEXT";
         }
 #endif
+#ifdef VK_EXT_host_image_copy
+        case OP_vkCopyImageToMemoryEXT: {
+            return "OP_vkCopyImageToMemoryEXT";
+        }
+#endif
 #ifdef VK_EXT_extended_dynamic_state2
         case OP_vkCmdSetPatchControlPointsEXT: {
             return "OP_vkCmdSetPatchControlPointsEXT";
@@ -19545,6 +20443,11 @@
             return "OP_vkCmdSetDepthWriteEnableEXT";
         }
 #endif
+#ifdef VK_EXT_host_image_copy
+        case OP_vkCopyMemoryToImageEXT: {
+            return "OP_vkCopyMemoryToImageEXT";
+        }
+#endif
 #ifdef VK_KHR_buffer_device_address
         case OP_vkGetBufferDeviceAddressKHR: {
             return "OP_vkGetBufferDeviceAddressKHR";
@@ -19579,6 +20482,11 @@
             return "OP_vkCmdSetDepthBoundsTestEnableEXT";
         }
 #endif
+#ifdef VK_EXT_host_image_copy
+        case OP_vkCopyImageToImageEXT: {
+            return "OP_vkCopyImageToImageEXT";
+        }
+#endif
 #ifdef VK_VERSION_1_3
         case OP_vkDestroyPrivateDataSlot: {
             return "OP_vkDestroyPrivateDataSlot";
@@ -19657,6 +20565,13 @@
         case OP_vkGetPrivateData: {
             return "OP_vkGetPrivateData";
         }
+#endif
+#ifdef VK_KHR_maintenance5
+        case OP_vkGetRenderingAreaGranularityKHR: {
+            return "OP_vkGetRenderingAreaGranularityKHR";
+        }
+#endif
+#ifdef VK_VERSION_1_3
         case OP_vkCmdSetDepthWriteEnable: {
             return "OP_vkCmdSetDepthWriteEnable";
         }
@@ -19664,11 +20579,21 @@
             return "OP_vkSetPrivateData";
         }
 #endif
+#ifdef VK_EXT_host_image_copy
+        case OP_vkTransitionImageLayoutEXT: {
+            return "OP_vkTransitionImageLayoutEXT";
+        }
+#endif
 #ifdef VK_KHR_maintenance4
         case OP_vkGetDeviceImageMemoryRequirementsKHR: {
             return "OP_vkGetDeviceImageMemoryRequirementsKHR";
         }
 #endif
+#ifdef VK_KHR_maintenance5
+        case OP_vkGetImageSubresourceLayout2KHR: {
+            return "OP_vkGetImageSubresourceLayout2KHR";
+        }
+#endif
 #ifdef VK_EXT_extended_dynamic_state
         case OP_vkCmdBindVertexBuffers2EXT: {
             return "OP_vkCmdBindVertexBuffers2EXT";
@@ -19748,6 +20673,11 @@
             return "OP_vkCmdWriteTimestamp2KHR";
         }
 #endif
+#ifdef VK_KHR_maintenance5
+        case OP_vkGetDeviceImageSubresourceLayoutKHR: {
+            return "OP_vkGetDeviceImageSubresourceLayoutKHR";
+        }
+#endif
 #ifdef VK_KHR_copy_commands2
         case OP_vkCmdResolveImage2KHR: {
             return "OP_vkCmdResolveImage2KHR";
@@ -20008,7 +20938,7 @@
             return "OP_vkGetDeviceMemoryOpaqueCaptureAddressKHR";
         }
 #endif
-#ifdef VK_EXT_image_compression_control
+#ifdef VK_EXT_host_image_copy
         case OP_vkGetImageSubresourceLayout2EXT: {
             return "OP_vkGetImageSubresourceLayout2EXT";
         }
diff --git a/host/vulkan/cereal/common/goldfish_vk_marshaling.h b/host/vulkan/cereal/common/goldfish_vk_marshaling.h
index 15565a6..1518799 100644
--- a/host/vulkan/cereal/common/goldfish_vk_marshaling.h
+++ b/host/vulkan/cereal/common/goldfish_vk_marshaling.h
@@ -15,9 +15,9 @@
 
 // Autogenerated module goldfish_vk_marshaling
 //
-// (header) generated by codegen/vulkan/vulkan-docs/scripts/genvk.py -registry
-// codegen/vulkan/vulkan-docs/xml/vk.xml -registryGfxstream
-// codegen/vulkan/vulkan-docs/xml/vk_gfxstream.xml cereal -o host/vulkan/cereal
+// (header) generated by codegen/vulkan/vulkan-docs-next/scripts/genvk.py -registry
+// codegen/vulkan/vulkan-docs-next/xml/vk.xml -registryGfxstream
+// codegen/vulkan/vulkan-docs-next/xml/vk_gfxstream.xml cereal -o host/vulkan/cereal
 //
 // Please do not modify directly;
 // re-run gfxstream-protocols/scripts/generate-vulkan-sources.sh,
@@ -35,7 +35,7 @@
 #include "VulkanStream.h"
 #include "aemu/base/files/StreamSerializing.h"
 #include "goldfish_vk_private_defs.h"
-#include "vk_android_native_buffer.h"
+#include "vk_android_native_buffer_gfxstream.h"
 #include "vulkan_gfxstream.h"
 
 namespace gfxstream {
@@ -3034,6 +3034,67 @@
 #define OP_vkGetDeviceImageMemoryRequirementsKHR 243155021
 #define OP_vkGetDeviceImageSparseMemoryRequirementsKHR 275585477
 #endif
+#ifdef VK_KHR_maintenance5
+void marshal_VkPhysicalDeviceMaintenance5FeaturesKHR(
+    VulkanStream* vkStream, VkStructureType rootType,
+    const VkPhysicalDeviceMaintenance5FeaturesKHR* forMarshaling);
+
+void unmarshal_VkPhysicalDeviceMaintenance5FeaturesKHR(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPhysicalDeviceMaintenance5FeaturesKHR* forUnmarshaling);
+
+void marshal_VkPhysicalDeviceMaintenance5PropertiesKHR(
+    VulkanStream* vkStream, VkStructureType rootType,
+    const VkPhysicalDeviceMaintenance5PropertiesKHR* forMarshaling);
+
+void unmarshal_VkPhysicalDeviceMaintenance5PropertiesKHR(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPhysicalDeviceMaintenance5PropertiesKHR* forUnmarshaling);
+
+void marshal_VkRenderingAreaInfoKHR(VulkanStream* vkStream, VkStructureType rootType,
+                                    const VkRenderingAreaInfoKHR* forMarshaling);
+
+void unmarshal_VkRenderingAreaInfoKHR(VulkanStream* vkStream, VkStructureType rootType,
+                                      VkRenderingAreaInfoKHR* forUnmarshaling);
+
+void marshal_VkImageSubresource2KHR(VulkanStream* vkStream, VkStructureType rootType,
+                                    const VkImageSubresource2KHR* forMarshaling);
+
+void unmarshal_VkImageSubresource2KHR(VulkanStream* vkStream, VkStructureType rootType,
+                                      VkImageSubresource2KHR* forUnmarshaling);
+
+void marshal_VkDeviceImageSubresourceInfoKHR(VulkanStream* vkStream, VkStructureType rootType,
+                                             const VkDeviceImageSubresourceInfoKHR* forMarshaling);
+
+void unmarshal_VkDeviceImageSubresourceInfoKHR(VulkanStream* vkStream, VkStructureType rootType,
+                                               VkDeviceImageSubresourceInfoKHR* forUnmarshaling);
+
+void marshal_VkSubresourceLayout2KHR(VulkanStream* vkStream, VkStructureType rootType,
+                                     const VkSubresourceLayout2KHR* forMarshaling);
+
+void unmarshal_VkSubresourceLayout2KHR(VulkanStream* vkStream, VkStructureType rootType,
+                                       VkSubresourceLayout2KHR* forUnmarshaling);
+
+#define OP_vkCmdBindIndexBuffer2KHR 202856085
+#define OP_vkGetRenderingAreaGranularityKHR 238658496
+#define OP_vkGetDeviceImageSubresourceLayoutKHR 252830318
+#define OP_vkGetImageSubresourceLayout2KHR 243334937
+void marshal_VkPipelineCreateFlags2CreateInfoKHR(
+    VulkanStream* vkStream, VkStructureType rootType,
+    const VkPipelineCreateFlags2CreateInfoKHR* forMarshaling);
+
+void unmarshal_VkPipelineCreateFlags2CreateInfoKHR(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPipelineCreateFlags2CreateInfoKHR* forUnmarshaling);
+
+void marshal_VkBufferUsageFlags2CreateInfoKHR(
+    VulkanStream* vkStream, VkStructureType rootType,
+    const VkBufferUsageFlags2CreateInfoKHR* forMarshaling);
+
+void unmarshal_VkBufferUsageFlags2CreateInfoKHR(VulkanStream* vkStream, VkStructureType rootType,
+                                                VkBufferUsageFlags2CreateInfoKHR* forUnmarshaling);
+
+#endif
 #ifdef VK_ANDROID_native_buffer
 void marshal_VkNativeBufferUsage2ANDROID(VulkanStream* vkStream, VkStructureType rootType,
                                          const VkNativeBufferUsage2ANDROID* forMarshaling);
@@ -3276,6 +3337,89 @@
 #define OP_vkCmdSetStencilTestEnableEXT 286438749
 #define OP_vkCmdSetStencilOpEXT 277159578
 #endif
+#ifdef VK_EXT_host_image_copy
+void marshal_VkPhysicalDeviceHostImageCopyFeaturesEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    const VkPhysicalDeviceHostImageCopyFeaturesEXT* forMarshaling);
+
+void unmarshal_VkPhysicalDeviceHostImageCopyFeaturesEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPhysicalDeviceHostImageCopyFeaturesEXT* forUnmarshaling);
+
+void marshal_VkPhysicalDeviceHostImageCopyPropertiesEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    const VkPhysicalDeviceHostImageCopyPropertiesEXT* forMarshaling);
+
+void unmarshal_VkPhysicalDeviceHostImageCopyPropertiesEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPhysicalDeviceHostImageCopyPropertiesEXT* forUnmarshaling);
+
+void marshal_VkMemoryToImageCopyEXT(VulkanStream* vkStream, VkStructureType rootType,
+                                    const VkMemoryToImageCopyEXT* forMarshaling);
+
+void unmarshal_VkMemoryToImageCopyEXT(VulkanStream* vkStream, VkStructureType rootType,
+                                      VkMemoryToImageCopyEXT* forUnmarshaling);
+
+void marshal_VkImageToMemoryCopyEXT(VulkanStream* vkStream, VkStructureType rootType,
+                                    const VkImageToMemoryCopyEXT* forMarshaling);
+
+void unmarshal_VkImageToMemoryCopyEXT(VulkanStream* vkStream, VkStructureType rootType,
+                                      VkImageToMemoryCopyEXT* forUnmarshaling);
+
+void marshal_VkCopyMemoryToImageInfoEXT(VulkanStream* vkStream, VkStructureType rootType,
+                                        const VkCopyMemoryToImageInfoEXT* forMarshaling);
+
+void unmarshal_VkCopyMemoryToImageInfoEXT(VulkanStream* vkStream, VkStructureType rootType,
+                                          VkCopyMemoryToImageInfoEXT* forUnmarshaling);
+
+void marshal_VkCopyImageToMemoryInfoEXT(VulkanStream* vkStream, VkStructureType rootType,
+                                        const VkCopyImageToMemoryInfoEXT* forMarshaling);
+
+void unmarshal_VkCopyImageToMemoryInfoEXT(VulkanStream* vkStream, VkStructureType rootType,
+                                          VkCopyImageToMemoryInfoEXT* forUnmarshaling);
+
+void marshal_VkCopyImageToImageInfoEXT(VulkanStream* vkStream, VkStructureType rootType,
+                                       const VkCopyImageToImageInfoEXT* forMarshaling);
+
+void unmarshal_VkCopyImageToImageInfoEXT(VulkanStream* vkStream, VkStructureType rootType,
+                                         VkCopyImageToImageInfoEXT* forUnmarshaling);
+
+void marshal_VkHostImageLayoutTransitionInfoEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    const VkHostImageLayoutTransitionInfoEXT* forMarshaling);
+
+void unmarshal_VkHostImageLayoutTransitionInfoEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkHostImageLayoutTransitionInfoEXT* forUnmarshaling);
+
+void marshal_VkSubresourceHostMemcpySizeEXT(VulkanStream* vkStream, VkStructureType rootType,
+                                            const VkSubresourceHostMemcpySizeEXT* forMarshaling);
+
+void unmarshal_VkSubresourceHostMemcpySizeEXT(VulkanStream* vkStream, VkStructureType rootType,
+                                              VkSubresourceHostMemcpySizeEXT* forUnmarshaling);
+
+void marshal_VkHostImageCopyDevicePerformanceQueryEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    const VkHostImageCopyDevicePerformanceQueryEXT* forMarshaling);
+
+void unmarshal_VkHostImageCopyDevicePerformanceQueryEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkHostImageCopyDevicePerformanceQueryEXT* forUnmarshaling);
+
+DEFINE_ALIAS_FUNCTION(marshal_VkSubresourceLayout2KHR, marshal_VkSubresourceLayout2EXT)
+
+DEFINE_ALIAS_FUNCTION(unmarshal_VkSubresourceLayout2KHR, unmarshal_VkSubresourceLayout2EXT)
+
+DEFINE_ALIAS_FUNCTION(marshal_VkImageSubresource2KHR, marshal_VkImageSubresource2EXT)
+
+DEFINE_ALIAS_FUNCTION(unmarshal_VkImageSubresource2KHR, unmarshal_VkImageSubresource2EXT)
+
+#define OP_vkCopyMemoryToImageEXT 218832495
+#define OP_vkCopyImageToMemoryEXT 204695490
+#define OP_vkCopyImageToImageEXT 223534798
+#define OP_vkTransitionImageLayoutEXT 242817558
+#define OP_vkGetImageSubresourceLayout2EXT 296152177
+#endif
 #ifdef VK_EXT_swapchain_maintenance1
 void marshal_VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT(
     VulkanStream* vkStream, VkStructureType rootType,
@@ -3487,25 +3631,12 @@
 void unmarshal_VkImageCompressionControlEXT(VulkanStream* vkStream, VkStructureType rootType,
                                             VkImageCompressionControlEXT* forUnmarshaling);
 
-void marshal_VkSubresourceLayout2EXT(VulkanStream* vkStream, VkStructureType rootType,
-                                     const VkSubresourceLayout2EXT* forMarshaling);
-
-void unmarshal_VkSubresourceLayout2EXT(VulkanStream* vkStream, VkStructureType rootType,
-                                       VkSubresourceLayout2EXT* forUnmarshaling);
-
-void marshal_VkImageSubresource2EXT(VulkanStream* vkStream, VkStructureType rootType,
-                                    const VkImageSubresource2EXT* forMarshaling);
-
-void unmarshal_VkImageSubresource2EXT(VulkanStream* vkStream, VkStructureType rootType,
-                                      VkImageSubresource2EXT* forUnmarshaling);
-
 void marshal_VkImageCompressionPropertiesEXT(VulkanStream* vkStream, VkStructureType rootType,
                                              const VkImageCompressionPropertiesEXT* forMarshaling);
 
 void unmarshal_VkImageCompressionPropertiesEXT(VulkanStream* vkStream, VkStructureType rootType,
                                                VkImageCompressionPropertiesEXT* forUnmarshaling);
 
-#define OP_vkGetImageSubresourceLayout2EXT 296152177
 #endif
 #ifdef VK_EXT_4444_formats
 void marshal_VkPhysicalDevice4444FormatsFeaturesEXT(
diff --git a/host/vulkan/cereal/common/goldfish_vk_reserved_marshaling.cpp b/host/vulkan/cereal/common/goldfish_vk_reserved_marshaling.cpp
index ae252b6..d98dfa7 100644
--- a/host/vulkan/cereal/common/goldfish_vk_reserved_marshaling.cpp
+++ b/host/vulkan/cereal/common/goldfish_vk_reserved_marshaling.cpp
@@ -15,9 +15,9 @@
 
 // Autogenerated module goldfish_vk_reserved_marshaling
 //
-// (impl) generated by codegen/vulkan/vulkan-docs/scripts/genvk.py -registry
-// codegen/vulkan/vulkan-docs/xml/vk.xml -registryGfxstream
-// codegen/vulkan/vulkan-docs/xml/vk_gfxstream.xml cereal -o host/vulkan/cereal
+// (impl) generated by codegen/vulkan/vulkan-docs-next/scripts/genvk.py -registry
+// codegen/vulkan/vulkan-docs-next/xml/vk.xml -registryGfxstream
+// codegen/vulkan/vulkan-docs-next/xml/vk_gfxstream.xml cereal -o host/vulkan/cereal
 //
 // Please do not modify directly;
 // re-run gfxstream-protocols/scripts/generate-vulkan-sources.sh,
@@ -11402,6 +11402,275 @@
 #endif
 #ifdef VK_KHR_maintenance4
 #endif
+#ifdef VK_KHR_maintenance5
+void reservedunmarshal_VkPhysicalDeviceMaintenance5FeaturesKHR(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPhysicalDeviceMaintenance5FeaturesKHR* forUnmarshaling, uint8_t** ptr) {
+    memcpy((VkStructureType*)&forUnmarshaling->sType, *ptr, sizeof(VkStructureType));
+    *ptr += sizeof(VkStructureType);
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    uint32_t pNext_size;
+    memcpy((uint32_t*)&pNext_size, *ptr, sizeof(uint32_t));
+    android::base::Stream::fromBe32((uint8_t*)&pNext_size);
+    *ptr += sizeof(uint32_t);
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        memcpy((void*)forUnmarshaling->pNext, *ptr, sizeof(VkStructureType));
+        *ptr += sizeof(VkStructureType);
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        reservedunmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext),
+                                           ptr);
+    }
+    memcpy((VkBool32*)&forUnmarshaling->maintenance5, *ptr, sizeof(VkBool32));
+    *ptr += sizeof(VkBool32);
+}
+
+void reservedunmarshal_VkPhysicalDeviceMaintenance5PropertiesKHR(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPhysicalDeviceMaintenance5PropertiesKHR* forUnmarshaling, uint8_t** ptr) {
+    memcpy((VkStructureType*)&forUnmarshaling->sType, *ptr, sizeof(VkStructureType));
+    *ptr += sizeof(VkStructureType);
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    uint32_t pNext_size;
+    memcpy((uint32_t*)&pNext_size, *ptr, sizeof(uint32_t));
+    android::base::Stream::fromBe32((uint8_t*)&pNext_size);
+    *ptr += sizeof(uint32_t);
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        memcpy((void*)forUnmarshaling->pNext, *ptr, sizeof(VkStructureType));
+        *ptr += sizeof(VkStructureType);
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        reservedunmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext),
+                                           ptr);
+    }
+    memcpy((VkBool32*)&forUnmarshaling->earlyFragmentMultisampleCoverageAfterSampleCounting, *ptr,
+           sizeof(VkBool32));
+    *ptr += sizeof(VkBool32);
+    memcpy((VkBool32*)&forUnmarshaling->earlyFragmentSampleMaskTestBeforeSampleCounting, *ptr,
+           sizeof(VkBool32));
+    *ptr += sizeof(VkBool32);
+    memcpy((VkBool32*)&forUnmarshaling->depthStencilSwizzleOneSupport, *ptr, sizeof(VkBool32));
+    *ptr += sizeof(VkBool32);
+    memcpy((VkBool32*)&forUnmarshaling->polygonModePointSize, *ptr, sizeof(VkBool32));
+    *ptr += sizeof(VkBool32);
+    memcpy((VkBool32*)&forUnmarshaling->nonStrictSinglePixelWideLinesUseParallelogram, *ptr,
+           sizeof(VkBool32));
+    *ptr += sizeof(VkBool32);
+    memcpy((VkBool32*)&forUnmarshaling->nonStrictWideLinesUseParallelogram, *ptr, sizeof(VkBool32));
+    *ptr += sizeof(VkBool32);
+}
+
+void reservedunmarshal_VkRenderingAreaInfoKHR(VulkanStream* vkStream, VkStructureType rootType,
+                                              VkRenderingAreaInfoKHR* forUnmarshaling,
+                                              uint8_t** ptr) {
+    memcpy((VkStructureType*)&forUnmarshaling->sType, *ptr, sizeof(VkStructureType));
+    *ptr += sizeof(VkStructureType);
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    uint32_t pNext_size;
+    memcpy((uint32_t*)&pNext_size, *ptr, sizeof(uint32_t));
+    android::base::Stream::fromBe32((uint8_t*)&pNext_size);
+    *ptr += sizeof(uint32_t);
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        memcpy((void*)forUnmarshaling->pNext, *ptr, sizeof(VkStructureType));
+        *ptr += sizeof(VkStructureType);
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        reservedunmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext),
+                                           ptr);
+    }
+    memcpy((uint32_t*)&forUnmarshaling->viewMask, *ptr, sizeof(uint32_t));
+    *ptr += sizeof(uint32_t);
+    memcpy((uint32_t*)&forUnmarshaling->colorAttachmentCount, *ptr, sizeof(uint32_t));
+    *ptr += sizeof(uint32_t);
+    // WARNING PTR CHECK
+    memcpy((VkFormat**)&forUnmarshaling->pColorAttachmentFormats, (*ptr), 8);
+    android::base::Stream::fromBe64((uint8_t*)&forUnmarshaling->pColorAttachmentFormats);
+    *ptr += 8;
+    if (forUnmarshaling->pColorAttachmentFormats) {
+        vkStream->alloc((void**)&forUnmarshaling->pColorAttachmentFormats,
+                        forUnmarshaling->colorAttachmentCount * sizeof(const VkFormat));
+        memcpy((VkFormat*)forUnmarshaling->pColorAttachmentFormats, *ptr,
+               forUnmarshaling->colorAttachmentCount * sizeof(const VkFormat));
+        *ptr += forUnmarshaling->colorAttachmentCount * sizeof(const VkFormat);
+    }
+    memcpy((VkFormat*)&forUnmarshaling->depthAttachmentFormat, *ptr, sizeof(VkFormat));
+    *ptr += sizeof(VkFormat);
+    memcpy((VkFormat*)&forUnmarshaling->stencilAttachmentFormat, *ptr, sizeof(VkFormat));
+    *ptr += sizeof(VkFormat);
+}
+
+void reservedunmarshal_VkImageSubresource2KHR(VulkanStream* vkStream, VkStructureType rootType,
+                                              VkImageSubresource2KHR* forUnmarshaling,
+                                              uint8_t** ptr) {
+    memcpy((VkStructureType*)&forUnmarshaling->sType, *ptr, sizeof(VkStructureType));
+    *ptr += sizeof(VkStructureType);
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    uint32_t pNext_size;
+    memcpy((uint32_t*)&pNext_size, *ptr, sizeof(uint32_t));
+    android::base::Stream::fromBe32((uint8_t*)&pNext_size);
+    *ptr += sizeof(uint32_t);
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        memcpy((void*)forUnmarshaling->pNext, *ptr, sizeof(VkStructureType));
+        *ptr += sizeof(VkStructureType);
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        reservedunmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext),
+                                           ptr);
+    }
+    reservedunmarshal_VkImageSubresource(
+        vkStream, rootType, (VkImageSubresource*)(&forUnmarshaling->imageSubresource), ptr);
+}
+
+void reservedunmarshal_VkDeviceImageSubresourceInfoKHR(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkDeviceImageSubresourceInfoKHR* forUnmarshaling, uint8_t** ptr) {
+    memcpy((VkStructureType*)&forUnmarshaling->sType, *ptr, sizeof(VkStructureType));
+    *ptr += sizeof(VkStructureType);
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    uint32_t pNext_size;
+    memcpy((uint32_t*)&pNext_size, *ptr, sizeof(uint32_t));
+    android::base::Stream::fromBe32((uint8_t*)&pNext_size);
+    *ptr += sizeof(uint32_t);
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        memcpy((void*)forUnmarshaling->pNext, *ptr, sizeof(VkStructureType));
+        *ptr += sizeof(VkStructureType);
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        reservedunmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext),
+                                           ptr);
+    }
+    vkStream->alloc((void**)&forUnmarshaling->pCreateInfo, sizeof(const VkImageCreateInfo));
+    reservedunmarshal_VkImageCreateInfo(vkStream, rootType,
+                                        (VkImageCreateInfo*)(forUnmarshaling->pCreateInfo), ptr);
+    vkStream->alloc((void**)&forUnmarshaling->pSubresource, sizeof(const VkImageSubresource2KHR));
+    reservedunmarshal_VkImageSubresource2KHR(
+        vkStream, rootType, (VkImageSubresource2KHR*)(forUnmarshaling->pSubresource), ptr);
+}
+
+void reservedunmarshal_VkSubresourceLayout2KHR(VulkanStream* vkStream, VkStructureType rootType,
+                                               VkSubresourceLayout2KHR* forUnmarshaling,
+                                               uint8_t** ptr) {
+    memcpy((VkStructureType*)&forUnmarshaling->sType, *ptr, sizeof(VkStructureType));
+    *ptr += sizeof(VkStructureType);
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    uint32_t pNext_size;
+    memcpy((uint32_t*)&pNext_size, *ptr, sizeof(uint32_t));
+    android::base::Stream::fromBe32((uint8_t*)&pNext_size);
+    *ptr += sizeof(uint32_t);
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        memcpy((void*)forUnmarshaling->pNext, *ptr, sizeof(VkStructureType));
+        *ptr += sizeof(VkStructureType);
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        reservedunmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext),
+                                           ptr);
+    }
+    reservedunmarshal_VkSubresourceLayout(
+        vkStream, rootType, (VkSubresourceLayout*)(&forUnmarshaling->subresourceLayout), ptr);
+}
+
+void reservedunmarshal_VkPipelineCreateFlags2CreateInfoKHR(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPipelineCreateFlags2CreateInfoKHR* forUnmarshaling, uint8_t** ptr) {
+    memcpy((VkStructureType*)&forUnmarshaling->sType, *ptr, sizeof(VkStructureType));
+    *ptr += sizeof(VkStructureType);
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    uint32_t pNext_size;
+    memcpy((uint32_t*)&pNext_size, *ptr, sizeof(uint32_t));
+    android::base::Stream::fromBe32((uint8_t*)&pNext_size);
+    *ptr += sizeof(uint32_t);
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        memcpy((void*)forUnmarshaling->pNext, *ptr, sizeof(VkStructureType));
+        *ptr += sizeof(VkStructureType);
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        reservedunmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext),
+                                           ptr);
+    }
+    memcpy((VkPipelineCreateFlags2KHR*)&forUnmarshaling->flags, *ptr,
+           sizeof(VkPipelineCreateFlags2KHR));
+    *ptr += sizeof(VkPipelineCreateFlags2KHR);
+}
+
+void reservedunmarshal_VkBufferUsageFlags2CreateInfoKHR(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkBufferUsageFlags2CreateInfoKHR* forUnmarshaling, uint8_t** ptr) {
+    memcpy((VkStructureType*)&forUnmarshaling->sType, *ptr, sizeof(VkStructureType));
+    *ptr += sizeof(VkStructureType);
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    uint32_t pNext_size;
+    memcpy((uint32_t*)&pNext_size, *ptr, sizeof(uint32_t));
+    android::base::Stream::fromBe32((uint8_t*)&pNext_size);
+    *ptr += sizeof(uint32_t);
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        memcpy((void*)forUnmarshaling->pNext, *ptr, sizeof(VkStructureType));
+        *ptr += sizeof(VkStructureType);
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        reservedunmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext),
+                                           ptr);
+    }
+    memcpy((VkBufferUsageFlags2KHR*)&forUnmarshaling->usage, *ptr, sizeof(VkBufferUsageFlags2KHR));
+    *ptr += sizeof(VkBufferUsageFlags2KHR);
+}
+
+#endif
 #ifdef VK_ANDROID_native_buffer
 void reservedunmarshal_VkNativeBufferUsage2ANDROID(VulkanStream* vkStream, VkStructureType rootType,
                                                    VkNativeBufferUsage2ANDROID* forUnmarshaling,
@@ -11922,6 +12191,410 @@
 }
 
 #endif
+#ifdef VK_EXT_host_image_copy
+void reservedunmarshal_VkPhysicalDeviceHostImageCopyFeaturesEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPhysicalDeviceHostImageCopyFeaturesEXT* forUnmarshaling, uint8_t** ptr) {
+    memcpy((VkStructureType*)&forUnmarshaling->sType, *ptr, sizeof(VkStructureType));
+    *ptr += sizeof(VkStructureType);
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    uint32_t pNext_size;
+    memcpy((uint32_t*)&pNext_size, *ptr, sizeof(uint32_t));
+    android::base::Stream::fromBe32((uint8_t*)&pNext_size);
+    *ptr += sizeof(uint32_t);
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        memcpy((void*)forUnmarshaling->pNext, *ptr, sizeof(VkStructureType));
+        *ptr += sizeof(VkStructureType);
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        reservedunmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext),
+                                           ptr);
+    }
+    memcpy((VkBool32*)&forUnmarshaling->hostImageCopy, *ptr, sizeof(VkBool32));
+    *ptr += sizeof(VkBool32);
+}
+
+void reservedunmarshal_VkPhysicalDeviceHostImageCopyPropertiesEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPhysicalDeviceHostImageCopyPropertiesEXT* forUnmarshaling, uint8_t** ptr) {
+    memcpy((VkStructureType*)&forUnmarshaling->sType, *ptr, sizeof(VkStructureType));
+    *ptr += sizeof(VkStructureType);
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    uint32_t pNext_size;
+    memcpy((uint32_t*)&pNext_size, *ptr, sizeof(uint32_t));
+    android::base::Stream::fromBe32((uint8_t*)&pNext_size);
+    *ptr += sizeof(uint32_t);
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        memcpy((void*)forUnmarshaling->pNext, *ptr, sizeof(VkStructureType));
+        *ptr += sizeof(VkStructureType);
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        reservedunmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext),
+                                           ptr);
+    }
+    memcpy((uint32_t*)&forUnmarshaling->copySrcLayoutCount, *ptr, sizeof(uint32_t));
+    *ptr += sizeof(uint32_t);
+    // WARNING PTR CHECK
+    memcpy((VkImageLayout**)&forUnmarshaling->pCopySrcLayouts, (*ptr), 8);
+    android::base::Stream::fromBe64((uint8_t*)&forUnmarshaling->pCopySrcLayouts);
+    *ptr += 8;
+    if (forUnmarshaling->pCopySrcLayouts) {
+        vkStream->alloc((void**)&forUnmarshaling->pCopySrcLayouts,
+                        forUnmarshaling->copySrcLayoutCount * sizeof(VkImageLayout));
+        memcpy((VkImageLayout*)forUnmarshaling->pCopySrcLayouts, *ptr,
+               forUnmarshaling->copySrcLayoutCount * sizeof(VkImageLayout));
+        *ptr += forUnmarshaling->copySrcLayoutCount * sizeof(VkImageLayout);
+    }
+    memcpy((uint32_t*)&forUnmarshaling->copyDstLayoutCount, *ptr, sizeof(uint32_t));
+    *ptr += sizeof(uint32_t);
+    // WARNING PTR CHECK
+    memcpy((VkImageLayout**)&forUnmarshaling->pCopyDstLayouts, (*ptr), 8);
+    android::base::Stream::fromBe64((uint8_t*)&forUnmarshaling->pCopyDstLayouts);
+    *ptr += 8;
+    if (forUnmarshaling->pCopyDstLayouts) {
+        vkStream->alloc((void**)&forUnmarshaling->pCopyDstLayouts,
+                        forUnmarshaling->copyDstLayoutCount * sizeof(VkImageLayout));
+        memcpy((VkImageLayout*)forUnmarshaling->pCopyDstLayouts, *ptr,
+               forUnmarshaling->copyDstLayoutCount * sizeof(VkImageLayout));
+        *ptr += forUnmarshaling->copyDstLayoutCount * sizeof(VkImageLayout);
+    }
+    memcpy((uint8_t*)forUnmarshaling->optimalTilingLayoutUUID, *ptr,
+           VK_UUID_SIZE * sizeof(uint8_t));
+    *ptr += VK_UUID_SIZE * sizeof(uint8_t);
+    memcpy((VkBool32*)&forUnmarshaling->identicalMemoryTypeRequirements, *ptr, sizeof(VkBool32));
+    *ptr += sizeof(VkBool32);
+}
+
+void reservedunmarshal_VkMemoryToImageCopyEXT(VulkanStream* vkStream, VkStructureType rootType,
+                                              VkMemoryToImageCopyEXT* forUnmarshaling,
+                                              uint8_t** ptr) {
+    memcpy((VkStructureType*)&forUnmarshaling->sType, *ptr, sizeof(VkStructureType));
+    *ptr += sizeof(VkStructureType);
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    uint32_t pNext_size;
+    memcpy((uint32_t*)&pNext_size, *ptr, sizeof(uint32_t));
+    android::base::Stream::fromBe32((uint8_t*)&pNext_size);
+    *ptr += sizeof(uint32_t);
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        memcpy((void*)forUnmarshaling->pNext, *ptr, sizeof(VkStructureType));
+        *ptr += sizeof(VkStructureType);
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        reservedunmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext),
+                                           ptr);
+    }
+    vkStream->alloc((void**)&forUnmarshaling->pHostPointer, sizeof(const uint8_t));
+    memcpy((void*)forUnmarshaling->pHostPointer, *ptr, sizeof(const uint8_t));
+    *ptr += sizeof(const uint8_t);
+    memcpy((uint32_t*)&forUnmarshaling->memoryRowLength, *ptr, sizeof(uint32_t));
+    *ptr += sizeof(uint32_t);
+    memcpy((uint32_t*)&forUnmarshaling->memoryImageHeight, *ptr, sizeof(uint32_t));
+    *ptr += sizeof(uint32_t);
+    reservedunmarshal_VkImageSubresourceLayers(
+        vkStream, rootType, (VkImageSubresourceLayers*)(&forUnmarshaling->imageSubresource), ptr);
+    reservedunmarshal_VkOffset3D(vkStream, rootType, (VkOffset3D*)(&forUnmarshaling->imageOffset),
+                                 ptr);
+    reservedunmarshal_VkExtent3D(vkStream, rootType, (VkExtent3D*)(&forUnmarshaling->imageExtent),
+                                 ptr);
+}
+
+void reservedunmarshal_VkImageToMemoryCopyEXT(VulkanStream* vkStream, VkStructureType rootType,
+                                              VkImageToMemoryCopyEXT* forUnmarshaling,
+                                              uint8_t** ptr) {
+    memcpy((VkStructureType*)&forUnmarshaling->sType, *ptr, sizeof(VkStructureType));
+    *ptr += sizeof(VkStructureType);
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    uint32_t pNext_size;
+    memcpy((uint32_t*)&pNext_size, *ptr, sizeof(uint32_t));
+    android::base::Stream::fromBe32((uint8_t*)&pNext_size);
+    *ptr += sizeof(uint32_t);
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        memcpy((void*)forUnmarshaling->pNext, *ptr, sizeof(VkStructureType));
+        *ptr += sizeof(VkStructureType);
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        reservedunmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext),
+                                           ptr);
+    }
+    vkStream->alloc((void**)&forUnmarshaling->pHostPointer, sizeof(uint8_t));
+    memcpy((void*)forUnmarshaling->pHostPointer, *ptr, sizeof(uint8_t));
+    *ptr += sizeof(uint8_t);
+    memcpy((uint32_t*)&forUnmarshaling->memoryRowLength, *ptr, sizeof(uint32_t));
+    *ptr += sizeof(uint32_t);
+    memcpy((uint32_t*)&forUnmarshaling->memoryImageHeight, *ptr, sizeof(uint32_t));
+    *ptr += sizeof(uint32_t);
+    reservedunmarshal_VkImageSubresourceLayers(
+        vkStream, rootType, (VkImageSubresourceLayers*)(&forUnmarshaling->imageSubresource), ptr);
+    reservedunmarshal_VkOffset3D(vkStream, rootType, (VkOffset3D*)(&forUnmarshaling->imageOffset),
+                                 ptr);
+    reservedunmarshal_VkExtent3D(vkStream, rootType, (VkExtent3D*)(&forUnmarshaling->imageExtent),
+                                 ptr);
+}
+
+void reservedunmarshal_VkCopyMemoryToImageInfoEXT(VulkanStream* vkStream, VkStructureType rootType,
+                                                  VkCopyMemoryToImageInfoEXT* forUnmarshaling,
+                                                  uint8_t** ptr) {
+    memcpy((VkStructureType*)&forUnmarshaling->sType, *ptr, sizeof(VkStructureType));
+    *ptr += sizeof(VkStructureType);
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    uint32_t pNext_size;
+    memcpy((uint32_t*)&pNext_size, *ptr, sizeof(uint32_t));
+    android::base::Stream::fromBe32((uint8_t*)&pNext_size);
+    *ptr += sizeof(uint32_t);
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        memcpy((void*)forUnmarshaling->pNext, *ptr, sizeof(VkStructureType));
+        *ptr += sizeof(VkStructureType);
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        reservedunmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext),
+                                           ptr);
+    }
+    memcpy((VkHostImageCopyFlagsEXT*)&forUnmarshaling->flags, *ptr,
+           sizeof(VkHostImageCopyFlagsEXT));
+    *ptr += sizeof(VkHostImageCopyFlagsEXT);
+    uint64_t cgen_var_0;
+    memcpy((uint64_t*)&cgen_var_0, *ptr, 1 * 8);
+    *ptr += 1 * 8;
+    *(VkImage*)&forUnmarshaling->dstImage = (VkImage)unbox_VkImage((VkImage)(*&cgen_var_0));
+    memcpy((VkImageLayout*)&forUnmarshaling->dstImageLayout, *ptr, sizeof(VkImageLayout));
+    *ptr += sizeof(VkImageLayout);
+    memcpy((uint32_t*)&forUnmarshaling->regionCount, *ptr, sizeof(uint32_t));
+    *ptr += sizeof(uint32_t);
+    vkStream->alloc((void**)&forUnmarshaling->pRegions,
+                    forUnmarshaling->regionCount * sizeof(const VkMemoryToImageCopyEXT));
+    for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->regionCount; ++i) {
+        reservedunmarshal_VkMemoryToImageCopyEXT(
+            vkStream, rootType, (VkMemoryToImageCopyEXT*)(forUnmarshaling->pRegions + i), ptr);
+    }
+}
+
+void reservedunmarshal_VkCopyImageToMemoryInfoEXT(VulkanStream* vkStream, VkStructureType rootType,
+                                                  VkCopyImageToMemoryInfoEXT* forUnmarshaling,
+                                                  uint8_t** ptr) {
+    memcpy((VkStructureType*)&forUnmarshaling->sType, *ptr, sizeof(VkStructureType));
+    *ptr += sizeof(VkStructureType);
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    uint32_t pNext_size;
+    memcpy((uint32_t*)&pNext_size, *ptr, sizeof(uint32_t));
+    android::base::Stream::fromBe32((uint8_t*)&pNext_size);
+    *ptr += sizeof(uint32_t);
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        memcpy((void*)forUnmarshaling->pNext, *ptr, sizeof(VkStructureType));
+        *ptr += sizeof(VkStructureType);
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        reservedunmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext),
+                                           ptr);
+    }
+    memcpy((VkHostImageCopyFlagsEXT*)&forUnmarshaling->flags, *ptr,
+           sizeof(VkHostImageCopyFlagsEXT));
+    *ptr += sizeof(VkHostImageCopyFlagsEXT);
+    uint64_t cgen_var_0;
+    memcpy((uint64_t*)&cgen_var_0, *ptr, 1 * 8);
+    *ptr += 1 * 8;
+    *(VkImage*)&forUnmarshaling->srcImage = (VkImage)unbox_VkImage((VkImage)(*&cgen_var_0));
+    memcpy((VkImageLayout*)&forUnmarshaling->srcImageLayout, *ptr, sizeof(VkImageLayout));
+    *ptr += sizeof(VkImageLayout);
+    memcpy((uint32_t*)&forUnmarshaling->regionCount, *ptr, sizeof(uint32_t));
+    *ptr += sizeof(uint32_t);
+    vkStream->alloc((void**)&forUnmarshaling->pRegions,
+                    forUnmarshaling->regionCount * sizeof(const VkImageToMemoryCopyEXT));
+    for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->regionCount; ++i) {
+        reservedunmarshal_VkImageToMemoryCopyEXT(
+            vkStream, rootType, (VkImageToMemoryCopyEXT*)(forUnmarshaling->pRegions + i), ptr);
+    }
+}
+
+void reservedunmarshal_VkCopyImageToImageInfoEXT(VulkanStream* vkStream, VkStructureType rootType,
+                                                 VkCopyImageToImageInfoEXT* forUnmarshaling,
+                                                 uint8_t** ptr) {
+    memcpy((VkStructureType*)&forUnmarshaling->sType, *ptr, sizeof(VkStructureType));
+    *ptr += sizeof(VkStructureType);
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    uint32_t pNext_size;
+    memcpy((uint32_t*)&pNext_size, *ptr, sizeof(uint32_t));
+    android::base::Stream::fromBe32((uint8_t*)&pNext_size);
+    *ptr += sizeof(uint32_t);
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        memcpy((void*)forUnmarshaling->pNext, *ptr, sizeof(VkStructureType));
+        *ptr += sizeof(VkStructureType);
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        reservedunmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext),
+                                           ptr);
+    }
+    memcpy((VkHostImageCopyFlagsEXT*)&forUnmarshaling->flags, *ptr,
+           sizeof(VkHostImageCopyFlagsEXT));
+    *ptr += sizeof(VkHostImageCopyFlagsEXT);
+    uint64_t cgen_var_0;
+    memcpy((uint64_t*)&cgen_var_0, *ptr, 1 * 8);
+    *ptr += 1 * 8;
+    *(VkImage*)&forUnmarshaling->srcImage = (VkImage)unbox_VkImage((VkImage)(*&cgen_var_0));
+    memcpy((VkImageLayout*)&forUnmarshaling->srcImageLayout, *ptr, sizeof(VkImageLayout));
+    *ptr += sizeof(VkImageLayout);
+    uint64_t cgen_var_1;
+    memcpy((uint64_t*)&cgen_var_1, *ptr, 1 * 8);
+    *ptr += 1 * 8;
+    *(VkImage*)&forUnmarshaling->dstImage = (VkImage)unbox_VkImage((VkImage)(*&cgen_var_1));
+    memcpy((VkImageLayout*)&forUnmarshaling->dstImageLayout, *ptr, sizeof(VkImageLayout));
+    *ptr += sizeof(VkImageLayout);
+    memcpy((uint32_t*)&forUnmarshaling->regionCount, *ptr, sizeof(uint32_t));
+    *ptr += sizeof(uint32_t);
+    vkStream->alloc((void**)&forUnmarshaling->pRegions,
+                    forUnmarshaling->regionCount * sizeof(const VkImageCopy2));
+    for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->regionCount; ++i) {
+        reservedunmarshal_VkImageCopy2(vkStream, rootType,
+                                       (VkImageCopy2*)(forUnmarshaling->pRegions + i), ptr);
+    }
+}
+
+void reservedunmarshal_VkHostImageLayoutTransitionInfoEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkHostImageLayoutTransitionInfoEXT* forUnmarshaling, uint8_t** ptr) {
+    memcpy((VkStructureType*)&forUnmarshaling->sType, *ptr, sizeof(VkStructureType));
+    *ptr += sizeof(VkStructureType);
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    uint32_t pNext_size;
+    memcpy((uint32_t*)&pNext_size, *ptr, sizeof(uint32_t));
+    android::base::Stream::fromBe32((uint8_t*)&pNext_size);
+    *ptr += sizeof(uint32_t);
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        memcpy((void*)forUnmarshaling->pNext, *ptr, sizeof(VkStructureType));
+        *ptr += sizeof(VkStructureType);
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        reservedunmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext),
+                                           ptr);
+    }
+    uint64_t cgen_var_0;
+    memcpy((uint64_t*)&cgen_var_0, *ptr, 1 * 8);
+    *ptr += 1 * 8;
+    *(VkImage*)&forUnmarshaling->image = (VkImage)unbox_VkImage((VkImage)(*&cgen_var_0));
+    memcpy((VkImageLayout*)&forUnmarshaling->oldLayout, *ptr, sizeof(VkImageLayout));
+    *ptr += sizeof(VkImageLayout);
+    memcpy((VkImageLayout*)&forUnmarshaling->newLayout, *ptr, sizeof(VkImageLayout));
+    *ptr += sizeof(VkImageLayout);
+    reservedunmarshal_VkImageSubresourceRange(
+        vkStream, rootType, (VkImageSubresourceRange*)(&forUnmarshaling->subresourceRange), ptr);
+}
+
+void reservedunmarshal_VkSubresourceHostMemcpySizeEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkSubresourceHostMemcpySizeEXT* forUnmarshaling, uint8_t** ptr) {
+    memcpy((VkStructureType*)&forUnmarshaling->sType, *ptr, sizeof(VkStructureType));
+    *ptr += sizeof(VkStructureType);
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    uint32_t pNext_size;
+    memcpy((uint32_t*)&pNext_size, *ptr, sizeof(uint32_t));
+    android::base::Stream::fromBe32((uint8_t*)&pNext_size);
+    *ptr += sizeof(uint32_t);
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        memcpy((void*)forUnmarshaling->pNext, *ptr, sizeof(VkStructureType));
+        *ptr += sizeof(VkStructureType);
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        reservedunmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext),
+                                           ptr);
+    }
+    memcpy((VkDeviceSize*)&forUnmarshaling->size, *ptr, sizeof(VkDeviceSize));
+    *ptr += sizeof(VkDeviceSize);
+}
+
+void reservedunmarshal_VkHostImageCopyDevicePerformanceQueryEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkHostImageCopyDevicePerformanceQueryEXT* forUnmarshaling, uint8_t** ptr) {
+    memcpy((VkStructureType*)&forUnmarshaling->sType, *ptr, sizeof(VkStructureType));
+    *ptr += sizeof(VkStructureType);
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    uint32_t pNext_size;
+    memcpy((uint32_t*)&pNext_size, *ptr, sizeof(uint32_t));
+    android::base::Stream::fromBe32((uint8_t*)&pNext_size);
+    *ptr += sizeof(uint32_t);
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        memcpy((void*)forUnmarshaling->pNext, *ptr, sizeof(VkStructureType));
+        *ptr += sizeof(VkStructureType);
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        reservedunmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext),
+                                           ptr);
+    }
+    memcpy((VkBool32*)&forUnmarshaling->optimalDeviceAccess, *ptr, sizeof(VkBool32));
+    *ptr += sizeof(VkBool32);
+    memcpy((VkBool32*)&forUnmarshaling->identicalMemoryLayout, *ptr, sizeof(VkBool32));
+    *ptr += sizeof(VkBool32);
+}
+
+#endif
 #ifdef VK_EXT_swapchain_maintenance1
 void reservedunmarshal_VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT(
     VulkanStream* vkStream, VkStructureType rootType,
@@ -12583,64 +13256,6 @@
     }
 }
 
-void reservedunmarshal_VkSubresourceLayout2EXT(VulkanStream* vkStream, VkStructureType rootType,
-                                               VkSubresourceLayout2EXT* forUnmarshaling,
-                                               uint8_t** ptr) {
-    memcpy((VkStructureType*)&forUnmarshaling->sType, *ptr, sizeof(VkStructureType));
-    *ptr += sizeof(VkStructureType);
-    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
-        rootType = forUnmarshaling->sType;
-    }
-    uint32_t pNext_size;
-    memcpy((uint32_t*)&pNext_size, *ptr, sizeof(uint32_t));
-    android::base::Stream::fromBe32((uint8_t*)&pNext_size);
-    *ptr += sizeof(uint32_t);
-    forUnmarshaling->pNext = nullptr;
-    if (pNext_size) {
-        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
-        memcpy((void*)forUnmarshaling->pNext, *ptr, sizeof(VkStructureType));
-        *ptr += sizeof(VkStructureType);
-        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
-        vkStream->alloc((void**)&forUnmarshaling->pNext,
-                        goldfish_vk_extension_struct_size_with_stream_features(
-                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
-        *(VkStructureType*)forUnmarshaling->pNext = extType;
-        reservedunmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext),
-                                           ptr);
-    }
-    reservedunmarshal_VkSubresourceLayout(
-        vkStream, rootType, (VkSubresourceLayout*)(&forUnmarshaling->subresourceLayout), ptr);
-}
-
-void reservedunmarshal_VkImageSubresource2EXT(VulkanStream* vkStream, VkStructureType rootType,
-                                              VkImageSubresource2EXT* forUnmarshaling,
-                                              uint8_t** ptr) {
-    memcpy((VkStructureType*)&forUnmarshaling->sType, *ptr, sizeof(VkStructureType));
-    *ptr += sizeof(VkStructureType);
-    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
-        rootType = forUnmarshaling->sType;
-    }
-    uint32_t pNext_size;
-    memcpy((uint32_t*)&pNext_size, *ptr, sizeof(uint32_t));
-    android::base::Stream::fromBe32((uint8_t*)&pNext_size);
-    *ptr += sizeof(uint32_t);
-    forUnmarshaling->pNext = nullptr;
-    if (pNext_size) {
-        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
-        memcpy((void*)forUnmarshaling->pNext, *ptr, sizeof(VkStructureType));
-        *ptr += sizeof(VkStructureType);
-        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
-        vkStream->alloc((void**)&forUnmarshaling->pNext,
-                        goldfish_vk_extension_struct_size_with_stream_features(
-                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
-        *(VkStructureType*)forUnmarshaling->pNext = extType;
-        reservedunmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext),
-                                           ptr);
-    }
-    reservedunmarshal_VkImageSubresource(
-        vkStream, rootType, (VkImageSubresource*)(&forUnmarshaling->imageSubresource), ptr);
-}
-
 void reservedunmarshal_VkImageCompressionPropertiesEXT(
     VulkanStream* vkStream, VkStructureType rootType,
     VkImageCompressionPropertiesEXT* forUnmarshaling, uint8_t** ptr) {
@@ -13735,6 +14350,34 @@
             break;
         }
 #endif
+#ifdef VK_KHR_maintenance5
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_FEATURES_KHR: {
+            reservedunmarshal_VkPhysicalDeviceMaintenance5FeaturesKHR(
+                vkStream, rootType,
+                reinterpret_cast<VkPhysicalDeviceMaintenance5FeaturesKHR*>(structExtension_out),
+                ptr);
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_PROPERTIES_KHR: {
+            reservedunmarshal_VkPhysicalDeviceMaintenance5PropertiesKHR(
+                vkStream, rootType,
+                reinterpret_cast<VkPhysicalDeviceMaintenance5PropertiesKHR*>(structExtension_out),
+                ptr);
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PIPELINE_CREATE_FLAGS_2_CREATE_INFO_KHR: {
+            reservedunmarshal_VkPipelineCreateFlags2CreateInfoKHR(
+                vkStream, rootType,
+                reinterpret_cast<VkPipelineCreateFlags2CreateInfoKHR*>(structExtension_out), ptr);
+            break;
+        }
+        case VK_STRUCTURE_TYPE_BUFFER_USAGE_FLAGS_2_CREATE_INFO_KHR: {
+            reservedunmarshal_VkBufferUsageFlags2CreateInfoKHR(
+                vkStream, rootType,
+                reinterpret_cast<VkBufferUsageFlags2CreateInfoKHR*>(structExtension_out), ptr);
+            break;
+        }
+#endif
 #ifdef VK_ANDROID_native_buffer
         case VK_STRUCTURE_TYPE_NATIVE_BUFFER_ANDROID: {
             reservedunmarshal_VkNativeBufferANDROID(
@@ -13839,6 +14482,35 @@
             break;
         }
 #endif
+#ifdef VK_EXT_host_image_copy
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_FEATURES_EXT: {
+            reservedunmarshal_VkPhysicalDeviceHostImageCopyFeaturesEXT(
+                vkStream, rootType,
+                reinterpret_cast<VkPhysicalDeviceHostImageCopyFeaturesEXT*>(structExtension_out),
+                ptr);
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_PROPERTIES_EXT: {
+            reservedunmarshal_VkPhysicalDeviceHostImageCopyPropertiesEXT(
+                vkStream, rootType,
+                reinterpret_cast<VkPhysicalDeviceHostImageCopyPropertiesEXT*>(structExtension_out),
+                ptr);
+            break;
+        }
+        case VK_STRUCTURE_TYPE_SUBRESOURCE_HOST_MEMCPY_SIZE_EXT: {
+            reservedunmarshal_VkSubresourceHostMemcpySizeEXT(
+                vkStream, rootType,
+                reinterpret_cast<VkSubresourceHostMemcpySizeEXT*>(structExtension_out), ptr);
+            break;
+        }
+        case VK_STRUCTURE_TYPE_HOST_IMAGE_COPY_DEVICE_PERFORMANCE_QUERY_EXT: {
+            reservedunmarshal_VkHostImageCopyDevicePerformanceQueryEXT(
+                vkStream, rootType,
+                reinterpret_cast<VkHostImageCopyDevicePerformanceQueryEXT*>(structExtension_out),
+                ptr);
+            break;
+        }
+#endif
 #ifdef VK_EXT_swapchain_maintenance1
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SWAPCHAIN_MAINTENANCE_1_FEATURES_EXT: {
             reservedunmarshal_VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT(
diff --git a/host/vulkan/cereal/common/goldfish_vk_reserved_marshaling.h b/host/vulkan/cereal/common/goldfish_vk_reserved_marshaling.h
index b7f2355..30bdcbc 100644
--- a/host/vulkan/cereal/common/goldfish_vk_reserved_marshaling.h
+++ b/host/vulkan/cereal/common/goldfish_vk_reserved_marshaling.h
@@ -15,9 +15,9 @@
 
 // Autogenerated module goldfish_vk_reserved_marshaling
 //
-// (header) generated by codegen/vulkan/vulkan-docs/scripts/genvk.py -registry
-// codegen/vulkan/vulkan-docs/xml/vk.xml -registryGfxstream
-// codegen/vulkan/vulkan-docs/xml/vk_gfxstream.xml cereal -o host/vulkan/cereal
+// (header) generated by codegen/vulkan/vulkan-docs-next/scripts/genvk.py -registry
+// codegen/vulkan/vulkan-docs-next/xml/vk.xml -registryGfxstream
+// codegen/vulkan/vulkan-docs-next/xml/vk_gfxstream.xml cereal -o host/vulkan/cereal
 //
 // Please do not modify directly;
 // re-run gfxstream-protocols/scripts/generate-vulkan-sources.sh,
@@ -35,7 +35,7 @@
 #include "VulkanStream.h"
 #include "aemu/base/files/StreamSerializing.h"
 #include "goldfish_vk_private_defs.h"
-#include "vk_android_native_buffer.h"
+#include "vk_android_native_buffer_gfxstream.h"
 #include "vulkan_gfxstream.h"
 
 namespace gfxstream {
@@ -1602,6 +1602,40 @@
                       reservedunmarshal_VkDeviceImageMemoryRequirementsKHR)
 
 #endif
+#ifdef VK_KHR_maintenance5
+void reservedunmarshal_VkPhysicalDeviceMaintenance5FeaturesKHR(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPhysicalDeviceMaintenance5FeaturesKHR* forUnmarshaling, uint8_t** ptr);
+
+void reservedunmarshal_VkPhysicalDeviceMaintenance5PropertiesKHR(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPhysicalDeviceMaintenance5PropertiesKHR* forUnmarshaling, uint8_t** ptr);
+
+void reservedunmarshal_VkRenderingAreaInfoKHR(VulkanStream* vkStream, VkStructureType rootType,
+                                              VkRenderingAreaInfoKHR* forUnmarshaling,
+                                              uint8_t** ptr);
+
+void reservedunmarshal_VkImageSubresource2KHR(VulkanStream* vkStream, VkStructureType rootType,
+                                              VkImageSubresource2KHR* forUnmarshaling,
+                                              uint8_t** ptr);
+
+void reservedunmarshal_VkDeviceImageSubresourceInfoKHR(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkDeviceImageSubresourceInfoKHR* forUnmarshaling, uint8_t** ptr);
+
+void reservedunmarshal_VkSubresourceLayout2KHR(VulkanStream* vkStream, VkStructureType rootType,
+                                               VkSubresourceLayout2KHR* forUnmarshaling,
+                                               uint8_t** ptr);
+
+void reservedunmarshal_VkPipelineCreateFlags2CreateInfoKHR(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPipelineCreateFlags2CreateInfoKHR* forUnmarshaling, uint8_t** ptr);
+
+void reservedunmarshal_VkBufferUsageFlags2CreateInfoKHR(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkBufferUsageFlags2CreateInfoKHR* forUnmarshaling, uint8_t** ptr);
+
+#endif
 #ifdef VK_ANDROID_native_buffer
 void reservedunmarshal_VkNativeBufferUsage2ANDROID(VulkanStream* vkStream, VkStructureType rootType,
                                                    VkNativeBufferUsage2ANDROID* forUnmarshaling,
@@ -1732,6 +1766,54 @@
     VkPhysicalDeviceExtendedDynamicStateFeaturesEXT* forUnmarshaling, uint8_t** ptr);
 
 #endif
+#ifdef VK_EXT_host_image_copy
+void reservedunmarshal_VkPhysicalDeviceHostImageCopyFeaturesEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPhysicalDeviceHostImageCopyFeaturesEXT* forUnmarshaling, uint8_t** ptr);
+
+void reservedunmarshal_VkPhysicalDeviceHostImageCopyPropertiesEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPhysicalDeviceHostImageCopyPropertiesEXT* forUnmarshaling, uint8_t** ptr);
+
+void reservedunmarshal_VkMemoryToImageCopyEXT(VulkanStream* vkStream, VkStructureType rootType,
+                                              VkMemoryToImageCopyEXT* forUnmarshaling,
+                                              uint8_t** ptr);
+
+void reservedunmarshal_VkImageToMemoryCopyEXT(VulkanStream* vkStream, VkStructureType rootType,
+                                              VkImageToMemoryCopyEXT* forUnmarshaling,
+                                              uint8_t** ptr);
+
+void reservedunmarshal_VkCopyMemoryToImageInfoEXT(VulkanStream* vkStream, VkStructureType rootType,
+                                                  VkCopyMemoryToImageInfoEXT* forUnmarshaling,
+                                                  uint8_t** ptr);
+
+void reservedunmarshal_VkCopyImageToMemoryInfoEXT(VulkanStream* vkStream, VkStructureType rootType,
+                                                  VkCopyImageToMemoryInfoEXT* forUnmarshaling,
+                                                  uint8_t** ptr);
+
+void reservedunmarshal_VkCopyImageToImageInfoEXT(VulkanStream* vkStream, VkStructureType rootType,
+                                                 VkCopyImageToImageInfoEXT* forUnmarshaling,
+                                                 uint8_t** ptr);
+
+void reservedunmarshal_VkHostImageLayoutTransitionInfoEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkHostImageLayoutTransitionInfoEXT* forUnmarshaling, uint8_t** ptr);
+
+void reservedunmarshal_VkSubresourceHostMemcpySizeEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkSubresourceHostMemcpySizeEXT* forUnmarshaling, uint8_t** ptr);
+
+void reservedunmarshal_VkHostImageCopyDevicePerformanceQueryEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkHostImageCopyDevicePerformanceQueryEXT* forUnmarshaling, uint8_t** ptr);
+
+DEFINE_ALIAS_FUNCTION(reservedunmarshal_VkSubresourceLayout2KHR,
+                      reservedunmarshal_VkSubresourceLayout2EXT)
+
+DEFINE_ALIAS_FUNCTION(reservedunmarshal_VkImageSubresource2KHR,
+                      reservedunmarshal_VkImageSubresource2EXT)
+
+#endif
 #ifdef VK_EXT_swapchain_maintenance1
 void reservedunmarshal_VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT(
     VulkanStream* vkStream, VkStructureType rootType,
@@ -1852,14 +1934,6 @@
                                                     VkImageCompressionControlEXT* forUnmarshaling,
                                                     uint8_t** ptr);
 
-void reservedunmarshal_VkSubresourceLayout2EXT(VulkanStream* vkStream, VkStructureType rootType,
-                                               VkSubresourceLayout2EXT* forUnmarshaling,
-                                               uint8_t** ptr);
-
-void reservedunmarshal_VkImageSubresource2EXT(VulkanStream* vkStream, VkStructureType rootType,
-                                              VkImageSubresource2EXT* forUnmarshaling,
-                                              uint8_t** ptr);
-
 void reservedunmarshal_VkImageCompressionPropertiesEXT(
     VulkanStream* vkStream, VkStructureType rootType,
     VkImageCompressionPropertiesEXT* forUnmarshaling, uint8_t** ptr);
diff --git a/host/vulkan/cereal/common/goldfish_vk_transform.cpp b/host/vulkan/cereal/common/goldfish_vk_transform.cpp
index 33a9c9e..b0e4a1a 100644
--- a/host/vulkan/cereal/common/goldfish_vk_transform.cpp
+++ b/host/vulkan/cereal/common/goldfish_vk_transform.cpp
@@ -15,9 +15,9 @@
 
 // Autogenerated module goldfish_vk_transform
 //
-// (impl) generated by codegen/vulkan/vulkan-docs/scripts/genvk.py -registry
-// codegen/vulkan/vulkan-docs/xml/vk.xml -registryGfxstream
-// codegen/vulkan/vulkan-docs/xml/vk_gfxstream.xml cereal -o host/vulkan/cereal
+// (impl) generated by codegen/vulkan/vulkan-docs-next/scripts/genvk.py -registry
+// codegen/vulkan/vulkan-docs-next/xml/vk.xml -registryGfxstream
+// codegen/vulkan/vulkan-docs-next/xml/vk_gfxstream.xml cereal -o host/vulkan/cereal
 //
 // Please do not modify directly;
 // re-run gfxstream-protocols/scripts/generate-vulkan-sources.sh,
@@ -6766,6 +6766,178 @@
 #endif
 #ifdef VK_KHR_maintenance4
 #endif
+#ifdef VK_KHR_maintenance5
+void transform_tohost_VkPhysicalDeviceMaintenance5FeaturesKHR(
+    VkDecoderGlobalState* resourceTracker, VkPhysicalDeviceMaintenance5FeaturesKHR* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+}
+
+void transform_fromhost_VkPhysicalDeviceMaintenance5FeaturesKHR(
+    VkDecoderGlobalState* resourceTracker, VkPhysicalDeviceMaintenance5FeaturesKHR* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+}
+
+void transform_tohost_VkPhysicalDeviceMaintenance5PropertiesKHR(
+    VkDecoderGlobalState* resourceTracker, VkPhysicalDeviceMaintenance5PropertiesKHR* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+}
+
+void transform_fromhost_VkPhysicalDeviceMaintenance5PropertiesKHR(
+    VkDecoderGlobalState* resourceTracker, VkPhysicalDeviceMaintenance5PropertiesKHR* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+}
+
+void transform_tohost_VkRenderingAreaInfoKHR(VkDecoderGlobalState* resourceTracker,
+                                             VkRenderingAreaInfoKHR* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+}
+
+void transform_fromhost_VkRenderingAreaInfoKHR(VkDecoderGlobalState* resourceTracker,
+                                               VkRenderingAreaInfoKHR* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+}
+
+void transform_tohost_VkImageSubresource2KHR(VkDecoderGlobalState* resourceTracker,
+                                             VkImageSubresource2KHR* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+    transform_tohost_VkImageSubresource(resourceTracker,
+                                        (VkImageSubresource*)(&toTransform->imageSubresource));
+}
+
+void transform_fromhost_VkImageSubresource2KHR(VkDecoderGlobalState* resourceTracker,
+                                               VkImageSubresource2KHR* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+    transform_fromhost_VkImageSubresource(resourceTracker,
+                                          (VkImageSubresource*)(&toTransform->imageSubresource));
+}
+
+void transform_tohost_VkDeviceImageSubresourceInfoKHR(
+    VkDecoderGlobalState* resourceTracker, VkDeviceImageSubresourceInfoKHR* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+    if (toTransform->pCreateInfo) {
+        resourceTracker->transformImpl_VkImageCreateInfo_tohost(toTransform->pCreateInfo, 1);
+        transform_tohost_VkImageCreateInfo(resourceTracker,
+                                           (VkImageCreateInfo*)(toTransform->pCreateInfo));
+    }
+    if (toTransform->pSubresource) {
+        transform_tohost_VkImageSubresource2KHR(
+            resourceTracker, (VkImageSubresource2KHR*)(toTransform->pSubresource));
+    }
+}
+
+void transform_fromhost_VkDeviceImageSubresourceInfoKHR(
+    VkDecoderGlobalState* resourceTracker, VkDeviceImageSubresourceInfoKHR* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+    if (toTransform->pCreateInfo) {
+        resourceTracker->transformImpl_VkImageCreateInfo_fromhost(toTransform->pCreateInfo, 1);
+        transform_fromhost_VkImageCreateInfo(resourceTracker,
+                                             (VkImageCreateInfo*)(toTransform->pCreateInfo));
+    }
+    if (toTransform->pSubresource) {
+        transform_fromhost_VkImageSubresource2KHR(
+            resourceTracker, (VkImageSubresource2KHR*)(toTransform->pSubresource));
+    }
+}
+
+void transform_tohost_VkSubresourceLayout2KHR(VkDecoderGlobalState* resourceTracker,
+                                              VkSubresourceLayout2KHR* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+    transform_tohost_VkSubresourceLayout(resourceTracker,
+                                         (VkSubresourceLayout*)(&toTransform->subresourceLayout));
+}
+
+void transform_fromhost_VkSubresourceLayout2KHR(VkDecoderGlobalState* resourceTracker,
+                                                VkSubresourceLayout2KHR* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+    transform_fromhost_VkSubresourceLayout(resourceTracker,
+                                           (VkSubresourceLayout*)(&toTransform->subresourceLayout));
+}
+
+void transform_tohost_VkPipelineCreateFlags2CreateInfoKHR(
+    VkDecoderGlobalState* resourceTracker, VkPipelineCreateFlags2CreateInfoKHR* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+}
+
+void transform_fromhost_VkPipelineCreateFlags2CreateInfoKHR(
+    VkDecoderGlobalState* resourceTracker, VkPipelineCreateFlags2CreateInfoKHR* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+}
+
+void transform_tohost_VkBufferUsageFlags2CreateInfoKHR(
+    VkDecoderGlobalState* resourceTracker, VkBufferUsageFlags2CreateInfoKHR* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+}
+
+void transform_fromhost_VkBufferUsageFlags2CreateInfoKHR(
+    VkDecoderGlobalState* resourceTracker, VkBufferUsageFlags2CreateInfoKHR* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+}
+
+#endif
 #ifdef VK_ANDROID_native_buffer
 void transform_tohost_VkNativeBufferUsage2ANDROID(VkDecoderGlobalState* resourceTracker,
                                                   VkNativeBufferUsage2ANDROID* toTransform) {
@@ -7094,6 +7266,258 @@
 }
 
 #endif
+#ifdef VK_EXT_host_image_copy
+void transform_tohost_VkPhysicalDeviceHostImageCopyFeaturesEXT(
+    VkDecoderGlobalState* resourceTracker, VkPhysicalDeviceHostImageCopyFeaturesEXT* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+}
+
+void transform_fromhost_VkPhysicalDeviceHostImageCopyFeaturesEXT(
+    VkDecoderGlobalState* resourceTracker, VkPhysicalDeviceHostImageCopyFeaturesEXT* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+}
+
+void transform_tohost_VkPhysicalDeviceHostImageCopyPropertiesEXT(
+    VkDecoderGlobalState* resourceTracker,
+    VkPhysicalDeviceHostImageCopyPropertiesEXT* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+}
+
+void transform_fromhost_VkPhysicalDeviceHostImageCopyPropertiesEXT(
+    VkDecoderGlobalState* resourceTracker,
+    VkPhysicalDeviceHostImageCopyPropertiesEXT* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+}
+
+void transform_tohost_VkMemoryToImageCopyEXT(VkDecoderGlobalState* resourceTracker,
+                                             VkMemoryToImageCopyEXT* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+    transform_tohost_VkImageSubresourceLayers(
+        resourceTracker, (VkImageSubresourceLayers*)(&toTransform->imageSubresource));
+    transform_tohost_VkOffset3D(resourceTracker, (VkOffset3D*)(&toTransform->imageOffset));
+    transform_tohost_VkExtent3D(resourceTracker, (VkExtent3D*)(&toTransform->imageExtent));
+}
+
+void transform_fromhost_VkMemoryToImageCopyEXT(VkDecoderGlobalState* resourceTracker,
+                                               VkMemoryToImageCopyEXT* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+    transform_fromhost_VkImageSubresourceLayers(
+        resourceTracker, (VkImageSubresourceLayers*)(&toTransform->imageSubresource));
+    transform_fromhost_VkOffset3D(resourceTracker, (VkOffset3D*)(&toTransform->imageOffset));
+    transform_fromhost_VkExtent3D(resourceTracker, (VkExtent3D*)(&toTransform->imageExtent));
+}
+
+void transform_tohost_VkImageToMemoryCopyEXT(VkDecoderGlobalState* resourceTracker,
+                                             VkImageToMemoryCopyEXT* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+    transform_tohost_VkImageSubresourceLayers(
+        resourceTracker, (VkImageSubresourceLayers*)(&toTransform->imageSubresource));
+    transform_tohost_VkOffset3D(resourceTracker, (VkOffset3D*)(&toTransform->imageOffset));
+    transform_tohost_VkExtent3D(resourceTracker, (VkExtent3D*)(&toTransform->imageExtent));
+}
+
+void transform_fromhost_VkImageToMemoryCopyEXT(VkDecoderGlobalState* resourceTracker,
+                                               VkImageToMemoryCopyEXT* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+    transform_fromhost_VkImageSubresourceLayers(
+        resourceTracker, (VkImageSubresourceLayers*)(&toTransform->imageSubresource));
+    transform_fromhost_VkOffset3D(resourceTracker, (VkOffset3D*)(&toTransform->imageOffset));
+    transform_fromhost_VkExtent3D(resourceTracker, (VkExtent3D*)(&toTransform->imageExtent));
+}
+
+void transform_tohost_VkCopyMemoryToImageInfoEXT(VkDecoderGlobalState* resourceTracker,
+                                                 VkCopyMemoryToImageInfoEXT* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+    if (toTransform) {
+        if (toTransform->pRegions) {
+            for (uint32_t i = 0; i < (uint32_t)toTransform->regionCount; ++i) {
+                transform_tohost_VkMemoryToImageCopyEXT(
+                    resourceTracker, (VkMemoryToImageCopyEXT*)(toTransform->pRegions + i));
+            }
+        }
+    }
+}
+
+void transform_fromhost_VkCopyMemoryToImageInfoEXT(VkDecoderGlobalState* resourceTracker,
+                                                   VkCopyMemoryToImageInfoEXT* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+    if (toTransform) {
+        if (toTransform->pRegions) {
+            for (uint32_t i = 0; i < (uint32_t)toTransform->regionCount; ++i) {
+                transform_fromhost_VkMemoryToImageCopyEXT(
+                    resourceTracker, (VkMemoryToImageCopyEXT*)(toTransform->pRegions + i));
+            }
+        }
+    }
+}
+
+void transform_tohost_VkCopyImageToMemoryInfoEXT(VkDecoderGlobalState* resourceTracker,
+                                                 VkCopyImageToMemoryInfoEXT* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+    if (toTransform) {
+        if (toTransform->pRegions) {
+            for (uint32_t i = 0; i < (uint32_t)toTransform->regionCount; ++i) {
+                transform_tohost_VkImageToMemoryCopyEXT(
+                    resourceTracker, (VkImageToMemoryCopyEXT*)(toTransform->pRegions + i));
+            }
+        }
+    }
+}
+
+void transform_fromhost_VkCopyImageToMemoryInfoEXT(VkDecoderGlobalState* resourceTracker,
+                                                   VkCopyImageToMemoryInfoEXT* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+    if (toTransform) {
+        if (toTransform->pRegions) {
+            for (uint32_t i = 0; i < (uint32_t)toTransform->regionCount; ++i) {
+                transform_fromhost_VkImageToMemoryCopyEXT(
+                    resourceTracker, (VkImageToMemoryCopyEXT*)(toTransform->pRegions + i));
+            }
+        }
+    }
+}
+
+void transform_tohost_VkCopyImageToImageInfoEXT(VkDecoderGlobalState* resourceTracker,
+                                                VkCopyImageToImageInfoEXT* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+    if (toTransform) {
+        if (toTransform->pRegions) {
+            for (uint32_t i = 0; i < (uint32_t)toTransform->regionCount; ++i) {
+                transform_tohost_VkImageCopy2(resourceTracker,
+                                              (VkImageCopy2*)(toTransform->pRegions + i));
+            }
+        }
+    }
+}
+
+void transform_fromhost_VkCopyImageToImageInfoEXT(VkDecoderGlobalState* resourceTracker,
+                                                  VkCopyImageToImageInfoEXT* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+    if (toTransform) {
+        if (toTransform->pRegions) {
+            for (uint32_t i = 0; i < (uint32_t)toTransform->regionCount; ++i) {
+                transform_fromhost_VkImageCopy2(resourceTracker,
+                                                (VkImageCopy2*)(toTransform->pRegions + i));
+            }
+        }
+    }
+}
+
+void transform_tohost_VkHostImageLayoutTransitionInfoEXT(
+    VkDecoderGlobalState* resourceTracker, VkHostImageLayoutTransitionInfoEXT* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+    transform_tohost_VkImageSubresourceRange(
+        resourceTracker, (VkImageSubresourceRange*)(&toTransform->subresourceRange));
+}
+
+void transform_fromhost_VkHostImageLayoutTransitionInfoEXT(
+    VkDecoderGlobalState* resourceTracker, VkHostImageLayoutTransitionInfoEXT* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+    transform_fromhost_VkImageSubresourceRange(
+        resourceTracker, (VkImageSubresourceRange*)(&toTransform->subresourceRange));
+}
+
+void transform_tohost_VkSubresourceHostMemcpySizeEXT(VkDecoderGlobalState* resourceTracker,
+                                                     VkSubresourceHostMemcpySizeEXT* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+}
+
+void transform_fromhost_VkSubresourceHostMemcpySizeEXT(
+    VkDecoderGlobalState* resourceTracker, VkSubresourceHostMemcpySizeEXT* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+}
+
+void transform_tohost_VkHostImageCopyDevicePerformanceQueryEXT(
+    VkDecoderGlobalState* resourceTracker, VkHostImageCopyDevicePerformanceQueryEXT* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+}
+
+void transform_fromhost_VkHostImageCopyDevicePerformanceQueryEXT(
+    VkDecoderGlobalState* resourceTracker, VkHostImageCopyDevicePerformanceQueryEXT* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+}
+
+#endif
 #ifdef VK_EXT_swapchain_maintenance1
 void transform_tohost_VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT(
     VkDecoderGlobalState* resourceTracker,
@@ -7479,50 +7903,6 @@
     }
 }
 
-void transform_tohost_VkSubresourceLayout2EXT(VkDecoderGlobalState* resourceTracker,
-                                              VkSubresourceLayout2EXT* toTransform) {
-    (void)resourceTracker;
-    (void)toTransform;
-    if (toTransform->pNext) {
-        transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
-    }
-    transform_tohost_VkSubresourceLayout(resourceTracker,
-                                         (VkSubresourceLayout*)(&toTransform->subresourceLayout));
-}
-
-void transform_fromhost_VkSubresourceLayout2EXT(VkDecoderGlobalState* resourceTracker,
-                                                VkSubresourceLayout2EXT* toTransform) {
-    (void)resourceTracker;
-    (void)toTransform;
-    if (toTransform->pNext) {
-        transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
-    }
-    transform_fromhost_VkSubresourceLayout(resourceTracker,
-                                           (VkSubresourceLayout*)(&toTransform->subresourceLayout));
-}
-
-void transform_tohost_VkImageSubresource2EXT(VkDecoderGlobalState* resourceTracker,
-                                             VkImageSubresource2EXT* toTransform) {
-    (void)resourceTracker;
-    (void)toTransform;
-    if (toTransform->pNext) {
-        transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
-    }
-    transform_tohost_VkImageSubresource(resourceTracker,
-                                        (VkImageSubresource*)(&toTransform->imageSubresource));
-}
-
-void transform_fromhost_VkImageSubresource2EXT(VkDecoderGlobalState* resourceTracker,
-                                               VkImageSubresource2EXT* toTransform) {
-    (void)resourceTracker;
-    (void)toTransform;
-    if (toTransform->pNext) {
-        transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
-    }
-    transform_fromhost_VkImageSubresource(resourceTracker,
-                                          (VkImageSubresource*)(&toTransform->imageSubresource));
-}
-
 void transform_tohost_VkImageCompressionPropertiesEXT(
     VkDecoderGlobalState* resourceTracker, VkImageCompressionPropertiesEXT* toTransform) {
     (void)resourceTracker;
@@ -8433,6 +8813,32 @@
             break;
         }
 #endif
+#ifdef VK_KHR_maintenance5
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_FEATURES_KHR: {
+            transform_tohost_VkPhysicalDeviceMaintenance5FeaturesKHR(
+                resourceTracker,
+                reinterpret_cast<VkPhysicalDeviceMaintenance5FeaturesKHR*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_PROPERTIES_KHR: {
+            transform_tohost_VkPhysicalDeviceMaintenance5PropertiesKHR(
+                resourceTracker,
+                reinterpret_cast<VkPhysicalDeviceMaintenance5PropertiesKHR*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PIPELINE_CREATE_FLAGS_2_CREATE_INFO_KHR: {
+            transform_tohost_VkPipelineCreateFlags2CreateInfoKHR(
+                resourceTracker,
+                reinterpret_cast<VkPipelineCreateFlags2CreateInfoKHR*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_BUFFER_USAGE_FLAGS_2_CREATE_INFO_KHR: {
+            transform_tohost_VkBufferUsageFlags2CreateInfoKHR(
+                resourceTracker,
+                reinterpret_cast<VkBufferUsageFlags2CreateInfoKHR*>(structExtension_out));
+            break;
+        }
+#endif
 #ifdef VK_ANDROID_native_buffer
         case VK_STRUCTURE_TYPE_NATIVE_BUFFER_ANDROID: {
             transform_tohost_VkNativeBufferANDROID(
@@ -8517,6 +8923,32 @@
             break;
         }
 #endif
+#ifdef VK_EXT_host_image_copy
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_FEATURES_EXT: {
+            transform_tohost_VkPhysicalDeviceHostImageCopyFeaturesEXT(
+                resourceTracker,
+                reinterpret_cast<VkPhysicalDeviceHostImageCopyFeaturesEXT*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_PROPERTIES_EXT: {
+            transform_tohost_VkPhysicalDeviceHostImageCopyPropertiesEXT(
+                resourceTracker,
+                reinterpret_cast<VkPhysicalDeviceHostImageCopyPropertiesEXT*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_SUBRESOURCE_HOST_MEMCPY_SIZE_EXT: {
+            transform_tohost_VkSubresourceHostMemcpySizeEXT(
+                resourceTracker,
+                reinterpret_cast<VkSubresourceHostMemcpySizeEXT*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_HOST_IMAGE_COPY_DEVICE_PERFORMANCE_QUERY_EXT: {
+            transform_tohost_VkHostImageCopyDevicePerformanceQueryEXT(
+                resourceTracker,
+                reinterpret_cast<VkHostImageCopyDevicePerformanceQueryEXT*>(structExtension_out));
+            break;
+        }
+#endif
 #ifdef VK_EXT_swapchain_maintenance1
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SWAPCHAIN_MAINTENANCE_1_FEATURES_EXT: {
             transform_tohost_VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT(
@@ -9449,6 +9881,32 @@
             break;
         }
 #endif
+#ifdef VK_KHR_maintenance5
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_FEATURES_KHR: {
+            transform_fromhost_VkPhysicalDeviceMaintenance5FeaturesKHR(
+                resourceTracker,
+                reinterpret_cast<VkPhysicalDeviceMaintenance5FeaturesKHR*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_PROPERTIES_KHR: {
+            transform_fromhost_VkPhysicalDeviceMaintenance5PropertiesKHR(
+                resourceTracker,
+                reinterpret_cast<VkPhysicalDeviceMaintenance5PropertiesKHR*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PIPELINE_CREATE_FLAGS_2_CREATE_INFO_KHR: {
+            transform_fromhost_VkPipelineCreateFlags2CreateInfoKHR(
+                resourceTracker,
+                reinterpret_cast<VkPipelineCreateFlags2CreateInfoKHR*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_BUFFER_USAGE_FLAGS_2_CREATE_INFO_KHR: {
+            transform_fromhost_VkBufferUsageFlags2CreateInfoKHR(
+                resourceTracker,
+                reinterpret_cast<VkBufferUsageFlags2CreateInfoKHR*>(structExtension_out));
+            break;
+        }
+#endif
 #ifdef VK_ANDROID_native_buffer
         case VK_STRUCTURE_TYPE_NATIVE_BUFFER_ANDROID: {
             transform_fromhost_VkNativeBufferANDROID(
@@ -9533,6 +9991,32 @@
             break;
         }
 #endif
+#ifdef VK_EXT_host_image_copy
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_FEATURES_EXT: {
+            transform_fromhost_VkPhysicalDeviceHostImageCopyFeaturesEXT(
+                resourceTracker,
+                reinterpret_cast<VkPhysicalDeviceHostImageCopyFeaturesEXT*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_PROPERTIES_EXT: {
+            transform_fromhost_VkPhysicalDeviceHostImageCopyPropertiesEXT(
+                resourceTracker,
+                reinterpret_cast<VkPhysicalDeviceHostImageCopyPropertiesEXT*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_SUBRESOURCE_HOST_MEMCPY_SIZE_EXT: {
+            transform_fromhost_VkSubresourceHostMemcpySizeEXT(
+                resourceTracker,
+                reinterpret_cast<VkSubresourceHostMemcpySizeEXT*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_HOST_IMAGE_COPY_DEVICE_PERFORMANCE_QUERY_EXT: {
+            transform_fromhost_VkHostImageCopyDevicePerformanceQueryEXT(
+                resourceTracker,
+                reinterpret_cast<VkHostImageCopyDevicePerformanceQueryEXT*>(structExtension_out));
+            break;
+        }
+#endif
 #ifdef VK_EXT_swapchain_maintenance1
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SWAPCHAIN_MAINTENANCE_1_FEATURES_EXT: {
             transform_fromhost_VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT(
diff --git a/host/vulkan/cereal/common/goldfish_vk_transform.h b/host/vulkan/cereal/common/goldfish_vk_transform.h
index 9135da1..29c74d3 100644
--- a/host/vulkan/cereal/common/goldfish_vk_transform.h
+++ b/host/vulkan/cereal/common/goldfish_vk_transform.h
@@ -15,9 +15,9 @@
 
 // Autogenerated module goldfish_vk_transform
 //
-// (header) generated by codegen/vulkan/vulkan-docs/scripts/genvk.py -registry
-// codegen/vulkan/vulkan-docs/xml/vk.xml -registryGfxstream
-// codegen/vulkan/vulkan-docs/xml/vk_gfxstream.xml cereal -o host/vulkan/cereal
+// (header) generated by codegen/vulkan/vulkan-docs-next/scripts/genvk.py -registry
+// codegen/vulkan/vulkan-docs-next/xml/vk.xml -registryGfxstream
+// codegen/vulkan/vulkan-docs-next/xml/vk_gfxstream.xml cereal -o host/vulkan/cereal
 //
 // Please do not modify directly;
 // re-run gfxstream-protocols/scripts/generate-vulkan-sources.sh,
@@ -34,7 +34,7 @@
 
 #include "goldfish_vk_extension_structs.h"
 #include "goldfish_vk_private_defs.h"
-#include "vk_android_native_buffer.h"
+#include "vk_android_native_buffer_gfxstream.h"
 #include "vulkan_gfxstream.h"
 
 namespace gfxstream {
@@ -2668,6 +2668,56 @@
                       transform_fromhost_VkDeviceImageMemoryRequirementsKHR)
 
 #endif
+#ifdef VK_KHR_maintenance5
+void transform_tohost_VkPhysicalDeviceMaintenance5FeaturesKHR(
+    VkDecoderGlobalState* resourceTracker, VkPhysicalDeviceMaintenance5FeaturesKHR* toTransform);
+
+void transform_fromhost_VkPhysicalDeviceMaintenance5FeaturesKHR(
+    VkDecoderGlobalState* resourceTracker, VkPhysicalDeviceMaintenance5FeaturesKHR* toTransform);
+
+void transform_tohost_VkPhysicalDeviceMaintenance5PropertiesKHR(
+    VkDecoderGlobalState* resourceTracker, VkPhysicalDeviceMaintenance5PropertiesKHR* toTransform);
+
+void transform_fromhost_VkPhysicalDeviceMaintenance5PropertiesKHR(
+    VkDecoderGlobalState* resourceTracker, VkPhysicalDeviceMaintenance5PropertiesKHR* toTransform);
+
+void transform_tohost_VkRenderingAreaInfoKHR(VkDecoderGlobalState* resourceTracker,
+                                             VkRenderingAreaInfoKHR* toTransform);
+
+void transform_fromhost_VkRenderingAreaInfoKHR(VkDecoderGlobalState* resourceTracker,
+                                               VkRenderingAreaInfoKHR* toTransform);
+
+void transform_tohost_VkImageSubresource2KHR(VkDecoderGlobalState* resourceTracker,
+                                             VkImageSubresource2KHR* toTransform);
+
+void transform_fromhost_VkImageSubresource2KHR(VkDecoderGlobalState* resourceTracker,
+                                               VkImageSubresource2KHR* toTransform);
+
+void transform_tohost_VkDeviceImageSubresourceInfoKHR(VkDecoderGlobalState* resourceTracker,
+                                                      VkDeviceImageSubresourceInfoKHR* toTransform);
+
+void transform_fromhost_VkDeviceImageSubresourceInfoKHR(
+    VkDecoderGlobalState* resourceTracker, VkDeviceImageSubresourceInfoKHR* toTransform);
+
+void transform_tohost_VkSubresourceLayout2KHR(VkDecoderGlobalState* resourceTracker,
+                                              VkSubresourceLayout2KHR* toTransform);
+
+void transform_fromhost_VkSubresourceLayout2KHR(VkDecoderGlobalState* resourceTracker,
+                                                VkSubresourceLayout2KHR* toTransform);
+
+void transform_tohost_VkPipelineCreateFlags2CreateInfoKHR(
+    VkDecoderGlobalState* resourceTracker, VkPipelineCreateFlags2CreateInfoKHR* toTransform);
+
+void transform_fromhost_VkPipelineCreateFlags2CreateInfoKHR(
+    VkDecoderGlobalState* resourceTracker, VkPipelineCreateFlags2CreateInfoKHR* toTransform);
+
+void transform_tohost_VkBufferUsageFlags2CreateInfoKHR(
+    VkDecoderGlobalState* resourceTracker, VkBufferUsageFlags2CreateInfoKHR* toTransform);
+
+void transform_fromhost_VkBufferUsageFlags2CreateInfoKHR(
+    VkDecoderGlobalState* resourceTracker, VkBufferUsageFlags2CreateInfoKHR* toTransform);
+
+#endif
 #ifdef VK_ANDROID_native_buffer
 void transform_tohost_VkNativeBufferUsage2ANDROID(VkDecoderGlobalState* resourceTracker,
                                                   VkNativeBufferUsage2ANDROID* toTransform);
@@ -2882,6 +2932,80 @@
     VkPhysicalDeviceExtendedDynamicStateFeaturesEXT* toTransform);
 
 #endif
+#ifdef VK_EXT_host_image_copy
+void transform_tohost_VkPhysicalDeviceHostImageCopyFeaturesEXT(
+    VkDecoderGlobalState* resourceTracker, VkPhysicalDeviceHostImageCopyFeaturesEXT* toTransform);
+
+void transform_fromhost_VkPhysicalDeviceHostImageCopyFeaturesEXT(
+    VkDecoderGlobalState* resourceTracker, VkPhysicalDeviceHostImageCopyFeaturesEXT* toTransform);
+
+void transform_tohost_VkPhysicalDeviceHostImageCopyPropertiesEXT(
+    VkDecoderGlobalState* resourceTracker, VkPhysicalDeviceHostImageCopyPropertiesEXT* toTransform);
+
+void transform_fromhost_VkPhysicalDeviceHostImageCopyPropertiesEXT(
+    VkDecoderGlobalState* resourceTracker, VkPhysicalDeviceHostImageCopyPropertiesEXT* toTransform);
+
+void transform_tohost_VkMemoryToImageCopyEXT(VkDecoderGlobalState* resourceTracker,
+                                             VkMemoryToImageCopyEXT* toTransform);
+
+void transform_fromhost_VkMemoryToImageCopyEXT(VkDecoderGlobalState* resourceTracker,
+                                               VkMemoryToImageCopyEXT* toTransform);
+
+void transform_tohost_VkImageToMemoryCopyEXT(VkDecoderGlobalState* resourceTracker,
+                                             VkImageToMemoryCopyEXT* toTransform);
+
+void transform_fromhost_VkImageToMemoryCopyEXT(VkDecoderGlobalState* resourceTracker,
+                                               VkImageToMemoryCopyEXT* toTransform);
+
+void transform_tohost_VkCopyMemoryToImageInfoEXT(VkDecoderGlobalState* resourceTracker,
+                                                 VkCopyMemoryToImageInfoEXT* toTransform);
+
+void transform_fromhost_VkCopyMemoryToImageInfoEXT(VkDecoderGlobalState* resourceTracker,
+                                                   VkCopyMemoryToImageInfoEXT* toTransform);
+
+void transform_tohost_VkCopyImageToMemoryInfoEXT(VkDecoderGlobalState* resourceTracker,
+                                                 VkCopyImageToMemoryInfoEXT* toTransform);
+
+void transform_fromhost_VkCopyImageToMemoryInfoEXT(VkDecoderGlobalState* resourceTracker,
+                                                   VkCopyImageToMemoryInfoEXT* toTransform);
+
+void transform_tohost_VkCopyImageToImageInfoEXT(VkDecoderGlobalState* resourceTracker,
+                                                VkCopyImageToImageInfoEXT* toTransform);
+
+void transform_fromhost_VkCopyImageToImageInfoEXT(VkDecoderGlobalState* resourceTracker,
+                                                  VkCopyImageToImageInfoEXT* toTransform);
+
+void transform_tohost_VkHostImageLayoutTransitionInfoEXT(
+    VkDecoderGlobalState* resourceTracker, VkHostImageLayoutTransitionInfoEXT* toTransform);
+
+void transform_fromhost_VkHostImageLayoutTransitionInfoEXT(
+    VkDecoderGlobalState* resourceTracker, VkHostImageLayoutTransitionInfoEXT* toTransform);
+
+void transform_tohost_VkSubresourceHostMemcpySizeEXT(VkDecoderGlobalState* resourceTracker,
+                                                     VkSubresourceHostMemcpySizeEXT* toTransform);
+
+void transform_fromhost_VkSubresourceHostMemcpySizeEXT(VkDecoderGlobalState* resourceTracker,
+                                                       VkSubresourceHostMemcpySizeEXT* toTransform);
+
+void transform_tohost_VkHostImageCopyDevicePerformanceQueryEXT(
+    VkDecoderGlobalState* resourceTracker, VkHostImageCopyDevicePerformanceQueryEXT* toTransform);
+
+void transform_fromhost_VkHostImageCopyDevicePerformanceQueryEXT(
+    VkDecoderGlobalState* resourceTracker, VkHostImageCopyDevicePerformanceQueryEXT* toTransform);
+
+DEFINE_ALIAS_FUNCTION(transform_tohost_VkSubresourceLayout2KHR,
+                      transform_tohost_VkSubresourceLayout2EXT)
+
+DEFINE_ALIAS_FUNCTION(transform_fromhost_VkSubresourceLayout2KHR,
+                      transform_fromhost_VkSubresourceLayout2EXT)
+
+DEFINE_ALIAS_FUNCTION(transform_tohost_VkImageSubresource2KHR,
+                      transform_tohost_VkImageSubresource2EXT)
+
+DEFINE_ALIAS_FUNCTION(transform_fromhost_VkImageSubresource2KHR,
+                      transform_fromhost_VkImageSubresource2EXT)
+
+#endif
 #ifdef VK_EXT_swapchain_maintenance1
 void transform_tohost_VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT(
     VkDecoderGlobalState* resourceTracker,
@@ -3077,18 +3201,6 @@
 void transform_fromhost_VkImageCompressionControlEXT(VkDecoderGlobalState* resourceTracker,
                                                      VkImageCompressionControlEXT* toTransform);
 
-void transform_tohost_VkSubresourceLayout2EXT(VkDecoderGlobalState* resourceTracker,
-                                              VkSubresourceLayout2EXT* toTransform);
-
-void transform_fromhost_VkSubresourceLayout2EXT(VkDecoderGlobalState* resourceTracker,
-                                                VkSubresourceLayout2EXT* toTransform);
-
-void transform_tohost_VkImageSubresource2EXT(VkDecoderGlobalState* resourceTracker,
-                                             VkImageSubresource2EXT* toTransform);
-
-void transform_fromhost_VkImageSubresource2EXT(VkDecoderGlobalState* resourceTracker,
-                                               VkImageSubresource2EXT* toTransform);
-
 void transform_tohost_VkImageCompressionPropertiesEXT(VkDecoderGlobalState* resourceTracker,
                                                       VkImageCompressionPropertiesEXT* toTransform);
 
diff --git a/host/vulkan/vk_android_native_buffer.h b/host/vulkan/vk_android_native_buffer.h
deleted file mode 100644
index 6e2060b..0000000
--- a/host/vulkan/vk_android_native_buffer.h
+++ /dev/null
@@ -1,116 +0,0 @@
-// Copyright (C) 2022 The Android Open Source Project
-// Copyright (C) 2022 Google Inc.
-//
-// 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.
-//
-// Autogenerated header vk_android_native_buffer.h
-// Please do not modify directly;
-// re-run scripts/generate-vulkan-sources.sh,
-// or directly from Python by calling the genvk.py script with correct parameters.
-//
-// This header is generated to support building the Gfxstream host components
-// with system installed Vulkan headers instead of with Gfxstream's generated
-// headers. Gfxstream's generated Vulkan headers include the Android extension
-// in vulkan/vulkan_core.h due to local edits (see `supported="vulkan"`) but
-// standard Vulkan headers do not. However, the host should still be able to
-// support an Android guest. Gfxstream could be updated in the future to always
-// generate and use the separate vulkan/vk_android_native_buffer.h to
-// consolidate the builds.
-
-#pragma once
-#ifndef VK_ANDROID_native_buffer
-#include "vk_android_native_buffer_structure_type.h"
-#endif /* VK_ANDROID_native_buffer */
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-#ifndef VK_ANDROID_native_buffer
-
-#define VK_ANDROID_native_buffer 1
-#define VK_ANDROID_NATIVE_BUFFER_SPEC_VERSION 8
-#define VK_ANDROID_NATIVE_BUFFER_NUMBER 11
-#define VK_ANDROID_NATIVE_BUFFER_EXTENSION_NAME "VK_ANDROID_native_buffer"
-#define VK_ANDROID_NATIVE_BUFFER_NAME VK_ANDROID_NATIVE_BUFFER_EXTENSION_NAME
-
-typedef enum VkSwapchainImageUsageFlagBitsANDROID {
-    VK_SWAPCHAIN_IMAGE_USAGE_SHARED_BIT_ANDROID = 0x00000001,
-    VK_SWAPCHAIN_IMAGE_USAGE_FLAG_BITS_MAX_ENUM_ANDROID = 0x7FFFFFFF
-} VkSwapchainImageUsageFlagBitsANDROID;
-typedef VkFlags VkSwapchainImageUsageFlagsANDROID;
-typedef struct VkNativeBufferUsage2ANDROID {
-    uint64_t consumer;
-    uint64_t producer;
-} VkNativeBufferUsage2ANDROID;
-
-typedef struct VkNativeBufferANDROID {
-    VkStructureType sType;
-    const void* pNext;
-    const uint32_t* handle;
-    int stride;
-    int format;
-    int usage;
-    VkNativeBufferUsage2ANDROID usage2;
-} VkNativeBufferANDROID;
-
-typedef struct VkSwapchainImageCreateInfoANDROID {
-    VkStructureType sType;
-    const void* pNext;
-    VkSwapchainImageUsageFlagsANDROID usage;
-} VkSwapchainImageCreateInfoANDROID;
-
-typedef struct VkPhysicalDevicePresentationPropertiesANDROID {
-    VkStructureType sType;
-    const void* pNext;
-    VkBool32 sharedImage;
-} VkPhysicalDevicePresentationPropertiesANDROID;
-
-typedef VkResult(VKAPI_PTR* PFN_vkGetSwapchainGrallocUsageANDROID)(VkDevice device, VkFormat format,
-                                                                   VkImageUsageFlags imageUsage,
-                                                                   int* grallocUsage);
-typedef VkResult(VKAPI_PTR* PFN_vkAcquireImageANDROID)(VkDevice device, VkImage image,
-                                                       int nativeFenceFd, VkSemaphore semaphore,
-                                                       VkFence fence);
-typedef VkResult(VKAPI_PTR* PFN_vkQueueSignalReleaseImageANDROID)(
-    VkQueue queue, uint32_t waitSemaphoreCount, const VkSemaphore* pWaitSemaphores, VkImage image,
-    int* pNativeFenceFd);
-typedef VkResult(VKAPI_PTR* PFN_vkGetSwapchainGrallocUsage2ANDROID)(
-    VkDevice device, VkFormat format, VkImageUsageFlags imageUsage,
-    VkSwapchainImageUsageFlagsANDROID swapchainImageUsage, uint64_t* grallocConsumerUsage,
-    uint64_t* grallocProducerUsage);
-
-#ifndef VK_NO_PROTOTYPES
-VKAPI_ATTR VkResult VKAPI_CALL vkGetSwapchainGrallocUsageANDROID(VkDevice device, VkFormat format,
-                                                                 VkImageUsageFlags imageUsage,
-                                                                 int* grallocUsage);
-
-VKAPI_ATTR VkResult VKAPI_CALL vkAcquireImageANDROID(VkDevice device, VkImage image,
-                                                     int nativeFenceFd, VkSemaphore semaphore,
-                                                     VkFence fence);
-
-VKAPI_ATTR VkResult VKAPI_CALL vkQueueSignalReleaseImageANDROID(VkQueue queue,
-                                                                uint32_t waitSemaphoreCount,
-                                                                const VkSemaphore* pWaitSemaphores,
-                                                                VkImage image, int* pNativeFenceFd);
-
-VKAPI_ATTR VkResult VKAPI_CALL
-vkGetSwapchainGrallocUsage2ANDROID(VkDevice device, VkFormat format, VkImageUsageFlags imageUsage,
-                                   VkSwapchainImageUsageFlagsANDROID swapchainImageUsage,
-                                   uint64_t* grallocConsumerUsage, uint64_t* grallocProducerUsage);
-#endif
-#endif /* VK_ANDROID_native_buffer */
-
-#ifdef __cplusplus
-}
-#endif
diff --git a/host/vulkan/vk_android_native_buffer_gfxstream.h b/host/vulkan/vk_android_native_buffer_gfxstream.h
new file mode 100644
index 0000000..70f3696
--- /dev/null
+++ b/host/vulkan/vk_android_native_buffer_gfxstream.h
@@ -0,0 +1,250 @@
+/*
+ * Copyright 2015 The Android Open Source Project
+ *
+ * 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.
+ */
+
+#ifndef __VK_ANDROID_NATIVE_BUFFER_H__
+#define __VK_ANDROID_NATIVE_BUFFER_H__
+
+/* MESA: A hack to avoid #ifdefs in driver code. */
+#if defined(ANDROID)
+#include <cutils/native_handle.h>
+#include <vulkan/vulkan.h>
+
+#if ANDROID_API_LEVEL < 28
+/* buffer_handle_t was defined in the deprecated system/window.h */
+typedef const native_handle_t* buffer_handle_t;
+#endif
+
+#else
+typedef void* buffer_handle_t;
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define VK_ANDROID_native_buffer 1
+
+#define VK_ANDROID_NATIVE_BUFFER_EXTENSION_NUMBER 11
+/*
+ * NOTE ON VK_ANDROID_NATIVE_BUFFER_SPEC_VERSION 6
+ *
+ * This version of the extension transitions from gralloc0 to gralloc1 usage
+ * flags (int -> 2x uint64_t). The WSI implementation will temporarily continue
+ * to fill out deprecated fields in VkNativeBufferANDROID, and will call the
+ * deprecated vkGetSwapchainGrallocUsageANDROID if the new
+ * vkGetSwapchainGrallocUsage2ANDROID is not supported. This transitionary
+ * backwards-compatibility support is temporary, and will likely be removed
+ * (along with all gralloc0 support) in a future release.
+ */
+/*
+ * NOTE ON VK_ANDROID_NATIVE_BUFFER_SPEC_VERSION 8
+ *
+ * This version of the extension doesn't introduce new types or structs, but is
+ * to accommodate the new struct VkBindImageMemorySwapchainInfoKHR added in
+ * VK_KHR_swapchain spec version 69. When VkBindImageMemorySwapchainInfoKHR is
+ * chained in the pNext chain of VkBindImageMemoryInfo, a VkNativeBufferANDROID
+ * that holds the correct gralloc handle according to the imageIndex specified
+ * in VkBindImageMemorySwapchainInfoKHR will be additionally chained to the
+ * pNext chain of VkBindImageMemoryInfo and passed down to the driver.
+ */
+/*
+ * NOTE ON VK_ANDROID_NATIVE_BUFFER_SPEC_VERSION 9
+ *
+ * This version of the extension is largely designed to clean up the mix of
+ * GrallocUsage and GrallocUsage2
+ */
+#define VK_ANDROID_NATIVE_BUFFER_SPEC_VERSION 9
+#define VK_ANDROID_NATIVE_BUFFER_EXTENSION_NAME "VK_ANDROID_native_buffer"
+
+#define VK_ANDROID_NATIVE_BUFFER_ENUM(type, id) \
+    ((type)(1000000000 + (1000 * (VK_ANDROID_NATIVE_BUFFER_EXTENSION_NUMBER - 1)) + (id)))
+#define VK_STRUCTURE_TYPE_NATIVE_BUFFER_ANDROID VK_ANDROID_NATIVE_BUFFER_ENUM(VkStructureType, 0)
+#define VK_STRUCTURE_TYPE_SWAPCHAIN_IMAGE_CREATE_INFO_ANDROID \
+    VK_ANDROID_NATIVE_BUFFER_ENUM(VkStructureType, 1)
+#define VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENTATION_PROPERTIES_ANDROID \
+    VK_ANDROID_NATIVE_BUFFER_ENUM(VkStructureType, 2)
+#define VK_STRUCTURE_TYPE_GRALLOC_USAGE_INFO_ANDROID \
+    VK_ANDROID_NATIVE_BUFFER_ENUM(VkStructureType, 3)
+
+/* clang-format off */
+typedef enum VkSwapchainImageUsageFlagBitsANDROID {
+    VK_SWAPCHAIN_IMAGE_USAGE_SHARED_BIT_ANDROID = 0x00000001,
+    VK_SWAPCHAIN_IMAGE_USAGE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
+} VkSwapchainImageUsageFlagBitsANDROID;
+typedef VkFlags VkSwapchainImageUsageFlagsANDROID;
+
+/*
+ * struct VkNativeBufferUsage2ANDROID
+ *
+ * consumer: gralloc1 consumer usage flag
+ * producer: gralloc1 producer usage flag
+ */
+typedef struct {
+    uint64_t                          consumer;
+    uint64_t                          producer;
+} VkNativeBufferUsage2ANDROID;
+
+/*
+ * struct VkNativeBufferANDROID
+ *
+ * sType: VK_STRUCTURE_TYPE_NATIVE_BUFFER_ANDROID
+ * pNext: NULL or a pointer to a structure extending this structure
+ * handle: buffer handle returned from gralloc alloc()
+ * stride: stride returned from gralloc alloc()
+ * format: gralloc format requested when the buffer was allocated
+ * usage: gralloc usage requested when the buffer was allocated
+ * usage2: gralloc usage requested when the buffer was allocated
+ * usage3: gralloc usage requested when the buffer was allocated
+ */
+typedef struct {
+    VkStructureType                   sType;
+    const void*                       pNext;
+    const uint32_t*                   handle;
+    int                               stride;
+    int                               format;
+    int                               usage; /* DEPRECATED in SPEC_VERSION 6 */
+    VkNativeBufferUsage2ANDROID       usage2; /* DEPRECATED in SPEC_VERSION 9 */
+    uint64_t                          usage3; /* ADDED in SPEC_VERSION 9 */
+} VkNativeBufferANDROID;
+
+/*
+ * struct VkSwapchainImageCreateInfoANDROID
+ *
+ * sType: VK_STRUCTURE_TYPE_SWAPCHAIN_IMAGE_CREATE_INFO_ANDROID
+ * pNext: NULL or a pointer to a structure extending this structure
+ * usage: is a bitmask of VkSwapchainImageUsageFlagsANDROID
+ */
+typedef struct {
+    VkStructureType                   sType;
+    const void*                       pNext;
+    VkSwapchainImageUsageFlagsANDROID usage;
+} VkSwapchainImageCreateInfoANDROID;
+
+/*
+ * struct VkPhysicalDevicePresentationPropertiesANDROID
+ *
+ * sType: VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENTATION_PROPERTIES_ANDROID
+ * pNext: NULL or a pointer to a structure extending this structure
+ * sharedImage: specifies if the image can be shared with the display system
+ */
+typedef struct {
+    VkStructureType                   sType;
+    const void*                       pNext;
+    VkBool32                          sharedImage;
+} VkPhysicalDevicePresentationPropertiesANDROID;
+
+/*
+ * struct VkGrallocUsageInfoANDROID
+ *
+ * sType: VK_STRUCTURE_TYPE_GRALLOC_USAGE_INFO_ANDROID
+ * pNext: NULL or a pointer to a structure extending this structure
+ * format: value specifying the format the image will be created with
+ * imageUsage: bitmask of VkImageUsageFlagBits describing intended usage
+ */
+typedef struct {
+    VkStructureType                   sType;
+    const void*                       pNext;
+    VkFormat                          format;
+    VkImageUsageFlags                 imageUsage;
+} VkGrallocUsageInfoANDROID;
+
+/* DEPRECATED in SPEC_VERSION 6 */
+typedef VkResult (VKAPI_PTR *PFN_vkGetSwapchainGrallocUsageANDROID)(
+    VkDevice                          device,
+    VkFormat                          format,
+    VkImageUsageFlags                 imageUsage,
+    int*                              grallocUsage);
+
+/* DEPRECATED in SPEC_VERSION 9 */
+typedef VkResult (VKAPI_PTR *PFN_vkGetSwapchainGrallocUsage2ANDROID)(
+    VkDevice                          device,
+    VkFormat                          format,
+    VkImageUsageFlags                 imageUsage,
+    VkSwapchainImageUsageFlagsANDROID swapchainImageUsage,
+    uint64_t*                         grallocConsumerUsage,
+    uint64_t*                         grallocProducerUsage);
+
+/* ADDED in SPEC_VERSION 9 */
+typedef VkResult (VKAPI_PTR *PFN_vkGetSwapchainGrallocUsage3ANDROID)(
+    VkDevice                          device,
+    const VkGrallocUsageInfoANDROID*  grallocUsageInfo,
+    uint64_t*                         grallocUsage);
+
+typedef VkResult (VKAPI_PTR *PFN_vkAcquireImageANDROID)(
+    VkDevice                          device,
+    VkImage                           image,
+    int                               nativeFenceFd,
+    VkSemaphore                       semaphore,
+    VkFence                           fence);
+
+typedef VkResult (VKAPI_PTR *PFN_vkQueueSignalReleaseImageANDROID)(
+    VkQueue                           queue,
+    uint32_t                          waitSemaphoreCount,
+    const VkSemaphore*                pWaitSemaphores,
+    VkImage                           image,
+    int*                              pNativeFenceFd);
+
+#ifndef VK_NO_PROTOTYPES
+
+/* DEPRECATED in SPEC_VERSION 6 */
+VKAPI_ATTR VkResult VKAPI_CALL vkGetSwapchainGrallocUsageANDROID(
+    VkDevice                          device,
+    VkFormat                          format,
+    VkImageUsageFlags                 imageUsage,
+    int*                              grallocUsage
+);
+
+/* DEPRECATED in SPEC_VERSION 9 */
+VKAPI_ATTR VkResult VKAPI_CALL vkGetSwapchainGrallocUsage2ANDROID(
+    VkDevice                          device,
+    VkFormat                          format,
+    VkImageUsageFlags                 imageUsage,
+    VkSwapchainImageUsageFlagsANDROID swapchainImageUsage,
+    uint64_t*                         grallocConsumerUsage,
+    uint64_t*                         grallocProducerUsage
+);
+
+/* ADDED in SPEC_VERSION 9 */
+VKAPI_ATTR VkResult VKAPI_CALL vkGetSwapchainGrallocUsage3ANDROID(
+    VkDevice                          device,
+    const VkGrallocUsageInfoANDROID*  grallocUsageInfo,
+    uint64_t*                         grallocUsage
+);
+
+VKAPI_ATTR VkResult VKAPI_CALL vkAcquireImageANDROID(
+    VkDevice                          device,
+    VkImage                           image,
+    int                               nativeFenceFd,
+    VkSemaphore                       semaphore,
+    VkFence                           fence
+);
+
+VKAPI_ATTR VkResult VKAPI_CALL vkQueueSignalReleaseImageANDROID(
+    VkQueue                           queue,
+    uint32_t                          waitSemaphoreCount,
+    const VkSemaphore*                pWaitSemaphores,
+    VkImage                           image,
+    int*                              pNativeFenceFd
+);
+
+#endif
+/* clang-format on */
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* __VK_ANDROID_NATIVE_BUFFER_H__ */
diff --git a/host/vulkan/vk_android_native_buffer_structure_type.h b/host/vulkan/vk_android_native_buffer_structure_type.h
index 81accfa..caa7ec6 100644
--- a/host/vulkan/vk_android_native_buffer_structure_type.h
+++ b/host/vulkan/vk_android_native_buffer_structure_type.h
@@ -15,9 +15,9 @@
 
 // Autogenerated module vk_android_native_buffer_structure_type
 //
-// (header) generated by codegen/vulkan/vulkan-docs/scripts/genvk.py -registry
-// codegen/vulkan/vulkan-docs/xml/vk.xml -registryGfxstream
-// codegen/vulkan/vulkan-docs/xml/vk_gfxstream.xml cereal -o host/vulkan/cereal
+// (header) generated by codegen/vulkan/vulkan-docs-next/scripts/genvk.py -registry
+// codegen/vulkan/vulkan-docs-next/xml/vk.xml -registryGfxstream
+// codegen/vulkan/vulkan-docs-next/xml/vk_gfxstream.xml cereal -o host/vulkan/cereal
 //
 // Please do not modify directly;
 // re-run gfxstream-protocols/scripts/generate-vulkan-sources.sh,
diff --git a/host/vulkan/vulkan_gfxstream.h b/host/vulkan/vulkan_gfxstream.h
index c0e23d5..44ec697 100644
--- a/host/vulkan/vulkan_gfxstream.h
+++ b/host/vulkan/vulkan_gfxstream.h
@@ -1,22 +1,13 @@
-// Copyright (C) 2022 The Android Open Source Project
-// Copyright (C) 2022 Google Inc.
-//
-// 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.
-//
-// Autogenerated header vulkan_gfxstream.h
-// Please do not modify directly;
-// re-run gfxstream-protocols/scripts/generate-vulkan-sources.sh,
-// or directly from Python by calling the genvk.py script with correct parameters.
+/*
+** Copyright 2015-2023 The Khronos Group Inc.
+**
+** SPDX-License-Identifier: Apache-2.0
+*/
+
+/*
+** This header is generated from the Khronos Vulkan XML API Registry.
+**
+*/
 
 #pragma once
 #ifdef VK_GFXSTREAM_STRUCTURE_TYPE_EXT
@@ -27,6 +18,7 @@
 extern "C" {
 #endif
 
+// VK_GOOGLE_gfxstream is a preprocessor guard. Do not pass it to API calls.
 #define VK_GOOGLE_gfxstream 1
 #define VK_GOOGLE_GFXSTREAM_SPEC_VERSION 0
 #define VK_GOOGLE_GFXSTREAM_NUMBER 386
diff --git a/host/vulkan/vulkan_gfxstream_structure_type.h b/host/vulkan/vulkan_gfxstream_structure_type.h
index 9d89082..7ef8ed8 100644
--- a/host/vulkan/vulkan_gfxstream_structure_type.h
+++ b/host/vulkan/vulkan_gfxstream_structure_type.h
@@ -15,9 +15,9 @@
 
 // Autogenerated module vulkan_gfxstream_structure_type
 //
-// (header) generated by codegen/vulkan/vulkan-docs/scripts/genvk.py -registry
-// codegen/vulkan/vulkan-docs/xml/vk.xml -registryGfxstream
-// codegen/vulkan/vulkan-docs/xml/vk_gfxstream.xml cereal -o host/vulkan/cereal
+// (header) generated by codegen/vulkan/vulkan-docs-next/scripts/genvk.py -registry
+// codegen/vulkan/vulkan-docs-next/xml/vk.xml -registryGfxstream
+// codegen/vulkan/vulkan-docs-next/xml/vk_gfxstream.xml cereal -o host/vulkan/cereal
 //
 // Please do not modify directly;
 // re-run gfxstream-protocols/scripts/generate-vulkan-sources.sh,