blob: 9f11e9700fb56842ba9cd6fe4f7c691eef702b95 [file] [log] [blame]
Cody Schuffelen20ecaca2019-01-29 17:43:38 -08001#include "host/commands/launch/flags.h"
2
3#include <iostream>
Ram Muthiahaad97c52019-08-14 17:05:01 -07004#include <fstream>
Cody Schuffelen20ecaca2019-01-29 17:43:38 -08005
6#include <gflags/gflags.h>
7#include <glog/logging.h>
8
Cody Schuffelen90b2fb22019-02-28 18:55:21 -08009#include "common/libs/strings/str_split.h"
Cody Schuffelen20ecaca2019-01-29 17:43:38 -080010#include "common/libs/utils/environment.h"
11#include "common/libs/utils/files.h"
12#include "common/vsoc/lib/vsoc_memory.h"
13#include "host/commands/launch/boot_image_unpacker.h"
14#include "host/commands/launch/data_image.h"
Cody Schuffelen3c99f5b2019-06-14 17:26:01 -070015#include "host/commands/launch/image_aggregator.h"
Cody Schuffelen20ecaca2019-01-29 17:43:38 -080016#include "host/commands/launch/launch.h"
17#include "host/commands/launch/launcher_defs.h"
Jorge E. Moreiraba626622019-01-28 17:47:50 -080018#include "host/libs/vm_manager/crosvm_manager.h"
Cody Schuffelen20ecaca2019-01-29 17:43:38 -080019#include "host/libs/vm_manager/qemu_manager.h"
20#include "host/libs/vm_manager/vm_manager.h"
21
22using vsoc::GetPerInstanceDefault;
23using cvd::LauncherExitCodes;
24
Cody Schuffelen20ecaca2019-01-29 17:43:38 -080025DEFINE_string(cache_image, "", "Location of the cache partition image.");
Paul Trautrimba8f8e92019-03-12 17:55:48 +090026DEFINE_string(metadata_image, "", "Location of the metadata partition image "
27 "to be generated.");
28DEFINE_int32(blank_metadata_image_mb, 16,
29 "The size of the blank metadata image to generate, MB.");
Cody Schuffelen20ecaca2019-01-29 17:43:38 -080030DEFINE_int32(cpus, 2, "Virtual CPU count.");
31DEFINE_string(data_image, "", "Location of the data partition image.");
32DEFINE_string(data_policy, "use_existing", "How to handle userdata partition."
33 " Either 'use_existing', 'create_if_missing', 'resize_up_to', or "
34 "'always_create'.");
35DEFINE_int32(blank_data_image_mb, 0,
36 "The size of the blank data image to generate, MB.");
37DEFINE_string(blank_data_image_fmt, "ext4",
38 "The fs format for the blank data image. Used with mkfs.");
39DEFINE_string(qemu_gdb, "",
Matthias Maennich454d7872019-02-06 16:35:17 +000040 "Debug flag to pass to qemu. e.g. -qemu_gdb=tcp::1234");
Cody Schuffelen20ecaca2019-01-29 17:43:38 -080041
42DEFINE_int32(x_res, 720, "Width of the screen in pixels");
43DEFINE_int32(y_res, 1280, "Height of the screen in pixels");
44DEFINE_int32(dpi, 160, "Pixels per inch for the screen");
45DEFINE_int32(refresh_rate_hz, 60, "Screen refresh rate in Hertz");
46DEFINE_int32(num_screen_buffers, 3, "The number of screen buffers");
47DEFINE_string(kernel_path, "",
48 "Path to the kernel. Overrides the one from the boot image");
Ram Muthiahaad97c52019-08-14 17:05:01 -070049DEFINE_string(initramfs_path, "", "Path to the initramfs");
Jorge E. Moreira80ddd7f2019-02-04 16:30:13 -080050DEFINE_bool(decompress_kernel, false,
Jorge E. Moreira36294042019-06-07 15:23:18 -070051 "Whether to decompress the kernel image.");
Jorge E. Moreira80ddd7f2019-02-04 16:30:13 -080052DEFINE_string(kernel_decompresser_executable,
53 vsoc::DefaultHostArtifactsPath("bin/extract-vmlinux"),
54 "Path to the extract-vmlinux executable.");
Cody Schuffelen20ecaca2019-01-29 17:43:38 -080055DEFINE_string(extra_kernel_cmdline, "",
56 "Additional flags to put on the kernel command line");
57DEFINE_int32(loop_max_part, 7, "Maximum number of loop partitions");
Cody Schuffelen20ecaca2019-01-29 17:43:38 -080058DEFINE_string(androidboot_console, "ttyS1",
59 "Console device for the Android framework");
Jorge E. Moreiraba626622019-01-28 17:47:50 -080060DEFINE_string(
61 hardware_name, "",
Jorge E. Moreirafd1a6b02019-02-27 16:25:00 -080062 "The codename of the device's hardware, one of {cutf_ivsh, cutf_cvm}");
Cody Schuffelen20ecaca2019-01-29 17:43:38 -080063DEFINE_string(guest_security, "selinux",
64 "The security module to use in the guest");
Jorge E. Moreira300f97f2019-04-09 13:48:01 -070065DEFINE_bool(guest_enforce_security, true,
Cody Schuffelen20ecaca2019-01-29 17:43:38 -080066 "Whether to run in enforcing mode (non permissive). Ignored if "
67 "-guest_security is empty.");
68DEFINE_bool(guest_audit_security, true,
69 "Whether to log security audits.");
Yifan Hong19d713e2019-05-01 14:12:07 -070070DEFINE_string(boot_image, "",
71 "Location of cuttlefish boot image. If empty it is assumed to be "
72 "boot.img in the directory specified by -system_image_dir.");
Cody Schuffelen20ecaca2019-01-29 17:43:38 -080073DEFINE_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(
Alistair Strachan5ab095c2019-05-23 20:41:20 +000088 vm_manager, vm_manager::CrosvmManager::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(
Greg Hartmanbc1bed42019-04-05 20:02:00 -070091 gpu_mode, vsoc::kGpuModeGuestSwiftshader,
92 "What gpu configuration to use, one of {guest_swiftshader, drm_virgl}");
Greg Hartmana3c552d2019-03-28 18:20:48 -070093DEFINE_string(wayland_socket, "",
Greg Hartmanbc1bed42019-04-05 20:02:00 -070094 "Location of the wayland socket to use for drm_virgl gpu_mode.");
Greg Hartmaneb04ac52019-07-16 16:44:18 -070095DEFINE_string(x_display, "",
96 "X display to use for drm_virgl gpu_mode.");
Greg Hartmana3c552d2019-03-28 18:20:48 -070097
Cody Schuffelen20ecaca2019-01-29 17:43:38 -080098DEFINE_string(system_image_dir, vsoc::DefaultGuestImagePath(""),
99 "Location of the system partition images.");
Alistair Strachan050ca932018-11-27 12:41:19 -0800100DEFINE_string(super_image, "", "Location of the super partition image.");
Yifan Hong19d713e2019-05-01 14:12:07 -0700101DEFINE_string(misc_image, "",
102 "Location of the misc partition image. If the image does not "
103 "exist, a blank new misc partition image is created.");
Cody Schuffelen68728802019-09-23 22:22:19 +0000104DEFINE_string(composite_disk, "", "Location of the composite disk image.");
Cody Schuffelen20ecaca2019-01-29 17:43:38 -0800105
106DEFINE_bool(deprecated_boot_completed, false, "Log boot completed message to"
107 " host kernel. This is only used during transition of our clients."
108 " Will be deprecated soon.");
109DEFINE_bool(start_vnc_server, true, "Whether to start the vnc server process.");
110DEFINE_string(vnc_server_binary,
111 vsoc::DefaultHostArtifactsPath("bin/vnc_server"),
112 "Location of the vnc server binary.");
Alistair Strachan7eeddf42019-03-04 18:13:34 -0800113DEFINE_bool(start_stream_audio, false,
Cody Schuffelen20ecaca2019-01-29 17:43:38 -0800114 "Whether to start the stream audio process.");
115DEFINE_string(stream_audio_binary,
116 vsoc::DefaultHostArtifactsPath("bin/stream_audio"),
117 "Location of the stream_audio binary.");
118DEFINE_string(virtual_usb_manager_binary,
119 vsoc::DefaultHostArtifactsPath("bin/virtual_usb_manager"),
120 "Location of the virtual usb manager binary.");
121DEFINE_string(kernel_log_monitor_binary,
122 vsoc::DefaultHostArtifactsPath("bin/kernel_log_monitor"),
123 "Location of the log monitor binary.");
124DEFINE_string(ivserver_binary,
125 vsoc::DefaultHostArtifactsPath("bin/ivserver"),
126 "Location of the ivshmem server binary.");
127DEFINE_int32(vnc_server_port, GetPerInstanceDefault(6444),
128 "The port on which the vnc server should listen");
129DEFINE_int32(stream_audio_port, GetPerInstanceDefault(7444),
130 "The port on which stream_audio should listen.");
131DEFINE_string(socket_forward_proxy_binary,
132 vsoc::DefaultHostArtifactsPath("bin/socket_forward_proxy"),
133 "Location of the socket_forward_proxy binary.");
134DEFINE_string(socket_vsock_proxy_binary,
135 vsoc::DefaultHostArtifactsPath("bin/socket_vsock_proxy"),
136 "Location of the socket_vsock_proxy binary.");
Cody Schuffelen10743332019-04-15 16:50:49 -0700137DEFINE_string(adb_mode, "vsock_half_tunnel",
Cody Schuffelen63d10052019-02-26 12:21:53 -0800138 "Mode for ADB connection. Can be 'usb' for USB forwarding, "
139 "'tunnel' for a TCP connection tunneled through VSoC, "
140 "'vsock_tunnel' for a TCP connection tunneled through vsock, "
141 "'native_vsock' for a direct connection to the guest ADB over "
142 "vsock, 'vsock_half_tunnel' for a TCP connection forwarded to "
143 "the guest ADB server, or a comma separated list of types as in "
144 "'usb,tunnel'");
Cody Schuffelen20ecaca2019-01-29 17:43:38 -0800145DEFINE_bool(run_adb_connector, true,
146 "Maintain adb connection by sending 'adb connect' commands to the "
Matthias Maennich454d7872019-02-06 16:35:17 +0000147 "server. Only relevant with -adb_mode=tunnel or vsock_tunnel");
Cody Schuffelen20ecaca2019-01-29 17:43:38 -0800148DEFINE_string(adb_connector_binary,
149 vsoc::DefaultHostArtifactsPath("bin/adb_connector"),
150 "Location of the adb_connector binary. Only relevant if "
Matthias Maennich454d7872019-02-06 16:35:17 +0000151 "-run_adb_connector is true");
Cody Schuffelen20ecaca2019-01-29 17:43:38 -0800152DEFINE_int32(vhci_port, GetPerInstanceDefault(0), "VHCI port to use for usb");
Cody Schuffelen20ecaca2019-01-29 17:43:38 -0800153DEFINE_string(wifi_tap_name, "", // default handled on ParseCommandLine
154 "The name of the tap interface to use for wifi");
155DEFINE_int32(vsock_guest_cid,
156 vsoc::GetDefaultPerInstanceVsockCid(),
157 "Guest identifier for vsock. Disabled if under 3.");
158
Cody Schuffelen20ecaca2019-01-29 17:43:38 -0800159DEFINE_string(uuid, vsoc::GetPerInstanceDefault(vsoc::kDefaultUuidPrefix),
160 "UUID to use for the device. Random if not specified");
161DEFINE_bool(daemon, false,
162 "Run cuttlefish in background, the launcher exits on boot "
163 "completed/failed");
164
165DEFINE_string(device_title, "", "Human readable name for the instance, "
166 "used by the vnc_server for its server title");
167DEFINE_string(setupwizard_mode, "DISABLED",
168 "One of DISABLED,OPTIONAL,REQUIRED");
169
170DEFINE_string(qemu_binary,
171 "/usr/bin/qemu-system-x86_64",
172 "The qemu binary to use");
Jorge E. Moreiraba626622019-01-28 17:47:50 -0800173DEFINE_string(crosvm_binary,
174 vsoc::DefaultHostArtifactsPath("bin/crosvm"),
175 "The Crosvm binary to use");
Jorge E. Moreira13cbd982019-06-06 16:06:34 -0700176DEFINE_string(console_forwarder_binary,
177 vsoc::DefaultHostArtifactsPath("bin/console_forwarder"),
178 "The Console Forwarder binary to use");
Cody Schuffelen20ecaca2019-01-29 17:43:38 -0800179DEFINE_bool(restart_subprocesses, true, "Restart any crashed host process");
180DEFINE_bool(run_e2e_test, true, "Run e2e test after device launches");
181DEFINE_string(e2e_test_binary,
182 vsoc::DefaultHostArtifactsPath("bin/host_region_e2e_test"),
183 "Location of the region end to end test binary");
Jorge E. Moreirafd10cae2019-02-19 15:35:42 -0800184DEFINE_string(logcat_receiver_binary,
185 vsoc::DefaultHostArtifactsPath("bin/logcat_receiver"),
186 "Binary for the logcat server");
187DEFINE_string(logcat_mode, "", "How to send android's log messages from "
188 "guest to host. One of [serial, vsock]");
189DEFINE_int32(logcat_vsock_port, vsoc::GetPerInstanceDefault(5620),
190 "The port for logcat over vsock");
Jorge E. Moreiraf1f7cb32019-04-15 18:44:41 -0700191DEFINE_string(config_server_binary,
192 vsoc::DefaultHostArtifactsPath("bin/config_server"),
193 "Binary for the configuration server");
194DEFINE_int32(config_server_port, vsoc::GetPerInstanceDefault(4680),
195 "The (vsock) port for the configuration server");
Jorge E. Moreirac87c2c72019-03-06 16:12:23 -0800196DEFINE_int32(frames_vsock_port, vsoc::GetPerInstanceDefault(5580),
197 "The vsock port to receive frames from the guest on");
Ram Muthiah6e9c98c2019-05-28 15:18:27 -0700198DEFINE_bool(enable_tombstone_receiver, true, "Enables the tombstone logger on "
Ram Muthiah792e2ad2019-04-19 11:19:46 -0700199 "both the guest and the host");
200DEFINE_string(tombstone_receiver_binary,
201 vsoc::DefaultHostArtifactsPath("bin/tombstone_receiver"),
202 "Binary for the tombstone server");
203DEFINE_int32(tombstone_receiver_port, vsoc::GetPerInstanceDefault(5630),
204 "The vsock port for tombstones");
Yifan Hong19d713e2019-05-01 14:12:07 -0700205
Cody Schuffelen20ecaca2019-01-29 17:43:38 -0800206namespace {
207
208template<typename S, typename T>
209static std::string concat(const S& s, const T& t) {
210 std::ostringstream os;
211 os << s << t;
212 return os.str();
213}
214
215bool ResolveInstanceFiles() {
216 if (FLAGS_system_image_dir.empty()) {
217 LOG(ERROR) << "--system_image_dir must be specified.";
218 return false;
219 }
220
221 // If user did not specify location of either of these files, expect them to
222 // be placed in --system_image_dir location.
Cody Schuffelen20ecaca2019-01-29 17:43:38 -0800223 std::string default_boot_image = FLAGS_system_image_dir + "/boot.img";
224 SetCommandLineOptionWithMode("boot_image", default_boot_image.c_str(),
225 google::FlagSettingMode::SET_FLAGS_DEFAULT);
226 std::string default_cache_image = FLAGS_system_image_dir + "/cache.img";
227 SetCommandLineOptionWithMode("cache_image", default_cache_image.c_str(),
228 google::FlagSettingMode::SET_FLAGS_DEFAULT);
229 std::string default_data_image = FLAGS_system_image_dir + "/userdata.img";
230 SetCommandLineOptionWithMode("data_image", default_data_image.c_str(),
231 google::FlagSettingMode::SET_FLAGS_DEFAULT);
Paul Trautrimba8f8e92019-03-12 17:55:48 +0900232 std::string default_metadata_image = FLAGS_system_image_dir + "/metadata.img";
233 SetCommandLineOptionWithMode("metadata_image", default_metadata_image.c_str(),
234 google::FlagSettingMode::SET_FLAGS_DEFAULT);
Alistair Strachan050ca932018-11-27 12:41:19 -0800235 std::string default_super_image = FLAGS_system_image_dir + "/super.img";
236 SetCommandLineOptionWithMode("super_image", default_super_image.c_str(),
237 google::FlagSettingMode::SET_FLAGS_DEFAULT);
Yifan Hong19d713e2019-05-01 14:12:07 -0700238 std::string default_misc_image = FLAGS_system_image_dir + "/misc.img";
239 SetCommandLineOptionWithMode("misc_image", default_misc_image.c_str(),
240 google::FlagSettingMode::SET_FLAGS_DEFAULT);
Cody Schuffelen20ecaca2019-01-29 17:43:38 -0800241
Cody Schuffelen20ecaca2019-01-29 17:43:38 -0800242 return true;
243}
244
245std::string GetCuttlefishEnvPath() {
246 return cvd::StringFromEnv("HOME", ".") + "/.cuttlefish.sh";
247}
248
249// Initializes the config object and saves it to file. It doesn't return it, all
250// further uses of the config should happen through the singleton
251bool InitializeCuttlefishConfiguration(
252 const cvd::BootImageUnpacker& boot_image_unpacker) {
253 vsoc::CuttlefishConfig tmp_config_obj;
254 auto& memory_layout = *vsoc::VSoCMemoryLayout::Get();
255 // Set this first so that calls to PerInstancePath below are correct
256 tmp_config_obj.set_instance_dir(FLAGS_instance_dir);
257 if (!vm_manager::VmManager::IsValidName(FLAGS_vm_manager)) {
258 LOG(ERROR) << "Invalid vm_manager: " << FLAGS_vm_manager;
259 return false;
260 }
Greg Hartmana3c552d2019-03-28 18:20:48 -0700261 if (!vm_manager::VmManager::IsValidName(FLAGS_vm_manager)) {
262 LOG(ERROR) << "Invalid vm_manager: " << FLAGS_vm_manager;
263 return false;
264 }
Cody Schuffelen20ecaca2019-01-29 17:43:38 -0800265 tmp_config_obj.set_vm_manager(FLAGS_vm_manager);
Greg Hartmana3c552d2019-03-28 18:20:48 -0700266 tmp_config_obj.set_gpu_mode(FLAGS_gpu_mode);
267 if (!vm_manager::VmManager::ConfigureGpuMode(&tmp_config_obj)) {
268 LOG(ERROR) << "Invalid gpu_mode=" << FLAGS_gpu_mode <<
269 " does not work with vm_manager=" << FLAGS_vm_manager;
270 return false;
271 }
272 tmp_config_obj.set_wayland_socket(FLAGS_wayland_socket);
Greg Hartmaneb04ac52019-07-16 16:44:18 -0700273 tmp_config_obj.set_x_display(FLAGS_x_display);
Cody Schuffelen20ecaca2019-01-29 17:43:38 -0800274
Alistair Strachan050ca932018-11-27 12:41:19 -0800275 vm_manager::VmManager::ConfigureBootDevices(&tmp_config_obj);
276
Cody Schuffelen20ecaca2019-01-29 17:43:38 -0800277 tmp_config_obj.set_serial_number(FLAGS_serial_number);
278
279 tmp_config_obj.set_cpus(FLAGS_cpus);
280 tmp_config_obj.set_memory_mb(FLAGS_memory_mb);
281
282 tmp_config_obj.set_dpi(FLAGS_dpi);
283 tmp_config_obj.set_setupwizard_mode(FLAGS_setupwizard_mode);
284 tmp_config_obj.set_x_res(FLAGS_x_res);
285 tmp_config_obj.set_y_res(FLAGS_y_res);
286 tmp_config_obj.set_num_screen_buffers(FLAGS_num_screen_buffers);
287 tmp_config_obj.set_refresh_rate_hz(FLAGS_refresh_rate_hz);
288 tmp_config_obj.set_gdb_flag(FLAGS_qemu_gdb);
Cody Schuffelen90b2fb22019-02-28 18:55:21 -0800289 std::vector<std::string> adb = cvd::StrSplit(FLAGS_adb_mode, ',');
290 tmp_config_obj.set_adb_mode(std::set<std::string>(adb.begin(), adb.end()));
Cody Schuffelen20ecaca2019-01-29 17:43:38 -0800291 tmp_config_obj.set_adb_ip_and_port("127.0.0.1:" + std::to_string(GetHostPort()));
292
293 tmp_config_obj.set_device_title(FLAGS_device_title);
294 if (FLAGS_kernel_path.size()) {
295 tmp_config_obj.set_kernel_image_path(FLAGS_kernel_path);
296 tmp_config_obj.set_use_unpacked_kernel(false);
297 } else {
298 tmp_config_obj.set_kernel_image_path(
299 tmp_config_obj.PerInstancePath("kernel"));
300 tmp_config_obj.set_use_unpacked_kernel(true);
301 }
Jorge E. Moreira80ddd7f2019-02-04 16:30:13 -0800302 tmp_config_obj.set_decompress_kernel(FLAGS_decompress_kernel);
303 if (FLAGS_decompress_kernel) {
304 tmp_config_obj.set_decompressed_kernel_image_path(
305 tmp_config_obj.PerInstancePath("vmlinux"));
306 }
Cody Schuffelen20ecaca2019-01-29 17:43:38 -0800307
308 auto ramdisk_path = tmp_config_obj.PerInstancePath("ramdisk.img");
309 bool use_ramdisk = boot_image_unpacker.HasRamdiskImage();
310 if (!use_ramdisk) {
311 LOG(INFO) << "No ramdisk present; assuming system-as-root build";
312 ramdisk_path = "";
313 }
314
Cody Schuffelen20ecaca2019-01-29 17:43:38 -0800315 tmp_config_obj.add_kernel_cmdline(boot_image_unpacker.kernel_cmdline());
Cody Schuffelen88b82d52019-05-29 14:16:03 -0700316
317 if (use_ramdisk) {
318 if (FLAGS_composite_disk.empty()) {
319 tmp_config_obj.add_kernel_cmdline("androidboot.fstab_name=fstab");
320 } else {
Alistair Delva73ad5ec2019-08-30 15:37:19 -0700321 tmp_config_obj.add_kernel_cmdline("androidboot.fstab_name=fstab.composite");
Cody Schuffelen88b82d52019-05-29 14:16:03 -0700322 }
323 } else {
324 if (FLAGS_composite_disk.empty()) {
325 tmp_config_obj.add_kernel_cmdline("root=/dev/vda");
326 tmp_config_obj.add_kernel_cmdline("androidboot.fstab_name=fstab");
327 } else {
328 tmp_config_obj.add_kernel_cmdline("root=/dev/vda1");
Alistair Delva73ad5ec2019-08-30 15:37:19 -0700329 tmp_config_obj.add_kernel_cmdline("androidboot.fstab_name=fstab.composite");
Cody Schuffelen88b82d52019-05-29 14:16:03 -0700330 }
Cody Schuffelen20ecaca2019-01-29 17:43:38 -0800331 }
Cody Schuffelen88b82d52019-05-29 14:16:03 -0700332
Alistair Strachan050ca932018-11-27 12:41:19 -0800333 if (!FLAGS_super_image.empty()) {
Cody Schuffelen88b82d52019-05-29 14:16:03 -0700334 if (FLAGS_composite_disk.empty()) {
335 tmp_config_obj.add_kernel_cmdline("androidboot.super_partition=vda");
336 } else {
337 tmp_config_obj.add_kernel_cmdline("androidboot.super_partition=super");
338 }
Alistair Strachan050ca932018-11-27 12:41:19 -0800339 }
Cody Schuffelen88b82d52019-05-29 14:16:03 -0700340
Cody Schuffelen20ecaca2019-01-29 17:43:38 -0800341 tmp_config_obj.add_kernel_cmdline("init=/init");
342 tmp_config_obj.add_kernel_cmdline(
343 concat("androidboot.serialno=", FLAGS_serial_number));
344 tmp_config_obj.add_kernel_cmdline("mac80211_hwsim.radios=0");
345 tmp_config_obj.add_kernel_cmdline(concat("androidboot.lcd_density=", FLAGS_dpi));
346 tmp_config_obj.add_kernel_cmdline(
347 concat("androidboot.setupwizard_mode=", FLAGS_setupwizard_mode));
348 tmp_config_obj.add_kernel_cmdline(concat("loop.max_part=", FLAGS_loop_max_part));
Cody Schuffelen20ecaca2019-01-29 17:43:38 -0800349 if (!FLAGS_androidboot_console.empty()) {
350 tmp_config_obj.add_kernel_cmdline(
351 concat("androidboot.console=", FLAGS_androidboot_console));
352 }
353 if (!FLAGS_hardware_name.empty()) {
354 tmp_config_obj.add_kernel_cmdline(
355 concat("androidboot.hardware=", FLAGS_hardware_name));
356 }
Jorge E. Moreirafd10cae2019-02-19 15:35:42 -0800357 if (FLAGS_logcat_mode == cvd::kLogcatVsockMode) {
358 tmp_config_obj.add_kernel_cmdline(concat("androidboot.vsock_logcat_port=",
359 FLAGS_logcat_vsock_port));
360 }
Jorge E. Moreiraf1f7cb32019-04-15 18:44:41 -0700361 tmp_config_obj.add_kernel_cmdline(concat("androidboot.cuttlefish_config_server_port=",
362 FLAGS_config_server_port));
Jorge E. Moreiraba626622019-01-28 17:47:50 -0800363 tmp_config_obj.set_hardware_name(FLAGS_hardware_name);
Cody Schuffelen20ecaca2019-01-29 17:43:38 -0800364 if (!FLAGS_guest_security.empty()) {
365 tmp_config_obj.add_kernel_cmdline(concat("security=", FLAGS_guest_security));
366 if (FLAGS_guest_enforce_security) {
367 tmp_config_obj.add_kernel_cmdline("enforcing=1");
368 } else {
369 tmp_config_obj.add_kernel_cmdline("enforcing=0");
370 tmp_config_obj.add_kernel_cmdline("androidboot.selinux=permissive");
371 }
372 if (FLAGS_guest_audit_security) {
373 tmp_config_obj.add_kernel_cmdline("audit=1");
374 } else {
375 tmp_config_obj.add_kernel_cmdline("audit=0");
376 }
377 }
378 if (FLAGS_run_e2e_test) {
379 tmp_config_obj.add_kernel_cmdline("androidboot.vsoc_e2e_test=1");
380 }
381 if (FLAGS_extra_kernel_cmdline.size()) {
382 tmp_config_obj.add_kernel_cmdline(FLAGS_extra_kernel_cmdline);
383 }
384
Cody Schuffelen3c99f5b2019-06-14 17:26:01 -0700385 if (!FLAGS_composite_disk.empty()) {
386 tmp_config_obj.set_virtual_disk_paths({FLAGS_composite_disk});
Cody Schuffelen4f7e4412019-08-30 16:10:59 -0700387 } else {
Cody Schuffelen3c99f5b2019-06-14 17:26:01 -0700388 tmp_config_obj.set_virtual_disk_paths({
389 FLAGS_super_image,
390 FLAGS_data_image,
391 FLAGS_cache_image,
392 FLAGS_metadata_image,
393 });
Cody Schuffelen3c99f5b2019-06-14 17:26:01 -0700394 }
395
Cody Schuffelen20ecaca2019-01-29 17:43:38 -0800396 tmp_config_obj.set_ramdisk_image_path(ramdisk_path);
Cody Schuffelen20ecaca2019-01-29 17:43:38 -0800397
398 tmp_config_obj.set_mempath(FLAGS_mempath);
399 tmp_config_obj.set_ivshmem_qemu_socket_path(
400 tmp_config_obj.PerInstancePath("ivshmem_socket_qemu"));
401 tmp_config_obj.set_ivshmem_client_socket_path(
402 tmp_config_obj.PerInstancePath("ivshmem_socket_client"));
403 tmp_config_obj.set_ivshmem_vector_count(memory_layout.GetRegions().size());
404
Cody Schuffelen75ef8872019-09-06 17:35:54 -0700405 if (tmp_config_obj.adb_mode().count(vsoc::AdbMode::Usb) > 0) {
Cody Schuffelen20ecaca2019-01-29 17:43:38 -0800406 tmp_config_obj.set_usb_v1_socket_name(tmp_config_obj.PerInstancePath("usb-v1"));
407 tmp_config_obj.set_vhci_port(FLAGS_vhci_port);
408 tmp_config_obj.set_usb_ip_socket_name(tmp_config_obj.PerInstancePath("usb-ip"));
409 }
410
Jorge E. Moreirab1ec4352019-06-04 11:43:08 -0700411 tmp_config_obj.set_kernel_log_pipe_name(tmp_config_obj.PerInstancePath("kernel-log"));
Cody Schuffelen20ecaca2019-01-29 17:43:38 -0800412 tmp_config_obj.set_deprecated_boot_completed(FLAGS_deprecated_boot_completed);
413 tmp_config_obj.set_console_path(tmp_config_obj.PerInstancePath("console"));
414 tmp_config_obj.set_logcat_path(tmp_config_obj.PerInstancePath("logcat"));
Jorge E. Moreirafd10cae2019-02-19 15:35:42 -0800415 tmp_config_obj.set_logcat_receiver_binary(FLAGS_logcat_receiver_binary);
Jorge E. Moreiraf1f7cb32019-04-15 18:44:41 -0700416 tmp_config_obj.set_config_server_binary(FLAGS_config_server_binary);
Cody Schuffelen20ecaca2019-01-29 17:43:38 -0800417 tmp_config_obj.set_launcher_log_path(tmp_config_obj.PerInstancePath("launcher.log"));
418 tmp_config_obj.set_launcher_monitor_socket_path(
419 tmp_config_obj.PerInstancePath("launcher_monitor.sock"));
420
421 tmp_config_obj.set_mobile_bridge_name(FLAGS_mobile_interface);
422 tmp_config_obj.set_mobile_tap_name(FLAGS_mobile_tap_name);
423
Cody Schuffelen20ecaca2019-01-29 17:43:38 -0800424 tmp_config_obj.set_wifi_tap_name(FLAGS_wifi_tap_name);
425
Cody Schuffelen20ecaca2019-01-29 17:43:38 -0800426 tmp_config_obj.set_vsock_guest_cid(FLAGS_vsock_guest_cid);
427
Cody Schuffelen20ecaca2019-01-29 17:43:38 -0800428 tmp_config_obj.set_uuid(FLAGS_uuid);
429
430 tmp_config_obj.set_qemu_binary(FLAGS_qemu_binary);
Jorge E. Moreiraba626622019-01-28 17:47:50 -0800431 tmp_config_obj.set_crosvm_binary(FLAGS_crosvm_binary);
Jorge E. Moreira13cbd982019-06-06 16:06:34 -0700432 tmp_config_obj.set_console_forwarder_binary(FLAGS_console_forwarder_binary);
Cody Schuffelen20ecaca2019-01-29 17:43:38 -0800433 tmp_config_obj.set_ivserver_binary(FLAGS_ivserver_binary);
434 tmp_config_obj.set_kernel_log_monitor_binary(FLAGS_kernel_log_monitor_binary);
435
436 tmp_config_obj.set_enable_vnc_server(FLAGS_start_vnc_server);
437 tmp_config_obj.set_vnc_server_binary(FLAGS_vnc_server_binary);
438 tmp_config_obj.set_vnc_server_port(FLAGS_vnc_server_port);
439
440 tmp_config_obj.set_enable_stream_audio(FLAGS_start_stream_audio);
441 tmp_config_obj.set_stream_audio_binary(FLAGS_stream_audio_binary);
442 tmp_config_obj.set_stream_audio_port(FLAGS_stream_audio_port);
443
444 tmp_config_obj.set_restart_subprocesses(FLAGS_restart_subprocesses);
445 tmp_config_obj.set_run_adb_connector(FLAGS_run_adb_connector);
446 tmp_config_obj.set_adb_connector_binary(FLAGS_adb_connector_binary);
447 tmp_config_obj.set_virtual_usb_manager_binary(
448 FLAGS_virtual_usb_manager_binary);
449 tmp_config_obj.set_socket_forward_proxy_binary(
450 FLAGS_socket_forward_proxy_binary);
451 tmp_config_obj.set_socket_vsock_proxy_binary(FLAGS_socket_vsock_proxy_binary);
452 tmp_config_obj.set_run_as_daemon(FLAGS_daemon);
453 tmp_config_obj.set_run_e2e_test(FLAGS_run_e2e_test);
454 tmp_config_obj.set_e2e_test_binary(FLAGS_e2e_test_binary);
455
Cody Schuffelen2b51bab2019-01-29 18:14:48 -0800456 tmp_config_obj.set_data_policy(FLAGS_data_policy);
457 tmp_config_obj.set_blank_data_image_mb(FLAGS_blank_data_image_mb);
458 tmp_config_obj.set_blank_data_image_fmt(FLAGS_blank_data_image_fmt);
459
Cody Schuffelen75ef8872019-09-06 17:35:54 -0700460 if(tmp_config_obj.adb_mode().count(vsoc::AdbMode::Usb) == 0) {
Cody Schuffelen20ecaca2019-01-29 17:43:38 -0800461 tmp_config_obj.disable_usb_adb();
462 }
463
Jorge E. Moreirafd10cae2019-02-19 15:35:42 -0800464 tmp_config_obj.set_logcat_mode(FLAGS_logcat_mode);
465 tmp_config_obj.set_logcat_vsock_port(FLAGS_logcat_vsock_port);
Jorge E. Moreiraf1f7cb32019-04-15 18:44:41 -0700466 tmp_config_obj.set_config_server_port(FLAGS_config_server_port);
Jorge E. Moreirac87c2c72019-03-06 16:12:23 -0800467 tmp_config_obj.set_frames_vsock_port(FLAGS_frames_vsock_port);
Jorge E. Moreira1859ccc2019-05-14 15:15:27 -0700468 if (!tmp_config_obj.enable_ivserver() && tmp_config_obj.enable_vnc_server()) {
Jorge E. Moreirac87c2c72019-03-06 16:12:23 -0800469 tmp_config_obj.add_kernel_cmdline(concat("androidboot.vsock_frames_port=",
470 FLAGS_frames_vsock_port));
471 }
Jorge E. Moreirafd10cae2019-02-19 15:35:42 -0800472
Ram Muthiah792e2ad2019-04-19 11:19:46 -0700473 tmp_config_obj.set_enable_tombstone_receiver(FLAGS_enable_tombstone_receiver);
474 tmp_config_obj.set_tombstone_receiver_port(FLAGS_tombstone_receiver_port);
475 tmp_config_obj.set_tombstone_receiver_binary(FLAGS_tombstone_receiver_binary);
476 if (FLAGS_enable_tombstone_receiver) {
477 tmp_config_obj.add_kernel_cmdline("androidboot.tombstone_transmit=1");
478 tmp_config_obj.add_kernel_cmdline(concat("androidboot.vsock_tombstone_port="
479 ,FLAGS_tombstone_receiver_port));
Alistair Strachan050ca932018-11-27 12:41:19 -0800480 // TODO (b/128842613) populate a cid flag to read the host CID during
Ram Muthiah792e2ad2019-04-19 11:19:46 -0700481 // runtime
482 } else {
483 tmp_config_obj.add_kernel_cmdline("androidboot.tombstone_transmit=0");
484 }
485
Cody Schuffelen20ecaca2019-01-29 17:43:38 -0800486 tmp_config_obj.set_cuttlefish_env_path(GetCuttlefishEnvPath());
487
488 auto config_file = GetConfigFilePath(tmp_config_obj);
489 auto config_link = vsoc::GetGlobalConfigFileLink();
490 // Save the config object before starting any host process
491 if (!tmp_config_obj.SaveToFile(config_file)) {
492 LOG(ERROR) << "Unable to save config object";
493 return false;
494 }
495 setenv(vsoc::kCuttlefishConfigEnvVarName, config_file.c_str(), true);
496 if (symlink(config_file.c_str(), config_link.c_str()) != 0) {
497 LOG(ERROR) << "Failed to create symlink to config file at " << config_link
498 << ": " << strerror(errno);
499 return false;
500 }
501
502 return true;
503}
504
505void SetDefaultFlagsForQemu() {
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);
Cody Schuffelen20ecaca2019-01-29 17:43:38 -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);
Jorge E. Moreirafd1a6b02019-02-27 16:25:00 -0800523 SetCommandLineOptionWithMode("hardware_name", "cutf_ivsh",
Jorge E. Moreiraba626622019-01-28 17:47:50 -0800524 google::FlagSettingMode::SET_FLAGS_DEFAULT);
Jorge E. Moreirafd10cae2019-02-19 15:35:42 -0800525 SetCommandLineOptionWithMode("logcat_mode", cvd::kLogcatSerialMode,
526 google::FlagSettingMode::SET_FLAGS_DEFAULT);
Jorge E. Moreiraba626622019-01-28 17:47:50 -0800527}
528
529void SetDefaultFlagsForCrosvm() {
530 auto default_mobile_interface = GetPerInstanceDefault("cvd-mbr-");
531 SetCommandLineOptionWithMode("mobile_interface",
532 default_mobile_interface.c_str(),
533 google::FlagSettingMode::SET_FLAGS_DEFAULT);
534 auto default_mobile_tap_name = GetPerInstanceDefault("cvd-mtap-");
535 SetCommandLineOptionWithMode("mobile_tap_name",
536 default_mobile_tap_name.c_str(),
537 google::FlagSettingMode::SET_FLAGS_DEFAULT);
Jorge E. Moreiraba626622019-01-28 17:47:50 -0800538 auto default_wifi_tap_name = GetPerInstanceDefault("cvd-wtap-");
539 SetCommandLineOptionWithMode("wifi_tap_name",
540 default_wifi_tap_name.c_str(),
541 google::FlagSettingMode::SET_FLAGS_DEFAULT);
542 auto default_instance_dir =
543 cvd::StringFromEnv("HOME", ".") + "/cuttlefish_runtime";
544 SetCommandLineOptionWithMode("instance_dir",
545 default_instance_dir.c_str(),
546 google::FlagSettingMode::SET_FLAGS_DEFAULT);
Greg Hartmana3c552d2019-03-28 18:20:48 -0700547 SetCommandLineOptionWithMode("wayland_socket",
Greg Hartmaneb04ac52019-07-16 16:44:18 -0700548 "",
549 google::FlagSettingMode::SET_FLAGS_DEFAULT);
550 SetCommandLineOptionWithMode("x_display",
551 getenv("DISPLAY"),
Greg Hartmana3c552d2019-03-28 18:20:48 -0700552 google::FlagSettingMode::SET_FLAGS_DEFAULT);
Jorge E. Moreirafd1a6b02019-02-27 16:25:00 -0800553 SetCommandLineOptionWithMode("hardware_name", "cutf_cvm",
Jorge E. Moreiraba626622019-01-28 17:47:50 -0800554 google::FlagSettingMode::SET_FLAGS_DEFAULT);
Jorge E. Moreira84d93c12019-02-05 12:02:29 -0800555 SetCommandLineOptionWithMode("run_e2e_test", "false",
556 google::FlagSettingMode::SET_FLAGS_DEFAULT);
Jorge E. Moreirafd10cae2019-02-19 15:35:42 -0800557 SetCommandLineOptionWithMode("logcat_mode", cvd::kLogcatVsockMode,
558 google::FlagSettingMode::SET_FLAGS_DEFAULT);
Cody Schuffelen20ecaca2019-01-29 17:43:38 -0800559}
560
561bool ParseCommandLineFlags(int* argc, char*** argv) {
562 // The config_file is created by the launcher, so the launcher is the only
563 // host process that doesn't use the flag.
564 // Set the default to empty.
565 google::SetCommandLineOptionWithMode("config_file", "",
566 gflags::SET_FLAGS_DEFAULT);
567 google::ParseCommandLineNonHelpFlags(argc, argv, true);
568 bool invalid_manager = false;
569 if (FLAGS_vm_manager == vm_manager::QemuManager::name()) {
570 SetDefaultFlagsForQemu();
Jorge E. Moreiraba626622019-01-28 17:47:50 -0800571 } else if (FLAGS_vm_manager == vm_manager::CrosvmManager::name()) {
572 SetDefaultFlagsForCrosvm();
Cody Schuffelen20ecaca2019-01-29 17:43:38 -0800573 } else {
574 std::cerr << "Unknown Virtual Machine Manager: " << FLAGS_vm_manager
575 << std::endl;
576 invalid_manager = true;
577 }
578 google::HandleCommandLineHelpFlags();
579 if (invalid_manager) {
580 return false;
581 }
582 // Set the env variable to empty (in case the caller passed a value for it).
583 unsetenv(vsoc::kCuttlefishConfigEnvVarName);
584
585 return ResolveInstanceFiles();
586}
587
588bool CleanPriorFiles() {
589 // Everything on the instance directory
590 std::string prior_files = FLAGS_instance_dir + "/*";
591 // The shared memory file
592 prior_files += " " + FLAGS_mempath;
593 // The environment file
594 prior_files += " " + GetCuttlefishEnvPath();
595 // The global link to the config file
596 prior_files += " " + vsoc::GetGlobalConfigFileLink();
597 LOG(INFO) << "Assuming prior files of " << prior_files;
598 std::string fuser_cmd = "fuser " + prior_files + " 2> /dev/null";
599 int rval = std::system(fuser_cmd.c_str());
600 // fuser returns 0 if any of the files are open
601 if (WEXITSTATUS(rval) == 0) {
602 LOG(ERROR) << "Clean aborted: files are in use";
603 return false;
604 }
605 std::string clean_command = "rm -rf " + prior_files;
606 rval = std::system(clean_command.c_str());
607 if (WEXITSTATUS(rval) != 0) {
608 LOG(ERROR) << "Remove of files failed";
609 return false;
610 }
611 return true;
612}
Jorge E. Moreira80ddd7f2019-02-04 16:30:13 -0800613
614bool DecompressKernel(const std::string& src, const std::string& dst) {
615 cvd::Command decomp_cmd(FLAGS_kernel_decompresser_executable);
616 decomp_cmd.AddParameter(src);
617 auto output_file = cvd::SharedFD::Creat(dst.c_str(), 0666);
618 if (!output_file->IsOpen()) {
619 LOG(ERROR) << "Unable to create decompressed image file: "
620 << output_file->StrError();
621 return false;
622 }
623 decomp_cmd.RedirectStdIO(cvd::Subprocess::StdIOChannel::kStdOut, output_file);
624 auto decomp_proc = decomp_cmd.Start(false);
625 return decomp_proc.Started() && decomp_proc.Wait() == 0;
626}
Cody Schuffelen20ecaca2019-01-29 17:43:38 -0800627} // namespace
628
Cody Schuffelen3c99f5b2019-06-14 17:26:01 -0700629namespace {
630
631std::vector<ImagePartition> disk_config() {
632 std::vector<ImagePartition> partitions;
Cody Schuffelen4f7e4412019-08-30 16:10:59 -0700633 partitions.push_back(ImagePartition {
634 .label = "super",
635 .image_file_path = FLAGS_super_image,
636 });
Cody Schuffelen3c99f5b2019-06-14 17:26:01 -0700637 partitions.push_back(ImagePartition {
638 .label = "userdata",
639 .image_file_path = FLAGS_data_image,
640 });
641 partitions.push_back(ImagePartition {
642 .label = "cache",
643 .image_file_path = FLAGS_cache_image,
644 });
645 partitions.push_back(ImagePartition {
646 .label = "metadata",
647 .image_file_path = FLAGS_metadata_image,
648 });
Cody Schuffelen3c99f5b2019-06-14 17:26:01 -0700649 partitions.push_back(ImagePartition {
650 .label = "boot",
651 .image_file_path = FLAGS_boot_image,
652 });
Yifan Hong19d713e2019-05-01 14:12:07 -0700653 partitions.push_back(ImagePartition {
654 .label = "misc",
655 .image_file_path = FLAGS_misc_image
656 });
Cody Schuffelen3c99f5b2019-06-14 17:26:01 -0700657 return partitions;
658}
659
660bool ShouldCreateCompositeDisk() {
661 if (FLAGS_composite_disk.empty()) {
662 return false;
663 }
Cody Schuffelenc3fd6e52019-08-30 15:14:07 -0700664 if (FLAGS_vm_manager == vm_manager::CrosvmManager::name()) {
665 // The crosvm implementation is very fast to rebuild but also more brittle due to being split
666 // into multiple files. The QEMU implementation is slow to build, but completely self-contained
667 // at that point. Therefore, always rebuild on crosvm but check if it is necessary for QEMU.
668 return true;
669 }
Cody Schuffelen3c99f5b2019-06-14 17:26:01 -0700670 auto composite_age = cvd::FileModificationTime(FLAGS_composite_disk);
671 for (auto& partition : disk_config()) {
672 auto partition_age = cvd::FileModificationTime(partition.image_file_path);
673 if (partition_age >= composite_age) {
674 LOG(INFO) << "composite disk age was \"" << std::chrono::system_clock::to_time_t(composite_age) << "\", "
675 << "partition age was \"" << std::chrono::system_clock::to_time_t(partition_age) << "\"";
676 return true;
677 }
678 }
679 return false;
680}
681
Ram Muthiah3db0a562019-08-26 13:35:19 -0700682bool ConcatRamdisks(const std::string& new_ramdisk_path, const std::string& ramdisk_a_path,
683 const std::string& ramdisk_b_path) {
684 // clear out file of any pre-existing content
685 std::ofstream new_ramdisk(new_ramdisk_path, std::ios_base::binary | std::ios_base::trunc);
686 std::ifstream ramdisk_a(ramdisk_a_path, std::ios_base::binary);
687 std::ifstream ramdisk_b(ramdisk_b_path, std::ios_base::binary);
Ram Muthiahaad97c52019-08-14 17:05:01 -0700688
Ram Muthiah3db0a562019-08-26 13:35:19 -0700689 if(!new_ramdisk.is_open() || !ramdisk_a.is_open() || !ramdisk_b.is_open()) {
Ram Muthiahaad97c52019-08-14 17:05:01 -0700690 return false;
691 }
692
Ram Muthiah3db0a562019-08-26 13:35:19 -0700693 new_ramdisk << ramdisk_a.rdbuf() << ramdisk_b.rdbuf();
Ram Muthiahaad97c52019-08-14 17:05:01 -0700694 return true;
695}
696
Cody Schuffelenc3fd6e52019-08-30 15:14:07 -0700697void CreateCompositeDisk(const vsoc::CuttlefishConfig& config) {
Cody Schuffelen3c99f5b2019-06-14 17:26:01 -0700698 if (FLAGS_composite_disk.empty()) {
699 LOG(FATAL) << "asked to create composite disk, but path was empty";
700 }
Cody Schuffelenc3fd6e52019-08-30 15:14:07 -0700701 if (FLAGS_vm_manager == vm_manager::CrosvmManager::name()) {
702 std::string header_path = config.PerInstancePath("gpt_header.img");
703 std::string footer_path = config.PerInstancePath("gpt_footer.img");
704 create_composite_disk(disk_config(), header_path, footer_path, FLAGS_composite_disk);
705 } else {
706 aggregate_image(disk_config(), FLAGS_composite_disk);
707 }
Cody Schuffelen3c99f5b2019-06-14 17:26:01 -0700708}
709
710} // namespace
711
Cody Schuffelen20ecaca2019-01-29 17:43:38 -0800712vsoc::CuttlefishConfig* InitFilesystemAndCreateConfig(int* argc, char*** argv) {
713 if (!ParseCommandLineFlags(argc, argv)) {
714 LOG(ERROR) << "Failed to parse command arguments";
715 exit(LauncherExitCodes::kArgumentParsingError);
716 }
717
718 // Clean up prior files before saving the config file (doing it after would
719 // delete it)
720 if (!CleanPriorFiles()) {
721 LOG(ERROR) << "Failed to clean prior files";
722 exit(LauncherExitCodes::kPrioFilesCleanupError);
723 }
724 // Create instance directory if it doesn't exist.
725 if (!cvd::DirectoryExists(FLAGS_instance_dir.c_str())) {
726 LOG(INFO) << "Setting up " << FLAGS_instance_dir;
727 if (mkdir(FLAGS_instance_dir.c_str(), S_IRWXU | S_IRWXG | S_IROTH | S_IXOTH) < 0) {
728 LOG(ERROR) << "Failed to create instance directory: "
729 << FLAGS_instance_dir << ". Error: " << errno;
730 exit(LauncherExitCodes::kInstanceDirCreationError);
731 }
732 }
733
Cody Schuffelen2b51bab2019-01-29 18:14:48 -0800734 if (!cvd::FileHasContent(FLAGS_boot_image)) {
735 LOG(ERROR) << "File not found: " << FLAGS_boot_image;
736 exit(cvd::kCuttlefishConfigurationInitError);
737 }
738
Cody Schuffelen20ecaca2019-01-29 17:43:38 -0800739 auto boot_img_unpacker = cvd::BootImageUnpacker::FromImage(FLAGS_boot_image);
740
741 if (!InitializeCuttlefishConfiguration(*boot_img_unpacker)) {
742 LOG(ERROR) << "Failed to initialize configuration";
743 exit(LauncherExitCodes::kCuttlefishConfigurationInitError);
744 }
745 // Do this early so that the config object is ready for anything that needs it
746 auto config = vsoc::CuttlefishConfig::Get();
747 if (!config) {
748 LOG(ERROR) << "Failed to obtain config singleton";
749 exit(LauncherExitCodes::kCuttlefishConfigurationInitError);
750 }
751
752 if (!boot_img_unpacker->Unpack(config->ramdisk_image_path(),
753 config->use_unpacked_kernel()
754 ? config->kernel_image_path()
755 : "")) {
756 LOG(ERROR) << "Failed to unpack boot image";
757 exit(LauncherExitCodes::kBootImageUnpackError);
758 }
759
Ram Muthiahaad97c52019-08-14 17:05:01 -0700760 if(FLAGS_initramfs_path.size()) {
Ram Muthiah3db0a562019-08-26 13:35:19 -0700761 auto concat_ramdisk_path = config->ramdisk_image_path() + ".concat";
762 if(!ConcatRamdisks(concat_ramdisk_path, config->ramdisk_image_path(), FLAGS_initramfs_path)) {
Ram Muthiahaad97c52019-08-14 17:05:01 -0700763 LOG(ERROR) << "Failed to concatenate ramdisk and initramfs";
764 exit(LauncherExitCodes::kInitRamFsConcatError);
765 }
Ram Muthiah3db0a562019-08-26 13:35:19 -0700766 config->set_ramdisk_image_path(concat_ramdisk_path);
Ram Muthiahaad97c52019-08-14 17:05:01 -0700767 }
768
Jorge E. Moreira80ddd7f2019-02-04 16:30:13 -0800769 if (config->decompress_kernel()) {
770 if (!DecompressKernel(config->kernel_image_path(),
771 config->decompressed_kernel_image_path())) {
772 LOG(ERROR) << "Failed to decompress kernel";
773 exit(LauncherExitCodes::kKernelDecompressError);
774 }
775 }
776
Cody Schuffelen20ecaca2019-01-29 17:43:38 -0800777 ValidateAdbModeFlag(*config);
778
Yifan Hong19d713e2019-05-01 14:12:07 -0700779 // Create misc if necessary
780 if (!InitializeMiscImage(FLAGS_misc_image)) {
781 exit(cvd::kCuttlefishConfigurationInitError);
782 }
783
Cody Schuffelen2b51bab2019-01-29 18:14:48 -0800784 // Create data if necessary
Cody Schuffelen3c99f5b2019-06-14 17:26:01 -0700785 if (!ApplyDataImagePolicy(*config, FLAGS_data_image)) {
Cody Schuffelen2b51bab2019-01-29 18:14:48 -0800786 exit(cvd::kCuttlefishConfigurationInitError);
787 }
788
Cody Schuffelen69c19592019-05-31 16:00:30 -0700789 if (!cvd::FileExists(FLAGS_metadata_image)) {
790 CreateBlankImage(FLAGS_metadata_image, FLAGS_blank_metadata_image_mb, "none");
791 }
Paul Trautrimba8f8e92019-03-12 17:55:48 +0900792
Cody Schuffelen3c99f5b2019-06-14 17:26:01 -0700793 if (ShouldCreateCompositeDisk()) {
Cody Schuffelenc3fd6e52019-08-30 15:14:07 -0700794 CreateCompositeDisk(*config);
Cody Schuffelen3c99f5b2019-06-14 17:26:01 -0700795 }
796
Cody Schuffelen2b51bab2019-01-29 18:14:48 -0800797 // Check that the files exist
Cody Schuffelen3c99f5b2019-06-14 17:26:01 -0700798 for (const auto& file : config->virtual_disk_paths()) {
Alistair Strachan050ca932018-11-27 12:41:19 -0800799 if (!file.empty() && !cvd::FileHasContent(file.c_str())) {
Cody Schuffelen2b51bab2019-01-29 18:14:48 -0800800 LOG(ERROR) << "File not found: " << file;
801 exit(cvd::kCuttlefishConfigurationInitError);
802 }
803 }
804
Cody Schuffelen20ecaca2019-01-29 17:43:38 -0800805 return config;
806}
807
808std::string GetConfigFilePath(const vsoc::CuttlefishConfig& config) {
809 return config.PerInstancePath("cuttlefish_config.json");
810}