tequilaOS/platform_system_core
2
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity

Merge "Move init to libbase logging."

Browse source
This commit is contained in:
Treehugger Robot 2016-06-27 16:17:17 +00:00 committed by Gerrit Code Review
commit 54c121962b
18 changed files with 258 additions and 284 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

15
init/action.cpp
View file

@ -42,7 +42,7 @@ int Command::InvokeFunc() const {
expanded_args[0] = args_[0];
for (std::size_t i = 1; i < args_.size(); ++i) {
if (!expand_props(args_[i], &expanded_args[i])) {
ERROR("%s: cannot expand '%s'\n", args_[0].c_str(), args_[i].c_str());
LOG(ERROR) << args_[0] << ": cannot expand '" << args_[i] << "'";
return -EINVAL;
}
}
@ -123,9 +123,8 @@ void Action::ExecuteCommand(const Command& command) const {
std::string cmd_str = command.BuildCommandString();
std::string source = command.BuildSourceString();
INFO("Command '%s' action=%s%s returned %d took %.2fs\n",
cmd_str.c_str(), trigger_name.c_str(), source.c_str(),
result, t.duration());
LOG(INFO) << "Command '" << cmd_str << "' action=" << trigger_name << source
<< " returned " << result << " took " << t.duration() << "s";
}
}
@ -253,13 +252,12 @@ std::string Action::BuildTriggersString() const {
void Action::DumpState() const {
std::string trigger_name = BuildTriggersString();
INFO("on %s\n", trigger_name.c_str());
LOG(INFO) << "on " << trigger_name;
for (const auto& c : commands_) {
std::string cmd_str = c.BuildCommandString();
INFO(" %s\n", cmd_str.c_str());
LOG(INFO) << " %s" << cmd_str;
}
INFO("\n");
}
class EventTrigger : public Trigger {
@ -366,7 +364,7 @@ void ActionManager::ExecuteOneCommand() {
if (current_command_ == 0) {
std::string trigger_name = action->BuildTriggersString();
INFO("processing action (%s)\n", trigger_name.c_str());
LOG(INFO) << "processing action (" << trigger_name << ")";
}
action->ExecuteOneCommand(current_command_);
@ -395,7 +393,6 @@ void ActionManager::DumpState() const {
for (const auto& a : actions_) {
a->DumpState();
}
INFO("\n");
}
bool ActionParser::ParseSection(const std::vector<std::string>& args,

8
init/bootchart.cpp
View file

@ -206,12 +206,12 @@ static int bootchart_init() {
int do_bootchart_init(const std::vector<std::string>& args) {
g_remaining_samples = bootchart_init();
if (g_remaining_samples < 0) {
ERROR("Bootcharting init failure: %s\n", strerror(errno));
PLOG(ERROR) << "Bootcharting initialization failed";
} else if (g_remaining_samples > 0) {
NOTICE("Bootcharting started (will run for %d s).\n",
(g_remaining_samples * BOOTCHART_POLLING_MS) / 1000);
LOG(INFO) << "Bootcharting started (will run for "
<< ((g_remaining_samples * BOOTCHART_POLLING_MS) / 1000) << " s).";
} else {
NOTICE("Not bootcharting.\n");
LOG(VERBOSE) << "Not bootcharting.";
}
return 0;
}

38
init/builtins.cpp
View file

@ -71,12 +71,12 @@ static const int kTerminateServiceDelayMicroSeconds = 50000;
static int insmod(const char *filename, const char *options, int flags) {
int fd = open(filename, O_RDONLY | O_NOFOLLOW | O_CLOEXEC);
if (fd == -1) {
ERROR("insmod: open(\"%s\") failed: %s", filename, strerror(errno));
PLOG(ERROR) << "insmod: open(\"" << filename << "\") failed";
return -1;
}
int rc = syscall(__NR_finit_module, fd, options, flags);
if (rc == -1) {
ERROR("finit_module for \"%s\" failed: %s", filename, strerror(errno));
PLOG(ERROR) << "finit_module for \"" << filename << "\" failed";
}
close(fd);
return rc;
@ -201,13 +201,13 @@ static void unmount_and_fsck(const struct mntent *entry) {
const char *f2fs_argv[] = {
"/system/bin/fsck.f2fs", "-f", entry->mnt_fsname,
};
android_fork_execvp_ext(ARRAY_SIZE(f2fs_argv), (char **)f2fs_argv,
android_fork_execvp_ext(arraysize(f2fs_argv), (char **)f2fs_argv,
&st, true, LOG_KLOG, true, NULL, NULL, 0);
} else if (!strcmp(entry->mnt_type, "ext4")) {
const char *ext4_argv[] = {
"/system/bin/e2fsck", "-f", "-y", entry->mnt_fsname,
};
android_fork_execvp_ext(ARRAY_SIZE(ext4_argv), (char **)ext4_argv,
android_fork_execvp_ext(arraysize(ext4_argv), (char **)ext4_argv,
&st, true, LOG_KLOG, true, NULL, NULL, 0);
}
}
@ -421,7 +421,7 @@ static int do_mount(const std::vector<std::string>& args) {
}
close(fd);
ERROR("out of loopback devices");
LOG(ERROR) << "out of loopback devices";
return -1;
} else {
if (wait)
@ -445,7 +445,7 @@ static int wipe_data_via_recovery() {
write(fd, "--reason=wipe_data_via_recovery\n", strlen("--reason=wipe_data_via_recovery\n") + 1);
close(fd);
} else {
ERROR("could not open /cache/recovery/command\n");
PLOG(ERROR) << "could not open /cache/recovery/command";
return -1;
}
android_reboot(ANDROID_RB_RESTART2, 0, "recovery");
@ -499,9 +499,9 @@ static int do_mount_all(const std::vector<std::string>& args) {
if (pid > 0) {
/* Parent. Wait for the child to return */
int wp_ret = TEMP_FAILURE_RETRY(waitpid(pid, &status, 0));
if (wp_ret < 0) {
/* Unexpected error code. We will continue anyway. */
NOTICE("waitpid failed rc=%d: %s\n", wp_ret, strerror(errno));
if (wp_ret == -1) {
// Unexpected error code. We will continue anyway.
PLOG(WARNING) << "waitpid failed";
}
if (WIFEXITED(status)) {
@ -516,7 +516,7 @@ static int do_mount_all(const std::vector<std::string>& args) {
child_ret = fs_mgr_mount_all(fstab);
fs_mgr_free_fstab(fstab);
if (child_ret == -1) {
ERROR("fs_mgr_mount_all returned an error\n");
PLOG(ERROR) << "fs_mgr_mount_all returned an error";
}
_exit(child_ret);
} else {
@ -541,7 +541,7 @@ static int do_mount_all(const std::vector<std::string>& args) {
ActionManager::GetInstance().QueueEventTrigger("nonencrypted");
} else if (ret == FS_MGR_MNTALL_DEV_NEEDS_RECOVERY) {
/* Setup a wipe via recovery, and reboot into recovery */
ERROR("fs_mgr_mount_all suggested recovery, so wiping data via recovery.\n");
PLOG(ERROR) << "fs_mgr_mount_all suggested recovery, so wiping data via recovery.";
ret = wipe_data_via_recovery();
/* If reboot worked, there is no return. */
} else if (ret == FS_MGR_MNTALL_DEV_DEFAULT_FILE_ENCRYPTED) {
@ -562,7 +562,7 @@ static int do_mount_all(const std::vector<std::string>& args) {
property_set("ro.crypto.type", "file");
property_set("vold.decrypt", "trigger_restart_min_framework");
} else if (ret > 0) {
ERROR("fs_mgr_mount_all returned unexpected error %d\n", ret);
PLOG(ERROR) << "fs_mgr_mount_all returned unexpected error " << ret;
}
/* else ... < 0: error */
@ -599,7 +599,7 @@ static int do_setrlimit(const std::vector<std::string>& args) {
static int do_start(const std::vector<std::string>& args) {
Service* svc = ServiceManager::GetInstance().FindServiceByName(args[1]);
if (!svc) {
ERROR("do_start: Service %s not found\n", args[1].c_str());
LOG(ERROR) << "do_start: Service " << args[1] << " not found";
return -1;
}
if (!svc->Start())
@ -610,7 +610,7 @@ static int do_start(const std::vector<std::string>& args) {
static int do_stop(const std::vector<std::string>& args) {
Service* svc = ServiceManager::GetInstance().FindServiceByName(args[1]);
if (!svc) {
ERROR("do_stop: Service %s not found\n", args[1].c_str());
LOG(ERROR) << "do_stop: Service " << args[1] << " not found";
return -1;
}
svc->Stop();
@ -620,7 +620,7 @@ static int do_stop(const std::vector<std::string>& args) {
static int do_restart(const std::vector<std::string>& args) {
Service* svc = ServiceManager::GetInstance().FindServiceByName(args[1]);
if (!svc) {
ERROR("do_restart: Service %s not found\n", args[1].c_str());
LOG(ERROR) << "do_restart: Service " << args[1] << " not found";
return -1;
}
svc->Restart();
@ -641,7 +641,7 @@ static int do_powerctl(const std::vector<std::string>& args) {
cmd = ANDROID_RB_RESTART2;
len = 6;
} else {
ERROR("powerctl: unrecognized command '%s'\n", command);
LOG(ERROR) << "powerctl: unrecognized command '" << command << "'";
return -EINVAL;
}
@ -655,7 +655,7 @@ static int do_powerctl(const std::vector<std::string>& args) {
reboot_target = &command[len + 1];
}
} else if (command[len] != '\0') {
ERROR("powerctl: unrecognized reboot target '%s'\n", &command[len]);
LOG(ERROR) << "powerctl: unrecognized reboot target '" << &command[len] << "'";
return -EINVAL;
}
@ -692,7 +692,7 @@ static int do_powerctl(const std::vector<std::string>& args) {
// Wait a bit before recounting the number or running services.
usleep(kTerminateServiceDelayMicroSeconds);
}
NOTICE("Terminating running services took %.02f seconds", t.duration());
LOG(VERBOSE) << "Terminating running services took " << t.duration() << " seconds";
}
return android_reboot_with_callback(cmd, 0, reboot_target,
@ -868,7 +868,7 @@ static int do_restorecon_recursive(const std::vector<std::string>& args) {
static int do_loglevel(const std::vector<std::string>& args) {
int log_level = std::stoi(args[1]);
if (log_level < KLOG_ERROR_LEVEL || log_level > KLOG_DEBUG_LEVEL) {
ERROR("loglevel: invalid log level'%d'\n", log_level);
LOG(ERROR) << "loglevel: invalid log level " << log_level;
return -EINVAL;
}
klog_set_level(log_level);

71
init/devices.cpp
View file

@ -174,13 +174,14 @@ static void fixup_sys_perms(const char* upath, const char* subsystem) {
}
std::string attr_file = path + "/" + dp->attr;
INFO("fixup %s %d %d 0%o\n", attr_file.c_str(), dp->uid, dp->gid, dp->perm);
LOG(INFO) << "fixup " << attr_file
<< " " << dp->uid << " " << dp->gid << " " << std::oct << dp->perm;
chown(attr_file.c_str(), dp->uid, dp->gid);
chmod(attr_file.c_str(), dp->perm);
}
if (access(path.c_str(), F_OK) == 0) {
INFO("restorecon_recursive: %s\n", path.c_str());
LOG(INFO) << "restorecon_recursive: " << path;
restorecon_recursive(path.c_str());
}
}
@ -241,8 +242,7 @@ static void make_device(const char *path,
mode = get_device_perm(path, links, &uid, &gid) | (block ? S_IFBLK : S_IFCHR);
if (selabel_lookup_best_match(sehandle, &secontext, path, links, mode)) {
ERROR("Device '%s' not created; cannot find SELinux label (%s)\n",
path, strerror(errno));
PLOG(ERROR) << "Device '" << path << "' not created; cannot find SELinux label";
return;
}
setfscreatecon(secontext);
@ -261,8 +261,7 @@ static void make_device(const char *path,
char* fcon = nullptr;
int rc = lgetfilecon(path, &fcon);
if (rc < 0) {
ERROR("Cannot get SELinux label on '%s' device (%s)\n",
path, strerror(errno));
PLOG(ERROR) << "Cannot get SELinux label on '" << path << "' device";
goto out;
}
@ -270,8 +269,7 @@ static void make_device(const char *path,
freecon(fcon);
if (different && lsetfilecon(path, secontext)) {
ERROR("Cannot set '%s' SELinux label on '%s' device (%s)\n",
secontext, path, strerror(errno));
PLOG(ERROR) << "Cannot set '" << secontext << "' SELinux label on '" << path << "' device";
}
}
@ -295,7 +293,7 @@ static void add_platform_device(const char *path)
name += 9;
}
INFO("adding platform device %s (%s)\n", name, path);
LOG(INFO) << "adding platform device " << name << " (" << path << ")";
bus = (platform_node*) calloc(1, sizeof(struct platform_node));
bus->path = strdup(path);
@ -334,7 +332,7 @@ static void remove_platform_device(const char *path)
list_for_each_reverse(node, &platform_names) {
bus = node_to_item(node, struct platform_node, list);
if (!strcmp(path, bus->path)) {
INFO("removing platform device %s\n", bus->name);
LOG(INFO) << "removing platform device " << bus->name;
free(bus->path);
list_remove(node);
free(bus);
@ -423,9 +421,9 @@ static void parse_event(const char *msg, struct uevent *uevent)
}
if (LOG_UEVENTS) {
INFO("event { '%s', '%s', '%s', '%s', %d, %d }\n",
uevent->action, uevent->path, uevent->subsystem,
uevent->firmware, uevent->major, uevent->minor);
LOG(INFO) << android::base::StringPrintf("event { '%s', '%s', '%s', '%s', %d, %d }",
uevent->action, uevent->path, uevent->subsystem,
uevent->firmware, uevent->major, uevent->minor);
}
}
@ -509,15 +507,16 @@ static char **get_block_device_symlinks(struct uevent *uevent)
return NULL;
memset(links, 0, sizeof(char *) * 4);
INFO("found %s device %s\n", type, device);
LOG(INFO) << "found " << type << " device " << device;
snprintf(link_path, sizeof(link_path), "/dev/block/%s/%s", type, device);
if (uevent->partition_name) {
p = strdup(uevent->partition_name);
sanitize(p);
if (strcmp(uevent->partition_name, p))
NOTICE("Linking partition '%s' as '%s'\n", uevent->partition_name, p);
if (strcmp(uevent->partition_name, p)) {
LOG(VERBOSE) << "Linking partition '" << uevent->partition_name << "' as '" << p << "'";
}
if (asprintf(&links[link_num], "%s/by-name/%s", link_path, p) > 0)
link_num++;
else
@ -595,8 +594,7 @@ static const char *parse_device_name(struct uevent *uevent, unsigned int len)
/* too-long names would overrun our buffer */
if(strlen(name) > len) {
ERROR("DEVPATH=%s exceeds %u-character limit on filename; ignoring event\n",
name, len);
LOG(ERROR) << "DEVPATH=" << name << " exceeds " << len << "-character limit on filename; ignoring event";
return NULL;
}
@ -631,12 +629,11 @@ static bool assemble_devpath(char *devpath, const char *dirname,
{
int s = snprintf(devpath, DEVPATH_LEN, "%s/%s", dirname, devname);
if (s < 0) {
ERROR("failed to assemble device path (%s); ignoring event\n",
strerror(errno));
PLOG(ERROR) << "failed to assemble device path; ignoring event";
return false;
} else if (s >= DEVPATH_LEN) {
ERROR("%s/%s exceeds %u-character limit on path; ignoring event\n",
dirname, devname, DEVPATH_LEN);
LOG(ERROR) << dirname << "/" << devname
<< " exceeds " << DEVPATH_LEN << "-character limit on path; ignoring event";
return false;
}
return true;
@ -680,8 +677,7 @@ static void handle_generic_device_event(struct uevent *uevent)
break;
default:
ERROR("%s subsystem's devpath option is not set; ignoring event\n",
uevent->subsystem);
LOG(ERROR) << uevent->subsystem << " subsystem's devpath option is not set; ignoring event";
return;
}
@ -737,9 +733,8 @@ static void handle_generic_device_event(struct uevent *uevent)
} else if(!strncmp(uevent->subsystem, "sound", 5)) {
base = "/dev/snd/";
make_dir(base, 0755);
} else if(!strncmp(uevent->subsystem, "misc", 4) &&
!strncmp(name, "log_", 4)) {
INFO("kernel logger is deprecated\n");
} else if(!strncmp(uevent->subsystem, "misc", 4) && !strncmp(name, "log_", 4)) {
LOG(INFO) << "kernel logger is deprecated";
base = "/dev/log/";
make_dir(base, 0755);
name += 4;
@ -818,8 +813,7 @@ static void process_firmware_event(struct uevent *uevent)
size_t i;
int booting = is_booting();
INFO("firmware: loading '%s' for '%s'\n",
uevent->firmware, uevent->path);
LOG(INFO) << "firmware: loading '" << uevent->firmware << "' for '" << uevent->path << "'";
l = asprintf(&root, SYSFS_PREFIX"%s/", uevent->path);
if (l == -1)
@ -842,7 +836,7 @@ static void process_firmware_event(struct uevent *uevent)
goto loading_close_out;
try_loading_again:
for (i = 0; i < ARRAY_SIZE(firmware_dirs); i++) {
for (i = 0; i < arraysize(firmware_dirs); i++) {
char *file = NULL;
l = asprintf(&file, "%s/%s", firmware_dirs[i], uevent->firmware);
if (l == -1)
@ -850,10 +844,11 @@ try_loading_again:
fw_fd = open(file, O_RDONLY|O_CLOEXEC);
free(file);
if (fw_fd >= 0) {
if(!load_firmware(fw_fd, loading_fd, data_fd))
INFO("firmware: copy success { '%s', '%s' }\n", root, uevent->firmware);
else
INFO("firmware: copy failure { '%s', '%s' }\n", root, uevent->firmware);
if (!load_firmware(fw_fd, loading_fd, data_fd)) {
LOG(INFO) << "firmware: copy success { '" << root << "', '" << uevent->firmware << "' }";
} else {
LOG(ERROR) << "firmware: copy failure { '" << root << "', '" << uevent->firmware << "' }";
}
break;
}
}
@ -866,7 +861,7 @@ try_loading_again:
booting = is_booting();
goto try_loading_again;
}
INFO("firmware: could not open '%s': %s\n", uevent->firmware, strerror(errno));
PLOG(ERROR) << "firmware: could not open '" << uevent->firmware << "'";
write(loading_fd, "-1", 2);
goto data_close_out;
}
@ -900,7 +895,7 @@ static void handle_firmware_event(struct uevent *uevent)
process_firmware_event(uevent);
_exit(EXIT_SUCCESS);
} else if (pid < 0) {
ERROR("could not fork to process firmware event: %s\n", strerror(errno));
PLOG(ERROR) << "could not fork to process firmware event";
}
}
@ -996,7 +991,7 @@ void device_init() {
fcntl(device_fd, F_SETFL, O_NONBLOCK);
if (access(COLDBOOT_DONE, F_OK) == 0) {
NOTICE("Skipping coldboot, already done!\n");
LOG(VERBOSE) << "Skipping coldboot, already done!";
return;
}
@ -1005,7 +1000,7 @@ void device_init() {
coldboot("/sys/block");
coldboot("/sys/devices");
close(open(COLDBOOT_DONE, O_WRONLY|O_CREAT|O_CLOEXEC, 0000));
NOTICE("Coldboot took %.2fs.\n", t.duration());
LOG(INFO) << "Coldboot took " << t.duration() << "s.";
}
int get_device_fd()

5
init/import_parser.cpp
View file

@ -38,7 +38,7 @@ bool ImportParser::ParseSection(const std::vector<std::string>& args,
return false;
}
INFO("Added '%s' to import list\n", conf_file.c_str());
LOG(INFO) << "Added '" << conf_file << "' to import list";
imports_.emplace_back(std::move(conf_file));
return true;
}
@ -48,8 +48,7 @@ void ImportParser::EndFile(const std::string& filename) {
imports_.clear();
for (const auto& s : current_imports) {
if (!Parser::GetInstance().ParseConfig(s)) {
ERROR("could not import file '%s' from '%s': %s\n",
s.c_str(), filename.c_str(), strerror(errno));
PLOG(ERROR) << "could not import file '" << s << "' from '" << filename << "'";
}
}
}

69
init/init.cpp
View file

@ -86,7 +86,7 @@ void register_epoll_handler(int fd, void (*fn)()) {
ev.events = EPOLLIN;
ev.data.ptr = reinterpret_cast<void*>(fn);
if (epoll_ctl(epoll_fd, EPOLL_CTL_ADD, fd, &ev) == -1) {
ERROR("epoll_ctl failed: %s\n", strerror(errno));
PLOG(ERROR) << "epoll_ctl failed";
}
}
@ -97,7 +97,7 @@ int add_environment(const char *key, const char *val)
size_t key_len = strlen(key);
/* The last environment entry is reserved to terminate the list */
for (n = 0; n < (ARRAY_SIZE(ENV) - 1); n++) {
for (n = 0; n < (arraysize(ENV) - 1); n++) {
/* Delete any existing entry for this key */
if (ENV[n] != NULL) {
@ -117,7 +117,7 @@ int add_environment(const char *key, const char *val)
}
}
ERROR("No env. room to store: '%s':'%s'\n", key, val);
LOG(ERROR) << "No env. room to store: '" << key << "':'" << val << "'";
return -1;
}
@ -140,7 +140,7 @@ static void restart_processes()
void handle_control_message(const std::string& msg, const std::string& name) {
Service* svc = ServiceManager::GetInstance().FindServiceByName(name);
if (svc == nullptr) {
ERROR("no such service '%s'\n", name.c_str());
LOG(ERROR) << "no such service '" << name << "'";
return;
}
@ -151,22 +151,22 @@ void handle_control_message(const std::string& msg, const std::string& name) {
} else if (msg == "restart") {
svc->Restart();
} else {
ERROR("unknown control msg '%s'\n", msg.c_str());
LOG(ERROR) << "unknown control msg '" << msg << "'";
}
}
static int wait_for_coldboot_done_action(const std::vector<std::string>& args) {
Timer t;
NOTICE("Waiting for %s...\n", COLDBOOT_DONE);
LOG(VERBOSE) << "Waiting for " COLDBOOT_DONE "...";
// Any longer than 1s is an unreasonable length of time to delay booting.
// If you're hitting this timeout, check that you didn't make your
// sepolicy regular expressions too expensive (http://b/19899875).
if (wait_for_file(COLDBOOT_DONE, 1)) {
ERROR("Timed out waiting for %s\n", COLDBOOT_DONE);
LOG(ERROR) << "Timed out waiting for " COLDBOOT_DONE;
}
NOTICE("Waiting for %s took %.2fs.\n", COLDBOOT_DONE, t.duration());
LOG(VERBOSE) << "Waiting for " COLDBOOT_DONE " took " << t.duration() << "s.";
return 0;
}
@ -198,11 +198,11 @@ static int mix_hwrng_into_linux_rng_action(const std::vector<std::string>& args)
open("/dev/hw_random", O_RDONLY | O_NOFOLLOW | O_CLOEXEC));
if (hwrandom_fd == -1) {
if (errno == ENOENT) {
ERROR("/dev/hw_random not found\n");
/* It's not an error to not have a Hardware RNG. */
result = 0;
LOG(ERROR) << "/dev/hw_random not found";
// It's not an error to not have a Hardware RNG.
result = 0;
} else {
ERROR("Failed to open /dev/hw_random: %s\n", strerror(errno));
PLOG(ERROR) << "Failed to open /dev/hw_random";
}
goto ret;
}
@ -210,7 +210,7 @@ static int mix_hwrng_into_linux_rng_action(const std::vector<std::string>& args)
urandom_fd = TEMP_FAILURE_RETRY(
open("/dev/urandom", O_WRONLY | O_NOFOLLOW | O_CLOEXEC));
if (urandom_fd == -1) {
ERROR("Failed to open /dev/urandom: %s\n", strerror(errno));
PLOG(ERROR) << "Failed to open /dev/urandom";
goto ret;
}
@ -218,23 +218,22 @@ static int mix_hwrng_into_linux_rng_action(const std::vector<std::string>& args)
chunk_size = TEMP_FAILURE_RETRY(
read(hwrandom_fd, buf, sizeof(buf) - total_bytes_written));
if (chunk_size == -1) {
ERROR("Failed to read from /dev/hw_random: %s\n", strerror(errno));
PLOG(ERROR) << "Failed to read from /dev/hw_random";
goto ret;
} else if (chunk_size == 0) {
ERROR("Failed to read from /dev/hw_random: EOF\n");
LOG(ERROR) << "Failed to read from /dev/hw_random: EOF";
goto ret;
}
chunk_size = TEMP_FAILURE_RETRY(write(urandom_fd, buf, chunk_size));
if (chunk_size == -1) {
ERROR("Failed to write to /dev/urandom: %s\n", strerror(errno));
PLOG(ERROR) << "Failed to write to /dev/urandom";
goto ret;
}
total_bytes_written += chunk_size;
}
INFO("Mixed %zu bytes from /dev/hw_random into /dev/urandom",
total_bytes_written);
LOG(INFO) << "Mixed " << total_bytes_written << " bytes from /dev/hw_random into /dev/urandom";
result = 0;
ret:
@ -304,7 +303,7 @@ static void export_kernel_boot_props() {
{ "ro.boot.hardware", "ro.hardware", "unknown", },
{ "ro.boot.revision", "ro.revision", "0", },
};
for (size_t i = 0; i < ARRAY_SIZE(prop_map); i++) {
for (size_t i = 0; i < arraysize(prop_map); i++) {
std::string value = property_get(prop_map[i].src_prop);
property_set(prop_map[i].dst_prop, (!value.empty()) ? value.c_str() : prop_map[i].default_value);
}
@ -318,7 +317,7 @@ static void process_kernel_dt() {
std::string dt_file;
android::base::ReadFileToString(file_name, &dt_file);
if (!dt_file.compare("android,firmware")) {
ERROR("firmware/android is not compatible with 'android,firmware'\n");
LOG(ERROR) << "firmware/android is not compatible with 'android,firmware'";
return;
}
@ -394,7 +393,7 @@ static int audit_callback(void *data, security_class_t /*cls*/, char *buf, size_
property_audit_data *d = reinterpret_cast<property_audit_data*>(data);
if (!d || !d->name || !d->cr) {
ERROR("audit_callback invoked with null data arguments!");
LOG(ERROR) << "audit_callback invoked with null data arguments!";
return 0;
}
@ -404,7 +403,7 @@ static int audit_callback(void *data, security_class_t /*cls*/, char *buf, size_
}
static void security_failure() {
ERROR("Security failure; rebooting into recovery mode...\n");
LOG(ERROR) << "Security failure; rebooting into recovery mode...";
android_reboot(ANDROID_RB_RESTART2, 0, "recovery");
while (true) { pause(); } // never reached
}
@ -419,9 +418,9 @@ static void selinux_initialize(bool in_kernel_domain) {
selinux_set_callback(SELINUX_CB_AUDIT, cb);
if (in_kernel_domain) {
INFO("Loading SELinux policy...\n");
LOG(INFO) << "Loading SELinux policy...";
if (selinux_android_load_policy() < 0) {
ERROR("failed to load policy: %s\n", strerror(errno));
PLOG(ERROR) << "failed to load policy";
security_failure();
}
@ -429,8 +428,7 @@ static void selinux_initialize(bool in_kernel_domain) {
bool is_enforcing = selinux_is_enforcing();
if (kernel_enforcing != is_enforcing) {
if (security_setenforce(is_enforcing)) {
ERROR("security_setenforce(%s) failed: %s\n",
is_enforcing ? "true" : "false", strerror(errno));
PLOG(ERROR) << "security_setenforce(%s) failed" << (is_enforcing ? "true" : "false");
security_failure();
}
}
@ -439,8 +437,8 @@ static void selinux_initialize(bool in_kernel_domain) {
security_failure();
}
NOTICE("(Initializing SELinux %s took %.2fs.)\n",
is_enforcing ? "enforcing" : "non-enforcing", t.duration());
LOG(INFO) << "(Initializing SELinux " << (is_enforcing ? "enforcing" : "non-enforcing")
<< " took " << t.duration() << "s.)";
} else {
selinux_init_all_handles();
}
@ -480,10 +478,9 @@ int main(int argc, char** argv) {
// later on. Now that tmpfs is mounted on /dev, we can actually talk
// to the outside world.
open_devnull_stdio();
klog_init();
klog_set_level(KLOG_NOTICE_LEVEL);
InitKernelLogging(argv);
NOTICE("init %s started!\n", is_first_stage ? "first stage" : "second stage");
LOG(INFO) << "init " << (is_first_stage ? "first stage" : "second stage") << " started!";
if (!is_first_stage) {
// Indicate that booting is in progress to background fw loaders, etc.
@ -508,13 +505,13 @@ int main(int argc, char** argv) {
// that the SELinux policy has been loaded.
if (is_first_stage) {
if (restorecon("/init") == -1) {
ERROR("restorecon failed: %s\n", strerror(errno));
PLOG(ERROR) << "restorecon failed";
security_failure();
}
char* path = argv[0];
char* args[] = { path, const_cast<char*>("--second-stage"), nullptr };
if (execv(path, args) == -1) {
ERROR("execv(\"%s\") failed: %s\n", path, strerror(errno));
PLOG(ERROR) << "execv(\"" << path << "\") failed";
security_failure();
}
}
@ -522,7 +519,7 @@ int main(int argc, char** argv) {
// These directories were necessarily created before initial policy load
// and therefore need their security context restored to the proper value.
// This must happen before /dev is populated by ueventd.
NOTICE("Running restorecon...\n");
LOG(INFO) << "Running restorecon...";
restorecon("/dev");
restorecon("/dev/socket");
restorecon("/dev/__properties__");
@ -531,7 +528,7 @@ int main(int argc, char** argv) {
epoll_fd = epoll_create1(EPOLL_CLOEXEC);
if (epoll_fd == -1) {
ERROR("epoll_create1 failed: %s\n", strerror(errno));
PLOG(ERROR) << "epoll_create1 failed";
exit(1);
}
@ -601,7 +598,7 @@ int main(int argc, char** argv) {
epoll_event ev;
int nr = TEMP_FAILURE_RETRY(epoll_wait(epoll_fd, &ev, 1, timeout));
if (nr == -1) {
ERROR("epoll_wait failed: %s\n", strerror(errno));
PLOG(ERROR) << "epoll_wait failed";
} else if (nr == 1) {
((void (*)()) ev.data.ptr)();
}

10
init/init_parser.cpp
View file

@ -93,7 +93,7 @@ void Parser::ParseData(const std::string& filename, const std::string& data) {
}
bool Parser::ParseConfigFile(const std::string& path) {
INFO("Parsing file %s...\n", path.c_str());
LOG(INFO) << "Parsing file " << path << "...";
Timer t;
std::string data;
if (!read_file(path.c_str(), &data)) {
@ -110,15 +110,15 @@ bool Parser::ParseConfigFile(const std::string& path) {
// Nexus 9 boot time, so it's disabled by default.
if (false) DumpState();
NOTICE("(Parsing %s took %.2fs.)\n", path.c_str(), t.duration());
LOG(VERBOSE) << "(Parsing " << path << " took " << t.duration() << "s.)";
return true;
}
bool Parser::ParseConfigDir(const std::string& path) {
INFO("Parsing directory %s...\n", path.c_str());
LOG(INFO) << "Parsing directory " << path << "...";
std::unique_ptr<DIR, int(*)(DIR*)> config_dir(opendir(path.c_str()), closedir);
if (!config_dir) {
ERROR("Could not import directory '%s'\n", path.c_str());
PLOG(ERROR) << "Could not import directory '" << path << "'";
return false;
}
dirent* current_file;
@ -128,7 +128,7 @@ bool Parser::ParseConfigDir(const std::string& path) {
// Ignore directories and only process regular files.
if (current_file->d_type == DT_REG) {
if (!ParseConfigFile(current_path)) {
ERROR("could not import file '%s'\n", current_path.c_str());
LOG(ERROR) << "could not import file '" << current_path << "'";
}
}
}

12
init/keychords.cpp
View file

@ -43,7 +43,7 @@ void add_service_keycodes(Service* svc)
size = sizeof(*keychord) + svc->keycodes().size() * sizeof(keychord->keycodes[0]);
keychords = (input_keychord*) realloc(keychords, keychords_length + size);
if (!keychords) {
ERROR("could not allocate keychords\n");
PLOG(ERROR) << "could not allocate keychords";
keychords_length = 0;
keychords_count = 0;
return;
@ -69,7 +69,7 @@ static void handle_keychord() {
ret = read(keychord_fd, &id, sizeof(id));
if (ret != sizeof(id)) {
ERROR("could not read keychord id\n");
PLOG(ERROR) << "could not read keychord id";
return;
}
@ -78,10 +78,10 @@ static void handle_keychord() {
if (adb_enabled == "running") {
Service* svc = ServiceManager::GetInstance().FindServiceByKeychord(id);
if (svc) {
INFO("Starting service %s from keychord\n", svc->name().c_str());
LOG(INFO) << "Starting service " << svc->name() << " from keychord...";
svc->Start();
} else {
ERROR("service for keychord %d not found\n", id);
LOG(ERROR) << "service for keychord " << id << " not found";
}
}
}
@ -96,13 +96,13 @@ void keychord_init() {
keychord_fd = TEMP_FAILURE_RETRY(open("/dev/keychord", O_RDWR | O_CLOEXEC));
if (keychord_fd == -1) {
ERROR("could not open /dev/keychord: %s\n", strerror(errno));
PLOG(ERROR) << "could not open /dev/keychord";
return;
}
int ret = write(keychord_fd, keychords, keychords_length);
if (ret != keychords_length) {
ERROR("could not configure /dev/keychord %d: %s\n", ret, strerror(errno));
PLOG(ERROR) << "could not configure /dev/keychord " << ret;
close(keychord_fd);
}

45
init/log.cpp
View file

@ -22,48 +22,53 @@
#include <selinux/selinux.h>
#include <android-base/stringprintf.h>
static void init_klog_vwrite(int level, const char* fmt, va_list ap) {
static const char* tag = basename(getprogname());
static const int kLogSeverityToKLogLevel[] = {
KLOG_NOTICE_LEVEL, KLOG_DEBUG_LEVEL, KLOG_INFO_LEVEL,
KLOG_WARNING_LEVEL, KLOG_ERROR_LEVEL, KLOG_ERROR_LEVEL,
};
static_assert(arraysize(kLogSeverityToKLogLevel) == android::base::FATAL + 1,
"Mismatch in size of kLogSeverityToKLogLevel and values in LogSeverity");
static void KernelLogger(android::base::LogId, android::base::LogSeverity severity,
const char* tag, const char*, unsigned int, const char* msg) {
int level = kLogSeverityToKLogLevel[severity];
if (level > klog_get_level()) return;
// The kernel's printk buffer is only 1024 bytes.
// TODO: should we automatically break up long lines into multiple lines?
// Or we could log but with something like "..." at the end?
char buf[1024];
size_t prefix_size = snprintf(buf, sizeof(buf), "<%d>%s: ", level, tag);
size_t msg_size = vsnprintf(buf + prefix_size, sizeof(buf) - prefix_size, fmt, ap);
if (msg_size >= sizeof(buf) - prefix_size) {
msg_size = snprintf(buf + prefix_size, sizeof(buf) - prefix_size,
"(%zu-byte message too long for printk)\n", msg_size);
size_t size = snprintf(buf, sizeof(buf), "<%d>%s: %s\n", level, tag, msg);
if (size > sizeof(buf)) {
size = snprintf(buf, sizeof(buf), "<%d>%s: %zu-byte message too long for printk\n",
level, tag, size);
}
iovec iov[1];
iov[0].iov_base = buf;
iov[0].iov_len = prefix_size + msg_size;
iov[0].iov_len = size;
klog_writev(level, iov, 1);
}
void init_klog_write(int level, const char* fmt, ...) {
va_list ap;
va_start(ap, fmt);
init_klog_vwrite(level, fmt, ap);
va_end(ap);
void InitKernelLogging(char* argv[]) {
android::base::InitLogging(argv, &KernelLogger);
klog_init();
klog_set_level(KLOG_NOTICE_LEVEL);
}
int selinux_klog_callback(int type, const char *fmt, ...) {
int level = KLOG_ERROR_LEVEL;
android::base::LogSeverity severity = android::base::ERROR;
if (type == SELINUX_WARNING) {
level = KLOG_WARNING_LEVEL;
severity = android::base::WARNING;
} else if (type == SELINUX_INFO) {
level = KLOG_INFO_LEVEL;
severity = android::base::INFO;
}
char buf[1024];
va_list ap;
va_start(ap, fmt);
init_klog_vwrite(level, fmt, ap);
vsnprintf(buf, sizeof(buf), fmt, ap);
va_end(ap);
KernelLogger(android::base::MAIN, severity, "selinux", nullptr, 0, buf);
return 0;
}

10
init/log.h
View file

@ -17,16 +17,12 @@
#ifndef _INIT_LOG_H_
#define _INIT_LOG_H_
#include <android-base/logging.h>
#include <cutils/klog.h>
#define ERROR(x...) init_klog_write(KLOG_ERROR_LEVEL, x)
#define WARNING(x...) init_klog_write(KLOG_WARNING_LEVEL, x)
#define NOTICE(x...) init_klog_write(KLOG_NOTICE_LEVEL, x)
#define INFO(x...) init_klog_write(KLOG_INFO_LEVEL, x)
#define DEBUG(x...) init_klog_write(KLOG_DEBUG_LEVEL, x)
#define VERBOSE(x...) init_klog_write(KLOG_DEBUG_LEVEL, x)
void InitKernelLogging(char* argv[]);
void init_klog_write(int level, const char* fmt, ...) __printflike(2, 3);
int selinux_klog_callback(int level, const char* fmt, ...) __printflike(2, 3);
#endif

2
init/parser.cpp
View file

@ -20,7 +20,7 @@ void parse_error(struct parse_state *state, const char *fmt, ...)
vsnprintf(buf + off, 128 - off, fmt, ap);
va_end(ap);
buf[127] = 0;
ERROR("%s", buf);
LOG(ERROR) << buf;
}
int next_token(struct parse_state *state)

68
init/property_service.cpp
View file

@ -64,7 +64,7 @@ static int property_set_fd = -1;
void property_init() {
if (__system_property_area_init()) {
ERROR("Failed to initialize property area\n");
LOG(ERROR) << "Failed to initialize property area";
exit(1);
}
}
@ -127,7 +127,7 @@ static void write_persistent_property(const char *name, const char *value)
snprintf(tempPath, sizeof(tempPath), "%s/.temp.XXXXXX", PERSISTENT_PROPERTY_DIR);
fd = mkstemp(tempPath);
if (fd < 0) {
ERROR("Unable to write persistent property to temp file %s: %s\n", tempPath, strerror(errno));
PLOG(ERROR) << "Unable to write persistent property to temp file " << tempPath;
return;
}
write(fd, value, strlen(value));
@ -136,8 +136,8 @@ static void write_persistent_property(const char *name, const char *value)
snprintf(path, sizeof(path), "%s/%s", PERSISTENT_PROPERTY_DIR, name);
if (rename(tempPath, path)) {
PLOG(ERROR) << "Unable to rename persistent property file " << tempPath << " to " << path;
unlink(tempPath);
ERROR("Unable to rename persistent property file %s to %s\n", tempPath, path);
}
}
@ -176,7 +176,7 @@ static int property_set_impl(const char* name, const char* value) {
if (strcmp("selinux.restorecon_recursive", name) == 0 && valuelen > 0) {
if (restorecon_recursive(value) != 0) {
ERROR("Failed to restorecon_recursive %s\n", value);
LOG(ERROR) << "Failed to restorecon_recursive " << value;
}
}
@ -219,7 +219,7 @@ static int property_set_impl(const char* name, const char* value) {
int property_set(const char* name, const char* value) {
int rc = property_set_impl(name, value);
if (rc == -1) {
ERROR("property_set(\"%s\", \"%s\") failed\n", name, value);
LOG(ERROR) << "property_set(\"" << name << "\", \"" << value << "\") failed";
}
return rc;
}
@ -245,7 +245,7 @@ static void handle_property_set_fd()
/* Check socket options here */
if (getsockopt(s, SOL_SOCKET, SO_PEERCRED, &cr, &cr_size) < 0) {
close(s);
ERROR("Unable to receive socket options\n");
PLOG(ERROR) << "Unable to receive socket options";
return;
}
@ -254,19 +254,18 @@ static void handle_property_set_fd()
ufds[0].revents = 0;
nr = TEMP_FAILURE_RETRY(poll(ufds, 1, timeout_ms));
if (nr == 0) {
ERROR("sys_prop: timeout waiting for uid=%d to send property message.\n", cr.uid);
LOG(ERROR) << "sys_prop: timeout waiting for uid " << cr.uid << " to send property message.";
close(s);
return;
} else if (nr < 0) {
ERROR("sys_prop: error waiting for uid=%d to send property message: %s\n", cr.uid, strerror(errno));
PLOG(ERROR) << "sys_prop: error waiting for uid " << cr.uid << " to send property message";
close(s);
return;
}
r = TEMP_FAILURE_RETRY(recv(s, &msg, sizeof(msg), MSG_DONTWAIT));
if(r != sizeof(prop_msg)) {
ERROR("sys_prop: mis-match msg size received: %d expected: %zu: %s\n",
r, sizeof(prop_msg), strerror(errno));
PLOG(ERROR) << "sys_prop: mis-match msg size received: " << r << " expected: " << sizeof(prop_msg);
close(s);
return;
}
@ -277,7 +276,7 @@ static void handle_property_set_fd()
msg.value[PROP_VALUE_MAX-1] = 0;
if (!is_legal_property_name(msg.name, strlen(msg.name))) {
ERROR("sys_prop: illegal property name. Got: \"%s\"\n", msg.name);
LOG(ERROR) << "sys_prop: illegal property name \"" << msg.name << "\"";
close(s);
return;
}
@ -291,15 +290,17 @@ static void handle_property_set_fd()
if (check_control_mac_perms(msg.value, source_ctx, &cr)) {
handle_control_message((char*) msg.name + 4, (char*) msg.value);
} else {
ERROR("sys_prop: Unable to %s service ctl [%s] uid:%d gid:%d pid:%d\n",
msg.name + 4, msg.value, cr.uid, cr.gid, cr.pid);
LOG(ERROR) << "sys_prop: Unable to " << (msg.name + 4)
<< " service ctl [" << msg.value << "]"
<< " uid:" << cr.uid
<< " gid:" << cr.gid
<< " pid:" << cr.pid;
}
} else {
if (check_mac_perms(msg.name, source_ctx, &cr)) {
property_set((char*) msg.name, (char*) msg.value);
} else {
ERROR("sys_prop: permission denied uid:%d name:%s\n",
cr.uid, msg.name);
LOG(ERROR) << "sys_prop: permission denied uid:" << cr.uid << " name:" << msg.name;
}
// Note: bionic's property client code assumes that the
@ -389,7 +390,7 @@ static void load_properties_from_file(const char* filename, const char* filter)
data.push_back('\n');
load_properties(&data[0], filter);
}
NOTICE("(Loading properties from %s took %.2fs.)\n", filename, t.duration());
LOG(VERBOSE) << "(Loading properties from " << filename << " took " << t.duration() << "s.)";
}
static void load_persistent_properties() {
@ -397,8 +398,8 @@ static void load_persistent_properties() {
std::unique_ptr<DIR, int(*)(DIR*)> dir(opendir(PERSISTENT_PROPERTY_DIR), closedir);
if (!dir) {
ERROR("Unable to open persistent property directory \"%s\": %s\n",
PERSISTENT_PROPERTY_DIR, strerror(errno));
PLOG(ERROR) << "Unable to open persistent property directory \""
<< PERSISTENT_PROPERTY_DIR << "\"";
return;
}
@ -414,25 +415,23 @@ static void load_persistent_properties() {
// Open the file and read the property value.
int fd = openat(dirfd(dir.get()), entry->d_name, O_RDONLY | O_NOFOLLOW);
if (fd == -1) {
ERROR("Unable to open persistent property file \"%s\": %s\n",
entry->d_name, strerror(errno));
PLOG(ERROR) << "Unable to open persistent property file \"" << entry->d_name << "\"";
continue;
}
struct stat sb;
if (fstat(fd, &sb) == -1) {
ERROR("fstat on property file \"%s\" failed: %s\n", entry->d_name, strerror(errno));
PLOG(ERROR) << "fstat on property file \"" << entry->d_name << "\" failed";
close(fd);
continue;
}
// File must not be accessible to others, be owned by root/root, and
// not be a hard link to any other file.
if (((sb.st_mode & (S_IRWXG | S_IRWXO)) != 0) || (sb.st_uid != 0) || (sb.st_gid != 0) ||
(sb.st_nlink != 1)) {
ERROR("skipping insecure property file %s (uid=%u gid=%u nlink=%u mode=%o)\n",
entry->d_name, (unsigned int)sb.st_uid, (unsigned int)sb.st_gid,
(unsigned int)sb.st_nlink, sb.st_mode);
if (((sb.st_mode & (S_IRWXG | S_IRWXO)) != 0) || sb.st_uid != 0 || sb.st_gid != 0 || sb.st_nlink != 1) {
PLOG(ERROR) << "skipping insecure property file " << entry->d_name
<< " (uid=" << sb.st_uid << " gid=" << sb.st_gid
<< " nlink=" << sb.st_nlink << " mode=" << std::oct << sb.st_mode << ")";
close(fd);
continue;
}
@ -443,8 +442,7 @@ static void load_persistent_properties() {
value[length] = 0;
property_set(entry->d_name, value);
} else {
ERROR("Unable to read persistent property file %s: %s\n",
entry->d_name, strerror(errno));
PLOG(ERROR) << "Unable to read persistent property file " << entry->d_name;
}
close(fd);
}
@ -477,27 +475,27 @@ void load_persist_props(void) {
void load_recovery_id_prop() {
std::string ro_hardware = property_get("ro.hardware");
if (ro_hardware.empty()) {
ERROR("ro.hardware not set - unable to load recovery id\n");
LOG(ERROR) << "ro.hardware not set - unable to load recovery id";
return;
}
std::string fstab_filename = FSTAB_PREFIX + ro_hardware;
std::unique_ptr<fstab, void(*)(fstab*)> tab(fs_mgr_read_fstab(fstab_filename.c_str()),
fs_mgr_free_fstab);
fs_mgr_free_fstab);
if (!tab) {
ERROR("unable to read fstab %s: %s\n", fstab_filename.c_str(), strerror(errno));
PLOG(ERROR) << "unable to read fstab " << fstab_filename;
return;
}
fstab_rec* rec = fs_mgr_get_entry_for_mount_point(tab.get(), RECOVERY_MOUNT_POINT);
if (rec == NULL) {
ERROR("/recovery not specified in fstab\n");
LOG(ERROR) << "/recovery not specified in fstab";
return;
}
int fd = open(rec->blk_device, O_RDONLY);
if (fd == -1) {
ERROR("error opening block device %s: %s\n", rec->blk_device, strerror(errno));
PLOG(ERROR) << "error opening block device " << rec->blk_device;
return;
}
@ -506,7 +504,7 @@ void load_recovery_id_prop() {
std::string hex = bytes_to_hex(reinterpret_cast<uint8_t*>(hdr.id), sizeof(hdr.id));
property_set("ro.recovery_id", hex.c_str());
} else {
ERROR("error reading /recovery: %s\n", strerror(errno));
PLOG(ERROR) << "error reading /recovery";
}
close(fd);
@ -523,7 +521,7 @@ void start_property_service() {
property_set_fd = create_socket(PROP_SERVICE_NAME, SOCK_STREAM | SOCK_CLOEXEC | SOCK_NONBLOCK,
0666, 0, 0, NULL);
if (property_set_fd == -1) {
ERROR("start_property_service socket creation failed: %s\n", strerror(errno));
PLOG(ERROR) << "start_property_service socket creation failed";
exit(1);
}

102
init/service.cpp
View file

@ -29,6 +29,7 @@
#include <android-base/file.h>
#include <android-base/stringprintf.h>
#include <android-base/strings.h>
#include <cutils/android_reboot.h>
#include <cutils/sockets.h>
#include <system/thread_defs.h>
@ -91,8 +92,7 @@ void Service::NotifyStateChange(const std::string& new_state) const {
std::string prop_name = StringPrintf("init.svc.%s", name_.c_str());
if (prop_name.length() >= PROP_NAME_MAX) {
// If the property name would be too long, we can't set it.
ERROR("Property name \"init.svc.%s\" too long; not setting to %s\n",
name_.c_str(), new_state.c_str());
LOG(ERROR) << "Property name \"init.svc." << name_ << "\" too long; not setting to " << new_state;
return;
}
@ -100,8 +100,9 @@ void Service::NotifyStateChange(const std::string& new_state) const {
}
void Service::KillProcessGroup(int signal) {
NOTICE("Sending signal %d to service '%s' (pid %d) process group...\n",
signal, name_.c_str(), pid_);
LOG(VERBOSE) << "Sending signal " << signal
<< " to service '" << name_
<< "' (pid " << pid_ << ") process group...\n",
kill(pid_, signal);
killProcessGroup(uid_, pid_, signal);
}
@ -118,7 +119,7 @@ bool Service::Reap() {
}
if (flags_ & SVC_EXEC) {
INFO("SVC_EXEC pid %d finished...\n", pid_);
LOG(INFO) << "SVC_EXEC pid " << pid_ << " finished...";
return true;
}
@ -141,9 +142,10 @@ bool Service::Reap() {
if ((flags_ & SVC_CRITICAL) && !(flags_ & SVC_RESTART)) {
if (time_crashed_ + CRITICAL_CRASH_WINDOW >= now) {
if (++nr_crashed_ > CRITICAL_CRASH_THRESHOLD) {
ERROR("critical process '%s' exited %d times in %d minutes; "
"rebooting into recovery mode\n", name_.c_str(),
CRITICAL_CRASH_THRESHOLD, CRITICAL_CRASH_WINDOW / 60);
LOG(ERROR) << "critical process '" << name_ << "' exited "
<< CRITICAL_CRASH_THRESHOLD << " times in "
<< (CRITICAL_CRASH_WINDOW / 60) << " minutes; "
<< "rebooting into recovery mode";
android_reboot(ANDROID_RB_RESTART2, 0, "recovery");
return false;
}
@ -164,15 +166,11 @@ bool Service::Reap() {
}
void Service::DumpState() const {
INFO("service %s\n", name_.c_str());
INFO(" class '%s'\n", classname_.c_str());
INFO(" exec");
for (const auto& s : args_) {
INFO(" '%s'", s.c_str());
}
INFO("\n");
LOG(INFO) << "service " << name_;
LOG(INFO) << " class '" << classname_ << "'";
LOG(INFO) << " exec "<< android::base::Join(args_, " ");
for (const auto& si : sockets_) {
INFO(" socket %s %s 0%o\n", si.name.c_str(), si.type.c_str(), si.perm);
LOG(INFO) << " socket " << si.name << " " << si.type << " " << std::oct << si.perm;
}
}
@ -362,8 +360,7 @@ bool Service::Start() {
bool have_console = (open(console_.c_str(), O_RDWR | O_CLOEXEC) != -1);
if (!have_console) {
ERROR("service '%s' couldn't open console '%s': %s\n",
name_.c_str(), console_.c_str(), strerror(errno));
PLOG(ERROR) << "service '" << name_ << "' couldn't open console '" << console_ << "'";
flags_ |= SVC_DISABLED;
return false;
}
@ -371,8 +368,7 @@ bool Service::Start() {
struct stat sb;
if (stat(args_[0].c_str(), &sb) == -1) {
ERROR("cannot find '%s' (%s), disabling '%s'\n",
args_[0].c_str(), strerror(errno), name_.c_str());
PLOG(ERROR) << "cannot find '" << args_[0] << "', disabling '" << name_ << "'";
flags_ |= SVC_DISABLED;
return false;
}
@ -384,16 +380,16 @@ bool Service::Start() {
char* mycon = nullptr;
char* fcon = nullptr;
INFO("computing context for service '%s'\n", args_[0].c_str());
LOG(INFO) << "computing context for service '" << args_[0] << "'";
int rc = getcon(&mycon);
if (rc < 0) {
ERROR("could not get context while starting '%s'\n", name_.c_str());
LOG(ERROR) << "could not get context while starting '" << name_ << "'";
return false;
}
rc = getfilecon(args_[0].c_str(), &fcon);
if (rc < 0) {
ERROR("could not get context while starting '%s'\n", name_.c_str());
LOG(ERROR) << "could not get context while starting '" << name_ << "'";
free(mycon);
return false;
}
@ -406,7 +402,7 @@ bool Service::Start() {
free(ret_scon);
}
if (rc == 0 && scon == mycon) {
ERROR("Service %s does not have a SELinux domain defined.\n", name_.c_str());
LOG(ERROR) << "Service " << name_ << " does not have a SELinux domain defined.";
free(mycon);
free(fcon);
return false;
@ -414,12 +410,12 @@ bool Service::Start() {
free(mycon);
free(fcon);
if (rc < 0) {
ERROR("could not get context while starting '%s'\n", name_.c_str());
LOG(ERROR) << "could not get context while starting '" << name_ << "'";
return false;
}
}
NOTICE("Starting service '%s'...\n", name_.c_str());
LOG(VERBOSE) << "Starting service '" << name_ << "'...";
pid_t pid = fork();
if (pid == 0) {
@ -446,15 +442,14 @@ bool Service::Start() {
std::string pid_str = StringPrintf("%d", getpid());
for (const auto& file : writepid_files_) {
if (!WriteStringToFile(pid_str, file)) {
ERROR("couldn't write %s to %s: %s\n",
pid_str.c_str(), file.c_str(), strerror(errno));
PLOG(ERROR) << "couldn't write " << pid_str << " to " << file;
}
}
if (ioprio_class_ != IoSchedClass_NONE) {
if (android_set_ioprio(getpid(), ioprio_class_, ioprio_pri_)) {
ERROR("Failed to set pid %d ioprio = %d,%d: %s\n",
getpid(), ioprio_class_, ioprio_pri_, strerror(errno));
PLOG(ERROR) << "Failed to set pid " << getpid()
<< " ioprio=" << ioprio_class_ << "," << ioprio_pri_;
}
}
@ -470,32 +465,31 @@ bool Service::Start() {
// As requested, set our gid, supplemental gids, and uid.
if (gid_) {
if (setgid(gid_) != 0) {
ERROR("setgid failed: %s\n", strerror(errno));
PLOG(ERROR) << "setgid failed";
_exit(127);
}
}
if (!supp_gids_.empty()) {
if (setgroups(supp_gids_.size(), &supp_gids_[0]) != 0) {
ERROR("setgroups failed: %s\n", strerror(errno));
PLOG(ERROR) << "setgroups failed";
_exit(127);
}
}
if (uid_) {
if (setuid(uid_) != 0) {
ERROR("setuid failed: %s\n", strerror(errno));
PLOG(ERROR) << "setuid failed";
_exit(127);
}
}
if (!seclabel_.empty()) {
if (setexeccon(seclabel_.c_str()) < 0) {
ERROR("cannot setexeccon('%s'): %s\n",
seclabel_.c_str(), strerror(errno));
PLOG(ERROR) << "cannot setexeccon('" << seclabel_ << "')";
_exit(127);
}
}
if (priority_ != 0) {
if (setpriority(PRIO_PROCESS, 0, priority_) != 0) {
ERROR("setpriority failed: %s\n", strerror(errno));
PLOG(ERROR) << "setpriority failed";
_exit(127);
}
}
@ -506,7 +500,7 @@ bool Service::Start() {
strs.push_back(const_cast<char*>(args_[0].c_str()));
for (std::size_t i = 1; i < args_.size(); ++i) {
if (!expand_props(args_[i], &expanded_args[i])) {
ERROR("%s: cannot expand '%s'\n", args_[0].c_str(), args_[i].c_str());
LOG(ERROR) << args_[0] << ": cannot expand '" << args_[i] << "'";
_exit(127);
}
strs.push_back(const_cast<char*>(expanded_args[i].c_str()));
@ -514,14 +508,14 @@ bool Service::Start() {
strs.push_back(nullptr);
if (execve(strs[0], (char**) &strs[0], (char**) ENV) < 0) {
ERROR("cannot execve('%s'): %s\n", strs[0], strerror(errno));
PLOG(ERROR) << "cannot execve('" << strs[0] << "')";
}
_exit(127);
}
if (pid < 0) {
ERROR("failed to start '%s'\n", name_.c_str());
PLOG(ERROR) << "failed to fork for '" << name_ << "'";
pid_ = 0;
return false;
}
@ -532,14 +526,13 @@ bool Service::Start() {
errno = -createProcessGroup(uid_, pid_);
if (errno != 0) {
ERROR("createProcessGroup(%d, %d) failed for service '%s': %s\n",
uid_, pid_, name_.c_str(), strerror(errno));
PLOG(ERROR) << "createProcessGroup(" << uid_ << ", " << pid_ << ") failed for service '" << name_ << "'";
}
if ((flags_ & SVC_EXEC) != 0) {
INFO("SVC_EXEC pid %d (uid %d gid %d+%zu context %s) started; waiting...\n",
pid_, uid_, gid_, supp_gids_.size(),
!seclabel_.empty() ? seclabel_.c_str() : "default");
LOG(INFO) << android::base::StringPrintf("SVC_EXEC pid %d (uid %d gid %d+%zu context %s) started; waiting...",
pid_, uid_, gid_, supp_gids_.size(),
!seclabel_.empty() ? seclabel_.c_str() : "default");
}
NotifyStateChange("running");
@ -672,8 +665,7 @@ ServiceManager& ServiceManager::GetInstance() {
void ServiceManager::AddService(std::unique_ptr<Service> service) {
Service* old_service = FindServiceByName(service->name());
if (old_service) {
ERROR("ignored duplicate definition of service '%s'",
service->name().c_str());
LOG(ERROR) << "ignored duplicate definition of service '" << service->name() << "'";
return;
}
services_.emplace_back(std::move(service));
@ -690,12 +682,12 @@ Service* ServiceManager::MakeExecOneshotService(const std::vector<std::string>&
}
}
if (command_arg > 4 + NR_SVC_SUPP_GIDS) {
ERROR("exec called with too many supplementary group ids\n");
LOG(ERROR) << "exec called with too many supplementary group ids";
return nullptr;
}
if (command_arg >= args.size()) {
ERROR("exec called without command\n");
LOG(ERROR) << "exec called without command";
return nullptr;
}
std::vector<std::string> str_args(args.begin() + command_arg, args.end());
@ -725,8 +717,7 @@ Service* ServiceManager::MakeExecOneshotService(const std::vector<std::string>&
std::unique_ptr<Service> svc_p(new Service(name, "default", flags, uid, gid,
supp_gids, seclabel, str_args));
if (!svc_p) {
ERROR("Couldn't allocate service for exec of '%s'",
str_args[0].c_str());
LOG(ERROR) << "Couldn't allocate service for exec of '" << str_args[0] << "'";
return nullptr;
}
Service* svc = svc_p.get();
@ -809,7 +800,6 @@ void ServiceManager::DumpState() const {
for (const auto& s : services_) {
s->DumpState();
}
INFO("\n");
}
bool ServiceManager::ReapOneProcess() {
@ -818,7 +808,7 @@ bool ServiceManager::ReapOneProcess() {
if (pid == 0) {
return false;
} else if (pid == -1) {
ERROR("waitpid failed: %s\n", strerror(errno));
PLOG(ERROR) << "waitpid failed";
return false;
}
@ -833,13 +823,13 @@ bool ServiceManager::ReapOneProcess() {
}
if (WIFEXITED(status)) {
NOTICE("%s exited with status %d\n", name.c_str(), WEXITSTATUS(status));
LOG(VERBOSE) << name << " exited with status " << WEXITSTATUS(status);
} else if (WIFSIGNALED(status)) {
NOTICE("%s killed by signal %d\n", name.c_str(), WTERMSIG(status));
LOG(VERBOSE) << name << " killed by signal " << WTERMSIG(status);
} else if (WIFSTOPPED(status)) {
NOTICE("%s stopped by signal %d\n", name.c_str(), WSTOPSIG(status));
LOG(VERBOSE) << name << " stopped by signal " << WSTOPSIG(status);
} else {
NOTICE("%s state changed", name.c_str());
LOG(VERBOSE) << name << " state changed";
}
if (!svc) {

4
init/signal_handler.cpp
View file

@ -47,7 +47,7 @@ static void handle_signal() {
static void SIGCHLD_handler(int) {
if (TEMP_FAILURE_RETRY(write(signal_write_fd, "1", 1)) == -1) {
ERROR("write(signal_write_fd) failed: %s\n", strerror(errno));
PLOG(ERROR) << "write(signal_write_fd) failed";
}
}
@ -55,7 +55,7 @@ void signal_handler_init() {
// Create a signalling mechanism for SIGCHLD.
int s[2];
if (socketpair(AF_UNIX, SOCK_STREAM | SOCK_NONBLOCK | SOCK_CLOEXEC, 0, s) == -1) {
ERROR("socketpair failed: %s\n", strerror(errno));
PLOG(ERROR) << "socketpair failed";
exit(1);
}

15
init/ueventd.cpp
View file

@ -53,10 +53,9 @@ int ueventd_main(int argc, char **argv)
signal(SIGCHLD, SIG_IGN);
open_devnull_stdio();
klog_init();
klog_set_level(KLOG_NOTICE_LEVEL);
InitKernelLogging(argv);
NOTICE("ueventd started!\n");
LOG(INFO) << "ueventd started!";
selinux_callback cb;
cb.func_log = selinux_klog_callback;
@ -108,14 +107,14 @@ void set_device_permission(int nargs, char **args)
name = args[0];
if (!strncmp(name,"/sys/", 5) && (nargs == 5)) {
INFO("/sys/ rule %s %s\n",args[0],args[1]);
LOG(INFO) << "/sys/ rule " << args[0] << " " << args[1];
attr = args[1];
args++;
nargs--;
}
if (nargs != 4) {
ERROR("invalid line ueventd.rc line for '%s'\n", args[0]);
LOG(ERROR) << "invalid line ueventd.rc line for '" << args[0] << "'";
return;
}
@ -130,14 +129,14 @@ void set_device_permission(int nargs, char **args)
perm = strtol(args[1], &endptr, 8);
if (!endptr || *endptr != '\0') {
ERROR("invalid mode '%s'\n", args[1]);
LOG(ERROR) << "invalid mode '" << args[1] << "'";
free(tmp);
return;
}
struct passwd* pwd = getpwnam(args[2]);
if (!pwd) {
ERROR("invalid uid '%s'\n", args[2]);
LOG(ERROR) << "invalid uid '" << args[2] << "'";
free(tmp);
return;
}
@ -145,7 +144,7 @@ void set_device_permission(int nargs, char **args)
struct group* grp = getgrnam(args[3]);
if (!grp) {
ERROR("invalid gid '%s'\n", args[3]);
LOG(ERROR) << "invalid gid '" << args[3] << "'";
free(tmp);
return;
}

48
init/util.cpp
View file

@ -34,6 +34,7 @@
#include <sys/un.h>
#include <android-base/file.h>
#include <android-base/logging.h>
#include <android-base/strings.h>
/* for ANDROID_SOCKET_* */
@ -74,7 +75,7 @@ static unsigned int do_decode_uid(const char *s)
unsigned int decode_uid(const char *s) {
unsigned int v = do_decode_uid(s);
if (v == UINT_MAX) {
ERROR("decode_uid: Unable to find UID for '%s'. Returning UINT_MAX\n", s);
LOG(ERROR) << "decode_uid: Unable to find UID for '" << s << "'; returning UINT_MAX";
}
return v;
}
@ -94,14 +95,14 @@ int create_socket(const char *name, int type, mode_t perm, uid_t uid,
if (socketcon) {
if (setsockcreatecon(socketcon) == -1) {
ERROR("setsockcreatecon(\"%s\") failed: %s\n", socketcon, strerror(errno));
PLOG(ERROR) << "setsockcreatecon(\"" << socketcon << "\") failed";
return -1;
}
}
fd = socket(PF_UNIX, type, 0);
if (fd < 0) {
ERROR("Failed to open socket '%s': %s\n", name, strerror(errno));
PLOG(ERROR) << "Failed to open socket '" << name << "'";
return -1;
}
@ -115,7 +116,7 @@ int create_socket(const char *name, int type, mode_t perm, uid_t uid,
ret = unlink(addr.sun_path);
if (ret != 0 && errno != ENOENT) {
ERROR("Failed to unlink old socket '%s': %s\n", name, strerror(errno));
PLOG(ERROR) << "Failed to unlink old socket '" << name << "'";
goto out_close;
}
@ -133,23 +134,26 @@ int create_socket(const char *name, int type, mode_t perm, uid_t uid,
freecon(filecon);
if (ret) {
ERROR("Failed to bind socket '%s': %s\n", name, strerror(savederrno));
errno = savederrno;
PLOG(ERROR) << "Failed to bind socket '" << name << "'";
goto out_unlink;
}
ret = lchown(addr.sun_path, uid, gid);
if (ret) {
ERROR("Failed to lchown socket '%s': %s\n", addr.sun_path, strerror(errno));
PLOG(ERROR) << "Failed to lchown socket '" << addr.sun_path << "'";
goto out_unlink;
}
ret = fchmodat(AT_FDCWD, addr.sun_path, perm, AT_SYMLINK_NOFOLLOW);
if (ret) {
ERROR("Failed to fchmodat socket '%s': %s\n", addr.sun_path, strerror(errno));
PLOG(ERROR) << "Failed to fchmodat socket '" << addr.sun_path << "'";
goto out_unlink;
}
INFO("Created socket '%s' with mode '%o', user '%d', group '%d'\n",
addr.sun_path, perm, uid, gid);
LOG(INFO) << "Created socket '" << addr.sun_path << "'"
<< ", mode " << std::oct << perm << std::dec
<< ", user " << uid
<< ", group " << gid;
return fd;
@ -172,11 +176,11 @@ bool read_file(const char* path, std::string* content) {
// or group-writable files.
struct stat sb;
if (fstat(fd, &sb) == -1) {
ERROR("fstat failed for '%s': %s\n", path, strerror(errno));
PLOG(ERROR) << "fstat failed for '" << path << "'";
return false;
}
if ((sb.st_mode & (S_IWGRP | S_IWOTH)) != 0) {
ERROR("skipping insecure file '%s'\n", path);
PLOG(ERROR) << "skipping insecure file '" << path << "'";
return false;
}
@ -188,12 +192,12 @@ bool read_file(const char* path, std::string* content) {
int write_file(const char* path, const char* content) {
int fd = TEMP_FAILURE_RETRY(open(path, O_WRONLY|O_CREAT|O_NOFOLLOW|O_CLOEXEC, 0600));
if (fd == -1) {
NOTICE("write_file: Unable to open '%s': %s\n", path, strerror(errno));
PLOG(ERROR) << "write_file: Unable to open '" << path << "'";
return -1;
}
int result = android::base::WriteStringToFd(content, fd) ? 0 : -1;
if (result == -1) {
NOTICE("write_file: Unable to write to '%s': %s\n", path, strerror(errno));
PLOG(ERROR) << "write_file: Unable to write to '" << path << "'";
}
close(fd);
return result;
@ -228,7 +232,7 @@ int mkdir_recursive(const char *pathname, mode_t mode)
if (width == 0)
continue;
if ((unsigned int)width > sizeof(buf) - 1) {
ERROR("path too long for mkdir_recursive\n");
LOG(ERROR) << "path too long for mkdir_recursive";
return -1;
}
memcpy(buf, pathname, width);
@ -282,12 +286,10 @@ void make_link_init(const char *oldpath, const char *newpath)
memcpy(buf, newpath, width);
buf[width] = 0;
ret = mkdir_recursive(buf, 0755);
if (ret)
ERROR("Failed to create directory %s: %s (%d)\n", buf, strerror(errno), errno);
if (ret) PLOG(ERROR) << "Failed to create directory " << buf;
ret = symlink(oldpath, newpath);
if (ret && errno != EEXIST)
ERROR("Failed to symlink %s to %s: %s (%d)\n", oldpath, newpath, strerror(errno), errno);
if (ret && errno != EEXIST) PLOG(ERROR) << "Failed to symlink " << oldpath << " to " << newpath;
}
void remove_link(const char *oldpath, const char *newpath)
@ -446,7 +448,7 @@ bool expand_props(const std::string& src, std::string* dst) {
const char* end = strchr(c, '}');
if (!end) {
// failed to find closing brace, abort.
ERROR("unexpected end of string in '%s', looking for }\n", src.c_str());
LOG(ERROR) << "unexpected end of string in '" << src << "', looking for }";
return false;
}
prop_name = std::string(c, end);
@ -458,21 +460,19 @@ bool expand_props(const std::string& src, std::string* dst) {
}
} else {
prop_name = c;
ERROR("using deprecated syntax for specifying property '%s', use ${name} instead\n",
c);
LOG(ERROR) << "using deprecated syntax for specifying property '" << c << "', use ${name} instead";
c += prop_name.size();
}
if (prop_name.empty()) {
ERROR("invalid zero-length prop name in '%s'\n", src.c_str());
LOG(ERROR) << "invalid zero-length property name in '" << src << "'";
return false;
}
std::string prop_val = property_get(prop_name.c_str());
if (prop_val.empty()) {
if (def_val.empty()) {
ERROR("property '%s' doesn't exist while expanding '%s'\n",
prop_name.c_str(), src.c_str());
LOG(ERROR) << "property '" << prop_name << "' doesn't exist while expanding '" << src << "'";
return false;
}
prop_val = def_val;

2
init/util.h
View file

@ -23,8 +23,6 @@
#include <string>
#include <functional>
#define ARRAY_SIZE(x) (sizeof(x)/sizeof((x)[0]))
#define COLDBOOT_DONE "/dev/.coldboot_done"
int create_socket(const char *name, int type, mode_t perm,

18
init/watchdogd.cpp
View file

@ -29,8 +29,7 @@
int watchdogd_main(int argc, char **argv) {
open_devnull_stdio();
klog_init();
klog_set_level(KLOG_NOTICE_LEVEL);
InitKernelLogging(argv);
int interval = 10;
if (argc >= 2) interval = atoi(argv[1]);
@ -38,30 +37,31 @@ int watchdogd_main(int argc, char **argv) {
int margin = 10;
if (argc >= 3) margin = atoi(argv[2]);
NOTICE("started (interval %d, margin %d)!\n", interval, margin);
LOG(INFO) << "watchdogd started (interval " << interval << ", margin " << margin << ")!";
int fd = open(DEV_NAME, O_RDWR|O_CLOEXEC);
if (fd == -1) {
ERROR("Failed to open %s: %s\n", DEV_NAME, strerror(errno));
PLOG(ERROR) << "Failed to open " << DEV_NAME;
return 1;
}
int timeout = interval + margin;
int ret = ioctl(fd, WDIOC_SETTIMEOUT, &timeout);
if (ret) {
ERROR("Failed to set timeout to %d: %s\n", timeout, strerror(errno));
PLOG(ERROR) << "Failed to set timeout to " << timeout;
ret = ioctl(fd, WDIOC_GETTIMEOUT, &timeout);
if (ret) {
ERROR("Failed to get timeout: %s\n", strerror(errno));
PLOG(ERROR) << "Failed to get timeout";
} else {
if (timeout > margin) {
interval = timeout - margin;
} else {
interval = 1;
}
WARNING("Adjusted interval to timeout returned by driver:"
" timeout %d, interval %d, margin %d\n",
timeout, interval, margin);
LOG(WARNING) << "Adjusted interval to timeout returned by driver: "
<< "timeout " << timeout
<< ", interval " << interval
<< ", margin " << margin;
}
}