//* Copyright 2017 The Dawn Authors //* //* 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 "dawn_wire/Wire.h" #include "dawn_wire/WireCmd.h" #include "common/Assert.h" #include #include #include #include #include #include namespace dawn_wire { //* Client side implementation of the API, will serialize everything to memory to send to the server side. namespace client { class Device; struct BuilderCallbackData { bool Call(dawnBuilderErrorStatus status, const char* message) { if (canCall && callback != nullptr) { canCall = true; callback(status, message, userdata1, userdata2); return true; } return false; } //* For help with development, prints all builder errors by default. dawnBuilderErrorCallback callback = nullptr; dawnCallbackUserdata userdata1 = 0; dawnCallbackUserdata userdata2 = 0; bool canCall = true; }; //* All non-Device objects of the client side have: //* - A pointer to the device to get where to serialize commands //* - The external reference count //* - An ID that is used to refer to this object when talking with the server side struct ObjectBase { ObjectBase(Device* device, uint32_t refcount, uint32_t id) :device(device), refcount(refcount), id(id) { } Device* device; uint32_t refcount; uint32_t id; BuilderCallbackData builderCallback; }; {% set special_objects = [ "device", "buffer", ] %} {% for type in by_category["object"] if not type.name.canonical_case() in special_objects %} struct {{type.name.CamelCase()}} : ObjectBase { using ObjectBase::ObjectBase; }; {% endfor %} struct Buffer : ObjectBase { using ObjectBase::ObjectBase; ~Buffer() { //* Callbacks need to be fired in all cases, as they can handle freeing resources //* so we call them with "Unknown" status. ClearMapRequests(DAWN_BUFFER_MAP_ASYNC_STATUS_UNKNOWN); if (mappedData) { free(mappedData); } } void ClearMapRequests(dawnBufferMapAsyncStatus status) { for (auto& it : requests) { if (it.second.isWrite) { it.second.writeCallback(status, nullptr, it.second.userdata); } else { it.second.readCallback(status, nullptr, it.second.userdata); } } requests.clear(); } //* We want to defer all the validation to the server, which means we could have multiple //* map request in flight at a single time and need to track them separately. //* On well-behaved applications, only one request should exist at a single time. struct MapRequestData { dawnBufferMapReadCallback readCallback = nullptr; dawnBufferMapWriteCallback writeCallback = nullptr; dawnCallbackUserdata userdata = 0; uint32_t size = 0; bool isWrite = false; }; std::map requests; uint32_t requestSerial = 0; //* Only one mapped pointer can be active at a time because Unmap clears all the in-flight requests. void* mappedData = nullptr; size_t mappedDataSize = 0; bool isWriteMapped = false; }; //* TODO(cwallez@chromium.org): Do something with objects before they are destroyed ? //* - Call still uncalled builder callbacks template class ObjectAllocator { public: struct ObjectAndSerial { ObjectAndSerial(std::unique_ptr object, uint32_t serial) : object(std::move(object)), serial(serial) { } std::unique_ptr object; uint32_t serial; }; ObjectAllocator(Device* device) : mDevice(device) { // ID 0 is nullptr mObjects.emplace_back(nullptr, 0); } ObjectAndSerial* New() { uint32_t id = GetNewId(); T* result = new T(mDevice, 1, id); auto object = std::unique_ptr(result); if (id >= mObjects.size()) { ASSERT(id == mObjects.size()); mObjects.emplace_back(std::move(object), 0); } else { ASSERT(mObjects[id].object == nullptr); //* TODO(cwallez@chromium.org): investigate if overflows could cause bad things to happen mObjects[id].serial++; mObjects[id].object = std::move(object); } return &mObjects[id]; } void Free(T* obj) { FreeId(obj->id); mObjects[obj->id].object = nullptr; } T* GetObject(uint32_t id) { if (id >= mObjects.size()) { return nullptr; } return mObjects[id].object.get(); } uint32_t GetSerial(uint32_t id) { if (id >= mObjects.size()) { return 0; } return mObjects[id].serial; } private: uint32_t GetNewId() { if (mFreeIds.empty()) { return mCurrentId ++; } uint32_t id = mFreeIds.back(); mFreeIds.pop_back(); return id; } void FreeId(uint32_t id) { mFreeIds.push_back(id); } // 0 is an ID reserved to represent nullptr uint32_t mCurrentId = 1; std::vector mFreeIds; std::vector mObjects; Device* mDevice; }; //* The client wire uses the global Dawn device to store its global data such as the serializer //* and the object id allocators. class Device : public ObjectBase, public ObjectIdProvider { public: Device(CommandSerializer* serializer) : ObjectBase(this, 1, 1), {% for type in by_category["object"] if not type.name.canonical_case() == "device" %} {{type.name.camelCase()}}(this), {% endfor %} mSerializer(serializer) { } void* GetCmdSpace(size_t size) { return mSerializer->GetCmdSpace(size); } {% for type in by_category["object"] if not type.name.canonical_case() == "device" %} ObjectAllocator<{{type.name.CamelCase()}}> {{type.name.camelCase()}}; {% endfor %} // Implementation of the ObjectIdProvider interface {% for type in by_category["object"] %} ObjectId GetId({{as_cType(type.name)}} object) const override { if (object == nullptr) { return 0; } return reinterpret_cast<{{as_wireType(type)}}>(object)->id; } {% endfor %} void HandleError(const char* message) { if (errorCallback) { errorCallback(message, errorUserdata); } } dawnDeviceErrorCallback errorCallback = nullptr; dawnCallbackUserdata errorUserdata; private: CommandSerializer* mSerializer = nullptr; }; //* Implementation of the client API functions. {% for type in by_category["object"] %} {% set Type = type.name.CamelCase() %} {% set cType = as_cType(type.name) %} {% for method in type.methods %} {% set Suffix = as_MethodSuffix(type.name, method.name) %} {{as_cType(method.return_type.name)}} Client{{Suffix}}( {{-cType}} cSelf {%- for arg in method.arguments -%} , {{as_annotated_cType(arg)}} {%- endfor -%} ) { auto self = reinterpret_cast<{{as_wireType(type)}}>(cSelf); Device* device = self->device; {{Suffix}}Cmd cmd; //* Create the structure going on the wire on the stack and fill it with the value //* arguments so it can compute its size. cmd.self = cSelf; //* For object creation, store the object ID the client will use for the result. {% if method.return_type.category == "object" %} auto* allocation = self->device->{{method.return_type.name.camelCase()}}.New(); {% if type.is_builder %} //* We are in GetResult, so the callback that should be called is the //* currently set one. Copy it over to the created object and prevent the //* builder from calling the callback on destruction. allocation->object->builderCallback = self->builderCallback; self->builderCallback.canCall = false; {% endif %} cmd.resultId = allocation->object->id; cmd.resultSerial = allocation->serial; {% endif %} {% for arg in method.arguments %} cmd.{{as_varName(arg.name)}} = {{as_varName(arg.name)}}; {% endfor %} //* Allocate space to send the command and copy the value args over. size_t requiredSize = cmd.GetRequiredSize(); char* allocatedBuffer = static_cast(device->GetCmdSpace(requiredSize)); cmd.Serialize(allocatedBuffer, *device); {% if method.return_type.category == "object" %} return reinterpret_cast<{{as_cType(method.return_type.name)}}>(allocation->object.get()); {% endif %} } {% endfor %} {% if type.is_builder %} void Client{{as_MethodSuffix(type.name, Name("set error callback"))}}({{cType}} cSelf, dawnBuilderErrorCallback callback, dawnCallbackUserdata userdata1, dawnCallbackUserdata userdata2) { {{Type}}* self = reinterpret_cast<{{Type}}*>(cSelf); self->builderCallback.callback = callback; self->builderCallback.userdata1 = userdata1; self->builderCallback.userdata2 = userdata2; } {% endif %} {% if not type.name.canonical_case() == "device" %} //* When an object's refcount reaches 0, notify the server side of it and delete it. void Client{{as_MethodSuffix(type.name, Name("release"))}}({{cType}} cObj) { {{Type}}* obj = reinterpret_cast<{{Type}}*>(cObj); obj->refcount --; if (obj->refcount > 0) { return; } obj->builderCallback.Call(DAWN_BUILDER_ERROR_STATUS_UNKNOWN, "Unknown"); {{as_MethodSuffix(type.name, Name("destroy"))}}Cmd cmd; cmd.objectId = obj->id; auto allocCmd = static_cast(obj->device->GetCmdSpace(sizeof(cmd))); *allocCmd = cmd; obj->device->{{type.name.camelCase()}}.Free(obj); } void Client{{as_MethodSuffix(type.name, Name("reference"))}}({{cType}} cObj) { {{Type}}* obj = reinterpret_cast<{{Type}}*>(cObj); obj->refcount ++; } {% endif %} {% endfor %} void ClientBufferMapReadAsync(dawnBuffer cBuffer, uint32_t start, uint32_t size, dawnBufferMapReadCallback callback, dawnCallbackUserdata userdata) { Buffer* buffer = reinterpret_cast(cBuffer); uint32_t serial = buffer->requestSerial++; ASSERT(buffer->requests.find(serial) == buffer->requests.end()); Buffer::MapRequestData request; request.readCallback = callback; request.userdata = userdata; request.size = size; request.isWrite = false; buffer->requests[serial] = request; BufferMapAsyncCmd cmd; cmd.bufferId = buffer->id; cmd.requestSerial = serial; cmd.start = start; cmd.size = size; cmd.isWrite = false; auto allocCmd = static_cast(buffer->device->GetCmdSpace(sizeof(cmd))); *allocCmd = cmd; } void ClientBufferMapWriteAsync(dawnBuffer cBuffer, uint32_t start, uint32_t size, dawnBufferMapWriteCallback callback, dawnCallbackUserdata userdata) { Buffer* buffer = reinterpret_cast(cBuffer); uint32_t serial = buffer->requestSerial++; ASSERT(buffer->requests.find(serial) == buffer->requests.end()); Buffer::MapRequestData request; request.writeCallback = callback; request.userdata = userdata; request.size = size; request.isWrite = true; buffer->requests[serial] = request; BufferMapAsyncCmd cmd; cmd.bufferId = buffer->id; cmd.requestSerial = serial; cmd.start = start; cmd.size = size; cmd.isWrite = true; auto allocCmd = static_cast(buffer->device->GetCmdSpace(sizeof(cmd))); *allocCmd = cmd; } void ProxyClientBufferUnmap(dawnBuffer cBuffer) { Buffer* buffer = reinterpret_cast(cBuffer); //* Invalidate the local pointer, and cancel all other in-flight requests that would turn into //* errors anyway (you can't double map). This prevents race when the following happens, where //* the application code would have unmapped a buffer but still receive a callback: //* - Client -> Server: MapRequest1, Unmap, MapRequest2 //* - Server -> Client: Result of MapRequest1 //* - Unmap locally on the client //* - Server -> Client: Result of MapRequest2 if (buffer->mappedData) { // If the buffer was mapped for writing, send the update to the data to the server if (buffer->isWriteMapped) { BufferUpdateMappedDataCmd cmd; cmd.bufferId = buffer->id; cmd.dataLength = static_cast(buffer->mappedDataSize); auto allocCmd = static_cast(buffer->device->GetCmdSpace(sizeof(cmd))); *allocCmd = cmd; void* dataAlloc = buffer->device->GetCmdSpace(cmd.dataLength); memcpy(dataAlloc, buffer->mappedData, cmd.dataLength); } free(buffer->mappedData); buffer->mappedData = nullptr; } buffer->ClearMapRequests(DAWN_BUFFER_MAP_ASYNC_STATUS_UNKNOWN); ClientBufferUnmap(cBuffer); } void ClientDeviceReference(dawnDevice) { } void ClientDeviceRelease(dawnDevice) { } void ClientDeviceSetErrorCallback(dawnDevice cSelf, dawnDeviceErrorCallback callback, dawnCallbackUserdata userdata) { Device* self = reinterpret_cast(cSelf); self->errorCallback = callback; self->errorUserdata = userdata; } // Some commands don't have a custom wire format, but need to be handled manually to update // some client-side state tracking. For these we have two functions: // - An autogenerated Client{{suffix}} method that sends the command on the wire // - A manual ProxyClient{{suffix}} method that will be inserted in the proctable instead of // the autogenerated one, and that will have to call Client{{suffix}} {% set proxied_commands = ["BufferUnmap"] %} dawnProcTable GetProcs() { dawnProcTable table; {% for type in by_category["object"] %} {% for method in native_methods(type) %} {% set suffix = as_MethodSuffix(type.name, method.name) %} {% if suffix in proxied_commands %} table.{{as_varName(type.name, method.name)}} = ProxyClient{{suffix}}; {% else %} table.{{as_varName(type.name, method.name)}} = Client{{suffix}}; {% endif %} {% endfor %} {% endfor %} return table; } class Client : public CommandHandler { public: Client(Device* device) : mDevice(device) { } const char* HandleCommands(const char* commands, size_t size) override { while (size >= sizeof(ReturnWireCmd)) { ReturnWireCmd cmdId = *reinterpret_cast(commands); bool success = false; switch (cmdId) { case ReturnWireCmd::DeviceErrorCallback: success = HandleDeviceErrorCallbackCmd(&commands, &size); break; {% for type in by_category["object"] if type.is_builder %} case ReturnWireCmd::{{type.name.CamelCase()}}ErrorCallback: success = Handle{{type.name.CamelCase()}}ErrorCallbackCmd(&commands, &size); break; {% endfor %} case ReturnWireCmd::BufferMapReadAsyncCallback: success = HandleBufferMapReadAsyncCallback(&commands, &size); break; case ReturnWireCmd::BufferMapWriteAsyncCallback: success = HandleBufferMapWriteAsyncCallback(&commands, &size); break; default: success = false; } if (!success) { return nullptr; } } if (size != 0) { return nullptr; } return commands; } private: Device* mDevice = nullptr; //* Helper function for the getting of the command data in command handlers. //* Checks there is enough data left, updates the buffer / size and returns //* the command (or nullptr for an error). template static const T* GetData(const char** buffer, size_t* size, size_t count) { // TODO(cwallez@chromium.org): Check for overflow size_t totalSize = count * sizeof(T); if (*size < totalSize) { return nullptr; } const T* data = reinterpret_cast(*buffer); *buffer += totalSize; *size -= totalSize; return data; } template static const T* GetCommand(const char** commands, size_t* size) { return GetData(commands, size, 1); } bool HandleDeviceErrorCallbackCmd(const char** commands, size_t* size) { const auto* cmd = GetCommand(commands, size); if (cmd == nullptr) { return false; } const char* message = GetData(commands, size, cmd->messageStrlen + 1); if (message == nullptr || message[cmd->messageStrlen] != '\0') { return false; } mDevice->HandleError(message); return true; } {% for type in by_category["object"] if type.is_builder %} {% set Type = type.name.CamelCase() %} bool Handle{{Type}}ErrorCallbackCmd(const char** commands, size_t* size) { const auto* cmd = GetCommand(commands, size); if (cmd == nullptr) { return false; } const char* message = GetData(commands, size, cmd->messageStrlen + 1); if (message == nullptr || message[cmd->messageStrlen] != '\0') { return false; } auto* builtObject = mDevice->{{type.built_type.name.camelCase()}}.GetObject(cmd->builtObjectId); uint32_t objectSerial = mDevice->{{type.built_type.name.camelCase()}}.GetSerial(cmd->builtObjectId); //* The object might have been deleted or a new object created with the same ID. if (builtObject == nullptr || objectSerial != cmd->builtObjectSerial) { return true; } bool called = builtObject->builderCallback.Call(static_cast(cmd->status), message); // Unhandled builder errors are forwarded to the device if (!called && cmd->status != DAWN_BUILDER_ERROR_STATUS_SUCCESS && cmd->status != DAWN_BUILDER_ERROR_STATUS_UNKNOWN) { mDevice->HandleError(("Unhandled builder error: " + std::string(message)).c_str()); } return true; } {% endfor %} bool HandleBufferMapReadAsyncCallback(const char** commands, size_t* size) { const auto* cmd = GetCommand(commands, size); if (cmd == nullptr) { return false; } //* Unconditionnally get the data from the buffer so that the correct amount of data is //* consumed from the buffer, even when we ignore the command and early out. const char* requestData = nullptr; if (cmd->status == DAWN_BUFFER_MAP_ASYNC_STATUS_SUCCESS) { requestData = GetData(commands, size, cmd->dataLength); if (requestData == nullptr) { return false; } } auto* buffer = mDevice->buffer.GetObject(cmd->bufferId); uint32_t bufferSerial = mDevice->buffer.GetSerial(cmd->bufferId); //* The buffer might have been deleted or recreated so this isn't an error. if (buffer == nullptr || bufferSerial != cmd->bufferSerial) { return true; } //* The requests can have been deleted via an Unmap so this isn't an error. auto requestIt = buffer->requests.find(cmd->requestSerial); if (requestIt == buffer->requests.end()) { return true; } //* It is an error for the server to call the read callback when we asked for a map write if (requestIt->second.isWrite) { return false; } auto request = requestIt->second; //* Delete the request before calling the callback otherwise the callback could be fired a //* second time. If, for example, buffer.Unmap() is called inside the callback. buffer->requests.erase(requestIt); //* On success, we copy the data locally because the IPC buffer isn't valid outside of this function if (cmd->status == DAWN_BUFFER_MAP_ASYNC_STATUS_SUCCESS) { //* The server didn't send the right amount of data, this is an error and could cause //* the application to crash if we did call the callback. if (request.size != cmd->dataLength) { return false; } ASSERT(requestData != nullptr); if (buffer->mappedData != nullptr) { return false; } buffer->isWriteMapped = false; buffer->mappedDataSize = request.size; buffer->mappedData = malloc(request.size); memcpy(buffer->mappedData, requestData, request.size); request.readCallback(static_cast(cmd->status), buffer->mappedData, request.userdata); } else { request.readCallback(static_cast(cmd->status), nullptr, request.userdata); } return true; } bool HandleBufferMapWriteAsyncCallback(const char** commands, size_t* size) { const auto* cmd = GetCommand(commands, size); if (cmd == nullptr) { return false; } auto* buffer = mDevice->buffer.GetObject(cmd->bufferId); uint32_t bufferSerial = mDevice->buffer.GetSerial(cmd->bufferId); //* The buffer might have been deleted or recreated so this isn't an error. if (buffer == nullptr || bufferSerial != cmd->bufferSerial) { return true; } //* The requests can have been deleted via an Unmap so this isn't an error. auto requestIt = buffer->requests.find(cmd->requestSerial); if (requestIt == buffer->requests.end()) { return true; } //* It is an error for the server to call the write callback when we asked for a map read if (!requestIt->second.isWrite) { return false; } auto request = requestIt->second; //* Delete the request before calling the callback otherwise the callback could be fired a second time. If, for example, buffer.Unmap() is called inside the callback. buffer->requests.erase(requestIt); //* On success, we copy the data locally because the IPC buffer isn't valid outside of this function if (cmd->status == DAWN_BUFFER_MAP_ASYNC_STATUS_SUCCESS) { if (buffer->mappedData != nullptr) { return false; } buffer->isWriteMapped = true; buffer->mappedDataSize = request.size; buffer->mappedData = malloc(request.size); memset(buffer->mappedData, 0, request.size); request.writeCallback(static_cast(cmd->status), buffer->mappedData, request.userdata); } else { request.writeCallback(static_cast(cmd->status), nullptr, request.userdata); } return true; } }; } CommandHandler* NewClientDevice(dawnProcTable* procs, dawnDevice* device, CommandSerializer* serializer) { auto clientDevice = new client::Device(serializer); *device = reinterpret_cast(clientDevice); *procs = client::GetProcs(); return new client::Client(clientDevice); } } // namespace dawn_wire