c583305ed7
fork() subprocesses to handle uevents in parallel. This reduces coldboot time on bullhead from ~446ms to ~230ms. This reduces coldboot time on sailfish from ~690ms to ~360ms. This reduces coldboot time on ryu from ~187ms to ~122ms. Bug: 33785894 Test: boot bullhead x40, observe no major differences in /dev and /sys Test: boot sailfish x40, observe no major differences in /dev and /sys Test: boot ryu x40, observe no major differences in /dev and /sys Test: boottime tests on bullhead and sailfish Test: init unit tests Change-Id: Ie2f63e000b8af78d187477d31fe109f20304d749
132 lines
4.2 KiB
C++
132 lines
4.2 KiB
C++
/*
|
|
* Copyright (C) 2017 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.
|
|
*/
|
|
|
|
#include "firmware_handler.h"
|
|
|
|
#include <fcntl.h>
|
|
#include <sys/sendfile.h>
|
|
#include <sys/wait.h>
|
|
#include <unistd.h>
|
|
|
|
#include <string>
|
|
#include <thread>
|
|
|
|
#include <android-base/file.h>
|
|
#include <android-base/logging.h>
|
|
#include <android-base/unique_fd.h>
|
|
|
|
#include "util.h"
|
|
|
|
static void LoadFirmware(const Uevent& uevent, const std::string& root, int fw_fd, size_t fw_size,
|
|
int loading_fd, int data_fd) {
|
|
// Start transfer.
|
|
android::base::WriteFully(loading_fd, "1", 1);
|
|
|
|
// Copy the firmware.
|
|
int rc = sendfile(data_fd, fw_fd, nullptr, fw_size);
|
|
if (rc == -1) {
|
|
PLOG(ERROR) << "firmware: sendfile failed { '" << root << "', '" << uevent.firmware
|
|
<< "' }";
|
|
}
|
|
|
|
// Tell the firmware whether to abort or commit.
|
|
const char* response = (rc != -1) ? "0" : "-1";
|
|
android::base::WriteFully(loading_fd, response, strlen(response));
|
|
}
|
|
|
|
static bool IsBooting() {
|
|
return access("/dev/.booting", F_OK) == 0;
|
|
}
|
|
|
|
static void ProcessFirmwareEvent(const Uevent& uevent) {
|
|
int booting = IsBooting();
|
|
|
|
LOG(INFO) << "firmware: loading '" << uevent.firmware << "' for '" << uevent.path << "'";
|
|
|
|
std::string root = "/sys" + uevent.path;
|
|
std::string loading = root + "/loading";
|
|
std::string data = root + "/data";
|
|
|
|
android::base::unique_fd loading_fd(open(loading.c_str(), O_WRONLY | O_CLOEXEC));
|
|
if (loading_fd == -1) {
|
|
PLOG(ERROR) << "couldn't open firmware loading fd for " << uevent.firmware;
|
|
return;
|
|
}
|
|
|
|
android::base::unique_fd data_fd(open(data.c_str(), O_WRONLY | O_CLOEXEC));
|
|
if (data_fd == -1) {
|
|
PLOG(ERROR) << "couldn't open firmware data fd for " << uevent.firmware;
|
|
return;
|
|
}
|
|
|
|
static const char* firmware_dirs[] = {"/etc/firmware/", "/vendor/firmware/",
|
|
"/firmware/image/"};
|
|
|
|
try_loading_again:
|
|
for (size_t i = 0; i < arraysize(firmware_dirs); i++) {
|
|
std::string file = firmware_dirs[i] + uevent.firmware;
|
|
android::base::unique_fd fw_fd(open(file.c_str(), O_RDONLY | O_CLOEXEC));
|
|
struct stat sb;
|
|
if (fw_fd != -1 && fstat(fw_fd, &sb) != -1) {
|
|
LoadFirmware(uevent, root, fw_fd, sb.st_size, loading_fd, data_fd);
|
|
return;
|
|
}
|
|
}
|
|
|
|
if (booting) {
|
|
// If we're not fully booted, we may be missing
|
|
// filesystems needed for firmware, wait and retry.
|
|
std::this_thread::sleep_for(100ms);
|
|
booting = IsBooting();
|
|
goto try_loading_again;
|
|
}
|
|
|
|
LOG(ERROR) << "firmware: could not find firmware for " << uevent.firmware;
|
|
|
|
// Write "-1" as our response to the kernel's firmware request, since we have nothing for it.
|
|
write(loading_fd, "-1", 2);
|
|
}
|
|
|
|
void HandleFirmwareEvent(const Uevent& uevent) {
|
|
if (uevent.subsystem != "firmware" || uevent.action != "add") return;
|
|
|
|
// Loading the firmware in a child means we can do that in parallel...
|
|
// We double fork instead of waiting for these processes.
|
|
pid_t pid = fork();
|
|
if (pid == -1) {
|
|
PLOG(ERROR) << "could not fork to process firmware event for " << uevent.firmware;
|
|
return;
|
|
}
|
|
|
|
if (pid == 0) {
|
|
pid = fork();
|
|
if (pid == -1) {
|
|
PLOG(ERROR) << "could not fork a sceond time to process firmware event for "
|
|
<< uevent.firmware;
|
|
_exit(EXIT_FAILURE);
|
|
}
|
|
if (pid == 0) {
|
|
Timer t;
|
|
ProcessFirmwareEvent(uevent);
|
|
LOG(INFO) << "loading " << uevent.path << " took " << t;
|
|
_exit(EXIT_SUCCESS);
|
|
}
|
|
|
|
_exit(EXIT_SUCCESS);
|
|
}
|
|
|
|
waitpid(pid, nullptr, 0);
|
|
}
|