1 /*
2 * Copyright (C) 2017 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17 #include "host/commands/run_cvd/kernel_args.h"
18
19 #include <array>
20 #include <sstream>
21 #include <string>
22 #include <vector>
23
24 #include "common/libs/utils/files.h"
25 #include "host/commands/run_cvd/launch.h"
26 #include "host/commands/run_cvd/runner_defs.h"
27 #include "host/libs/config/cuttlefish_config.h"
28 #include "host/libs/vm_manager/vm_manager.h"
29
30 template<typename T>
AppendVector(std::vector<T> * destination,const std::vector<T> & source)31 static void AppendVector(std::vector<T>* destination, const std::vector<T>& source) {
32 destination->insert(destination->end(), source.begin(), source.end());
33 }
34
35 template<typename S, typename T>
concat(const S & s,const T & t)36 static std::string concat(const S& s, const T& t) {
37 std::ostringstream os;
38 os << s << t;
39 return os.str();
40 }
41
mac_to_str(const std::array<unsigned char,6> & mac)42 static std::string mac_to_str(const std::array<unsigned char, 6>& mac) {
43 std::ostringstream stream;
44 stream << std::hex << (int) mac[0];
45 for (int i = 1; i < 6; i++) {
46 stream << ":" << std::hex << (int) mac[i];
47 }
48 return stream.str();
49 }
50
KernelCommandLineFromConfig(const vsoc::CuttlefishConfig & config)51 std::vector<std::string> KernelCommandLineFromConfig(const vsoc::CuttlefishConfig& config) {
52 auto instance = config.ForDefaultInstance();
53 std::vector<std::string> kernel_cmdline;
54
55 AppendVector(&kernel_cmdline, config.boot_image_kernel_cmdline());
56 AppendVector(&kernel_cmdline,
57 vm_manager::VmManager::ConfigureGpuMode(config.vm_manager(), config.gpu_mode()));
58 AppendVector(&kernel_cmdline, vm_manager::VmManager::ConfigureBootDevices(config.vm_manager()));
59
60 kernel_cmdline.push_back(concat("androidboot.serialno=", instance.serial_number()));
61 kernel_cmdline.push_back(concat("androidboot.lcd_density=", config.dpi()));
62 if (config.logcat_mode() == cvd::kLogcatVsockMode) {
63 }
64 kernel_cmdline.push_back(concat(
65 "androidboot.setupwizard_mode=", config.setupwizard_mode()));
66 if (!config.use_bootloader()) {
67 std::string slot_suffix;
68 if (config.boot_slot().empty()) {
69 slot_suffix = "_a";
70 } else {
71 slot_suffix = "_" + config.boot_slot();
72 }
73 kernel_cmdline.push_back(concat("androidboot.slot_suffix=", slot_suffix));
74 }
75 kernel_cmdline.push_back(concat("loop.max_part=", config.loop_max_part()));
76 if (config.guest_enforce_security()) {
77 kernel_cmdline.push_back("enforcing=1");
78 } else {
79 kernel_cmdline.push_back("enforcing=0");
80 kernel_cmdline.push_back("androidboot.selinux=permissive");
81 }
82 if (config.guest_audit_security()) {
83 kernel_cmdline.push_back("audit=1");
84 } else {
85 kernel_cmdline.push_back("audit=0");
86 }
87 if (config.guest_force_normal_boot()) {
88 kernel_cmdline.push_back("androidboot.force_normal_boot=1");
89 }
90
91 if (config.enable_vehicle_hal_grpc_server() && instance.vehicle_hal_server_port() &&
92 cvd::FileExists(config.vehicle_hal_grpc_server_binary())) {
93 constexpr int vehicle_hal_server_cid = 2;
94 kernel_cmdline.push_back(concat("androidboot.vendor.vehiclehal.server.cid=", vehicle_hal_server_cid));
95 kernel_cmdline.push_back(concat("androidboot.vendor.vehiclehal.server.port=", instance.vehicle_hal_server_port()));
96 }
97
98 if (instance.audiocontrol_server_port()) {
99 kernel_cmdline.push_back(concat("androidboot.vendor.audiocontrol.server.cid=", instance.vsock_guest_cid()));
100 kernel_cmdline.push_back(concat("androidboot.vendor.audiocontrol.server.port=", instance.audiocontrol_server_port()));
101 }
102
103 // TODO(b/158131610): Set this in crosvm instead
104 kernel_cmdline.push_back(concat("androidboot.wifi_mac_address=",
105 mac_to_str(instance.wifi_mac_address())));
106
107 AppendVector(&kernel_cmdline, config.extra_kernel_cmdline());
108
109 return kernel_cmdline;
110 }
111
KernelCommandLineFromStreamer(const StreamerLaunchResult & streamer_launch)112 std::vector<std::string> KernelCommandLineFromStreamer(
113 const StreamerLaunchResult& streamer_launch) {
114 std::vector<std::string> kernel_args;
115 if (streamer_launch.frames_server_vsock_port) {
116 kernel_args.push_back(concat("androidboot.vsock_frames_port=",
117 *streamer_launch.frames_server_vsock_port));
118 }
119 if (streamer_launch.touch_server_vsock_port) {
120 kernel_args.push_back(concat("androidboot.vsock_touch_port=",
121 *streamer_launch.touch_server_vsock_port));
122 }
123 if (streamer_launch.keyboard_server_vsock_port) {
124 kernel_args.push_back(concat("androidboot.vsock_keyboard_port=",
125 *streamer_launch.keyboard_server_vsock_port));
126 }
127 return kernel_args;
128 }
129
KernelCommandLineFromTombstone(const TombstoneReceiverPorts & tombstone)130 std::vector<std::string> KernelCommandLineFromTombstone(const TombstoneReceiverPorts& tombstone) {
131 if (!tombstone.server_vsock_port) {
132 return { "androidboot.tombstone_transmit=0" };
133 }
134 return {
135 "androidboot.tombstone_transmit=1",
136 concat("androidboot.vsock_tombstone_port=", *tombstone.server_vsock_port),
137 };
138 }
139
KernelCommandLineFromConfigServer(const ConfigServerPorts & config_server)140 std::vector<std::string> KernelCommandLineFromConfigServer(const ConfigServerPorts& config_server) {
141 if (!config_server.server_vsock_port) {
142 return {};
143 }
144 return {
145 concat("androidboot.cuttlefish_config_server_port=", *config_server.server_vsock_port),
146 };
147 }
148
KernelCommandLineFromLogcatServer(const LogcatServerPorts & logcat_server)149 std::vector<std::string> KernelCommandLineFromLogcatServer(const LogcatServerPorts& logcat_server) {
150 if (!logcat_server.server_vsock_port) {
151 return {};
152 }
153 return {
154 concat("androidboot.vsock_logcat_port=", *logcat_server.server_vsock_port),
155 };
156 }
157