| /* |
| * Copyright (C) 2009 The Android Open Source Project |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| |
| /* this program is used to read a set of system properties and their values |
| * from the emulator program and set them in the currently-running emulated |
| * system. It does so by connecting to the 'boot-properties' qemud service. |
| * |
| * This program should be run as root and called from |
| * /system/etc/init.ranchu.rc exclusively. |
| */ |
| |
| #define LOG_TAG "qemu-props" |
| |
| #define DEBUG 1 |
| |
| #if DEBUG |
| # include <log/log.h> |
| # define DD(...) ALOGI(__VA_ARGS__) |
| #else |
| # define DD(...) ((void)0) |
| #endif |
| |
| #include <string_view> |
| #include <cutils/properties.h> |
| #include <unistd.h> |
| #include <qemu_pipe_bp.h> |
| #include <qemud.h> |
| #include <string.h> |
| #include <stdio.h> |
| |
| /* Name of the qemud service we want to connect to. |
| */ |
| #define QEMUD_SERVICE "boot-properties" |
| |
| #define MAX_TRIES 5 |
| |
| #define QEMU_MISC_PIPE "QemuMiscPipe" |
| |
| namespace { |
| // qemu-props will not set these properties. |
| const char* const k_properties_to_ignore[] = { |
| "dalvik.vm.heapsize", |
| "ro.opengles.version", |
| "qemu.adb.secure", |
| nullptr, |
| }; |
| |
| // These properties will not be prefixed with "vendor.". |
| const char* const k_system_properties[] = { |
| "qemu.sf.lcd_density", |
| "qemu.hw.mainkeys", |
| nullptr, |
| }; |
| |
| bool check_if_property_in_list(const char* prop_name, const char* const* prop_list) { |
| for (; *prop_list; ++prop_list) { |
| if (!strcmp(prop_name, *prop_list)) { |
| return true; |
| } |
| } |
| return false; |
| } |
| |
| // We don't want to rename properties which already have the prefix |
| // or the system properties. |
| bool need_prepend_prefix(const char* prop, const std::string_view prefix) { |
| return strncmp(prefix.data(), prop, prefix.size()) && |
| !check_if_property_in_list(prop, k_system_properties); |
| } |
| } // namespace |
| |
| int s_QemuMiscPipe = -1; |
| void static notifyHostBootComplete(); |
| void static sendHeartBeat(); |
| void static sendMessage(const char* mesg); |
| void static closeMiscPipe(); |
| extern void parse_virtio_serial(); |
| |
| int main(void) |
| { |
| int qemud_fd, count = 0; |
| |
| /* try to connect to the qemud service */ |
| { |
| int tries = MAX_TRIES; |
| |
| while (true) { |
| qemud_fd = qemud_channel_open( "boot-properties" ); |
| if (qemud_fd >= 0) |
| break; |
| |
| if (--tries <= 0) { |
| DD("Could not connect after too many tries. Aborting"); |
| return 1; |
| } |
| |
| DD("waiting 1s to wait for qemud."); |
| sleep(1); |
| } |
| } |
| |
| DD("connected to '%s' qemud service.", QEMUD_SERVICE); |
| |
| /* send the 'list' command to the service */ |
| if (qemud_channel_send(qemud_fd, "list", -1) < 0) { |
| DD("could not send command to '%s' service", QEMUD_SERVICE); |
| return 1; |
| } |
| |
| /* read each system property as a single line from the service, |
| * until exhaustion. |
| */ |
| while (true) { |
| #define BUFF_SIZE (PROPERTY_KEY_MAX + PROPERTY_VALUE_MAX + 2) |
| DD("receiving.."); |
| char* prop_value; |
| char temp[BUFF_SIZE]; |
| int len = qemud_channel_recv(qemud_fd, temp, sizeof(temp) - 1); |
| |
| /* lone NUL-byte signals end of properties */ |
| if (len < 0 || len > (BUFF_SIZE - 1) || !temp[0]) { |
| break; |
| } |
| |
| temp[len] = '\0'; /* zero-terminate string */ |
| |
| DD("received: %.*s", len, temp); |
| |
| /* separate propery name from value */ |
| prop_value = strchr(temp, '='); |
| if (!prop_value) { |
| DD("invalid format, ignored."); |
| continue; |
| } |
| |
| *prop_value = 0; |
| ++prop_value; |
| |
| if (check_if_property_in_list(temp, k_properties_to_ignore)) { |
| ALOGI("ignoring '%s' property", temp); |
| continue; // do not set these |
| } |
| |
| char renamed_property[BUFF_SIZE]; |
| const char* final_prop_name = nullptr; |
| |
| using namespace std::literals; |
| static constexpr std::string_view k_vendor_prefix = "vendor."sv; |
| if (need_prepend_prefix(temp, k_vendor_prefix)) { |
| snprintf(renamed_property, sizeof(renamed_property), "%.*s%s", |
| int(k_vendor_prefix.size()), k_vendor_prefix.data(), temp); |
| |
| final_prop_name = renamed_property; |
| } else { |
| final_prop_name = temp; |
| } |
| |
| if (property_set(final_prop_name, prop_value) < 0) { |
| ALOGW("could not set property '%s' to '%s'", final_prop_name, prop_value); |
| } else { |
| ALOGI("successfully set property '%s' to '%s'", final_prop_name, prop_value); |
| count += 1; |
| } |
| } |
| |
| close(qemud_fd); |
| |
| parse_virtio_serial(); |
| |
| char temp[BUFF_SIZE]; |
| sendHeartBeat(); |
| while (s_QemuMiscPipe >= 0) { |
| usleep(5000000); /* 5 seconds */ |
| sendHeartBeat(); |
| property_get("vendor.qemu.dev.bootcomplete", temp, ""); |
| int is_boot_completed = (strncmp(temp, "1", 1) == 0) ? 1 : 0; |
| if (is_boot_completed) { |
| ALOGI("tell the host boot completed"); |
| notifyHostBootComplete(); |
| break; |
| } |
| } |
| |
| while (s_QemuMiscPipe >= 0) { |
| usleep(30*1000000); /* 30 seconds */ |
| sendHeartBeat(); |
| } |
| |
| /* finally, close the channel and exit */ |
| closeMiscPipe(); |
| DD("exiting (%d properties set).", count); |
| return 0; |
| } |
| |
| void sendHeartBeat() { |
| sendMessage("heartbeat"); |
| } |
| |
| void notifyHostBootComplete() { |
| sendMessage("bootcomplete"); |
| } |
| |
| void sendMessage(const char* mesg) { |
| if (s_QemuMiscPipe < 0) { |
| s_QemuMiscPipe = qemu_pipe_open_ns(NULL, QEMU_MISC_PIPE, O_RDWR); |
| if (s_QemuMiscPipe < 0) { |
| ALOGE("failed to open %s", QEMU_MISC_PIPE); |
| return; |
| } |
| } |
| |
| int32_t cmd_len = strlen(mesg) + 1; //including trailing '\0' |
| qemu_pipe_write_fully(s_QemuMiscPipe, &cmd_len, sizeof(cmd_len)); |
| qemu_pipe_write_fully(s_QemuMiscPipe, mesg, cmd_len); |
| |
| int r = qemu_pipe_read_fully(s_QemuMiscPipe, &cmd_len, sizeof(cmd_len)); |
| if (r || (cmd_len < 0)) { |
| closeMiscPipe(); |
| return; |
| } |
| |
| while (cmd_len > 0) { |
| char buf[64]; |
| const size_t chunk = std::min<size_t>(cmd_len, sizeof(buf)); |
| r = qemu_pipe_read_fully(s_QemuMiscPipe, buf, chunk); |
| if (r) { |
| closeMiscPipe(); |
| return; |
| } else { |
| cmd_len -= chunk; |
| } |
| } |
| } |
| |
| void closeMiscPipe() { |
| if (s_QemuMiscPipe >= 0) { |
| close(s_QemuMiscPipe); |
| s_QemuMiscPipe = -1; |
| } |
| } |