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