Debian Codegraph @

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

raw
1 /*
2 * Copyright 2024 Google LLC
3 * SPDX-License-Identifier: MIT
4 */
5
6 #include "GfxStreamConnectionManager.h"
7
8 #include <cerrno>
9
10 #include "GoldfishAddressSpaceStream.h"
11 #include "QemuPipeStream.h"
12 #include "VirtGpu.h"
13 #include "VirtioGpuAddressSpaceStream.h"
14 #include "VirtioGpuPipeStream.h"
15 #include "c11/threads.h"
16 #include "util/log.h"
17
18 #define STREAM_BUFFER_SIZE (4 * 1024 * 1024)
19
20 static tss_t gfxstream_connection_manager_tls_key;
21 static bool gfxstream_connection_manager_tls_key_valid;
22
23 static void gfxstream_connection_manager_tls_free(void* tls) {
24 if (tls) {
25 delete ((GfxStreamConnectionManager*)tls);
26 }
27 }
28
29 static void gfxstream_connection_manager_tls_key_create_once(void) {
30 gfxstream_connection_manager_tls_key_valid =
31 tss_create(&gfxstream_connection_manager_tls_key, gfxstream_connection_manager_tls_free) ==
32 thrd_success;
33 if (!gfxstream_connection_manager_tls_key_valid) {
34 mesa_logd("WARNING: failed to create gfxstream_connection_manager_tls_key");
35 }
36 }
37
38 GfxStreamConnectionManager* GfxStreamConnectionManager::getThreadLocalInstance(
39 GfxStreamTransportType type, VirtGpuCapset capset) {
40 static once_flag once = ONCE_FLAG_INIT;
41 call_once(&once, gfxstream_connection_manager_tls_key_create_once);
42 if (unlikely(!gfxstream_connection_manager_tls_key_valid)) {
43 return nullptr;
44 }
45
46 GfxStreamConnectionManager* tls =
47 (GfxStreamConnectionManager*)tss_get(gfxstream_connection_manager_tls_key);
48 if (likely(tls)) {
49 return tls;
50 }
51
52 tls = new GfxStreamConnectionManager(type, capset);
53 if (!tls) {
54 return nullptr;
55 }
56
57 if (!tls->initialize()) {
58 delete tls;
59 return nullptr;
60 }
61
62 if (tss_set(gfxstream_connection_manager_tls_key, tls) != thrd_success) {
63 delete tls;
64 return nullptr;
65 }
66
67 return tls;
68 }
69
70 void GfxStreamConnectionManager::resetThreadLocalInstance() {
71 if (unlikely(!gfxstream_connection_manager_tls_key_valid)) {
72 return;
73 }
74
75 GfxStreamConnectionManager* tls =
76 (GfxStreamConnectionManager*)tss_get(gfxstream_connection_manager_tls_key);
77 if (unlikely(!tls)) {
78 return;
79 }
80
81 delete tls;
82 void* null_ptr = nullptr;
83 tss_set(gfxstream_connection_manager_tls_key, null_ptr);
84 }
85
86 GfxStreamConnectionManager::GfxStreamConnectionManager(GfxStreamTransportType type,
87 VirtGpuCapset capset)
88 : mTransportType(type), mCapset(capset) {}
89
90 GfxStreamConnectionManager::~GfxStreamConnectionManager() {}
91
92 bool GfxStreamConnectionManager::initialize() {
93 switch (mTransportType) {
94 #ifdef GFXSTREAM_ENABLE_GUEST_GOLDFISH
95 case GFXSTREAM_TRANSPORT_ADDRESS_SPACE: {
96 mStream = createGoldfishAddressSpaceStream(STREAM_BUFFER_SIZE);
97 if (!mStream) {
98 mesa_loge("Failed to create AddressSpaceStream for host connection\n");
99 return false;
100 }
101 break;
102 }
103 #endif
104 case GFXSTREAM_TRANSPORT_QEMU_PIPE: {
105 mStream = new QemuPipeStream(STREAM_BUFFER_SIZE);
106 if (mStream->connect() < 0) {
107 mesa_loge("Failed to connect to host (QemuPipeStream)\n");
108 return false;
109 }
110
111 break;
112 }
113 case GFXSTREAM_TRANSPORT_VIRTIO_GPU_PIPE: {
114 VirtioGpuPipeStream* pipeStream =
115 new VirtioGpuPipeStream(STREAM_BUFFER_SIZE, INVALID_DESCRIPTOR);
116 if (!pipeStream) {
117 mesa_loge("Failed to create VirtioGpu for host connection\n");
118 return false;
119 }
120 if (pipeStream->connect() < 0) {
121 mesa_loge("Failed to connect to host (VirtioGpu)\n");
122 return false;
123 }
124
125 mDescriptor = pipeStream->getRendernodeFd();
126 VirtGpuDevice::getInstance(mCapset);
127 mStream = pipeStream;
128 break;
129 }
130 case GFXSTREAM_TRANSPORT_VIRTIO_GPU_ADDRESS_SPACE: {
131 // Use kCapsetGfxStreamVulkan for now, Ranchu HWC needs to be modified to pass in
132 // right capset.
133 auto device = VirtGpuDevice::getInstance(kCapsetGfxStreamVulkan);
134 if (!device) {
135 mesa_logd("Failed to get VirtGpuDevice\n");
136 return false;
137 }
138
139 mDescriptor = device->getDeviceHandle();
140 mStream = createVirtioGpuAddressSpaceStream(kCapsetGfxStreamVulkan);
141 if (!mStream) {
142 mesa_loge("Failed to create virtgpu AddressSpaceStream\n");
143 return false;
144 }
145
146 break;
147 }
148 default:
149 return false;
150 }
151
152 // send zero 'clientFlags' to the host. This is actually part of the gfxstream protocol.
153 unsigned int* pClientFlags = (unsigned int*)mStream->allocBuffer(sizeof(unsigned int));
154 *pClientFlags = 0;
155 mStream->commitBuffer(sizeof(unsigned int));
156
157 return true;
158 }
159
160 int32_t GfxStreamConnectionManager::addConnection(GfxStreamConnectionType type,
161 std::unique_ptr<GfxStreamConnection> connection) {
162 if (mConnections.find(type) != mConnections.end()) {
163 return -EINVAL;
164 }
165
166 mConnections[type] = std::move(connection);
167 return 0;
168 }
169
170 void* GfxStreamConnectionManager::getEncoder(GfxStreamConnectionType type) {
171 auto iterator = mConnections.find(type);
172 if (iterator == mConnections.end()) {
173 return nullptr;
174 }
175
176 return iterator->second->getEncoder();
177 }
178
179 gfxstream::guest::IOStream* GfxStreamConnectionManager::getStream() { return mStream; }
180
181 gfxstream::guest::IOStream* GfxStreamConnectionManager::processPipeStream(
182 GfxStreamTransportType transportType) {
183 switch (transportType) {
184 case GFXSTREAM_TRANSPORT_ADDRESS_SPACE:
185 case GFXSTREAM_TRANSPORT_QEMU_PIPE:
186 return new QemuPipeStream(STREAM_BUFFER_SIZE);
187 case GFXSTREAM_TRANSPORT_VIRTIO_GPU_ADDRESS_SPACE:
188 case GFXSTREAM_TRANSPORT_VIRTIO_GPU_PIPE:
189 return new VirtioGpuPipeStream(STREAM_BUFFER_SIZE, mDescriptor);
190 default:
191 return nullptr;
192 }
193 }