blob: 40ba1e5bc571b6bfe16f66108b7607c5443a49fe [file] [log] [blame]
/*
* Copyright 2016 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.
*/
#include "driver.h"
namespace vulkan {
namespace driver {
DebugReportCallbackList::Node* DebugReportCallbackList::AddCallback(
const VkDebugReportCallbackCreateInfoEXT& info,
VkDebugReportCallbackEXT driver_handle,
const VkAllocationCallbacks& allocator) {
void* mem = allocator.pfnAllocation(allocator.pUserData, sizeof(Node),
alignof(Node),
VK_SYSTEM_ALLOCATION_SCOPE_OBJECT);
if (!mem)
return nullptr;
// initialize and prepend node to the list
std::lock_guard<decltype(rwmutex_)> lock(rwmutex_);
head_.next = new (mem) Node{head_.next, info.flags, info.pfnCallback,
info.pUserData, driver_handle};
return head_.next;
}
void DebugReportCallbackList::RemoveCallback(
Node* node,
const VkAllocationCallbacks& allocator) {
// remove node from the list
{
std::lock_guard<decltype(rwmutex_)> lock(rwmutex_);
Node* prev = &head_;
while (prev && prev->next != node)
prev = prev->next;
if (prev)
prev->next = node->next;
}
allocator.pfnFree(allocator.pUserData, node);
}
void DebugReportCallbackList::Message(VkDebugReportFlagsEXT flags,
VkDebugReportObjectTypeEXT object_type,
uint64_t object,
size_t location,
int32_t message_code,
const char* layer_prefix,
const char* message) const {
std::shared_lock<decltype(rwmutex_)> lock(rwmutex_);
const Node* node = &head_;
while ((node = node->next)) {
if ((node->flags & flags) != 0) {
node->callback(flags, object_type, object, location, message_code,
layer_prefix, message, node->user_data);
}
}
}
void DebugReportLogger::Message(VkDebugReportFlagsEXT flags,
VkDebugReportObjectTypeEXT object_type,
uint64_t object,
size_t location,
int32_t message_code,
const char* layer_prefix,
const char* message) const {
const VkDebugReportCallbackCreateInfoEXT* info =
reinterpret_cast<const VkDebugReportCallbackCreateInfoEXT*>(
instance_pnext_);
while (info) {
if (info->sType ==
VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT &&
(info->flags & flags) != 0) {
info->pfnCallback(flags, object_type, object, location,
message_code, layer_prefix, message,
info->pUserData);
}
info = reinterpret_cast<const VkDebugReportCallbackCreateInfoEXT*>(
info->pNext);
}
if (callbacks_) {
callbacks_->Message(flags, object_type, object, location, message_code,
layer_prefix, message);
}
}
void DebugReportLogger::PrintV(VkDebugReportFlagsEXT flags,
VkDebugReportObjectTypeEXT object_type,
uint64_t object,
const char* format,
va_list ap) const {
char buf[1024];
int len = vsnprintf(buf, sizeof(buf), format, ap);
// message truncated
if (len >= static_cast<int>(sizeof(buf)))
memcpy(buf + sizeof(buf) - 4, "...", 4);
Message(flags, object_type, object, 0, 0, LOG_TAG, buf);
}
VkResult CreateDebugReportCallbackEXT(
VkInstance instance,
const VkDebugReportCallbackCreateInfoEXT* create_info,
const VkAllocationCallbacks* allocator,
VkDebugReportCallbackEXT* callback) {
const auto& driver = GetData(instance).driver;
VkDebugReportCallbackEXT driver_handle = VK_NULL_HANDLE;
if (driver.CreateDebugReportCallbackEXT) {
VkResult result = driver.CreateDebugReportCallbackEXT(
instance, create_info, allocator, &driver_handle);
if (result != VK_SUCCESS)
return result;
}
auto& callbacks = GetData(instance).debug_report_callbacks;
auto node = callbacks.AddCallback(
*create_info, driver_handle,
(allocator) ? *allocator : GetData(instance).allocator);
if (!node) {
if (driver_handle != VK_NULL_HANDLE) {
driver.DestroyDebugReportCallbackEXT(instance, driver_handle,
allocator);
}
return VK_ERROR_OUT_OF_HOST_MEMORY;
}
*callback = callbacks.GetHandle(node);
return VK_SUCCESS;
}
void DestroyDebugReportCallbackEXT(VkInstance instance,
VkDebugReportCallbackEXT callback,
const VkAllocationCallbacks* allocator) {
if (callback == VK_NULL_HANDLE)
return;
auto& callbacks = GetData(instance).debug_report_callbacks;
auto node = callbacks.FromHandle(callback);
auto driver_handle = callbacks.GetDriverHandle(node);
callbacks.RemoveCallback(
node, (allocator) ? *allocator : GetData(instance).allocator);
if (driver_handle != VK_NULL_HANDLE) {
GetData(instance).driver.DestroyDebugReportCallbackEXT(
instance, driver_handle, allocator);
}
}
void DebugReportMessageEXT(VkInstance instance,
VkDebugReportFlagsEXT flags,
VkDebugReportObjectTypeEXT object_type,
uint64_t object,
size_t location,
int32_t message_code,
const char* layer_prefix,
const char* message) {
if (GetData(instance).driver.DebugReportMessageEXT) {
GetData(instance).driver.DebugReportMessageEXT(
instance, flags, object_type, object, location, message_code,
layer_prefix, message);
} else {
GetData(instance).debug_report_callbacks.Message(
flags, object_type, object, location, message_code, layer_prefix,
message);
}
}
} // namespace driver
} // namespace vulkan