blob: db611d82be61efb7ce11db489fd48b02edd5ddf8 [file] [log] [blame]
Cody Schuffelen20ecaca2019-01-29 17:43:38 -08001#include "host/commands/launch/flags.h"
2
3#include <iostream>
4
5#include <gflags/gflags.h>
6#include <glog/logging.h>
7
Cody Schuffelen90b2fb22019-02-28 18:55:21 -08008#include "common/libs/strings/str_split.h"
Cody Schuffelen20ecaca2019-01-29 17:43:38 -08009#include "common/libs/utils/environment.h"
10#include "common/libs/utils/files.h"
11#include "common/vsoc/lib/vsoc_memory.h"
12#include "host/commands/launch/boot_image_unpacker.h"
13#include "host/commands/launch/data_image.h"
14#include "host/commands/launch/launch.h"
15#include "host/commands/launch/launcher_defs.h"
Jorge E. Moreiraba626622019-01-28 17:47:50 -080016#include "host/libs/vm_manager/crosvm_manager.h"
Cody Schuffelen20ecaca2019-01-29 17:43:38 -080017#include "host/libs/vm_manager/qemu_manager.h"
18#include "host/libs/vm_manager/vm_manager.h"
19
20using vsoc::GetPerInstanceDefault;
21using cvd::LauncherExitCodes;
22
23DEFINE_string(
24 system_image, "",
25 "Path to the system image, if empty it is assumed to be a file named "
26 "system.img in the directory specified by -system_image_dir");
27DEFINE_string(cache_image, "", "Location of the cache partition image.");
Paul Trautrimba8f8e92019-03-12 17:55:48 +090028DEFINE_string(metadata_image, "", "Location of the metadata partition image "
29 "to be generated.");
30DEFINE_int32(blank_metadata_image_mb, 16,
31 "The size of the blank metadata image to generate, MB.");
Cody Schuffelen20ecaca2019-01-29 17:43:38 -080032DEFINE_int32(cpus, 2, "Virtual CPU count.");
33DEFINE_string(data_image, "", "Location of the data partition image.");
34DEFINE_string(data_policy, "use_existing", "How to handle userdata partition."
35 " Either 'use_existing', 'create_if_missing', 'resize_up_to', or "
36 "'always_create'.");
37DEFINE_int32(blank_data_image_mb, 0,
38 "The size of the blank data image to generate, MB.");
39DEFINE_string(blank_data_image_fmt, "ext4",
40 "The fs format for the blank data image. Used with mkfs.");
41DEFINE_string(qemu_gdb, "",
Matthias Maennich454d7872019-02-06 16:35:17 +000042 "Debug flag to pass to qemu. e.g. -qemu_gdb=tcp::1234");
Cody Schuffelen20ecaca2019-01-29 17:43:38 -080043
44DEFINE_int32(x_res, 720, "Width of the screen in pixels");
45DEFINE_int32(y_res, 1280, "Height of the screen in pixels");
46DEFINE_int32(dpi, 160, "Pixels per inch for the screen");
47DEFINE_int32(refresh_rate_hz, 60, "Screen refresh rate in Hertz");
48DEFINE_int32(num_screen_buffers, 3, "The number of screen buffers");
49DEFINE_string(kernel_path, "",
50 "Path to the kernel. Overrides the one from the boot image");
Jorge E. Moreira80ddd7f2019-02-04 16:30:13 -080051DEFINE_bool(decompress_kernel, false,
52 "Whether to decompress the kernel image. Required for crosvm.");
53DEFINE_string(kernel_decompresser_executable,
54 vsoc::DefaultHostArtifactsPath("bin/extract-vmlinux"),
55 "Path to the extract-vmlinux executable.");
Cody Schuffelen20ecaca2019-01-29 17:43:38 -080056DEFINE_string(extra_kernel_cmdline, "",
57 "Additional flags to put on the kernel command line");
58DEFINE_int32(loop_max_part, 7, "Maximum number of loop partitions");
59DEFINE_string(console, "ttyS0", "Console device for the guest kernel.");
60DEFINE_string(androidboot_console, "ttyS1",
61 "Console device for the Android framework");
Jorge E. Moreiraba626622019-01-28 17:47:50 -080062DEFINE_string(
63 hardware_name, "",
Jorge E. Moreirafd1a6b02019-02-27 16:25:00 -080064 "The codename of the device's hardware, one of {cutf_ivsh, cutf_cvm}");
Cody Schuffelen20ecaca2019-01-29 17:43:38 -080065DEFINE_string(guest_security, "selinux",
66 "The security module to use in the guest");
Jorge E. Moreira300f97f2019-04-09 13:48:01 -070067DEFINE_bool(guest_enforce_security, true,
Cody Schuffelen20ecaca2019-01-29 17:43:38 -080068 "Whether to run in enforcing mode (non permissive). Ignored if "
69 "-guest_security is empty.");
70DEFINE_bool(guest_audit_security, true,
71 "Whether to log security audits.");
72DEFINE_string(boot_image, "", "Location of cuttlefish boot image.");
73DEFINE_int32(memory_mb, 2048,
74 "Total amount of memory available for guest, MB.");
75std::string g_default_mempath{vsoc::GetDefaultMempath()};
76DEFINE_string(mempath, g_default_mempath.c_str(),
77 "Target location for the shmem file.");
78DEFINE_string(mobile_interface, "", // default handled on ParseCommandLine
79 "Network interface to use for mobile networking");
80DEFINE_string(mobile_tap_name, "", // default handled on ParseCommandLine
81 "The name of the tap interface to use for mobile");
82std::string g_default_serial_number{GetPerInstanceDefault("CUTTLEFISHCVD")};
83DEFINE_string(serial_number, g_default_serial_number.c_str(),
84 "Serial number to use for the device");
85DEFINE_string(instance_dir, "", // default handled on ParseCommandLine
86 "A directory to put all instance specific files");
87DEFINE_string(
88 vm_manager, vm_manager::QemuManager::name(),
Jorge E. Moreiraba626622019-01-28 17:47:50 -080089 "What virtual machine manager to use, one of {qemu_cli, crosvm}");
Greg Hartmana3c552d2019-03-28 18:20:48 -070090DEFINE_string(
91 gpu_mode, vsoc::kGpuModeGuestAshmem,
92 "What gpu configuration to use, one of {guest_ashmem, guest_drm}");
93DEFINE_string(wayland_socket, "",
94 "Location of the wayland socket to use for *_drm gpu_modes.");
95
Cody Schuffelen20ecaca2019-01-29 17:43:38 -080096DEFINE_string(system_image_dir, vsoc::DefaultGuestImagePath(""),
97 "Location of the system partition images.");
98DEFINE_string(vendor_image, "", "Location of the vendor partition image.");
Alistair Strachan5782ce42019-03-28 22:05:13 -070099DEFINE_string(product_image, "", "Location of the product partition image.");
Cody Schuffelen20ecaca2019-01-29 17:43:38 -0800100
101DEFINE_bool(deprecated_boot_completed, false, "Log boot completed message to"
102 " host kernel. This is only used during transition of our clients."
103 " Will be deprecated soon.");
104DEFINE_bool(start_vnc_server, true, "Whether to start the vnc server process.");
105DEFINE_string(vnc_server_binary,
106 vsoc::DefaultHostArtifactsPath("bin/vnc_server"),
107 "Location of the vnc server binary.");
Alistair Strachan7eeddf42019-03-04 18:13:34 -0800108DEFINE_bool(start_stream_audio, false,
Cody Schuffelen20ecaca2019-01-29 17:43:38 -0800109 "Whether to start the stream audio process.");
110DEFINE_string(stream_audio_binary,
111 vsoc::DefaultHostArtifactsPath("bin/stream_audio"),
112 "Location of the stream_audio binary.");
113DEFINE_string(virtual_usb_manager_binary,
114 vsoc::DefaultHostArtifactsPath("bin/virtual_usb_manager"),
115 "Location of the virtual usb manager binary.");
116DEFINE_string(kernel_log_monitor_binary,
117 vsoc::DefaultHostArtifactsPath("bin/kernel_log_monitor"),
118 "Location of the log monitor binary.");
119DEFINE_string(ivserver_binary,
120 vsoc::DefaultHostArtifactsPath("bin/ivserver"),
121 "Location of the ivshmem server binary.");
122DEFINE_int32(vnc_server_port, GetPerInstanceDefault(6444),
123 "The port on which the vnc server should listen");
124DEFINE_int32(stream_audio_port, GetPerInstanceDefault(7444),
125 "The port on which stream_audio should listen.");
126DEFINE_string(socket_forward_proxy_binary,
127 vsoc::DefaultHostArtifactsPath("bin/socket_forward_proxy"),
128 "Location of the socket_forward_proxy binary.");
129DEFINE_string(socket_vsock_proxy_binary,
130 vsoc::DefaultHostArtifactsPath("bin/socket_vsock_proxy"),
131 "Location of the socket_vsock_proxy binary.");
Cody Schuffelen10743332019-04-15 16:50:49 -0700132DEFINE_string(adb_mode, "vsock_half_tunnel",
Cody Schuffelen63d10052019-02-26 12:21:53 -0800133 "Mode for ADB connection. Can be 'usb' for USB forwarding, "
134 "'tunnel' for a TCP connection tunneled through VSoC, "
135 "'vsock_tunnel' for a TCP connection tunneled through vsock, "
136 "'native_vsock' for a direct connection to the guest ADB over "
137 "vsock, 'vsock_half_tunnel' for a TCP connection forwarded to "
138 "the guest ADB server, or a comma separated list of types as in "
139 "'usb,tunnel'");
Cody Schuffelen20ecaca2019-01-29 17:43:38 -0800140DEFINE_bool(run_adb_connector, true,
141 "Maintain adb connection by sending 'adb connect' commands to the "
Matthias Maennich454d7872019-02-06 16:35:17 +0000142 "server. Only relevant with -adb_mode=tunnel or vsock_tunnel");
Cody Schuffelen20ecaca2019-01-29 17:43:38 -0800143DEFINE_string(adb_connector_binary,
144 vsoc::DefaultHostArtifactsPath("bin/adb_connector"),
145 "Location of the adb_connector binary. Only relevant if "
Matthias Maennich454d7872019-02-06 16:35:17 +0000146 "-run_adb_connector is true");
Cody Schuffelen20ecaca2019-01-29 17:43:38 -0800147DEFINE_int32(vhci_port, GetPerInstanceDefault(0), "VHCI port to use for usb");
148DEFINE_string(guest_mac_address,
149 GetPerInstanceDefault("00:43:56:44:80:"), // 00:43:56:44:80:0x
150 "MAC address of the wifi interface to be created on the guest.");
151DEFINE_string(host_mac_address,
152 "42:00:00:00:00:00",
153 "MAC address of the wifi interface running on the host.");
Cody Schuffelen20ecaca2019-01-29 17:43:38 -0800154DEFINE_string(wifi_tap_name, "", // default handled on ParseCommandLine
155 "The name of the tap interface to use for wifi");
156DEFINE_int32(vsock_guest_cid,
157 vsoc::GetDefaultPerInstanceVsockCid(),
158 "Guest identifier for vsock. Disabled if under 3.");
159
160// TODO(b/72969289) This should be generated
161DEFINE_string(dtb, "", "Path to the cuttlefish.dtb file");
Jorge E. Moreiraba626622019-01-28 17:47:50 -0800162DEFINE_string(gsi_fstab,
163 vsoc::DefaultHostArtifactsPath("config/gsi.fstab"),
164 "Path to the GSI fstab file");
Cody Schuffelen20ecaca2019-01-29 17:43:38 -0800165
166DEFINE_string(uuid, vsoc::GetPerInstanceDefault(vsoc::kDefaultUuidPrefix),
167 "UUID to use for the device. Random if not specified");
168DEFINE_bool(daemon, false,
169 "Run cuttlefish in background, the launcher exits on boot "
170 "completed/failed");
171
172DEFINE_string(device_title, "", "Human readable name for the instance, "
173 "used by the vnc_server for its server title");
174DEFINE_string(setupwizard_mode, "DISABLED",
175 "One of DISABLED,OPTIONAL,REQUIRED");
176
177DEFINE_string(qemu_binary,
178 "/usr/bin/qemu-system-x86_64",
179 "The qemu binary to use");
Jorge E. Moreiraba626622019-01-28 17:47:50 -0800180DEFINE_string(crosvm_binary,
181 vsoc::DefaultHostArtifactsPath("bin/crosvm"),
182 "The Crosvm binary to use");
Cody Schuffelen20ecaca2019-01-29 17:43:38 -0800183DEFINE_bool(restart_subprocesses, true, "Restart any crashed host process");
184DEFINE_bool(run_e2e_test, true, "Run e2e test after device launches");
185DEFINE_string(e2e_test_binary,
186 vsoc::DefaultHostArtifactsPath("bin/host_region_e2e_test"),
187 "Location of the region end to end test binary");
Jorge E. Moreirafd10cae2019-02-19 15:35:42 -0800188DEFINE_string(logcat_receiver_binary,
189 vsoc::DefaultHostArtifactsPath("bin/logcat_receiver"),
190 "Binary for the logcat server");
191DEFINE_string(logcat_mode, "", "How to send android's log messages from "
192 "guest to host. One of [serial, vsock]");
193DEFINE_int32(logcat_vsock_port, vsoc::GetPerInstanceDefault(5620),
194 "The port for logcat over vsock");
Jorge E. Moreiraf1f7cb32019-04-15 18:44:41 -0700195DEFINE_string(config_server_binary,
196 vsoc::DefaultHostArtifactsPath("bin/config_server"),
197 "Binary for the configuration server");
198DEFINE_int32(config_server_port, vsoc::GetPerInstanceDefault(4680),
199 "The (vsock) port for the configuration server");
Jorge E. Moreirac87c2c72019-03-06 16:12:23 -0800200DEFINE_int32(frames_vsock_port, vsoc::GetPerInstanceDefault(5580),
201 "The vsock port to receive frames from the guest on");
Cody Schuffelen20ecaca2019-01-29 17:43:38 -0800202namespace {
203
204template<typename S, typename T>
205static std::string concat(const S& s, const T& t) {
206 std::ostringstream os;
207 os << s << t;
208 return os.str();
209}
210
211bool ResolveInstanceFiles() {
212 if (FLAGS_system_image_dir.empty()) {
213 LOG(ERROR) << "--system_image_dir must be specified.";
214 return false;
215 }
216
217 // If user did not specify location of either of these files, expect them to
218 // be placed in --system_image_dir location.
219 std::string default_system_image = FLAGS_system_image_dir + "/system.img";
220 SetCommandLineOptionWithMode("system_image", default_system_image.c_str(),
221 google::FlagSettingMode::SET_FLAGS_DEFAULT);
222 std::string default_boot_image = FLAGS_system_image_dir + "/boot.img";
223 SetCommandLineOptionWithMode("boot_image", default_boot_image.c_str(),
224 google::FlagSettingMode::SET_FLAGS_DEFAULT);
225 std::string default_cache_image = FLAGS_system_image_dir + "/cache.img";
226 SetCommandLineOptionWithMode("cache_image", default_cache_image.c_str(),
227 google::FlagSettingMode::SET_FLAGS_DEFAULT);
228 std::string default_data_image = FLAGS_system_image_dir + "/userdata.img";
229 SetCommandLineOptionWithMode("data_image", default_data_image.c_str(),
230 google::FlagSettingMode::SET_FLAGS_DEFAULT);
231 std::string default_vendor_image = FLAGS_system_image_dir + "/vendor.img";
232 SetCommandLineOptionWithMode("vendor_image", default_vendor_image.c_str(),
233 google::FlagSettingMode::SET_FLAGS_DEFAULT);
Paul Trautrimba8f8e92019-03-12 17:55:48 +0900234 std::string default_metadata_image = FLAGS_system_image_dir + "/metadata.img";
235 SetCommandLineOptionWithMode("metadata_image", default_metadata_image.c_str(),
236 google::FlagSettingMode::SET_FLAGS_DEFAULT);
Alistair Strachan5782ce42019-03-28 22:05:13 -0700237 std::string default_product_image = FLAGS_system_image_dir + "/product.img";
238 SetCommandLineOptionWithMode("product_image", default_product_image.c_str(),
239 google::FlagSettingMode::SET_FLAGS_DEFAULT);
Cody Schuffelen20ecaca2019-01-29 17:43:38 -0800240
Cody Schuffelen20ecaca2019-01-29 17:43:38 -0800241 return true;
242}
243
244std::string GetCuttlefishEnvPath() {
245 return cvd::StringFromEnv("HOME", ".") + "/.cuttlefish.sh";
246}
247
248// Initializes the config object and saves it to file. It doesn't return it, all
249// further uses of the config should happen through the singleton
250bool InitializeCuttlefishConfiguration(
251 const cvd::BootImageUnpacker& boot_image_unpacker) {
252 vsoc::CuttlefishConfig tmp_config_obj;
253 auto& memory_layout = *vsoc::VSoCMemoryLayout::Get();
254 // Set this first so that calls to PerInstancePath below are correct
255 tmp_config_obj.set_instance_dir(FLAGS_instance_dir);
256 if (!vm_manager::VmManager::IsValidName(FLAGS_vm_manager)) {
257 LOG(ERROR) << "Invalid vm_manager: " << FLAGS_vm_manager;
258 return false;
259 }
Greg Hartmana3c552d2019-03-28 18:20:48 -0700260 if (!vm_manager::VmManager::IsValidName(FLAGS_vm_manager)) {
261 LOG(ERROR) << "Invalid vm_manager: " << FLAGS_vm_manager;
262 return false;
263 }
Cody Schuffelen20ecaca2019-01-29 17:43:38 -0800264 tmp_config_obj.set_vm_manager(FLAGS_vm_manager);
Greg Hartmana3c552d2019-03-28 18:20:48 -0700265 tmp_config_obj.set_gpu_mode(FLAGS_gpu_mode);
266 if (!vm_manager::VmManager::ConfigureGpuMode(&tmp_config_obj)) {
267 LOG(ERROR) << "Invalid gpu_mode=" << FLAGS_gpu_mode <<
268 " does not work with vm_manager=" << FLAGS_vm_manager;
269 return false;
270 }
271 tmp_config_obj.set_wayland_socket(FLAGS_wayland_socket);
Cody Schuffelen20ecaca2019-01-29 17:43:38 -0800272
273 tmp_config_obj.set_serial_number(FLAGS_serial_number);
274
275 tmp_config_obj.set_cpus(FLAGS_cpus);
276 tmp_config_obj.set_memory_mb(FLAGS_memory_mb);
277
278 tmp_config_obj.set_dpi(FLAGS_dpi);
279 tmp_config_obj.set_setupwizard_mode(FLAGS_setupwizard_mode);
280 tmp_config_obj.set_x_res(FLAGS_x_res);
281 tmp_config_obj.set_y_res(FLAGS_y_res);
282 tmp_config_obj.set_num_screen_buffers(FLAGS_num_screen_buffers);
283 tmp_config_obj.set_refresh_rate_hz(FLAGS_refresh_rate_hz);
284 tmp_config_obj.set_gdb_flag(FLAGS_qemu_gdb);
Cody Schuffelen90b2fb22019-02-28 18:55:21 -0800285 std::vector<std::string> adb = cvd::StrSplit(FLAGS_adb_mode, ',');
286 tmp_config_obj.set_adb_mode(std::set<std::string>(adb.begin(), adb.end()));
Cody Schuffelen20ecaca2019-01-29 17:43:38 -0800287 tmp_config_obj.set_adb_ip_and_port("127.0.0.1:" + std::to_string(GetHostPort()));
288
289 tmp_config_obj.set_device_title(FLAGS_device_title);
290 if (FLAGS_kernel_path.size()) {
291 tmp_config_obj.set_kernel_image_path(FLAGS_kernel_path);
292 tmp_config_obj.set_use_unpacked_kernel(false);
293 } else {
294 tmp_config_obj.set_kernel_image_path(
295 tmp_config_obj.PerInstancePath("kernel"));
296 tmp_config_obj.set_use_unpacked_kernel(true);
297 }
Jorge E. Moreira80ddd7f2019-02-04 16:30:13 -0800298 tmp_config_obj.set_decompress_kernel(FLAGS_decompress_kernel);
299 if (FLAGS_decompress_kernel) {
300 tmp_config_obj.set_decompressed_kernel_image_path(
301 tmp_config_obj.PerInstancePath("vmlinux"));
302 }
Cody Schuffelen20ecaca2019-01-29 17:43:38 -0800303
304 auto ramdisk_path = tmp_config_obj.PerInstancePath("ramdisk.img");
305 bool use_ramdisk = boot_image_unpacker.HasRamdiskImage();
306 if (!use_ramdisk) {
307 LOG(INFO) << "No ramdisk present; assuming system-as-root build";
308 ramdisk_path = "";
309 }
310
311 // This needs to be done here because the dtb path depends on the presence of
312 // the ramdisk
313 if (FLAGS_dtb.empty()) {
314 if (use_ramdisk) {
315 FLAGS_dtb = vsoc::DefaultHostArtifactsPath("config/initrd-root.dtb");
316 } else {
317 FLAGS_dtb = vsoc::DefaultHostArtifactsPath("config/system-root.dtb");
318 }
319 }
320
321 tmp_config_obj.add_kernel_cmdline(boot_image_unpacker.kernel_cmdline());
322 if (!use_ramdisk) {
323 tmp_config_obj.add_kernel_cmdline("root=/dev/vda");
324 }
325 tmp_config_obj.add_kernel_cmdline("init=/init");
326 tmp_config_obj.add_kernel_cmdline(
327 concat("androidboot.serialno=", FLAGS_serial_number));
328 tmp_config_obj.add_kernel_cmdline("mac80211_hwsim.radios=0");
329 tmp_config_obj.add_kernel_cmdline(concat("androidboot.lcd_density=", FLAGS_dpi));
330 tmp_config_obj.add_kernel_cmdline(
331 concat("androidboot.setupwizard_mode=", FLAGS_setupwizard_mode));
332 tmp_config_obj.add_kernel_cmdline(concat("loop.max_part=", FLAGS_loop_max_part));
333 if (!FLAGS_console.empty()) {
334 tmp_config_obj.add_kernel_cmdline(concat("console=", FLAGS_console));
335 }
336 if (!FLAGS_androidboot_console.empty()) {
337 tmp_config_obj.add_kernel_cmdline(
338 concat("androidboot.console=", FLAGS_androidboot_console));
339 }
340 if (!FLAGS_hardware_name.empty()) {
341 tmp_config_obj.add_kernel_cmdline(
342 concat("androidboot.hardware=", FLAGS_hardware_name));
343 }
Jorge E. Moreirafd10cae2019-02-19 15:35:42 -0800344 if (FLAGS_logcat_mode == cvd::kLogcatVsockMode) {
345 tmp_config_obj.add_kernel_cmdline(concat("androidboot.vsock_logcat_port=",
346 FLAGS_logcat_vsock_port));
347 }
Jorge E. Moreiraf1f7cb32019-04-15 18:44:41 -0700348 tmp_config_obj.add_kernel_cmdline(concat("androidboot.cuttlefish_config_server_port=",
349 FLAGS_config_server_port));
Jorge E. Moreiraba626622019-01-28 17:47:50 -0800350 tmp_config_obj.set_hardware_name(FLAGS_hardware_name);
Cody Schuffelen20ecaca2019-01-29 17:43:38 -0800351 if (!FLAGS_guest_security.empty()) {
352 tmp_config_obj.add_kernel_cmdline(concat("security=", FLAGS_guest_security));
353 if (FLAGS_guest_enforce_security) {
354 tmp_config_obj.add_kernel_cmdline("enforcing=1");
355 } else {
356 tmp_config_obj.add_kernel_cmdline("enforcing=0");
357 tmp_config_obj.add_kernel_cmdline("androidboot.selinux=permissive");
358 }
359 if (FLAGS_guest_audit_security) {
360 tmp_config_obj.add_kernel_cmdline("audit=1");
361 } else {
362 tmp_config_obj.add_kernel_cmdline("audit=0");
363 }
364 }
365 if (FLAGS_run_e2e_test) {
366 tmp_config_obj.add_kernel_cmdline("androidboot.vsoc_e2e_test=1");
367 }
368 if (FLAGS_extra_kernel_cmdline.size()) {
369 tmp_config_obj.add_kernel_cmdline(FLAGS_extra_kernel_cmdline);
370 }
371
372 tmp_config_obj.set_ramdisk_image_path(ramdisk_path);
373 tmp_config_obj.set_system_image_path(FLAGS_system_image);
374 tmp_config_obj.set_cache_image_path(FLAGS_cache_image);
375 tmp_config_obj.set_data_image_path(FLAGS_data_image);
376 tmp_config_obj.set_vendor_image_path(FLAGS_vendor_image);
Paul Trautrimba8f8e92019-03-12 17:55:48 +0900377 tmp_config_obj.set_metadata_image_path(FLAGS_metadata_image);
Alistair Strachan5782ce42019-03-28 22:05:13 -0700378 tmp_config_obj.set_product_image_path(FLAGS_product_image);
Cody Schuffelen20ecaca2019-01-29 17:43:38 -0800379 tmp_config_obj.set_dtb_path(FLAGS_dtb);
Jorge E. Moreiraba626622019-01-28 17:47:50 -0800380 tmp_config_obj.set_gsi_fstab_path(FLAGS_gsi_fstab);
Cody Schuffelen20ecaca2019-01-29 17:43:38 -0800381
382 tmp_config_obj.set_mempath(FLAGS_mempath);
383 tmp_config_obj.set_ivshmem_qemu_socket_path(
384 tmp_config_obj.PerInstancePath("ivshmem_socket_qemu"));
385 tmp_config_obj.set_ivshmem_client_socket_path(
386 tmp_config_obj.PerInstancePath("ivshmem_socket_client"));
387 tmp_config_obj.set_ivshmem_vector_count(memory_layout.GetRegions().size());
388
389 if (AdbUsbEnabled(tmp_config_obj)) {
390 tmp_config_obj.set_usb_v1_socket_name(tmp_config_obj.PerInstancePath("usb-v1"));
391 tmp_config_obj.set_vhci_port(FLAGS_vhci_port);
392 tmp_config_obj.set_usb_ip_socket_name(tmp_config_obj.PerInstancePath("usb-ip"));
393 }
394
395 tmp_config_obj.set_kernel_log_socket_name(tmp_config_obj.PerInstancePath("kernel-log"));
396 tmp_config_obj.set_deprecated_boot_completed(FLAGS_deprecated_boot_completed);
397 tmp_config_obj.set_console_path(tmp_config_obj.PerInstancePath("console"));
398 tmp_config_obj.set_logcat_path(tmp_config_obj.PerInstancePath("logcat"));
Jorge E. Moreirafd10cae2019-02-19 15:35:42 -0800399 tmp_config_obj.set_logcat_receiver_binary(FLAGS_logcat_receiver_binary);
Jorge E. Moreiraf1f7cb32019-04-15 18:44:41 -0700400 tmp_config_obj.set_config_server_binary(FLAGS_config_server_binary);
Cody Schuffelen20ecaca2019-01-29 17:43:38 -0800401 tmp_config_obj.set_launcher_log_path(tmp_config_obj.PerInstancePath("launcher.log"));
402 tmp_config_obj.set_launcher_monitor_socket_path(
403 tmp_config_obj.PerInstancePath("launcher_monitor.sock"));
404
405 tmp_config_obj.set_mobile_bridge_name(FLAGS_mobile_interface);
406 tmp_config_obj.set_mobile_tap_name(FLAGS_mobile_tap_name);
407
Cody Schuffelen20ecaca2019-01-29 17:43:38 -0800408 tmp_config_obj.set_wifi_tap_name(FLAGS_wifi_tap_name);
409
410 tmp_config_obj.set_wifi_guest_mac_addr(FLAGS_guest_mac_address);
411 tmp_config_obj.set_wifi_host_mac_addr(FLAGS_host_mac_address);
412
413 tmp_config_obj.set_vsock_guest_cid(FLAGS_vsock_guest_cid);
414
415 tmp_config_obj.set_entropy_source("/dev/urandom");
416 tmp_config_obj.set_uuid(FLAGS_uuid);
417
418 tmp_config_obj.set_qemu_binary(FLAGS_qemu_binary);
Jorge E. Moreiraba626622019-01-28 17:47:50 -0800419 tmp_config_obj.set_crosvm_binary(FLAGS_crosvm_binary);
Cody Schuffelen20ecaca2019-01-29 17:43:38 -0800420 tmp_config_obj.set_ivserver_binary(FLAGS_ivserver_binary);
421 tmp_config_obj.set_kernel_log_monitor_binary(FLAGS_kernel_log_monitor_binary);
422
423 tmp_config_obj.set_enable_vnc_server(FLAGS_start_vnc_server);
424 tmp_config_obj.set_vnc_server_binary(FLAGS_vnc_server_binary);
425 tmp_config_obj.set_vnc_server_port(FLAGS_vnc_server_port);
426
427 tmp_config_obj.set_enable_stream_audio(FLAGS_start_stream_audio);
428 tmp_config_obj.set_stream_audio_binary(FLAGS_stream_audio_binary);
429 tmp_config_obj.set_stream_audio_port(FLAGS_stream_audio_port);
430
431 tmp_config_obj.set_restart_subprocesses(FLAGS_restart_subprocesses);
432 tmp_config_obj.set_run_adb_connector(FLAGS_run_adb_connector);
433 tmp_config_obj.set_adb_connector_binary(FLAGS_adb_connector_binary);
434 tmp_config_obj.set_virtual_usb_manager_binary(
435 FLAGS_virtual_usb_manager_binary);
436 tmp_config_obj.set_socket_forward_proxy_binary(
437 FLAGS_socket_forward_proxy_binary);
438 tmp_config_obj.set_socket_vsock_proxy_binary(FLAGS_socket_vsock_proxy_binary);
439 tmp_config_obj.set_run_as_daemon(FLAGS_daemon);
440 tmp_config_obj.set_run_e2e_test(FLAGS_run_e2e_test);
441 tmp_config_obj.set_e2e_test_binary(FLAGS_e2e_test_binary);
442
Cody Schuffelen2b51bab2019-01-29 18:14:48 -0800443 tmp_config_obj.set_data_policy(FLAGS_data_policy);
444 tmp_config_obj.set_blank_data_image_mb(FLAGS_blank_data_image_mb);
445 tmp_config_obj.set_blank_data_image_fmt(FLAGS_blank_data_image_fmt);
446
Cody Schuffelen20ecaca2019-01-29 17:43:38 -0800447 if(!AdbUsbEnabled(tmp_config_obj)) {
448 tmp_config_obj.disable_usb_adb();
449 }
450
Jorge E. Moreirafd10cae2019-02-19 15:35:42 -0800451 tmp_config_obj.set_logcat_mode(FLAGS_logcat_mode);
452 tmp_config_obj.set_logcat_vsock_port(FLAGS_logcat_vsock_port);
Jorge E. Moreiraf1f7cb32019-04-15 18:44:41 -0700453 tmp_config_obj.set_config_server_port(FLAGS_config_server_port);
Jorge E. Moreirac87c2c72019-03-06 16:12:23 -0800454 tmp_config_obj.set_frames_vsock_port(FLAGS_frames_vsock_port);
455 if (!tmp_config_obj.enable_ivserver()) {
456 tmp_config_obj.add_kernel_cmdline(concat("androidboot.vsock_frames_port=",
457 FLAGS_frames_vsock_port));
458 }
Jorge E. Moreirafd10cae2019-02-19 15:35:42 -0800459
Cody Schuffelen20ecaca2019-01-29 17:43:38 -0800460 tmp_config_obj.set_cuttlefish_env_path(GetCuttlefishEnvPath());
461
462 auto config_file = GetConfigFilePath(tmp_config_obj);
463 auto config_link = vsoc::GetGlobalConfigFileLink();
464 // Save the config object before starting any host process
465 if (!tmp_config_obj.SaveToFile(config_file)) {
466 LOG(ERROR) << "Unable to save config object";
467 return false;
468 }
469 setenv(vsoc::kCuttlefishConfigEnvVarName, config_file.c_str(), true);
470 if (symlink(config_file.c_str(), config_link.c_str()) != 0) {
471 LOG(ERROR) << "Failed to create symlink to config file at " << config_link
472 << ": " << strerror(errno);
473 return false;
474 }
475
476 return true;
477}
478
479void SetDefaultFlagsForQemu() {
480 auto default_mobile_interface = GetPerInstanceDefault("cvd-mbr-");
481 SetCommandLineOptionWithMode("mobile_interface",
482 default_mobile_interface.c_str(),
483 google::FlagSettingMode::SET_FLAGS_DEFAULT);
484 auto default_mobile_tap_name = GetPerInstanceDefault("cvd-mtap-");
485 SetCommandLineOptionWithMode("mobile_tap_name",
486 default_mobile_tap_name.c_str(),
487 google::FlagSettingMode::SET_FLAGS_DEFAULT);
Cody Schuffelen20ecaca2019-01-29 17:43:38 -0800488 auto default_wifi_tap_name = GetPerInstanceDefault("cvd-wtap-");
489 SetCommandLineOptionWithMode("wifi_tap_name",
490 default_wifi_tap_name.c_str(),
491 google::FlagSettingMode::SET_FLAGS_DEFAULT);
492 auto default_instance_dir =
493 cvd::StringFromEnv("HOME", ".") + "/cuttlefish_runtime";
494 SetCommandLineOptionWithMode("instance_dir",
495 default_instance_dir.c_str(),
496 google::FlagSettingMode::SET_FLAGS_DEFAULT);
Jorge E. Moreirafd1a6b02019-02-27 16:25:00 -0800497 SetCommandLineOptionWithMode("hardware_name", "cutf_ivsh",
Jorge E. Moreiraba626622019-01-28 17:47:50 -0800498 google::FlagSettingMode::SET_FLAGS_DEFAULT);
Jorge E. Moreira80ddd7f2019-02-04 16:30:13 -0800499 SetCommandLineOptionWithMode("decompress_kernel", "false",
500 google::FlagSettingMode::SET_FLAGS_DEFAULT);
Jorge E. Moreirafd10cae2019-02-19 15:35:42 -0800501 SetCommandLineOptionWithMode("logcat_mode", cvd::kLogcatSerialMode,
502 google::FlagSettingMode::SET_FLAGS_DEFAULT);
Jorge E. Moreiraba626622019-01-28 17:47:50 -0800503}
504
505void SetDefaultFlagsForCrosvm() {
506 auto default_mobile_interface = GetPerInstanceDefault("cvd-mbr-");
507 SetCommandLineOptionWithMode("mobile_interface",
508 default_mobile_interface.c_str(),
509 google::FlagSettingMode::SET_FLAGS_DEFAULT);
510 auto default_mobile_tap_name = GetPerInstanceDefault("cvd-mtap-");
511 SetCommandLineOptionWithMode("mobile_tap_name",
512 default_mobile_tap_name.c_str(),
513 google::FlagSettingMode::SET_FLAGS_DEFAULT);
Jorge E. Moreiraba626622019-01-28 17:47:50 -0800514 auto default_wifi_tap_name = GetPerInstanceDefault("cvd-wtap-");
515 SetCommandLineOptionWithMode("wifi_tap_name",
516 default_wifi_tap_name.c_str(),
517 google::FlagSettingMode::SET_FLAGS_DEFAULT);
518 auto default_instance_dir =
519 cvd::StringFromEnv("HOME", ".") + "/cuttlefish_runtime";
520 SetCommandLineOptionWithMode("instance_dir",
521 default_instance_dir.c_str(),
522 google::FlagSettingMode::SET_FLAGS_DEFAULT);
Greg Hartmana3c552d2019-03-28 18:20:48 -0700523 auto default_wayland_socket = vsoc::DefaultEnvironmentPath(
524 "XDG_RUNTIME_DIR", default_instance_dir.c_str(), "wayland-0");
525 SetCommandLineOptionWithMode("wayland_socket",
526 default_wayland_socket.c_str(),
527 google::FlagSettingMode::SET_FLAGS_DEFAULT);
Jorge E. Moreirafd1a6b02019-02-27 16:25:00 -0800528 SetCommandLineOptionWithMode("hardware_name", "cutf_cvm",
Jorge E. Moreiraba626622019-01-28 17:47:50 -0800529 google::FlagSettingMode::SET_FLAGS_DEFAULT);
Jorge E. Moreira80ddd7f2019-02-04 16:30:13 -0800530 SetCommandLineOptionWithMode("decompress_kernel", "true",
531 google::FlagSettingMode::SET_FLAGS_DEFAULT);
Jorge E. Moreira84d93c12019-02-05 12:02:29 -0800532 SetCommandLineOptionWithMode("run_e2e_test", "false",
533 google::FlagSettingMode::SET_FLAGS_DEFAULT);
Jorge E. Moreirafd10cae2019-02-19 15:35:42 -0800534 SetCommandLineOptionWithMode("logcat_mode", cvd::kLogcatVsockMode,
535 google::FlagSettingMode::SET_FLAGS_DEFAULT);
Cody Schuffelen20ecaca2019-01-29 17:43:38 -0800536}
537
538bool ParseCommandLineFlags(int* argc, char*** argv) {
539 // The config_file is created by the launcher, so the launcher is the only
540 // host process that doesn't use the flag.
541 // Set the default to empty.
542 google::SetCommandLineOptionWithMode("config_file", "",
543 gflags::SET_FLAGS_DEFAULT);
544 google::ParseCommandLineNonHelpFlags(argc, argv, true);
545 bool invalid_manager = false;
546 if (FLAGS_vm_manager == vm_manager::QemuManager::name()) {
547 SetDefaultFlagsForQemu();
Jorge E. Moreiraba626622019-01-28 17:47:50 -0800548 } else if (FLAGS_vm_manager == vm_manager::CrosvmManager::name()) {
549 SetDefaultFlagsForCrosvm();
Cody Schuffelen20ecaca2019-01-29 17:43:38 -0800550 } else {
551 std::cerr << "Unknown Virtual Machine Manager: " << FLAGS_vm_manager
552 << std::endl;
553 invalid_manager = true;
554 }
555 google::HandleCommandLineHelpFlags();
556 if (invalid_manager) {
557 return false;
558 }
559 // Set the env variable to empty (in case the caller passed a value for it).
560 unsetenv(vsoc::kCuttlefishConfigEnvVarName);
561
562 return ResolveInstanceFiles();
563}
564
565bool CleanPriorFiles() {
566 // Everything on the instance directory
567 std::string prior_files = FLAGS_instance_dir + "/*";
568 // The shared memory file
569 prior_files += " " + FLAGS_mempath;
570 // The environment file
571 prior_files += " " + GetCuttlefishEnvPath();
572 // The global link to the config file
573 prior_files += " " + vsoc::GetGlobalConfigFileLink();
574 LOG(INFO) << "Assuming prior files of " << prior_files;
575 std::string fuser_cmd = "fuser " + prior_files + " 2> /dev/null";
576 int rval = std::system(fuser_cmd.c_str());
577 // fuser returns 0 if any of the files are open
578 if (WEXITSTATUS(rval) == 0) {
579 LOG(ERROR) << "Clean aborted: files are in use";
580 return false;
581 }
582 std::string clean_command = "rm -rf " + prior_files;
583 rval = std::system(clean_command.c_str());
584 if (WEXITSTATUS(rval) != 0) {
585 LOG(ERROR) << "Remove of files failed";
586 return false;
587 }
588 return true;
589}
Jorge E. Moreira80ddd7f2019-02-04 16:30:13 -0800590
591bool DecompressKernel(const std::string& src, const std::string& dst) {
592 cvd::Command decomp_cmd(FLAGS_kernel_decompresser_executable);
593 decomp_cmd.AddParameter(src);
594 auto output_file = cvd::SharedFD::Creat(dst.c_str(), 0666);
595 if (!output_file->IsOpen()) {
596 LOG(ERROR) << "Unable to create decompressed image file: "
597 << output_file->StrError();
598 return false;
599 }
600 decomp_cmd.RedirectStdIO(cvd::Subprocess::StdIOChannel::kStdOut, output_file);
601 auto decomp_proc = decomp_cmd.Start(false);
602 return decomp_proc.Started() && decomp_proc.Wait() == 0;
603}
Cody Schuffelen20ecaca2019-01-29 17:43:38 -0800604} // namespace
605
606vsoc::CuttlefishConfig* InitFilesystemAndCreateConfig(int* argc, char*** argv) {
607 if (!ParseCommandLineFlags(argc, argv)) {
608 LOG(ERROR) << "Failed to parse command arguments";
609 exit(LauncherExitCodes::kArgumentParsingError);
610 }
611
612 // Clean up prior files before saving the config file (doing it after would
613 // delete it)
614 if (!CleanPriorFiles()) {
615 LOG(ERROR) << "Failed to clean prior files";
616 exit(LauncherExitCodes::kPrioFilesCleanupError);
617 }
618 // Create instance directory if it doesn't exist.
619 if (!cvd::DirectoryExists(FLAGS_instance_dir.c_str())) {
620 LOG(INFO) << "Setting up " << FLAGS_instance_dir;
621 if (mkdir(FLAGS_instance_dir.c_str(), S_IRWXU | S_IRWXG | S_IROTH | S_IXOTH) < 0) {
622 LOG(ERROR) << "Failed to create instance directory: "
623 << FLAGS_instance_dir << ". Error: " << errno;
624 exit(LauncherExitCodes::kInstanceDirCreationError);
625 }
626 }
627
Cody Schuffelen2b51bab2019-01-29 18:14:48 -0800628 if (!cvd::FileHasContent(FLAGS_boot_image)) {
629 LOG(ERROR) << "File not found: " << FLAGS_boot_image;
630 exit(cvd::kCuttlefishConfigurationInitError);
631 }
632
Cody Schuffelen20ecaca2019-01-29 17:43:38 -0800633 auto boot_img_unpacker = cvd::BootImageUnpacker::FromImage(FLAGS_boot_image);
634
635 if (!InitializeCuttlefishConfiguration(*boot_img_unpacker)) {
636 LOG(ERROR) << "Failed to initialize configuration";
637 exit(LauncherExitCodes::kCuttlefishConfigurationInitError);
638 }
639 // Do this early so that the config object is ready for anything that needs it
640 auto config = vsoc::CuttlefishConfig::Get();
641 if (!config) {
642 LOG(ERROR) << "Failed to obtain config singleton";
643 exit(LauncherExitCodes::kCuttlefishConfigurationInitError);
644 }
645
646 if (!boot_img_unpacker->Unpack(config->ramdisk_image_path(),
647 config->use_unpacked_kernel()
648 ? config->kernel_image_path()
649 : "")) {
650 LOG(ERROR) << "Failed to unpack boot image";
651 exit(LauncherExitCodes::kBootImageUnpackError);
652 }
653
Jorge E. Moreira80ddd7f2019-02-04 16:30:13 -0800654 if (config->decompress_kernel()) {
655 if (!DecompressKernel(config->kernel_image_path(),
656 config->decompressed_kernel_image_path())) {
657 LOG(ERROR) << "Failed to decompress kernel";
658 exit(LauncherExitCodes::kKernelDecompressError);
659 }
660 }
661
Cody Schuffelen20ecaca2019-01-29 17:43:38 -0800662 ValidateAdbModeFlag(*config);
663
Cody Schuffelen2b51bab2019-01-29 18:14:48 -0800664 // Create data if necessary
665 if (!ApplyDataImagePolicy(*config)) {
666 exit(cvd::kCuttlefishConfigurationInitError);
667 }
668
Paul Trautrimba8f8e92019-03-12 17:55:48 +0900669 CreateBlankImage(FLAGS_metadata_image, FLAGS_blank_metadata_image_mb, "none");
670
Cody Schuffelen2b51bab2019-01-29 18:14:48 -0800671 // Check that the files exist
672 for (const auto& file :
673 {config->system_image_path(), config->vendor_image_path(),
Paul Trautrimba8f8e92019-03-12 17:55:48 +0900674 config->cache_image_path(), config->data_image_path(),
Alistair Strachan5782ce42019-03-28 22:05:13 -0700675 config->metadata_image_path(), config->product_image_path()}) {
Cody Schuffelen2b51bab2019-01-29 18:14:48 -0800676 if (!cvd::FileHasContent(file.c_str())) {
677 LOG(ERROR) << "File not found: " << file;
678 exit(cvd::kCuttlefishConfigurationInitError);
679 }
680 }
681
Cody Schuffelen20ecaca2019-01-29 17:43:38 -0800682 return config;
683}
684
685std::string GetConfigFilePath(const vsoc::CuttlefishConfig& config) {
686 return config.PerInstancePath("cuttlefish_config.json");
687}