1 // Copyright (C) 2018 The Android Open Source Project
2 //
3 // Licensed under the Apache License, Version 2.0 (the "License");
4 // you may not use this file except in compliance with the License.
5 // You may obtain a copy of the License at
6 //
7 // http://www.apache.org/licenses/LICENSE-2.0
8 //
9 // Unless required by applicable law or agreed to in writing, software
10 // distributed under the License is distributed on an "AS IS" BASIS,
11 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 // See the License for the specific language governing permissions and
13 // limitations under the License.
14 #include "VulkanStreamGuest.h"
15
16 namespace gfxstream {
17 namespace vk {
18
VulkanStreamGuest(gfxstream::guest::IOStream * stream)19 VulkanStreamGuest::VulkanStreamGuest(gfxstream::guest::IOStream* stream) : mStream(stream) {
20 unsetHandleMapping();
21 mFeatureBits = ResourceTracker::get()->getStreamFeatures();
22 }
23
24 VulkanStreamGuest::~VulkanStreamGuest() = default;
25
valid()26 bool VulkanStreamGuest::valid() { return true; }
27
alloc(void ** ptrAddr,size_t bytes)28 void VulkanStreamGuest::alloc(void** ptrAddr, size_t bytes) {
29 if (!bytes) {
30 *ptrAddr = nullptr;
31 return;
32 }
33
34 *ptrAddr = mPool.alloc(bytes);
35 }
36
loadStringInPlace(char ** forOutput)37 void VulkanStreamGuest::loadStringInPlace(char** forOutput) {
38 size_t len = getBe32();
39
40 alloc((void**)forOutput, len + 1);
41
42 memset(*forOutput, 0x0, len + 1);
43
44 if (len > 0) read(*forOutput, len);
45 }
46
loadStringArrayInPlace(char *** forOutput)47 void VulkanStreamGuest::loadStringArrayInPlace(char*** forOutput) {
48 size_t count = getBe32();
49
50 if (!count) {
51 *forOutput = nullptr;
52 return;
53 }
54
55 alloc((void**)forOutput, count * sizeof(char*));
56
57 char** stringsForOutput = *forOutput;
58
59 for (size_t i = 0; i < count; i++) {
60 loadStringInPlace(stringsForOutput + i);
61 }
62 }
63
loadStringInPlaceWithStreamPtr(char ** forOutput,uint8_t ** streamPtr)64 void VulkanStreamGuest::loadStringInPlaceWithStreamPtr(char** forOutput, uint8_t** streamPtr) {
65 uint32_t len;
66 memcpy(&len, *streamPtr, sizeof(uint32_t));
67 *streamPtr += sizeof(uint32_t);
68 gfxstream::guest::Stream::fromBe32((uint8_t*)&len);
69
70 alloc((void**)forOutput, len + 1);
71
72 memset(*forOutput, 0x0, len + 1);
73
74 if (len > 0) {
75 memcpy(*forOutput, *streamPtr, len);
76 *streamPtr += len;
77 }
78 }
79
loadStringArrayInPlaceWithStreamPtr(char *** forOutput,uint8_t ** streamPtr)80 void VulkanStreamGuest::loadStringArrayInPlaceWithStreamPtr(char*** forOutput,
81 uint8_t** streamPtr) {
82 uint32_t count;
83 memcpy(&count, *streamPtr, sizeof(uint32_t));
84 *streamPtr += sizeof(uint32_t);
85 gfxstream::guest::Stream::fromBe32((uint8_t*)&count);
86 if (!count) {
87 *forOutput = nullptr;
88 return;
89 }
90
91 alloc((void**)forOutput, count * sizeof(char*));
92
93 char** stringsForOutput = *forOutput;
94
95 for (size_t i = 0; i < count; i++) {
96 loadStringInPlaceWithStreamPtr(stringsForOutput + i, streamPtr);
97 }
98 }
99
read(void * buffer,size_t size)100 ssize_t VulkanStreamGuest::read(void* buffer, size_t size) {
101 if (!mStream->readback(buffer, size)) {
102 ALOGE("FATAL: Could not read back %zu bytes", size);
103 abort();
104 }
105 return size;
106 }
107
write(const void * buffer,size_t size)108 ssize_t VulkanStreamGuest::write(const void* buffer, size_t size) {
109 uint8_t* streamBuf = (uint8_t*)mStream->alloc(size);
110 memcpy(streamBuf, buffer, size);
111 return size;
112 }
113
writeLarge(const void * buffer,size_t size)114 void VulkanStreamGuest::writeLarge(const void* buffer, size_t size) {
115 mStream->writeFullyAsync(buffer, size);
116 }
117
clearPool()118 void VulkanStreamGuest::clearPool() { mPool.freeAll(); }
119
setHandleMapping(VulkanHandleMapping * mapping)120 void VulkanStreamGuest::setHandleMapping(VulkanHandleMapping* mapping) {
121 mCurrentHandleMapping = mapping;
122 }
123
unsetHandleMapping()124 void VulkanStreamGuest::unsetHandleMapping() { mCurrentHandleMapping = &mDefaultHandleMapping; }
125
handleMapping() const126 VulkanHandleMapping* VulkanStreamGuest::handleMapping() const { return mCurrentHandleMapping; }
127
flush()128 void VulkanStreamGuest::flush() {
129 AEMU_SCOPED_TRACE("VulkanStreamGuest device write");
130 mStream->flush();
131 }
132
getFeatureBits() const133 uint32_t VulkanStreamGuest::getFeatureBits() const { return mFeatureBits; }
134
incStreamRef()135 void VulkanStreamGuest::incStreamRef() { mStream->incRef(); }
136
decStreamRef()137 bool VulkanStreamGuest::decStreamRef() { return mStream->decRef(); }
138
reserve(size_t size)139 uint8_t* VulkanStreamGuest::reserve(size_t size) { return (uint8_t*)mStream->alloc(size); }
140
VulkanCountingStream()141 VulkanCountingStream::VulkanCountingStream() : VulkanStreamGuest(nullptr) {}
142 VulkanCountingStream::~VulkanCountingStream() = default;
143
read(void *,size_t size)144 ssize_t VulkanCountingStream::read(void*, size_t size) {
145 m_read += size;
146 return size;
147 }
148
write(const void *,size_t size)149 ssize_t VulkanCountingStream::write(const void*, size_t size) {
150 m_written += size;
151 return size;
152 }
153
rewind()154 void VulkanCountingStream::rewind() {
155 m_written = 0;
156 m_read = 0;
157 }
158
159 } // namespace vk
160 } // namespace gfxstream
161