| // Copyright 2019 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/client/Buffer.h" | |
| #include <limits> | |
| #include <utility> | |
| #include "dawn/wire/BufferConsumer_impl.h" | |
| #include "dawn/wire/WireCmd_autogen.h" | |
| #include "dawn/wire/client/Client.h" | |
| #include "dawn/wire/client/Device.h" | |
| namespace dawn::wire::client { | |
| namespace { | |
| WGPUBuffer CreateErrorBufferOOMAtClient(Device* device, const WGPUBufferDescriptor* descriptor) { | |
| if (descriptor->mappedAtCreation) { | |
| return nullptr; | |
| } | |
| WGPUBufferDescriptor errorBufferDescriptor = *descriptor; | |
| WGPUDawnBufferDescriptorErrorInfoFromWireClient errorInfo = {}; | |
| errorInfo.chain.sType = WGPUSType_DawnBufferDescriptorErrorInfoFromWireClient; | |
| errorInfo.outOfMemory = true; | |
| errorBufferDescriptor.nextInChain = &errorInfo.chain; | |
| return device->CreateErrorBuffer(&errorBufferDescriptor); | |
| } | |
| } // anonymous namespace | |
| // static | |
| WGPUBuffer Buffer::Create(Device* device, const WGPUBufferDescriptor* descriptor) { | |
| Client* wireClient = device->GetClient(); | |
| bool mappable = | |
| (descriptor->usage & (WGPUBufferUsage_MapRead | WGPUBufferUsage_MapWrite)) != 0 || | |
| descriptor->mappedAtCreation; | |
| if (mappable && descriptor->size >= std::numeric_limits<size_t>::max()) { | |
| return CreateErrorBufferOOMAtClient(device, descriptor); | |
| } | |
| std::unique_ptr<MemoryTransferService::ReadHandle> readHandle = nullptr; | |
| std::unique_ptr<MemoryTransferService::WriteHandle> writeHandle = nullptr; | |
| DeviceCreateBufferCmd cmd; | |
| cmd.deviceId = device->GetWireId(); | |
| cmd.descriptor = descriptor; | |
| cmd.readHandleCreateInfoLength = 0; | |
| cmd.readHandleCreateInfo = nullptr; | |
| cmd.writeHandleCreateInfoLength = 0; | |
| cmd.writeHandleCreateInfo = nullptr; | |
| size_t readHandleCreateInfoLength = 0; | |
| size_t writeHandleCreateInfoLength = 0; | |
| if (mappable) { | |
| if ((descriptor->usage & WGPUBufferUsage_MapRead) != 0) { | |
| // Create the read handle on buffer creation. | |
| readHandle.reset( | |
| wireClient->GetMemoryTransferService()->CreateReadHandle(descriptor->size)); | |
| if (readHandle == nullptr) { | |
| return CreateErrorBufferOOMAtClient(device, descriptor); | |
| } | |
| readHandleCreateInfoLength = readHandle->SerializeCreateSize(); | |
| cmd.readHandleCreateInfoLength = readHandleCreateInfoLength; | |
| } | |
| if ((descriptor->usage & WGPUBufferUsage_MapWrite) != 0 || descriptor->mappedAtCreation) { | |
| // Create the write handle on buffer creation. | |
| writeHandle.reset( | |
| wireClient->GetMemoryTransferService()->CreateWriteHandle(descriptor->size)); | |
| if (writeHandle == nullptr) { | |
| return CreateErrorBufferOOMAtClient(device, descriptor); | |
| } | |
| writeHandleCreateInfoLength = writeHandle->SerializeCreateSize(); | |
| cmd.writeHandleCreateInfoLength = writeHandleCreateInfoLength; | |
| } | |
| } | |
| // Create the buffer and send the creation command. | |
| // This must happen after any potential device->CreateErrorBuffer() | |
| // as server expects allocating ids to be monotonically increasing | |
| Buffer* buffer = wireClient->Make<Buffer>(device, descriptor); | |
| buffer->mDestructWriteHandleOnUnmap = false; | |
| if (descriptor->mappedAtCreation) { | |
| // If the buffer is mapped at creation, a write handle is created and will be | |
| // destructed on unmap if the buffer doesn't have MapWrite usage | |
| // The buffer is mapped right now. | |
| buffer->mMapState = MapState::MappedAtCreation; | |
| // This flag is for write handle created by mappedAtCreation | |
| // instead of MapWrite usage. We don't have such a case for read handle | |
| buffer->mDestructWriteHandleOnUnmap = (descriptor->usage & WGPUBufferUsage_MapWrite) == 0; | |
| buffer->mMapOffset = 0; | |
| buffer->mMapSize = buffer->mSize; | |
| ASSERT(writeHandle != nullptr); | |
| buffer->mMappedData = writeHandle->GetData(); | |
| } | |
| cmd.result = buffer->GetWireHandle(); | |
| // clang-format off | |
| // Turning off clang format here because for some reason it does not format the | |
| // CommandExtensions consistently, making it harder to read. | |
| wireClient->SerializeCommand( | |
| cmd, | |
| CommandExtension{readHandleCreateInfoLength, | |
| [&](char* readHandleBuffer) { | |
| if (readHandle != nullptr) { | |
| // Serialize the ReadHandle into the space after the command. | |
| readHandle->SerializeCreate(readHandleBuffer); | |
| buffer->mReadHandle = std::move(readHandle); | |
| } | |
| }}, | |
| CommandExtension{writeHandleCreateInfoLength, | |
| [&](char* writeHandleBuffer) { | |
| if (writeHandle != nullptr) { | |
| // Serialize the WriteHandle into the space after the command. | |
| writeHandle->SerializeCreate(writeHandleBuffer); | |
| buffer->mWriteHandle = std::move(writeHandle); | |
| } | |
| }}); | |
| // clang-format on | |
| return ToAPI(buffer); | |
| } | |
| // static | |
| WGPUBuffer Buffer::CreateError(Device* device, const WGPUBufferDescriptor* descriptor) { | |
| Client* client = device->GetClient(); | |
| Buffer* buffer = client->Make<Buffer>(device, descriptor); | |
| DeviceCreateErrorBufferCmd cmd; | |
| cmd.self = ToAPI(device); | |
| cmd.selfId = device->GetWireId(); | |
| cmd.descriptor = descriptor; | |
| cmd.result = buffer->GetWireHandle(); | |
| client->SerializeCommand(cmd); | |
| return ToAPI(buffer); | |
| } | |
| Buffer::Buffer(const ObjectBaseParams& params, | |
| Device* device, | |
| const WGPUBufferDescriptor* descriptor) | |
| : ObjectBase(params), | |
| mSize(descriptor->size), | |
| mUsage(static_cast<WGPUBufferUsage>(descriptor->usage)), | |
| mDeviceIsAlive(device->GetAliveWeakPtr()) {} | |
| Buffer::~Buffer() { | |
| FreeMappedData(); | |
| InvokeAndClearCallback(WGPUBufferMapAsyncStatus_DestroyedBeforeCallback); | |
| } | |
| void Buffer::CancelCallbacksForDisconnect() { | |
| InvokeAndClearCallback(WGPUBufferMapAsyncStatus_DeviceLost); | |
| } | |
| void Buffer::InvokeAndClearCallback(WGPUBufferMapAsyncStatus status) { | |
| WGPUBufferMapCallback callback = mRequest.callback; | |
| void* userdata = mRequest.userdata; | |
| mRequest.callback = nullptr; | |
| mRequest.userdata = nullptr; | |
| mPendingMap = false; | |
| if (callback != nullptr) { | |
| callback(status, userdata); | |
| } | |
| } | |
| void Buffer::MapAsync(WGPUMapModeFlags mode, | |
| size_t offset, | |
| size_t size, | |
| WGPUBufferMapCallback callback, | |
| void* userdata) { | |
| ASSERT(GetRefcount() != 0); | |
| if (mPendingMap) { | |
| return callback(WGPUBufferMapAsyncStatus_Error, userdata); | |
| } | |
| Client* client = GetClient(); | |
| if (client->IsDisconnected()) { | |
| return callback(WGPUBufferMapAsyncStatus_DeviceLost, userdata); | |
| } | |
| // Handle the defaulting of size required by WebGPU. | |
| if ((size == WGPU_WHOLE_MAP_SIZE) && (offset <= mSize)) { | |
| size = mSize - offset; | |
| } | |
| // Set up the request structure that will hold information while this mapping is | |
| // in flight. | |
| mRequest.callback = callback; | |
| mRequest.userdata = userdata; | |
| mRequest.offset = offset; | |
| mRequest.size = size; | |
| if (mode & WGPUMapMode_Read) { | |
| mRequest.type = MapRequestType::Read; | |
| } else if (mode & WGPUMapMode_Write) { | |
| mRequest.type = MapRequestType::Write; | |
| } | |
| // Serialize the command to send to the server. | |
| mPendingMap = true; | |
| mSerial++; | |
| BufferMapAsyncCmd cmd; | |
| cmd.bufferId = GetWireId(); | |
| cmd.requestSerial = mSerial; | |
| cmd.mode = mode; | |
| cmd.offset = offset; | |
| cmd.size = size; | |
| client->SerializeCommand(cmd); | |
| } | |
| bool Buffer::OnMapAsyncCallback(uint64_t requestSerial, | |
| uint32_t status, | |
| uint64_t readDataUpdateInfoLength, | |
| const uint8_t* readDataUpdateInfo) { | |
| // If requestSerial doesn't match mSerial the corresponding request must have | |
| // already been rejected by unmap or destroy and another MapAsync request must | |
| // have been issued. | |
| if (mSerial != requestSerial) { | |
| return true; | |
| } | |
| // If mPendingMap is false the request must have been already rejected | |
| // by unmap or destroy. | |
| if (!mPendingMap) { | |
| return true; | |
| } | |
| auto FailRequest = [this]() -> bool { | |
| InvokeAndClearCallback(WGPUBufferMapAsyncStatus_DeviceLost); | |
| return false; | |
| }; | |
| if (status == WGPUBufferMapAsyncStatus_Success) { | |
| switch (mRequest.type) { | |
| case MapRequestType::Read: { | |
| if (readDataUpdateInfoLength > std::numeric_limits<size_t>::max()) { | |
| // This is the size of data deserialized from the command stream, which must | |
| // be CPU-addressable. | |
| return FailRequest(); | |
| } | |
| // Validate to prevent bad map request; buffer destroyed during map request | |
| if (mReadHandle == nullptr) { | |
| return FailRequest(); | |
| } | |
| // Update user map data with server returned data | |
| if (!mReadHandle->DeserializeDataUpdate( | |
| readDataUpdateInfo, static_cast<size_t>(readDataUpdateInfoLength), | |
| mRequest.offset, mRequest.size)) { | |
| return FailRequest(); | |
| } | |
| mMapState = MapState::MappedForRead; | |
| mMappedData = const_cast<void*>(mReadHandle->GetData()); | |
| break; | |
| } | |
| case MapRequestType::Write: { | |
| if (mWriteHandle == nullptr) { | |
| return FailRequest(); | |
| } | |
| mMapState = MapState::MappedForWrite; | |
| mMappedData = mWriteHandle->GetData(); | |
| break; | |
| } | |
| default: | |
| UNREACHABLE(); | |
| } | |
| mMapOffset = mRequest.offset; | |
| mMapSize = mRequest.size; | |
| } | |
| InvokeAndClearCallback(static_cast<WGPUBufferMapAsyncStatus>(status)); | |
| return true; | |
| } | |
| void* Buffer::GetMappedRange(size_t offset, size_t size) { | |
| if (!IsMappedForWriting() || !CheckGetMappedRangeOffsetSize(offset, size)) { | |
| return nullptr; | |
| } | |
| return static_cast<uint8_t*>(mMappedData) + offset; | |
| } | |
| const void* Buffer::GetConstMappedRange(size_t offset, size_t size) { | |
| if (!(IsMappedForWriting() || IsMappedForReading()) || | |
| !CheckGetMappedRangeOffsetSize(offset, size)) { | |
| return nullptr; | |
| } | |
| return static_cast<uint8_t*>(mMappedData) + offset; | |
| } | |
| void Buffer::Unmap() { | |
| // 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 | |
| Client* client = GetClient(); | |
| // mWriteHandle can still be nullptr if buffer has been destroyed before unmap | |
| if ((mMapState == MapState::MappedForWrite || mMapState == MapState::MappedAtCreation) && | |
| mWriteHandle != nullptr) { | |
| // Writes need to be flushed before Unmap is sent. Unmap calls all associated | |
| // in-flight callbacks which may read the updated data. | |
| // Get the serialization size of data update writes. | |
| size_t writeDataUpdateInfoLength = | |
| mWriteHandle->SizeOfSerializeDataUpdate(mMapOffset, mMapSize); | |
| BufferUpdateMappedDataCmd cmd; | |
| cmd.bufferId = GetWireId(); | |
| cmd.writeDataUpdateInfoLength = writeDataUpdateInfoLength; | |
| cmd.writeDataUpdateInfo = nullptr; | |
| cmd.offset = mMapOffset; | |
| cmd.size = mMapSize; | |
| client->SerializeCommand( | |
| cmd, CommandExtension{writeDataUpdateInfoLength, [&](char* writeHandleBuffer) { | |
| // Serialize flush metadata into the space after the command. | |
| // This closes the handle for writing. | |
| mWriteHandle->SerializeDataUpdate(writeHandleBuffer, | |
| cmd.offset, cmd.size); | |
| }}); | |
| // If mDestructWriteHandleOnUnmap is true, that means the write handle is merely | |
| // for mappedAtCreation usage. It is destroyed on unmap after flush to server | |
| // instead of at buffer destruction. | |
| if (mMapState == MapState::MappedAtCreation && mDestructWriteHandleOnUnmap) { | |
| mWriteHandle = nullptr; | |
| if (mReadHandle) { | |
| // If it's both mappedAtCreation and MapRead we need to reset | |
| // mMappedData to readHandle's GetData(). This could be changed to | |
| // merging read/write handle in future | |
| mMappedData = const_cast<void*>(mReadHandle->GetData()); | |
| } | |
| } | |
| } | |
| // Free map access tokens | |
| mMapState = MapState::Unmapped; | |
| mMapOffset = 0; | |
| mMapSize = 0; | |
| BufferUnmapCmd cmd; | |
| cmd.self = ToAPI(this); | |
| client->SerializeCommand(cmd); | |
| InvokeAndClearCallback(WGPUBufferMapAsyncStatus_UnmappedBeforeCallback); | |
| } | |
| void Buffer::Destroy() { | |
| Client* client = GetClient(); | |
| // Remove the current mapping and destroy Read/WriteHandles. | |
| FreeMappedData(); | |
| mMapState = MapState::Unmapped; | |
| BufferDestroyCmd cmd; | |
| cmd.self = ToAPI(this); | |
| client->SerializeCommand(cmd); | |
| InvokeAndClearCallback(WGPUBufferMapAsyncStatus_DestroyedBeforeCallback); | |
| } | |
| WGPUBufferUsage Buffer::GetUsage() const { | |
| return mUsage; | |
| } | |
| uint64_t Buffer::GetSize() const { | |
| return mSize; | |
| } | |
| WGPUBufferMapState Buffer::GetMapState() const { | |
| switch (mMapState) { | |
| case MapState::MappedForRead: | |
| case MapState::MappedForWrite: | |
| case MapState::MappedAtCreation: | |
| return WGPUBufferMapState_Mapped; | |
| case MapState::Unmapped: | |
| if (mPendingMap) { | |
| return WGPUBufferMapState_Pending; | |
| } else { | |
| return WGPUBufferMapState_Unmapped; | |
| } | |
| } | |
| } | |
| bool Buffer::IsMappedForReading() const { | |
| return mMapState == MapState::MappedForRead; | |
| } | |
| bool Buffer::IsMappedForWriting() const { | |
| return mMapState == MapState::MappedForWrite || mMapState == MapState::MappedAtCreation; | |
| } | |
| bool Buffer::CheckGetMappedRangeOffsetSize(size_t offset, size_t size) const { | |
| if (offset % 8 != 0 || offset < mMapOffset || offset > mSize) { | |
| return false; | |
| } | |
| size_t rangeSize = size == WGPU_WHOLE_MAP_SIZE ? mSize - offset : size; | |
| if (rangeSize % 4 != 0 || rangeSize > mMapSize) { | |
| return false; | |
| } | |
| size_t offsetInMappedRange = offset - mMapOffset; | |
| return offsetInMappedRange <= mMapSize - rangeSize; | |
| } | |
| void Buffer::FreeMappedData() { | |
| #if defined(DAWN_ENABLE_ASSERTS) | |
| // When in "debug" mode, 0xCA-out the mapped data when we free it so that in we can detect | |
| // use-after-free of the mapped data. This is particularly useful for WebGPU test about the | |
| // interaction of mapping and GC. | |
| if (mMappedData) { | |
| memset(static_cast<uint8_t*>(mMappedData) + mMapOffset, 0xCA, mMapSize); | |
| } | |
| #endif // defined(DAWN_ENABLE_ASSERTS) | |
| mMapOffset = 0; | |
| mMapSize = 0; | |
| mReadHandle = nullptr; | |
| mWriteHandle = nullptr; | |
| mMappedData = nullptr; | |
| } | |
| } // namespace dawn::wire::client |