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 goldfish_vk {
17
VulkanStreamGuest(IOStream * stream)18 VulkanStreamGuest::VulkanStreamGuest(IOStream *stream): mStream(stream) {
19 unsetHandleMapping();
20 mFeatureBits = ResourceTracker::get()->getStreamFeatures();
21 }
22
23 VulkanStreamGuest::~VulkanStreamGuest() = default;
24
valid()25 bool VulkanStreamGuest::valid() {
26 return true;
27 }
28
alloc(void ** ptrAddr,size_t bytes)29 void VulkanStreamGuest::alloc(void** ptrAddr, size_t bytes) {
30 if (!bytes) {
31 *ptrAddr = nullptr;
32 return;
33 }
34
35 *ptrAddr = mPool.alloc(bytes);
36 }
37
loadStringInPlace(char ** forOutput)38 void VulkanStreamGuest::loadStringInPlace(char** forOutput) {
39 size_t len = getBe32();
40
41 alloc((void**)forOutput, len + 1);
42
43 memset(*forOutput, 0x0, len + 1);
44
45 if (len > 0) read(*forOutput, len);
46 }
47
loadStringArrayInPlace(char *** forOutput)48 void VulkanStreamGuest::loadStringArrayInPlace(char*** forOutput) {
49 size_t count = getBe32();
50
51 if (!count) {
52 *forOutput = nullptr;
53 return;
54 }
55
56 alloc((void**)forOutput, count * sizeof(char*));
57
58 char **stringsForOutput = *forOutput;
59
60 for (size_t i = 0; i < count; i++) {
61 loadStringInPlace(stringsForOutput + i);
62 }
63 }
64
loadStringInPlaceWithStreamPtr(char ** forOutput,uint8_t ** streamPtr)65 void VulkanStreamGuest::loadStringInPlaceWithStreamPtr(char** forOutput, uint8_t** streamPtr) {
66 uint32_t len;
67 memcpy(&len, *streamPtr, sizeof(uint32_t));
68 *streamPtr += sizeof(uint32_t);
69 android::base::Stream::fromBe32((uint8_t*)&len);
70
71 alloc((void**)forOutput, len + 1);
72
73 memset(*forOutput, 0x0, len + 1);
74
75 if (len > 0) {
76 memcpy(*forOutput, *streamPtr, len);
77 *streamPtr += len;
78 }
79 }
80
loadStringArrayInPlaceWithStreamPtr(char *** forOutput,uint8_t ** streamPtr)81 void VulkanStreamGuest::loadStringArrayInPlaceWithStreamPtr(char*** forOutput, uint8_t** streamPtr) {
82 uint32_t count;
83 memcpy(&count, *streamPtr, sizeof(uint32_t));
84 *streamPtr += sizeof(uint32_t);
85 android::base::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
100
read(void * buffer,size_t size)101 ssize_t VulkanStreamGuest::read(void *buffer, size_t size) {
102 if (!mStream->readback(buffer, size)) {
103 ALOGE("FATAL: Could not read back %zu bytes", size);
104 abort();
105 }
106 return size;
107 }
108
write(const void * buffer,size_t size)109 ssize_t VulkanStreamGuest::write(const void *buffer, size_t size) {
110 uint8_t* streamBuf = (uint8_t*)mStream->alloc(size);
111 memcpy(streamBuf, buffer, size);
112 return size;
113 }
114
writeLarge(const void * buffer,size_t size)115 void VulkanStreamGuest::writeLarge(const void* buffer, size_t size) {
116 mStream->writeFullyAsync(buffer, size);
117 }
118
clearPool()119 void VulkanStreamGuest::clearPool() {
120 mPool.freeAll();
121 }
122
setHandleMapping(VulkanHandleMapping * mapping)123 void VulkanStreamGuest::setHandleMapping(VulkanHandleMapping* mapping) {
124 mCurrentHandleMapping = mapping;
125 }
126
unsetHandleMapping()127 void VulkanStreamGuest::unsetHandleMapping() {
128 mCurrentHandleMapping = &mDefaultHandleMapping;
129 }
130
handleMapping() const131 VulkanHandleMapping* VulkanStreamGuest::handleMapping() const {
132 return mCurrentHandleMapping;
133 }
134
flush()135 void VulkanStreamGuest::flush() {
136 AEMU_SCOPED_TRACE("VulkanStreamGuest device write");
137 mStream->flush();
138 }
139
getFeatureBits() const140 uint32_t VulkanStreamGuest::getFeatureBits() const {
141 return mFeatureBits;
142 }
143
incStreamRef()144 void VulkanStreamGuest::incStreamRef() {
145 mStream->incRef();
146 }
147
decStreamRef()148 bool VulkanStreamGuest::decStreamRef() {
149 return mStream->decRef();
150 }
151
reserve(size_t size)152 uint8_t* VulkanStreamGuest::reserve(size_t size) {
153 return (uint8_t*)mStream->alloc(size);
154 }
155
VulkanCountingStream()156 VulkanCountingStream::VulkanCountingStream() : VulkanStreamGuest(nullptr) { }
157 VulkanCountingStream::~VulkanCountingStream() = default;
158
read(void *,size_t size)159 ssize_t VulkanCountingStream::read(void*, size_t size) {
160 m_read += size;
161 return size;
162 }
163
write(const void *,size_t size)164 ssize_t VulkanCountingStream::write(const void*, size_t size) {
165 m_written += size;
166 return size;
167 }
168
rewind()169 void VulkanCountingStream::rewind() {
170 m_written = 0;
171 m_read = 0;
172 }
173
174 } // namespace goldfish_vk
175