Merge "Even moar refactoring..." (1a516bbd) · Commits · e / os / android_frameworks_native-old

cmds/dumpstate/Android.mk

+5 −4

Original line number	Diff line number	Diff line
		@@ -12,6 +12,7 @@ COMMON_ZIP_LIBRARIES := libziparchive libz libcrypto_static
		COMMON_LOCAL_CFLAGS := \
		-Wall -Werror -Wno-missing-field-initializers -Wno-unused-variable -Wunused-parameter
		COMMON_SRC_FILES := \
		DumpstateInternal.cpp \
		utils.cpp
		COMMON_SHARED_LIBRARIES := \
		android.hardware.dumpstate@1.0 \
		@@ -38,10 +39,10 @@ LOCAL_CFLAGS := $(COMMON_LOCAL_CFLAGS)
		LOCAL_C_INCLUDES := $(LOCAL_PATH)
		LOCAL_EXPORT_C_INCLUDE_DIRS := $(LOCAL_PATH)
		LOCAL_SRC_FILES := \
		utils.cpp # TODO: temporary, until functions are moved to DumpstateUtil.cpp
		# TODO: include just what it uses (libbase, libcutils, etc...) once split from utils.cpp
		LOCAL_SHARED_LIBRARIES := $(COMMON_SHARED_LIBRARIES)
		LOCAL_STATIC_LIBRARIES := $(COMMON_ZIP_LIBRARIES)
		DumpstateInternal.cpp \
		DumpstateUtil.cpp
		LOCAL_SHARED_LIBRARIES := \
		libbase

		include $(BUILD_STATIC_LIBRARY)

cmds/dumpstate/DumpstateInternal.cpp

0 → 100644

+162 −0

Original line number	Diff line number	Diff line
		/*
		* Copyright (C) 2016 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.
		*/

		#define LOG_TAG "dumpstate"

		#include "DumpstateInternal.h"

		#include <stdint.h>
		#include <stdio.h>
		#include <string.h>
		#include <sys/capability.h>
		#include <sys/prctl.h>
		#include <sys/stat.h>
		#include <sys/types.h>

		#include <cstdint>
		#include <string>
		#include <vector>

		#include <android-base/file.h>
		#include <cutils/log.h>
		#include <private/android_filesystem_config.h>

		uint64_t Nanotime() {
		timespec ts;
		clock_gettime(CLOCK_MONOTONIC, &ts);
		return static_cast<uint64_t>(ts.tv_sec * NANOS_PER_SEC + ts.tv_nsec);
		}

		// Switches to non-root user and group.
		bool DropRootUser() {
		if (getgid() == AID_SHELL && getuid() == AID_SHELL) {
		MYLOGD("drop_root_user(): already running as Shell\n");
		return true;
		}
		/* ensure we will keep capabilities when we drop root */
		if (prctl(PR_SET_KEEPCAPS, 1) < 0) {
		MYLOGE("prctl(PR_SET_KEEPCAPS) failed: %s\n", strerror(errno));
		return false;
		}

		gid_t groups[] = {AID_LOG, AID_SDCARD_R, AID_SDCARD_RW, AID_MOUNT, AID_INET,
		AID_NET_BW_STATS, AID_READPROC, AID_WAKELOCK, AID_BLUETOOTH};
		if (setgroups(sizeof(groups) / sizeof(groups[0]), groups) != 0) {
		MYLOGE("Unable to setgroups, aborting: %s\n", strerror(errno));
		return false;
		}
		if (setgid(AID_SHELL) != 0) {
		MYLOGE("Unable to setgid, aborting: %s\n", strerror(errno));
		return false;
		}
		if (setuid(AID_SHELL) != 0) {
		MYLOGE("Unable to setuid, aborting: %s\n", strerror(errno));
		return false;
		}

		struct __user_cap_header_struct capheader;
		struct __user_cap_data_struct capdata[2];
		memset(&capheader, 0, sizeof(capheader));
		memset(&capdata, 0, sizeof(capdata));
		capheader.version = _LINUX_CAPABILITY_VERSION_3;
		capheader.pid = 0;

		capdata[CAP_TO_INDEX(CAP_SYSLOG)].permitted =
		(CAP_TO_MASK(CAP_SYSLOG) \| CAP_TO_MASK(CAP_BLOCK_SUSPEND));
		capdata[CAP_TO_INDEX(CAP_SYSLOG)].effective =
		(CAP_TO_MASK(CAP_SYSLOG) \| CAP_TO_MASK(CAP_BLOCK_SUSPEND));
		capdata[0].inheritable = 0;
		capdata[1].inheritable = 0;

		if (capset(&capheader, &capdata[0]) < 0) {
		MYLOGE("capset failed: %s\n", strerror(errno));
		return false;
		}

		return true;
		}

		int DumpFileFromFdToFd(const std::string& title, const std::string& path_string, int fd, int out_fd,
		bool dry_run) {
		const char* path = path_string.c_str();
		if (!title.empty()) {
		dprintf(out_fd, "------ %s (%s", title.c_str(), path);

		struct stat st;
		// Only show the modification time of non-device files.
		size_t path_len = strlen(path);
		if ((path_len < 6 \|\| memcmp(path, "/proc/", 6)) &&
		(path_len < 5 \|\| memcmp(path, "/sys/", 5)) &&
		(path_len < 3 \|\| memcmp(path, "/d/", 3)) && !fstat(fd, &st)) {
		char stamp[80];
		time_t mtime = st.st_mtime;
		strftime(stamp, sizeof(stamp), "%Y-%m-%d %H:%M:%S", localtime(&mtime));
		dprintf(out_fd, ": %s", stamp);
		}
		dprintf(out_fd, ") ------\n");
		fsync(out_fd);
		}
		if (dry_run) {
		if (out_fd != STDOUT_FILENO) {
		// There is no title, but we should still print a dry-run message
		dprintf(out_fd, "%s: skipped on dry run\n", path);
		} else if (!title.empty()) {
		dprintf(out_fd, "\t(skipped on dry run)\n");
		}
		fsync(out_fd);
		return 0;
		}
		bool newline = false;
		fd_set read_set;
		timeval tm;
		while (true) {
		FD_ZERO(&read_set);
		FD_SET(fd, &read_set);
		/* Timeout if no data is read for 30 seconds. */
		tm.tv_sec = 30;
		tm.tv_usec = 0;
		uint64_t elapsed = Nanotime();
		int ret = TEMP_FAILURE_RETRY(select(fd + 1, &read_set, nullptr, nullptr, &tm));
		if (ret == -1) {
		dprintf(out_fd, "*** %s: select failed: %s\n", path, strerror(errno));
		newline = true;
		break;
		} else if (ret == 0) {
		elapsed = Nanotime() - elapsed;
		dprintf(out_fd, "*** %s: Timed out after %.3fs\n", path, (float)elapsed / NANOS_PER_SEC);
		newline = true;
		break;
		} else {
		char buffer[65536];
		ssize_t bytes_read = TEMP_FAILURE_RETRY(read(fd, buffer, sizeof(buffer)));
		if (bytes_read > 0) {
		android::base::WriteFully(out_fd, buffer, bytes_read);
		newline = (buffer[bytes_read - 1] == '\n');
		} else {
		if (bytes_read == -1) {
		dprintf(out_fd, "*** %s: Failed to read from fd: %s", path, strerror(errno));
		newline = true;
		}
		break;
		}
		}
		}
		close(fd);

		if (!newline) dprintf(out_fd, "\n");
		if (!title.empty()) dprintf(out_fd, "\n");
		return 0;
		}

cmds/dumpstate/DumpstateInternal.h

0 → 100644

+55 −0

Original line number	Diff line number	Diff line
		/*
		* Copyright (C) 2016 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.
		*/
		#ifndef FRAMEWORK_NATIVE_CMD_DUMPSTATE_INTERNAL_H_
		#define FRAMEWORK_NATIVE_CMD_DUMPSTATE_INTERNAL_H_

		#include <cstdint>
		#include <string>

		// TODO: rename macros to DUMPSTATE_LOGXXX
		#ifndef MYLOGD
		#define MYLOGD(...) \
		fprintf(stderr, __VA_ARGS__); \
		ALOGD(__VA_ARGS__);
		#endif

		#ifndef MYLOGI
		#define MYLOGI(...) \
		fprintf(stderr, __VA_ARGS__); \
		ALOGI(__VA_ARGS__);
		#endif

		#ifndef MYLOGE
		#define MYLOGE(...) \
		fprintf(stderr, __VA_ARGS__); \
		ALOGE(__VA_ARGS__);
		#endif

		// Internal functions used by .cpp files on multiple build targets.
		// TODO: move to android::os::dumpstate::internal namespace

		// TODO: use functions from <chrono> instead
		const uint64_t NANOS_PER_SEC = 1000000000;
		uint64_t Nanotime();

		// Switches to non-root user and group.
		bool DropRootUser();

		// TODO: move to .cpp as static once is not used by utils.cpp anymore.
		int DumpFileFromFdToFd(const std::string& title, const std::string& path_string, int fd, int out_fd,
		bool dry_run = false);

		#endif // FRAMEWORK_NATIVE_CMD_DUMPSTATE_INTERNAL_H_

cmds/dumpstate/DumpstateService.cpp

+2 −0

Original line number	Diff line number	Diff line
		@@ -22,6 +22,8 @@

		#include "android/os/BnDumpstate.h"

		#include "DumpstateInternal.h"

		namespace android {
		namespace os {

cmds/dumpstate/DumpstateUtil.cpp

0 → 100644

+344 −0

Original line number	Diff line number	Diff line
		/*
		* Copyright (C) 2016 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.
		*/

		#define LOG_TAG "dumpstate"

		#include "DumpstateUtil.h"

		#include <fcntl.h>
		#include <sys/prctl.h>
		#include <sys/wait.h>
		#include <unistd.h>

		#include <vector>

		#include <android-base/properties.h>
		#include <cutils/log.h>

		#include "DumpstateInternal.h"

		// TODO: move to unnamed namespace
		static constexpr const char* kSuPath = "/system/xbin/su";

		// TODO: move to unnamed namespace
		static bool waitpid_with_timeout(pid_t pid, int timeout_seconds, int* status) {
		sigset_t child_mask, old_mask;
		sigemptyset(&child_mask);
		sigaddset(&child_mask, SIGCHLD);

		if (sigprocmask(SIG_BLOCK, &child_mask, &old_mask) == -1) {
		printf("*** sigprocmask failed: %s\n", strerror(errno));
		return false;
		}

		timespec ts;
		ts.tv_sec = timeout_seconds;
		ts.tv_nsec = 0;
		int ret = TEMP_FAILURE_RETRY(sigtimedwait(&child_mask, NULL, &ts));
		int saved_errno = errno;
		// Set the signals back the way they were.
		if (sigprocmask(SIG_SETMASK, &old_mask, NULL) == -1) {
		printf("*** sigprocmask failed: %s\n", strerror(errno));
		if (ret == 0) {
		return false;
		}
		}
		if (ret == -1) {
		errno = saved_errno;
		if (errno == EAGAIN) {
		errno = ETIMEDOUT;
		} else {
		printf("*** sigtimedwait failed: %s\n", strerror(errno));
		}
		return false;
		}

		pid_t child_pid = waitpid(pid, status, WNOHANG);
		if (child_pid != pid) {
		if (child_pid != -1) {
		printf("*** Waiting for pid %d, got pid %d instead\n", pid, child_pid);
		} else {
		printf("*** waitpid failed: %s\n", strerror(errno));
		}
		return false;
		}
		return true;
		}

		CommandOptions CommandOptions::DEFAULT = CommandOptions::WithTimeout(10).Build();
		CommandOptions CommandOptions::AS_ROOT = CommandOptions::WithTimeout(10).AsRoot().Build();
		CommandOptions CommandOptions::AS_ROOT_5 = CommandOptions::WithTimeout(5).AsRoot().Build();

		CommandOptions::CommandOptionsBuilder::CommandOptionsBuilder(int64_t timeout) : values(timeout) {
		}

		CommandOptions::CommandOptionsBuilder& CommandOptions::CommandOptionsBuilder::Always() {
		values.always_ = true;
		return *this;
		}

		CommandOptions::CommandOptionsBuilder& CommandOptions::CommandOptionsBuilder::AsRoot() {
		values.account_mode_ = SU_ROOT;
		return *this;
		}

		CommandOptions::CommandOptionsBuilder& CommandOptions::CommandOptionsBuilder::DropRoot() {
		values.account_mode_ = DROP_ROOT;
		return *this;
		}

		CommandOptions::CommandOptionsBuilder& CommandOptions::CommandOptionsBuilder::RedirectStderr() {
		values.output_mode_ = REDIRECT_TO_STDERR;
		return *this;
		}

		CommandOptions::CommandOptionsBuilder& CommandOptions::CommandOptionsBuilder::Log(
		const std::string& message) {
		values.logging_message_ = message;
		return *this;
		}

		CommandOptions CommandOptions::CommandOptionsBuilder::Build() {
		return CommandOptions(values);
		}

		CommandOptions::CommandOptionsValues::CommandOptionsValues(int64_t timeout)
		: timeout_(timeout),
		always_(false),
		account_mode_(DONT_DROP_ROOT),
		output_mode_(NORMAL_OUTPUT),
		logging_message_("") {
		}

		CommandOptions::CommandOptions(const CommandOptionsValues& values) : values(values) {
		}

		int64_t CommandOptions::Timeout() const {
		return values.timeout_;
		}

		bool CommandOptions::Always() const {
		return values.always_;
		}

		PrivilegeMode CommandOptions::PrivilegeMode() const {
		return values.account_mode_;
		}

		OutputMode CommandOptions::OutputMode() const {
		return values.output_mode_;
		}

		std::string CommandOptions::LoggingMessage() const {
		return values.logging_message_;
		}

		CommandOptions::CommandOptionsBuilder CommandOptions::WithTimeout(int64_t timeout) {
		return CommandOptions::CommandOptionsBuilder(timeout);
		}

		std::string PropertiesHelper::build_type_ = "";
		int PropertiesHelper::dry_run_ = -1;

		bool PropertiesHelper::IsUserBuild() {
		if (build_type_.empty()) {
		build_type_ = android::base::GetProperty("ro.build.type", "user");
		}
		return "user" == build_type_;
		}

		bool PropertiesHelper::IsDryRun() {
		if (dry_run_ == -1) {
		dry_run_ = android::base::GetBoolProperty("dumpstate.dry_run", false) ? 1 : 0;
		}
		return dry_run_ == 1;
		}

		int DumpFileToFd(int out_fd, const std::string& title, const std::string& path) {
		int fd = TEMP_FAILURE_RETRY(open(path.c_str(), O_RDONLY \| O_NONBLOCK \| O_CLOEXEC));
		if (fd < 0) {
		int err = errno;
		if (title.empty()) {
		dprintf(out_fd, "*** Error dumping %s: %s\n", path.c_str(), strerror(err));
		} else {
		dprintf(out_fd, "*** Error dumping %s (%s): %s\n", path.c_str(), title.c_str(),
		strerror(err));
		}
		fsync(out_fd);
		return -1;
		}
		return DumpFileFromFdToFd(title, path, fd, out_fd, PropertiesHelper::IsDryRun());
		}

		int RunCommandToFd(int fd, const std::string& title, const std::vector<std::string>& full_command,
		const CommandOptions& options) {
		if (full_command.empty()) {
		MYLOGE("No arguments on RunCommandToFd(%s)\n", title.c_str());
		return -1;
		}

		int size = full_command.size() + 1; // null terminated
		int starting_index = 0;
		if (options.PrivilegeMode() == SU_ROOT) {
		starting_index = 2; // "su" "root"
		size += starting_index;
		}

		std::vector<const char*> args;
		args.resize(size);

		std::string command_string;
		if (options.PrivilegeMode() == SU_ROOT) {
		args[0] = kSuPath;
		command_string += kSuPath;
		args[1] = "root";
		command_string += " root ";
		}
		for (size_t i = 0; i < full_command.size(); i++) {
		args[i + starting_index] = full_command[i].data();
		command_string += args[i + starting_index];
		if (i != full_command.size() - 1) {
		command_string += " ";
		}
		}
		args[size - 1] = nullptr;

		const char* command = command_string.c_str();

		if (options.PrivilegeMode() == SU_ROOT && PropertiesHelper::IsUserBuild()) {
		dprintf(fd, "Skipping '%s' on user build.\n", command);
		return 0;
		}

		if (!title.empty()) {
		dprintf(fd, "------ %s (%s) ------\n", title.c_str(), command);
		fsync(fd);
		}

		const std::string& logging_message = options.LoggingMessage();
		if (!logging_message.empty()) {
		MYLOGI(logging_message.c_str(), command_string.c_str());
		}

		bool silent = (options.OutputMode() == REDIRECT_TO_STDERR);
		bool redirecting_to_fd = STDOUT_FILENO != fd;

		if (PropertiesHelper::IsDryRun() && !options.Always()) {
		if (!title.empty()) {
		dprintf(fd, "\t(skipped on dry run)\n");
		} else if (redirecting_to_fd) {
		// There is no title, but we should still print a dry-run message
		dprintf(fd, "%s: skipped on dry run\n", command_string.c_str());
		}
		fsync(fd);
		return 0;
		}

		const char* path = args[0];

		uint64_t start = Nanotime();
		pid_t pid = fork();

		/* handle error case */
		if (pid < 0) {
		if (!silent) dprintf(fd, "*** fork: %s\n", strerror(errno));
		MYLOGE("*** fork: %s\n", strerror(errno));
		return pid;
		}

		/* handle child case */
		if (pid == 0) {
		if (options.PrivilegeMode() == DROP_ROOT && !DropRootUser()) {
		if (!silent) {
		dprintf(fd, "*** failed to drop root before running %s: %s\n", command,
		strerror(errno));
		}
		MYLOGE("*** could not drop root before running %s: %s\n", command, strerror(errno));
		return -1;
		}

		if (silent) {
		// Redirects stdout to stderr
		TEMP_FAILURE_RETRY(dup2(STDERR_FILENO, STDOUT_FILENO));
		} else if (redirecting_to_fd) {
		// Redirect stdout to fd
		TEMP_FAILURE_RETRY(dup2(fd, STDOUT_FILENO));
		close(fd);
		}

		/* make sure the child dies when dumpstate dies */
		prctl(PR_SET_PDEATHSIG, SIGKILL);

		/* just ignore SIGPIPE, will go down with parent's */
		struct sigaction sigact;
		memset(&sigact, 0, sizeof(sigact));
		sigact.sa_handler = SIG_IGN;
		sigaction(SIGPIPE, &sigact, NULL);

		execvp(path, (char**)args.data());
		// execvp's result will be handled after waitpid_with_timeout() below, but
		// if it failed, it's safer to exit dumpstate.
		MYLOGD("execvp on command '%s' failed (error: %s)\n", command, strerror(errno));
		// Must call _exit (instead of exit), otherwise it will corrupt the zip
		// file.
		_exit(EXIT_FAILURE);
		}

		/* handle parent case */
		int status;
		bool ret = waitpid_with_timeout(pid, options.Timeout(), &status);
		fsync(fd);

		uint64_t elapsed = Nanotime() - start;
		if (!ret) {
		if (errno == ETIMEDOUT) {
		if (!silent)
		dprintf(fd, "*** command '%s' timed out after %.3fs (killing pid %d)\n", command,
		static_cast<float>(elapsed) / NANOS_PER_SEC, pid);
		MYLOGE("*** command '%s' timed out after %.3fs (killing pid %d)\n", command,
		static_cast<float>(elapsed) / NANOS_PER_SEC, pid);
		} else {
		if (!silent)
		dprintf(fd, "*** command '%s': Error after %.4fs (killing pid %d)\n", command,
		static_cast<float>(elapsed) / NANOS_PER_SEC, pid);
		MYLOGE("command '%s': Error after %.4fs (killing pid %d)\n", command,
		static_cast<float>(elapsed) / NANOS_PER_SEC, pid);
		}
		kill(pid, SIGTERM);
		if (!waitpid_with_timeout(pid, 5, nullptr)) {
		kill(pid, SIGKILL);
		if (!waitpid_with_timeout(pid, 5, nullptr)) {
		if (!silent)
		dprintf(fd, "could not kill command '%s' (pid %d) even with SIGKILL.\n",
		command, pid);
		MYLOGE("could not kill command '%s' (pid %d) even with SIGKILL.\n", command, pid);
		}
		}
		return -1;
		}

		if (WIFSIGNALED(status)) {
		if (!silent)
		dprintf(fd, "*** command '%s' failed: killed by signal %d\n", command, WTERMSIG(status));
		MYLOGE("*** command '%s' failed: killed by signal %d\n", command, WTERMSIG(status));
		} else if (WIFEXITED(status) && WEXITSTATUS(status) > 0) {
		status = WEXITSTATUS(status);
		if (!silent) dprintf(fd, "*** command '%s' failed: exit code %d\n", command, status);
		MYLOGE("*** command '%s' failed: exit code %d\n", command, status);
		}

		return status;
		}