Debian Codegraph @

src/gfxstream/guest/connection-manager/VirtioGpuPipeStream.cpp

raw
1 /*
2 * Copyright 2018 Google LLC
3 * SPDX-License-Identifier: MIT
4 */
5
6 #include "VirtioGpuPipeStream.h"
7
8 #include <errno.h>
9
10 #include "util/detect_os.h"
11 #if DETECT_OS_LINUX
12 #include <sys/mman.h>
13 #include <unistd.h>
14 #endif
15 #include <sys/types.h>
16
17 #include <cstring>
18 #include <string>
19
20 #include "VirtGpu.h"
21 #include "util/log.h"
22 #include "virtio/virtio-gpu/virgl_hw.h"
23
24 static const size_t kTransferBufferSize = (1048576);
25
26 static const size_t kReadSize = 512 * 1024;
27 static const size_t kWriteOffset = kReadSize;
28
29 VirtioGpuPipeStream::VirtioGpuPipeStream(size_t bufSize, int32_t descriptor)
30 : IOStream(bufSize),
31 m_fd(descriptor),
32 m_virtio_mapped(nullptr),
33 m_bufsize(bufSize),
34 m_buf(nullptr),
35 m_writtenPos(0) {}
36
37 VirtioGpuPipeStream::~VirtioGpuPipeStream() { free(m_buf); }
38
39 bool VirtioGpuPipeStream::valid() { return m_device != nullptr; }
40
41 int VirtioGpuPipeStream::getRendernodeFd() {
42 if (m_device == nullptr) {
43 return -1;
44 }
45 return m_device->getDeviceHandle();
46 }
47
48 int VirtioGpuPipeStream::connect(const char* serviceName) {
49 if (!m_device) {
50 m_device.reset(createPlatformVirtGpuDevice(kCapsetNone, m_fd));
51 if (!m_device) {
52 mesa_loge("Failed to create VirtioGpuPipeStream VirtGpuDevice.");
53 return -1;
54 }
55
56 m_resource = m_device->createResource(/*width=*/kTransferBufferSize,
57 /*height=*/1,
58 /*stride=*/kTransferBufferSize,
59 /*size=*/kTransferBufferSize, VIRGL_FORMAT_R8_UNORM,
60 PIPE_BUFFER, VIRGL_BIND_CUSTOM);
61 if (!m_resource) {
62 mesa_loge("Failed to create VirtioGpuPipeStream resource.");
63 return -1;
64 }
65
66 m_resourceMapping = m_resource->createMapping();
67 if (!m_resourceMapping) {
68 mesa_loge("Failed to create VirtioGpuPipeStream resource mapping.");
69 return -1;
70 }
71
72 m_virtio_mapped = m_resourceMapping->asRawPtr();
73 if (!m_virtio_mapped) {
74 mesa_loge("Failed to create VirtioGpuPipeStream resource mapping ptr.");
75 return -1;
76 }
77 }
78
79 wait();
80
81 if (serviceName) {
82 writeFully(serviceName, strlen(serviceName) + 1);
83 } else {
84 static const char kPipeString[] = "pipe:opengles";
85 std::string pipeStr(kPipeString);
86 writeFully(kPipeString, sizeof(kPipeString));
87 }
88
89 return 0;
90 }
91
92 uint64_t VirtioGpuPipeStream::processPipeInit() {
93 connect("pipe:GLProcessPipe");
94 int32_t confirmInt = 100;
95 writeFully(&confirmInt, sizeof(confirmInt));
96 uint64_t res;
97 readFully(&res, sizeof(res));
98 return res;
99 }
100
101 void* VirtioGpuPipeStream::allocBuffer(size_t minSize) {
102 size_t allocSize = (m_bufsize < minSize ? minSize : m_bufsize);
103 if (!m_buf) {
104 m_buf = (unsigned char*)malloc(allocSize);
105 } else if (m_bufsize < allocSize) {
106 unsigned char* p = (unsigned char*)realloc(m_buf, allocSize);
107 if (p != NULL) {
108 m_buf = p;
109 m_bufsize = allocSize;
110 } else {
111 mesa_loge("realloc (%zu) failed\n", allocSize);
112 free(m_buf);
113 m_buf = NULL;
114 m_bufsize = 0;
115 }
116 }
117
118 return m_buf;
119 }
120
121 int VirtioGpuPipeStream::commitBuffer(size_t size) {
122 if (size == 0) return 0;
123 return writeFully(m_buf, size);
124 }
125
126 int VirtioGpuPipeStream::writeFully(const void* buf, size_t len) {
127 // DBG(">> VirtioGpuPipeStream::writeFully %d\n", len);
128 if (!valid()) return -1;
129 if (!buf) {
130 if (len > 0) {
131 // If len is non-zero, buf must not be NULL. Otherwise the pipe would be
132 // in a corrupted state, which is lethal for the emulator.
133 mesa_loge(
134 "VirtioGpuPipeStream::writeFully failed, buf=NULL, len %zu,"
135 " lethal error, exiting",
136 len);
137 abort();
138 }
139 return 0;
140 }
141
142 size_t res = len;
143 int retval = 0;
144
145 while (res > 0) {
146 ssize_t stat = transferToHost((const char*)(buf) + (len - res), res);
147 if (stat > 0) {
148 res -= stat;
149 continue;
150 }
151 if (stat == 0) { /* EOF */
152 mesa_loge("VirtioGpuPipeStream::writeFully failed: premature EOF\n");
153 retval = -1;
154 break;
155 }
156 if (errno == EAGAIN) {
157 continue;
158 }
159 retval = stat;
160 mesa_loge("VirtioGpuPipeStream::writeFully failed: %s, lethal error, exiting.\n",
161 strerror(errno));
162 abort();
163 }
164 // DBG("<< VirtioGpuPipeStream::writeFully %d\n", len );
165 return retval;
166 }
167
168 const unsigned char* VirtioGpuPipeStream::readFully(void* buf, size_t len) {
169 flush();
170
171 if (!valid()) return NULL;
172 if (!buf) {
173 if (len > 0) {
174 // If len is non-zero, buf must not be NULL. Otherwise the pipe would be
175 // in a corrupted state, which is lethal for the emulator.
176 mesa_loge(
177 "VirtioGpuPipeStream::readFully failed, buf=NULL, len %zu, lethal"
178 " error, exiting.",
179 len);
180 abort();
181 }
182 }
183
184 size_t res = len;
185 while (res > 0) {
186 ssize_t stat = transferFromHost((char*)(buf) + len - res, res);
187 if (stat == 0) {
188 // client shutdown;
189 return NULL;
190 } else if (stat < 0) {
191 if (errno == EAGAIN) {
192 continue;
193 } else {
194 mesa_loge(
195 "VirtioGpuPipeStream::readFully failed (buf %p, len %zu"
196 ", res %zu): %s, lethal error, exiting.",
197 buf, len, res, strerror(errno));
198 abort();
199 }
200 } else {
201 res -= stat;
202 }
203 }
204 // DBG("<< VirtioGpuPipeStream::readFully %d\n", len);
205 return (const unsigned char*)buf;
206 }
207
208 const unsigned char* VirtioGpuPipeStream::commitBufferAndReadFully(size_t writeSize,
209 void* userReadBufPtr,
210 size_t totalReadSize) {
211 return commitBuffer(writeSize) ? nullptr : readFully(userReadBufPtr, totalReadSize);
212 }
213
214 const unsigned char* VirtioGpuPipeStream::read(void* buf, size_t* inout_len) {
215 // DBG(">> VirtioGpuPipeStream::read %d\n", *inout_len);
216 if (!valid()) return NULL;
217 if (!buf) {
218 mesa_loge("VirtioGpuPipeStream::read failed, buf=NULL");
219 return NULL; // do not allow NULL buf in that implementation
220 }
221
222 int n = recv(buf, *inout_len);
223
224 if (n > 0) {
225 *inout_len = n;
226 return (const unsigned char*)buf;
227 }
228
229 // DBG("<< VirtioGpuPipeStream::read %d\n", *inout_len);
230 return NULL;
231 }
232
233 int VirtioGpuPipeStream::recv(void* buf, size_t len) {
234 if (!valid()) return -EINVAL;
235 char* p = (char*)buf;
236 int ret = 0;
237 while (len > 0) {
238 int res = transferFromHost(p, len);
239 if (res > 0) {
240 p += res;
241 ret += res;
242 len -= res;
243 continue;
244 }
245 if (res == 0) { /* EOF */
246 break;
247 }
248 if (errno != EAGAIN) {
249 continue;
250 }
251
252 /* A real error */
253 if (ret == 0) ret = -1;
254 break;
255 }
256 return ret;
257 }
258
259 void VirtioGpuPipeStream::wait() {
260 int ret = m_resource->wait();
261 if (ret) {
262 mesa_loge("VirtioGpuPipeStream: DRM_IOCTL_VIRTGPU_WAIT failed with %d (%s)\n", errno,
263 strerror(errno));
264 }
265
266 m_writtenPos = 0;
267 }
268
269 ssize_t VirtioGpuPipeStream::transferToHost(const void* buffer, size_t len) {
270 size_t todo = len;
271 size_t done = 0;
272 int ret = EAGAIN;
273
274 unsigned char* virtioPtr = m_virtio_mapped;
275
276 const unsigned char* readPtr = reinterpret_cast<const unsigned char*>(buffer);
277
278 while (done < len) {
279 size_t toXfer = todo > kTransferBufferSize ? kTransferBufferSize : todo;
280
281 if (toXfer > (kTransferBufferSize - m_writtenPos)) {
282 wait();
283 }
284
285 memcpy(virtioPtr + m_writtenPos, readPtr, toXfer);
286
287 ret = m_resource->transferToHost(m_writtenPos, toXfer);
288 if (ret) {
289 mesa_loge("VirtioGpuPipeStream: failed to transferToHost() with errno %d (%s)\n", errno,
290 strerror(errno));
291 return (ssize_t)ret;
292 }
293
294 done += toXfer;
295 readPtr += toXfer;
296 todo -= toXfer;
297 m_writtenPos += toXfer;
298 }
299
300 return len;
301 }
302
303 ssize_t VirtioGpuPipeStream::transferFromHost(void* buffer, size_t len) {
304 size_t todo = len;
305 size_t done = 0;
306 int ret = EAGAIN;
307
308 const unsigned char* virtioPtr = m_virtio_mapped;
309 unsigned char* readPtr = reinterpret_cast<unsigned char*>(buffer);
310
311 if (m_writtenPos) {
312 wait();
313 }
314
315 while (done < len) {
316 size_t toXfer = todo > kTransferBufferSize ? kTransferBufferSize : todo;
317
318 ret = m_resource->transferFromHost(0, toXfer);
319 if (ret) {
320 mesa_loge("VirtioGpuPipeStream: failed to transferFromHost() with errno %d (%s)\n",
321 errno, strerror(errno));
322 return (ssize_t)ret;
323 }
324
325 wait();
326
327 memcpy(readPtr, virtioPtr, toXfer);
328
329 done += toXfer;
330 readPtr += toXfer;
331 todo -= toXfer;
332 }
333
334 return len;
335 }