Cody Schuffelen | 147b88e | 2019-09-09 16:00:11 -0700 | [diff] [blame] | 1 | #include "host/commands/run_cvd/launch.h" |
Cody Schuffelen | 5bc697c | 2019-01-28 21:05:29 -0800 | [diff] [blame] | 2 | |
Jorge E. Moreira | b1ec435 | 2019-06-04 11:43:08 -0700 | [diff] [blame] | 3 | #include <sys/types.h> |
| 4 | #include <sys/stat.h> |
| 5 | |
Cody Schuffelen | 55676ca | 2019-01-28 22:00:05 -0800 | [diff] [blame] | 6 | #include <glog/logging.h> |
| 7 | |
Cody Schuffelen | 5bc697c | 2019-01-28 21:05:29 -0800 | [diff] [blame] | 8 | #include "common/libs/fs/shared_fd.h" |
Ram Muthiah | 792e2ad | 2019-04-19 11:19:46 -0700 | [diff] [blame] | 9 | #include "common/libs/utils/files.h" |
Cody Schuffelen | 5bc697c | 2019-01-28 21:05:29 -0800 | [diff] [blame] | 10 | #include "common/libs/utils/size_utils.h" |
| 11 | #include "common/vsoc/shm/screen_layout.h" |
Cody Schuffelen | 147b88e | 2019-09-09 16:00:11 -0700 | [diff] [blame] | 12 | #include "host/commands/run_cvd/runner_defs.h" |
| 13 | #include "host/commands/run_cvd/pre_launch_initializers.h" |
| 14 | #include "host/commands/run_cvd/vsoc_shared_memory.h" |
Cody Schuffelen | 5bc697c | 2019-01-28 21:05:29 -0800 | [diff] [blame] | 15 | |
Cody Schuffelen | a9d9a86 | 2019-09-10 16:16:06 -0700 | [diff] [blame] | 16 | using cvd::RunnerExitCodes; |
Cody Schuffelen | 17b3472 | 2019-01-28 22:57:14 -0800 | [diff] [blame] | 17 | using cvd::MonitorEntry; |
Cody Schuffelen | 55676ca | 2019-01-28 22:00:05 -0800 | [diff] [blame] | 18 | |
| 19 | namespace { |
Cody Schuffelen | 660d9e8 | 2019-01-29 16:33:33 -0800 | [diff] [blame] | 20 | |
Cody Schuffelen | 5bc697c | 2019-01-28 21:05:29 -0800 | [diff] [blame] | 21 | cvd::SharedFD CreateIvServerUnixSocket(const std::string& path) { |
| 22 | return cvd::SharedFD::SocketLocalServer(path.c_str(), false, SOCK_STREAM, |
| 23 | 0666); |
| 24 | } |
Cody Schuffelen | 660d9e8 | 2019-01-29 16:33:33 -0800 | [diff] [blame] | 25 | |
| 26 | std::string GetGuestPortArg() { |
| 27 | constexpr int kEmulatorPort = 5555; |
| 28 | return std::string{"--guest_ports="} + std::to_string(kEmulatorPort); |
| 29 | } |
| 30 | |
Cody Schuffelen | e0d0c46 | 2019-09-09 14:13:01 -0700 | [diff] [blame] | 31 | std::string GetHostPortArg(const vsoc::CuttlefishConfig& config) { |
| 32 | return std::string{"--host_ports="} + std::to_string(config.host_port()); |
Cody Schuffelen | 660d9e8 | 2019-01-29 16:33:33 -0800 | [diff] [blame] | 33 | } |
| 34 | |
Cody Schuffelen | e0d0c46 | 2019-09-09 14:13:01 -0700 | [diff] [blame] | 35 | std::string GetAdbConnectorTcpArg(const vsoc::CuttlefishConfig& config) { |
| 36 | return std::string{"127.0.0.1:"} + std::to_string(config.host_port()); |
Cody Schuffelen | 660d9e8 | 2019-01-29 16:33:33 -0800 | [diff] [blame] | 37 | } |
| 38 | |
Cody Schuffelen | fd96b23 | 2019-02-05 14:12:43 -0800 | [diff] [blame] | 39 | std::string GetAdbConnectorVsockArg(const vsoc::CuttlefishConfig& config) { |
Cody Schuffelen | 05385d0 | 2019-05-08 12:39:12 -0700 | [diff] [blame] | 40 | return std::string{"vsock:"} |
Cody Schuffelen | fd96b23 | 2019-02-05 14:12:43 -0800 | [diff] [blame] | 41 | + std::to_string(config.vsock_guest_cid()) |
| 42 | + std::string{":5555"}; |
| 43 | } |
| 44 | |
Cody Schuffelen | b6fa736 | 2019-05-08 11:58:14 -0700 | [diff] [blame] | 45 | bool AdbModeEnabled(const vsoc::CuttlefishConfig& config, vsoc::AdbMode mode) { |
Cody Schuffelen | 90b2fb2 | 2019-02-28 18:55:21 -0800 | [diff] [blame] | 46 | return config.adb_mode().count(mode) > 0; |
Cody Schuffelen | 660d9e8 | 2019-01-29 16:33:33 -0800 | [diff] [blame] | 47 | } |
| 48 | |
| 49 | bool AdbTunnelEnabled(const vsoc::CuttlefishConfig& config) { |
Cody Schuffelen | b6fa736 | 2019-05-08 11:58:14 -0700 | [diff] [blame] | 50 | return AdbModeEnabled(config, vsoc::AdbMode::Tunnel); |
Cody Schuffelen | 660d9e8 | 2019-01-29 16:33:33 -0800 | [diff] [blame] | 51 | } |
| 52 | |
| 53 | bool AdbVsockTunnelEnabled(const vsoc::CuttlefishConfig& config) { |
| 54 | return config.vsock_guest_cid() > 2 |
Cody Schuffelen | b6fa736 | 2019-05-08 11:58:14 -0700 | [diff] [blame] | 55 | && AdbModeEnabled(config, vsoc::AdbMode::VsockTunnel); |
Cody Schuffelen | 660d9e8 | 2019-01-29 16:33:33 -0800 | [diff] [blame] | 56 | } |
| 57 | |
Cody Schuffelen | 63d1005 | 2019-02-26 12:21:53 -0800 | [diff] [blame] | 58 | bool AdbVsockHalfTunnelEnabled(const vsoc::CuttlefishConfig& config) { |
| 59 | return config.vsock_guest_cid() > 2 |
Cody Schuffelen | b6fa736 | 2019-05-08 11:58:14 -0700 | [diff] [blame] | 60 | && AdbModeEnabled(config, vsoc::AdbMode::VsockHalfTunnel); |
Cody Schuffelen | 63d1005 | 2019-02-26 12:21:53 -0800 | [diff] [blame] | 61 | } |
| 62 | |
Cody Schuffelen | da018ca | 2019-02-05 13:49:56 -0800 | [diff] [blame] | 63 | bool AdbTcpConnectorEnabled(const vsoc::CuttlefishConfig& config) { |
Cody Schuffelen | 63d1005 | 2019-02-26 12:21:53 -0800 | [diff] [blame] | 64 | bool tunnel = AdbTunnelEnabled(config); |
Cody Schuffelen | 8a14d69 | 2019-03-01 14:09:35 -0800 | [diff] [blame] | 65 | bool vsock_tunnel = AdbVsockTunnelEnabled(config); |
Cody Schuffelen | 63d1005 | 2019-02-26 12:21:53 -0800 | [diff] [blame] | 66 | bool vsock_half_tunnel = AdbVsockHalfTunnelEnabled(config); |
Cody Schuffelen | 660d9e8 | 2019-01-29 16:33:33 -0800 | [diff] [blame] | 67 | return config.run_adb_connector() |
Cody Schuffelen | 63d1005 | 2019-02-26 12:21:53 -0800 | [diff] [blame] | 68 | && (tunnel || vsock_tunnel || vsock_half_tunnel); |
Cody Schuffelen | 660d9e8 | 2019-01-29 16:33:33 -0800 | [diff] [blame] | 69 | } |
| 70 | |
Cody Schuffelen | fd96b23 | 2019-02-05 14:12:43 -0800 | [diff] [blame] | 71 | bool AdbVsockConnectorEnabled(const vsoc::CuttlefishConfig& config) { |
| 72 | return config.run_adb_connector() |
Cody Schuffelen | b6fa736 | 2019-05-08 11:58:14 -0700 | [diff] [blame] | 73 | && AdbModeEnabled(config, vsoc::AdbMode::NativeVsock); |
Cody Schuffelen | fd96b23 | 2019-02-05 14:12:43 -0800 | [diff] [blame] | 74 | } |
| 75 | |
Cody Schuffelen | 75ef887 | 2019-09-06 17:35:54 -0700 | [diff] [blame] | 76 | bool AdbUsbEnabled(const vsoc::CuttlefishConfig& config) { |
| 77 | return AdbModeEnabled(config, vsoc::AdbMode::Usb); |
| 78 | } |
| 79 | |
Cody Schuffelen | 660d9e8 | 2019-01-29 16:33:33 -0800 | [diff] [blame] | 80 | cvd::OnSocketReadyCb GetOnSubprocessExitCallback( |
| 81 | const vsoc::CuttlefishConfig& config) { |
| 82 | if (config.restart_subprocesses()) { |
| 83 | return cvd::ProcessMonitor::RestartOnExitCb; |
| 84 | } else { |
| 85 | return cvd::ProcessMonitor::DoNotMonitorCb; |
| 86 | } |
| 87 | } |
Cody Schuffelen | 55676ca | 2019-01-28 22:00:05 -0800 | [diff] [blame] | 88 | } // namespace |
Cody Schuffelen | 5bc697c | 2019-01-28 21:05:29 -0800 | [diff] [blame] | 89 | |
Jorge E. Moreira | fd10cae | 2019-02-19 15:35:42 -0800 | [diff] [blame] | 90 | bool LogcatReceiverEnabled(const vsoc::CuttlefishConfig& config) { |
| 91 | return config.logcat_mode() == cvd::kLogcatVsockMode; |
| 92 | } |
| 93 | |
Cody Schuffelen | 5bc697c | 2019-01-28 21:05:29 -0800 | [diff] [blame] | 94 | cvd::Command GetIvServerCommand(const vsoc::CuttlefishConfig& config) { |
Jorge E. Moreira | 91ce18a | 2019-04-05 16:14:03 -0700 | [diff] [blame] | 95 | // Resize screen region |
Cody Schuffelen | 5bc697c | 2019-01-28 21:05:29 -0800 | [diff] [blame] | 96 | auto actual_width = cvd::AlignToPowerOf2(config.x_res() * 4, 4);// align to 16 |
| 97 | uint32_t screen_buffers_size = |
| 98 | config.num_screen_buffers() * |
| 99 | cvd::AlignToPageSize(actual_width * config.y_res() + 16 /* padding */); |
| 100 | screen_buffers_size += |
| 101 | (config.num_screen_buffers() - 1) * 4096; /* Guard pages */ |
| 102 | |
| 103 | // TODO(b/79170615) Resize gralloc region too. |
| 104 | |
| 105 | vsoc::CreateSharedMemoryFile( |
| 106 | config.mempath(), |
| 107 | {{vsoc::layout::screen::ScreenLayout::region_name, screen_buffers_size}}); |
| 108 | |
| 109 | |
| 110 | cvd::Command ivserver(config.ivserver_binary()); |
| 111 | ivserver.AddParameter( |
| 112 | "-qemu_socket_fd=", |
| 113 | CreateIvServerUnixSocket(config.ivshmem_qemu_socket_path())); |
| 114 | ivserver.AddParameter( |
| 115 | "-client_socket_fd=", |
| 116 | CreateIvServerUnixSocket(config.ivshmem_client_socket_path())); |
| 117 | return ivserver; |
| 118 | } |
Cody Schuffelen | 55676ca | 2019-01-28 22:00:05 -0800 | [diff] [blame] | 119 | |
Jorge E. Moreira | 277e1c4 | 2019-05-06 17:24:27 -0700 | [diff] [blame] | 120 | std::vector<cvd::SharedFD> LaunchKernelLogMonitor( |
| 121 | const vsoc::CuttlefishConfig& config, |
| 122 | cvd::ProcessMonitor* process_monitor, |
| 123 | unsigned int number_of_event_pipes) { |
Jorge E. Moreira | b1ec435 | 2019-06-04 11:43:08 -0700 | [diff] [blame] | 124 | auto log_name = config.kernel_log_pipe_name(); |
| 125 | if (mkfifo(log_name.c_str(), 0600) != 0) { |
| 126 | LOG(ERROR) << "Unable to create named pipe at " << log_name << ": " |
| 127 | << strerror(errno); |
| 128 | return {}; |
| 129 | } |
| 130 | |
| 131 | cvd::SharedFD pipe; |
| 132 | // Open the pipe here (from the launcher) to ensure the pipe is not deleted |
| 133 | // due to the usage counters in the kernel reaching zero. If this is not done |
| 134 | // and the kernel_log_monitor crashes for some reason the VMM may get SIGPIPE. |
| 135 | pipe = cvd::SharedFD::Open(log_name.c_str(), O_RDWR); |
Jorge E. Moreira | 277e1c4 | 2019-05-06 17:24:27 -0700 | [diff] [blame] | 136 | cvd::Command command(config.kernel_log_monitor_binary()); |
Jorge E. Moreira | b1ec435 | 2019-06-04 11:43:08 -0700 | [diff] [blame] | 137 | command.AddParameter("-log_pipe_fd=", pipe); |
Jorge E. Moreira | 9ec1585 | 2019-05-02 17:52:58 -0700 | [diff] [blame] | 138 | |
Jorge E. Moreira | 277e1c4 | 2019-05-06 17:24:27 -0700 | [diff] [blame] | 139 | std::vector<cvd::SharedFD> ret; |
Jorge E. Moreira | 9ec1585 | 2019-05-02 17:52:58 -0700 | [diff] [blame] | 140 | |
Jorge E. Moreira | 277e1c4 | 2019-05-06 17:24:27 -0700 | [diff] [blame] | 141 | if (number_of_event_pipes > 0) { |
| 142 | auto param_builder = command.GetParameterBuilder(); |
| 143 | param_builder << "-subscriber_fds="; |
| 144 | for (unsigned int i = 0; i < number_of_event_pipes; ++i) { |
| 145 | cvd::SharedFD event_pipe_write_end, event_pipe_read_end; |
| 146 | if (!cvd::SharedFD::Pipe(&event_pipe_read_end, &event_pipe_write_end)) { |
| 147 | LOG(ERROR) << "Unable to create boot events pipe: " << strerror(errno); |
Cody Schuffelen | a9d9a86 | 2019-09-10 16:16:06 -0700 | [diff] [blame] | 148 | std::exit(RunnerExitCodes::kPipeIOError); |
Jorge E. Moreira | 277e1c4 | 2019-05-06 17:24:27 -0700 | [diff] [blame] | 149 | } |
| 150 | if (i > 0) { |
| 151 | param_builder << ","; |
| 152 | } |
| 153 | param_builder << event_pipe_write_end; |
| 154 | ret.push_back(event_pipe_read_end); |
| 155 | } |
| 156 | param_builder.Build(); |
| 157 | } |
| 158 | |
| 159 | process_monitor->StartSubprocess(std::move(command), |
| 160 | GetOnSubprocessExitCallback(config)); |
| 161 | |
| 162 | return ret; |
Cody Schuffelen | 55676ca | 2019-01-28 22:00:05 -0800 | [diff] [blame] | 163 | } |
Cody Schuffelen | 17b3472 | 2019-01-28 22:57:14 -0800 | [diff] [blame] | 164 | |
Jorge E. Moreira | fd10cae | 2019-02-19 15:35:42 -0800 | [diff] [blame] | 165 | void LaunchLogcatReceiverIfEnabled(const vsoc::CuttlefishConfig& config, |
| 166 | cvd::ProcessMonitor* process_monitor) { |
| 167 | if (!LogcatReceiverEnabled(config)) { |
| 168 | return; |
| 169 | } |
| 170 | auto port = config.logcat_vsock_port(); |
| 171 | auto socket = cvd::SharedFD::VsockServer(port, SOCK_STREAM); |
| 172 | if (!socket->IsOpen()) { |
| 173 | LOG(ERROR) << "Unable to create logcat server socket: " |
| 174 | << socket->StrError(); |
Cody Schuffelen | a9d9a86 | 2019-09-10 16:16:06 -0700 | [diff] [blame] | 175 | std::exit(RunnerExitCodes::kLogcatServerError); |
Jorge E. Moreira | fd10cae | 2019-02-19 15:35:42 -0800 | [diff] [blame] | 176 | } |
| 177 | cvd::Command cmd(config.logcat_receiver_binary()); |
| 178 | cmd.AddParameter("-server_fd=", socket); |
| 179 | process_monitor->StartSubprocess(std::move(cmd), |
| 180 | GetOnSubprocessExitCallback(config)); |
| 181 | } |
| 182 | |
Jorge E. Moreira | f1f7cb3 | 2019-04-15 18:44:41 -0700 | [diff] [blame] | 183 | void LaunchConfigServer(const vsoc::CuttlefishConfig& config, |
| 184 | cvd::ProcessMonitor* process_monitor) { |
| 185 | auto port = config.config_server_port(); |
| 186 | auto socket = cvd::SharedFD::VsockServer(port, SOCK_STREAM); |
| 187 | if (!socket->IsOpen()) { |
| 188 | LOG(ERROR) << "Unable to create configuration server socket: " |
| 189 | << socket->StrError(); |
Cody Schuffelen | a9d9a86 | 2019-09-10 16:16:06 -0700 | [diff] [blame] | 190 | std::exit(RunnerExitCodes::kConfigServerError); |
Jorge E. Moreira | f1f7cb3 | 2019-04-15 18:44:41 -0700 | [diff] [blame] | 191 | } |
| 192 | cvd::Command cmd(config.config_server_binary()); |
| 193 | cmd.AddParameter("-server_fd=", socket); |
| 194 | process_monitor->StartSubprocess(std::move(cmd), |
| 195 | GetOnSubprocessExitCallback(config)); |
| 196 | } |
| 197 | |
Ram Muthiah | 792e2ad | 2019-04-19 11:19:46 -0700 | [diff] [blame] | 198 | void LaunchTombstoneReceiverIfEnabled(const vsoc::CuttlefishConfig& config, |
| 199 | cvd::ProcessMonitor* process_monitor) { |
| 200 | if (!config.enable_tombstone_receiver()) { |
| 201 | return; |
| 202 | } |
| 203 | |
| 204 | std::string tombstoneDir = config.PerInstancePath("tombstones"); |
| 205 | if (!cvd::DirectoryExists(tombstoneDir.c_str())) { |
| 206 | LOG(INFO) << "Setting up " << tombstoneDir; |
| 207 | if (mkdir(tombstoneDir.c_str(), S_IRWXU | S_IRWXG | S_IROTH | S_IXOTH) < |
| 208 | 0) { |
| 209 | LOG(ERROR) << "Failed to create tombstone directory: " << tombstoneDir |
| 210 | << ". Error: " << errno; |
Cody Schuffelen | a9d9a86 | 2019-09-10 16:16:06 -0700 | [diff] [blame] | 211 | exit(RunnerExitCodes::kTombstoneDirCreationError); |
Ram Muthiah | 792e2ad | 2019-04-19 11:19:46 -0700 | [diff] [blame] | 212 | } |
| 213 | } |
| 214 | |
| 215 | auto port = config.tombstone_receiver_port(); |
| 216 | auto socket = cvd::SharedFD::VsockServer(port, SOCK_STREAM); |
| 217 | if (!socket->IsOpen()) { |
| 218 | LOG(ERROR) << "Unable to create tombstone server socket: " |
| 219 | << socket->StrError(); |
Cody Schuffelen | a9d9a86 | 2019-09-10 16:16:06 -0700 | [diff] [blame] | 220 | std::exit(RunnerExitCodes::kTombstoneServerError); |
Ram Muthiah | 792e2ad | 2019-04-19 11:19:46 -0700 | [diff] [blame] | 221 | } |
| 222 | cvd::Command cmd(config.tombstone_receiver_binary()); |
| 223 | cmd.AddParameter("-server_fd=", socket); |
| 224 | cmd.AddParameter("-tombstone_dir=", tombstoneDir); |
| 225 | |
| 226 | process_monitor->StartSubprocess(std::move(cmd), |
| 227 | GetOnSubprocessExitCallback(config)); |
| 228 | } |
| 229 | |
Cody Schuffelen | 660d9e8 | 2019-01-29 16:33:33 -0800 | [diff] [blame] | 230 | void LaunchUsbServerIfEnabled(const vsoc::CuttlefishConfig& config, |
| 231 | cvd::ProcessMonitor* process_monitor) { |
| 232 | if (!AdbUsbEnabled(config)) { |
| 233 | return; |
| 234 | } |
| 235 | auto socket_name = config.usb_v1_socket_name(); |
| 236 | auto usb_v1_server = cvd::SharedFD::SocketLocalServer( |
| 237 | socket_name.c_str(), false, SOCK_STREAM, 0666); |
| 238 | if (!usb_v1_server->IsOpen()) { |
| 239 | LOG(ERROR) << "Unable to create USB v1 server socket: " |
| 240 | << usb_v1_server->StrError(); |
Cody Schuffelen | a9d9a86 | 2019-09-10 16:16:06 -0700 | [diff] [blame] | 241 | std::exit(cvd::RunnerExitCodes::kUsbV1SocketError); |
Cody Schuffelen | 660d9e8 | 2019-01-29 16:33:33 -0800 | [diff] [blame] | 242 | } |
| 243 | cvd::Command usb_server(config.virtual_usb_manager_binary()); |
| 244 | usb_server.AddParameter("-usb_v1_fd=", usb_v1_server); |
| 245 | process_monitor->StartSubprocess(std::move(usb_server), |
| 246 | GetOnSubprocessExitCallback(config)); |
| 247 | } |
| 248 | |
Jorge E. Moreira | c87c2c7 | 2019-03-06 16:12:23 -0800 | [diff] [blame] | 249 | cvd::SharedFD CreateVncInputServer(const std::string& path) { |
| 250 | auto server = cvd::SharedFD::SocketLocalServer(path.c_str(), false, SOCK_STREAM, 0666); |
| 251 | if (!server->IsOpen()) { |
| 252 | LOG(ERROR) << "Unable to create mouse server: " |
| 253 | << server->StrError(); |
| 254 | return cvd::SharedFD(); |
| 255 | } |
| 256 | return server; |
| 257 | } |
| 258 | |
Jorge E. Moreira | 7e1df15 | 2019-05-14 15:05:33 -0700 | [diff] [blame] | 259 | bool LaunchVNCServerIfEnabled(const vsoc::CuttlefishConfig& config, |
Cody Schuffelen | 17b3472 | 2019-01-28 22:57:14 -0800 | [diff] [blame] | 260 | cvd::ProcessMonitor* process_monitor, |
| 261 | std::function<bool(MonitorEntry*)> callback) { |
Jorge E. Moreira | cf4fc2a | 2019-02-05 17:33:20 -0800 | [diff] [blame] | 262 | if (config.enable_vnc_server()) { |
Cody Schuffelen | 17b3472 | 2019-01-28 22:57:14 -0800 | [diff] [blame] | 263 | // Launch the vnc server, don't wait for it to complete |
| 264 | auto port_options = "-port=" + std::to_string(config.vnc_server_port()); |
| 265 | cvd::Command vnc_server(config.vnc_server_binary()); |
| 266 | vnc_server.AddParameter(port_options); |
Jorge E. Moreira | c87c2c7 | 2019-03-06 16:12:23 -0800 | [diff] [blame] | 267 | if (!config.enable_ivserver()) { |
| 268 | // When the ivserver is not enabled, the vnc touch_server needs to serve |
| 269 | // on unix sockets and send input events to whoever connects to it (namely |
| 270 | // crosvm) |
| 271 | auto touch_server = CreateVncInputServer(config.touch_socket_path()); |
| 272 | if (!touch_server->IsOpen()) { |
Jorge E. Moreira | 7e1df15 | 2019-05-14 15:05:33 -0700 | [diff] [blame] | 273 | return false; |
Jorge E. Moreira | c87c2c7 | 2019-03-06 16:12:23 -0800 | [diff] [blame] | 274 | } |
| 275 | vnc_server.AddParameter("-touch_fd=", touch_server); |
| 276 | |
| 277 | auto keyboard_server = |
| 278 | CreateVncInputServer(config.keyboard_socket_path()); |
| 279 | if (!keyboard_server->IsOpen()) { |
Jorge E. Moreira | 7e1df15 | 2019-05-14 15:05:33 -0700 | [diff] [blame] | 280 | return false; |
Jorge E. Moreira | c87c2c7 | 2019-03-06 16:12:23 -0800 | [diff] [blame] | 281 | } |
| 282 | vnc_server.AddParameter("-keyboard_fd=", keyboard_server); |
| 283 | // TODO(b/128852363): This should be handled through the wayland mock |
| 284 | // instead. |
| 285 | // Additionally it receives the frame updates from a virtual socket |
| 286 | // instead |
| 287 | auto frames_server = |
| 288 | cvd::SharedFD::VsockServer(config.frames_vsock_port(), SOCK_STREAM); |
| 289 | if (!frames_server->IsOpen()) { |
Jorge E. Moreira | 7e1df15 | 2019-05-14 15:05:33 -0700 | [diff] [blame] | 290 | return false; |
Jorge E. Moreira | c87c2c7 | 2019-03-06 16:12:23 -0800 | [diff] [blame] | 291 | } |
| 292 | vnc_server.AddParameter("-frame_server_fd=", frames_server); |
| 293 | } |
Cody Schuffelen | 17b3472 | 2019-01-28 22:57:14 -0800 | [diff] [blame] | 294 | process_monitor->StartSubprocess(std::move(vnc_server), callback); |
Jorge E. Moreira | 7e1df15 | 2019-05-14 15:05:33 -0700 | [diff] [blame] | 295 | return true; |
Cody Schuffelen | 17b3472 | 2019-01-28 22:57:14 -0800 | [diff] [blame] | 296 | } |
Jorge E. Moreira | 7e1df15 | 2019-05-14 15:05:33 -0700 | [diff] [blame] | 297 | return false; |
Cody Schuffelen | 17b3472 | 2019-01-28 22:57:14 -0800 | [diff] [blame] | 298 | } |
| 299 | |
| 300 | void LaunchStreamAudioIfEnabled(const vsoc::CuttlefishConfig& config, |
| 301 | cvd::ProcessMonitor* process_monitor, |
| 302 | std::function<bool(MonitorEntry*)> callback) { |
Jorge E. Moreira | fb95b0d | 2019-02-05 17:40:20 -0800 | [diff] [blame] | 303 | if (config.enable_stream_audio()) { |
Cody Schuffelen | 17b3472 | 2019-01-28 22:57:14 -0800 | [diff] [blame] | 304 | auto port_options = "-port=" + std::to_string(config.stream_audio_port()); |
| 305 | cvd::Command stream_audio(config.stream_audio_binary()); |
| 306 | stream_audio.AddParameter(port_options); |
| 307 | process_monitor->StartSubprocess(std::move(stream_audio), callback); |
| 308 | } |
| 309 | } |
Cody Schuffelen | 660d9e8 | 2019-01-29 16:33:33 -0800 | [diff] [blame] | 310 | |
| 311 | void LaunchAdbConnectorIfEnabled(cvd::ProcessMonitor* process_monitor, |
Jorge E. Moreira | 9ec1585 | 2019-05-02 17:52:58 -0700 | [diff] [blame] | 312 | const vsoc::CuttlefishConfig& config, |
| 313 | cvd::SharedFD adbd_events_pipe) { |
Jorge E. Moreira | 9ec1585 | 2019-05-02 17:52:58 -0700 | [diff] [blame] | 314 | cvd::Command adb_connector(config.adb_connector_binary()); |
| 315 | adb_connector.AddParameter("-adbd_events_fd=", adbd_events_pipe); |
Cody Schuffelen | 05385d0 | 2019-05-08 12:39:12 -0700 | [diff] [blame] | 316 | std::set<std::string> addresses; |
Jorge E. Moreira | 9ec1585 | 2019-05-02 17:52:58 -0700 | [diff] [blame] | 317 | |
Cody Schuffelen | da018ca | 2019-02-05 13:49:56 -0800 | [diff] [blame] | 318 | if (AdbTcpConnectorEnabled(config)) { |
Cody Schuffelen | e0d0c46 | 2019-09-09 14:13:01 -0700 | [diff] [blame] | 319 | addresses.insert(GetAdbConnectorTcpArg(config)); |
Cody Schuffelen | 660d9e8 | 2019-01-29 16:33:33 -0800 | [diff] [blame] | 320 | } |
Cody Schuffelen | fd96b23 | 2019-02-05 14:12:43 -0800 | [diff] [blame] | 321 | if (AdbVsockConnectorEnabled(config)) { |
Cody Schuffelen | 05385d0 | 2019-05-08 12:39:12 -0700 | [diff] [blame] | 322 | addresses.insert(GetAdbConnectorVsockArg(config)); |
Jorge E. Moreira | 9ec1585 | 2019-05-02 17:52:58 -0700 | [diff] [blame] | 323 | } |
| 324 | |
Cody Schuffelen | 05385d0 | 2019-05-08 12:39:12 -0700 | [diff] [blame] | 325 | if (addresses.size() > 0) { |
| 326 | std::string address_arg = "--addresses="; |
| 327 | for (auto& arg : addresses) { |
| 328 | address_arg += arg + ","; |
| 329 | } |
| 330 | address_arg.pop_back(); |
| 331 | adb_connector.AddParameter(address_arg); |
Cody Schuffelen | fd96b23 | 2019-02-05 14:12:43 -0800 | [diff] [blame] | 332 | process_monitor->StartSubprocess(std::move(adb_connector), |
| 333 | GetOnSubprocessExitCallback(config)); |
| 334 | } |
Cody Schuffelen | 660d9e8 | 2019-01-29 16:33:33 -0800 | [diff] [blame] | 335 | } |
| 336 | |
| 337 | void LaunchSocketForwardProxyIfEnabled(cvd::ProcessMonitor* process_monitor, |
| 338 | const vsoc::CuttlefishConfig& config) { |
| 339 | if (AdbTunnelEnabled(config)) { |
| 340 | cvd::Command adb_tunnel(config.socket_forward_proxy_binary()); |
| 341 | adb_tunnel.AddParameter(GetGuestPortArg()); |
Cody Schuffelen | e0d0c46 | 2019-09-09 14:13:01 -0700 | [diff] [blame] | 342 | adb_tunnel.AddParameter(GetHostPortArg(config)); |
Cody Schuffelen | 660d9e8 | 2019-01-29 16:33:33 -0800 | [diff] [blame] | 343 | process_monitor->StartSubprocess(std::move(adb_tunnel), |
| 344 | GetOnSubprocessExitCallback(config)); |
| 345 | } |
| 346 | } |
| 347 | |
| 348 | void LaunchSocketVsockProxyIfEnabled(cvd::ProcessMonitor* process_monitor, |
| 349 | const vsoc::CuttlefishConfig& config) { |
| 350 | if (AdbVsockTunnelEnabled(config)) { |
| 351 | cvd::Command adb_tunnel(config.socket_vsock_proxy_binary()); |
Cody Schuffelen | 2716384 | 2019-02-07 15:36:51 -0800 | [diff] [blame] | 352 | adb_tunnel.AddParameter("--vsock_port=6520"); |
Cody Schuffelen | 660d9e8 | 2019-01-29 16:33:33 -0800 | [diff] [blame] | 353 | adb_tunnel.AddParameter( |
Cody Schuffelen | e0d0c46 | 2019-09-09 14:13:01 -0700 | [diff] [blame] | 354 | std::string{"--tcp_port="} + std::to_string(config.host_port())); |
Cody Schuffelen | 660d9e8 | 2019-01-29 16:33:33 -0800 | [diff] [blame] | 355 | adb_tunnel.AddParameter(std::string{"--vsock_guest_cid="} + |
| 356 | std::to_string(config.vsock_guest_cid())); |
| 357 | process_monitor->StartSubprocess(std::move(adb_tunnel), |
| 358 | GetOnSubprocessExitCallback(config)); |
| 359 | } |
Cody Schuffelen | 63d1005 | 2019-02-26 12:21:53 -0800 | [diff] [blame] | 360 | if (AdbVsockHalfTunnelEnabled(config)) { |
| 361 | cvd::Command adb_tunnel(config.socket_vsock_proxy_binary()); |
| 362 | adb_tunnel.AddParameter("--vsock_port=5555"); |
| 363 | adb_tunnel.AddParameter( |
Cody Schuffelen | e0d0c46 | 2019-09-09 14:13:01 -0700 | [diff] [blame] | 364 | std::string{"--tcp_port="} + std::to_string(config.host_port())); |
Cody Schuffelen | 63d1005 | 2019-02-26 12:21:53 -0800 | [diff] [blame] | 365 | adb_tunnel.AddParameter(std::string{"--vsock_guest_cid="} + |
| 366 | std::to_string(config.vsock_guest_cid())); |
| 367 | process_monitor->StartSubprocess(std::move(adb_tunnel), |
| 368 | GetOnSubprocessExitCallback(config)); |
| 369 | } |
Cody Schuffelen | 660d9e8 | 2019-01-29 16:33:33 -0800 | [diff] [blame] | 370 | } |
Jorge E. Moreira | ba62662 | 2019-01-28 17:47:50 -0800 | [diff] [blame] | 371 | |
| 372 | void LaunchIvServerIfEnabled(cvd::ProcessMonitor* process_monitor, |
| 373 | const vsoc::CuttlefishConfig& config) { |
Jorge E. Moreira | f4b202b | 2019-02-05 17:51:06 -0800 | [diff] [blame] | 374 | if (config.enable_ivserver()) { |
| 375 | process_monitor->StartSubprocess(GetIvServerCommand(config), |
| 376 | GetOnSubprocessExitCallback(config)); |
Jorge E. Moreira | ba62662 | 2019-01-28 17:47:50 -0800 | [diff] [blame] | 377 | |
Jorge E. Moreira | f4b202b | 2019-02-05 17:51:06 -0800 | [diff] [blame] | 378 | // Initialize the regions that require so before the VM starts. |
| 379 | PreLaunchInitializers::Initialize(config); |
| 380 | } |
Cody Schuffelen | da018ca | 2019-02-05 13:49:56 -0800 | [diff] [blame] | 381 | } |