Merge "Remove HOST_OS==windows check"
diff --git a/adb/Android.mk b/adb/Android.mk
index b228e86..b34a49f 100644
--- a/adb/Android.mk
+++ b/adb/Android.mk
@@ -132,7 +132,7 @@
LOCAL_SANITIZE := $(adb_target_sanitize)
LOCAL_STATIC_LIBRARIES := libadbd
-LOCAL_SHARED_LIBRARIES := liblog libbase libcutils
+LOCAL_SHARED_LIBRARIES := libbase libcutils
include $(BUILD_NATIVE_TEST)
# adb_test
@@ -147,7 +147,7 @@
LOCAL_SRC_FILES_linux := $(LIBADB_TEST_linux_SRCS)
LOCAL_SRC_FILES_darwin := $(LIBADB_TEST_darwin_SRCS)
LOCAL_SANITIZE := $(adb_host_sanitize)
-LOCAL_SHARED_LIBRARIES := liblog libbase
+LOCAL_SHARED_LIBRARIES := libbase
LOCAL_STATIC_LIBRARIES := \
libadb \
libcrypto_static \
@@ -171,7 +171,7 @@
LOCAL_CFLAGS_linux := $(LIBADB_linux_CFLAGS)
LOCAL_SRC_FILES := test_track_devices.cpp
LOCAL_SANITIZE := $(adb_host_sanitize)
-LOCAL_SHARED_LIBRARIES := liblog libbase
+LOCAL_SHARED_LIBRARIES := libbase
LOCAL_STATIC_LIBRARIES := libadb libcrypto_static libcutils
LOCAL_LDLIBS += -lrt -ldl -lpthread
include $(BUILD_HOST_EXECUTABLE)
@@ -246,6 +246,7 @@
framebuffer_service.cpp \
remount_service.cpp \
set_verity_enable_state_service.cpp \
+ shell_service.cpp \
LOCAL_CFLAGS := \
$(ADB_COMMON_CFLAGS) \
diff --git a/adb/adb.cpp b/adb/adb.cpp
index 14df8a1..0bd95a3 100644
--- a/adb/adb.cpp
+++ b/adb/adb.cpp
@@ -176,7 +176,8 @@
{"transport", TRACE_TRANSPORT},
{"jdwp", TRACE_JDWP},
{"services", TRACE_SERVICES},
- {"auth", TRACE_AUTH}};
+ {"auth", TRACE_AUTH},
+ {"shell", TRACE_SHELL}};
std::vector<std::string> elements = android::base::Split(trace_setting, " ");
for (const auto& elem : elements) {
@@ -1132,9 +1133,27 @@
}
if (!strcmp(service, "features")) {
- SendOkay(reply_fd);
- SendProtocolString(
- reply_fd, android::base::Join(supported_features(), '\n'));
+ std::string error_msg;
+ atransport* t = acquire_one_transport(kCsAny, type, serial, &error_msg);
+ if (t != nullptr) {
+ SendOkay(reply_fd, android::base::Join(t->features(), '\n'));
+ } else {
+ SendFail(reply_fd, error_msg);
+ }
+ return 0;
+ }
+
+ if (!strncmp(service, "check-feature:", strlen("check-feature:"))) {
+ std::string error_msg;
+ atransport* t = acquire_one_transport(kCsAny, type, serial, &error_msg);
+ if (t && t->CanUseFeature(service + strlen("check-feature:"))) {
+ // We could potentially extend this to reply with the feature
+ // version if that becomes necessary.
+ SendOkay(reply_fd, "1");
+ } else {
+ // Empty response means unsupported feature.
+ SendOkay(reply_fd, "");
+ }
return 0;
}
diff --git a/adb/adb_trace.h b/adb/adb_trace.h
index 67ee854..623108e 100644
--- a/adb/adb_trace.h
+++ b/adb/adb_trace.h
@@ -37,6 +37,7 @@
TRACE_SERVICES,
TRACE_AUTH,
TRACE_FDEVENT,
+ TRACE_SHELL
};
extern int adb_trace_mask;
diff --git a/adb/commandline.cpp b/adb/commandline.cpp
index 86f9263..8d50f46 100644
--- a/adb/commandline.cpp
+++ b/adb/commandline.cpp
@@ -931,6 +931,18 @@
return 0;
}
+// Disallow stdin, stdout, and stderr.
+static bool _is_valid_ack_reply_fd(const int ack_reply_fd) {
+#ifdef _WIN32
+ const HANDLE ack_reply_handle = cast_int_to_handle(ack_reply_fd);
+ return (GetStdHandle(STD_INPUT_HANDLE) != ack_reply_handle) &&
+ (GetStdHandle(STD_OUTPUT_HANDLE) != ack_reply_handle) &&
+ (GetStdHandle(STD_ERROR_HANDLE) != ack_reply_handle);
+#else
+ return ack_reply_fd > 2;
+#endif
+}
+
int adb_commandline(int argc, const char **argv) {
int no_daemon = 0;
int is_daemon = 0;
@@ -980,14 +992,7 @@
argc--;
argv++;
ack_reply_fd = strtol(reply_fd_str, nullptr, 10);
-#ifdef _WIN32
- const HANDLE ack_reply_handle = cast_int_to_handle(ack_reply_fd);
- if ((GetStdHandle(STD_INPUT_HANDLE) == ack_reply_handle) ||
- (GetStdHandle(STD_OUTPUT_HANDLE) == ack_reply_handle) ||
- (GetStdHandle(STD_ERROR_HANDLE) == ack_reply_handle)) {
-#else
- if (ack_reply_fd <= 2) { // Disallow stdin, stdout, and stderr.
-#endif
+ if (!_is_valid_ack_reply_fd(ack_reply_fd)) {
fprintf(stderr, "adb: invalid reply fd \"%s\"\n", reply_fd_str);
return usage();
}
@@ -1444,7 +1449,7 @@
return 0;
}
else if (!strcmp(argv[0], "features")) {
- return adb_query_command("host:features");
+ return adb_query_command(format_host_command("features", transport_type, serial));
}
usage();
diff --git a/adb/services.cpp b/adb/services.cpp
index ac672f0..561431c 100644
--- a/adb/services.cpp
+++ b/adb/services.cpp
@@ -24,11 +24,6 @@
#include <stdlib.h>
#include <string.h>
-#if !ADB_HOST
-#include <pty.h>
-#include <termios.h>
-#endif
-
#ifndef _WIN32
#include <netdb.h>
#include <netinet/in.h>
@@ -51,6 +46,7 @@
#include "adb_utils.h"
#include "file_sync_service.h"
#include "remount_service.h"
+#include "shell_service.h"
#include "transport.h"
struct stinfo {
@@ -59,11 +55,6 @@
void *cookie;
};
-enum class SubprocessType {
- kPty,
- kRaw,
-};
-
void *service_bootstrap_func(void *x)
{
stinfo* sti = reinterpret_cast<stinfo*>(x);
@@ -234,211 +225,6 @@
return s[0];
}
-#if !ADB_HOST
-
-static void init_subproc_child()
-{
- setsid();
-
- // Set OOM score adjustment to prevent killing
- int fd = adb_open("/proc/self/oom_score_adj", O_WRONLY | O_CLOEXEC);
- if (fd >= 0) {
- adb_write(fd, "0", 1);
- adb_close(fd);
- } else {
- D("adb: unable to update oom_score_adj");
- }
-}
-
-#if !ADB_HOST
-static int create_subproc_pty(const char* cmd, const char* arg0,
- const char* arg1, pid_t* pid) {
- D("create_subproc_pty(cmd=%s, arg0=%s, arg1=%s)", cmd, arg0, arg1);
- char pts_name[PATH_MAX];
- int ptm;
- *pid = forkpty(&ptm, pts_name, nullptr, nullptr);
- if (*pid == -1) {
- printf("- fork failed: %s -\n", strerror(errno));
- unix_close(ptm);
- return -1;
- }
-
- if (*pid == 0) {
- init_subproc_child();
-
- int pts = unix_open(pts_name, O_RDWR | O_CLOEXEC);
- if (pts == -1) {
- fprintf(stderr, "child failed to open pseudo-term slave %s: %s\n",
- pts_name, strerror(errno));
- unix_close(ptm);
- exit(-1);
- }
-
- // arg0 is "-c" in batch mode and "-" in interactive mode.
- if (strcmp(arg0, "-c") == 0) {
- termios tattr;
- if (tcgetattr(pts, &tattr) == -1) {
- fprintf(stderr, "tcgetattr failed: %s\n", strerror(errno));
- unix_close(pts);
- unix_close(ptm);
- exit(-1);
- }
-
- cfmakeraw(&tattr);
- if (tcsetattr(pts, TCSADRAIN, &tattr) == -1) {
- fprintf(stderr, "tcsetattr failed: %s\n", strerror(errno));
- unix_close(pts);
- unix_close(ptm);
- exit(-1);
- }
- }
-
- dup2(pts, STDIN_FILENO);
- dup2(pts, STDOUT_FILENO);
- dup2(pts, STDERR_FILENO);
-
- unix_close(pts);
- unix_close(ptm);
-
- execl(cmd, cmd, arg0, arg1, nullptr);
- fprintf(stderr, "- exec '%s' failed: %s (%d) -\n",
- cmd, strerror(errno), errno);
- exit(-1);
- } else {
- return ptm;
- }
-}
-#endif // !ADB_HOST
-
-static int create_subproc_raw(const char *cmd, const char *arg0, const char *arg1, pid_t *pid)
-{
- D("create_subproc_raw(cmd=%s, arg0=%s, arg1=%s)", cmd, arg0, arg1);
-#if defined(_WIN32)
- fprintf(stderr, "error: create_subproc_raw not implemented on Win32 (%s %s %s)\n", cmd, arg0, arg1);
- return -1;
-#else
-
- // 0 is parent socket, 1 is child socket
- int sv[2];
- if (adb_socketpair(sv) < 0) {
- printf("[ cannot create socket pair - %s ]\n", strerror(errno));
- return -1;
- }
- D("socketpair: (%d,%d)", sv[0], sv[1]);
-
- *pid = fork();
- if (*pid < 0) {
- printf("- fork failed: %s -\n", strerror(errno));
- adb_close(sv[0]);
- adb_close(sv[1]);
- return -1;
- }
-
- if (*pid == 0) {
- adb_close(sv[0]);
- init_subproc_child();
-
- dup2(sv[1], STDIN_FILENO);
- dup2(sv[1], STDOUT_FILENO);
- dup2(sv[1], STDERR_FILENO);
-
- adb_close(sv[1]);
-
- execl(cmd, cmd, arg0, arg1, NULL);
- fprintf(stderr, "- exec '%s' failed: %s (%d) -\n",
- cmd, strerror(errno), errno);
- exit(-1);
- } else {
- adb_close(sv[1]);
- return sv[0];
- }
-#endif /* !defined(_WIN32) */
-}
-#endif /* !ABD_HOST */
-
-#if ADB_HOST
-#define SHELL_COMMAND "/bin/sh"
-#else
-#define SHELL_COMMAND "/system/bin/sh"
-#endif
-
-#if !ADB_HOST
-static void subproc_waiter_service(int fd, void *cookie)
-{
- pid_t pid = (pid_t) (uintptr_t) cookie;
-
- D("entered. fd=%d of pid=%d", fd, pid);
- while (true) {
- int status;
- pid_t p = waitpid(pid, &status, 0);
- if (p == pid) {
- D("fd=%d, post waitpid(pid=%d) status=%04x", fd, p, status);
- if (WIFSIGNALED(status)) {
- D("*** Killed by signal %d", WTERMSIG(status));
- break;
- } else if (!WIFEXITED(status)) {
- D("*** Didn't exit!!. status %d", status);
- break;
- } else if (WEXITSTATUS(status) >= 0) {
- D("*** Exit code %d", WEXITSTATUS(status));
- break;
- }
- }
- }
- D("shell exited fd=%d of pid=%d err=%d", fd, pid, errno);
- if (SHELL_EXIT_NOTIFY_FD >=0) {
- int res;
- res = WriteFdExactly(SHELL_EXIT_NOTIFY_FD, &fd, sizeof(fd)) ? 0 : -1;
- D("notified shell exit via fd=%d for pid=%d res=%d errno=%d",
- SHELL_EXIT_NOTIFY_FD, pid, res, errno);
- }
-}
-
-// Starts a subprocess and spawns a thread to wait for the subprocess to finish
-// and trigger the necessary cleanup.
-//
-// |name| is the command to execute in the subprocess; empty string will start
-// an interactive session.
-// |type| selects between a PTY or raw subprocess.
-//
-// Returns an open file descriptor tied to the subprocess stdin/stdout/stderr.
-static int create_subproc_thread(const char *name, SubprocessType type) {
- const char *arg0, *arg1;
- if (*name == '\0') {
- arg0 = "-";
- arg1 = nullptr;
- } else {
- arg0 = "-c";
- arg1 = name;
- }
-
- pid_t pid = -1;
- int ret_fd;
- if (type == SubprocessType::kPty) {
- ret_fd = create_subproc_pty(SHELL_COMMAND, arg0, arg1, &pid);
- } else {
- ret_fd = create_subproc_raw(SHELL_COMMAND, arg0, arg1, &pid);
- }
- D("create_subproc ret_fd=%d pid=%d", ret_fd, pid);
-
- stinfo* sti = reinterpret_cast<stinfo*>(malloc(sizeof(stinfo)));
- if(sti == 0) fatal("cannot allocate stinfo");
- sti->func = subproc_waiter_service;
- sti->cookie = (void*) (uintptr_t) pid;
- sti->fd = ret_fd;
-
- if (!adb_thread_create(service_bootstrap_func, sti)) {
- free(sti);
- adb_close(ret_fd);
- fprintf(stderr, "cannot create service thread\n");
- return -1;
- }
-
- D("service thread started, fd=%d pid=%d", ret_fd, pid);
- return ret_fd;
-}
-#endif
-
int service_to_fd(const char* name) {
int ret = -1;
@@ -483,13 +269,13 @@
const char* args = name + 6;
if (*args) {
// Non-interactive session uses a raw subprocess.
- ret = create_subproc_thread(args, SubprocessType::kRaw);
+ ret = StartSubprocess(args, SubprocessType::kRaw);
} else {
// Interactive session uses a PTY subprocess.
- ret = create_subproc_thread(args, SubprocessType::kPty);
+ ret = StartSubprocess(args, SubprocessType::kPty);
}
} else if(!strncmp(name, "exec:", 5)) {
- ret = create_subproc_thread(name + 5, SubprocessType::kRaw);
+ ret = StartSubprocess(name + 5, SubprocessType::kRaw);
} else if(!strncmp(name, "sync:", 5)) {
ret = create_service_thread(file_sync_service, NULL);
} else if(!strncmp(name, "remount:", 8)) {
@@ -503,11 +289,11 @@
} else if(!strncmp(name, "unroot:", 7)) {
ret = create_service_thread(restart_unroot_service, NULL);
} else if(!strncmp(name, "backup:", 7)) {
- ret = create_subproc_thread(android::base::StringPrintf("/system/bin/bu backup %s",
- (name + 7)).c_str(),
- SubprocessType::kRaw);
+ ret = StartSubprocess(android::base::StringPrintf("/system/bin/bu backup %s",
+ (name + 7)).c_str(),
+ SubprocessType::kRaw);
} else if(!strncmp(name, "restore:", 8)) {
- ret = create_subproc_thread("/system/bin/bu restore", SubprocessType::kRaw);
+ ret = StartSubprocess("/system/bin/bu restore", SubprocessType::kRaw);
} else if(!strncmp(name, "tcpip:", 6)) {
int port;
if (sscanf(name + 6, "%d", &port) != 1) {
diff --git a/adb/shell_service.cpp b/adb/shell_service.cpp
new file mode 100644
index 0000000..5f80a59
--- /dev/null
+++ b/adb/shell_service.cpp
@@ -0,0 +1,329 @@
+/*
+ * Copyright (C) 2015 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 TRACE_TAG TRACE_SHELL
+
+#include "shell_service.h"
+
+#if !ADB_HOST
+
+#include <errno.h>
+#include <pty.h>
+#include <termios.h>
+
+#include <base/logging.h>
+#include <base/stringprintf.h>
+#include <paths.h>
+
+#include "adb.h"
+#include "adb_io.h"
+#include "adb_trace.h"
+#include "sysdeps.h"
+
+namespace {
+
+void init_subproc_child()
+{
+ setsid();
+
+ // Set OOM score adjustment to prevent killing
+ int fd = adb_open("/proc/self/oom_score_adj", O_WRONLY | O_CLOEXEC);
+ if (fd >= 0) {
+ adb_write(fd, "0", 1);
+ adb_close(fd);
+ } else {
+ D("adb: unable to update oom_score_adj");
+ }
+}
+
+// Reads from |fd| until close or failure.
+std::string ReadAll(int fd) {
+ char buffer[512];
+ std::string received;
+
+ while (1) {
+ int bytes = adb_read(fd, buffer, sizeof(buffer));
+ if (bytes <= 0) {
+ break;
+ }
+ received.append(buffer, bytes);
+ }
+
+ return received;
+}
+
+// Helper to automatically close an FD when it goes out of scope.
+class ScopedFd {
+ public:
+ ScopedFd() {}
+ ~ScopedFd() { Reset(); }
+
+ void Reset(int fd=-1) {
+ if (fd != fd_) {
+ if (valid()) {
+ adb_close(fd_);
+ }
+ fd_ = fd;
+ }
+ }
+
+ int Release() {
+ int temp = fd_;
+ fd_ = -1;
+ return temp;
+ }
+
+ bool valid() const { return fd_ >= 0; }
+
+ int fd() const { return fd_; }
+
+ private:
+ int fd_ = -1;
+
+ DISALLOW_COPY_AND_ASSIGN(ScopedFd);
+};
+
+// Creates a socketpair and saves the endpoints to |fd1| and |fd2|.
+bool CreateSocketpair(ScopedFd* fd1, ScopedFd* fd2) {
+ int sockets[2];
+ if (adb_socketpair(sockets) < 0) {
+ PLOG(ERROR) << "cannot create socket pair";
+ return false;
+ }
+ fd1->Reset(sockets[0]);
+ fd2->Reset(sockets[1]);
+ return true;
+}
+
+class Subprocess {
+ public:
+ Subprocess(const std::string& command, SubprocessType type);
+ ~Subprocess();
+
+ const std::string& command() const { return command_; }
+ bool is_interactive() const { return command_.empty(); }
+
+ int local_socket_fd() const { return local_socket_sfd_.fd(); }
+
+ pid_t pid() const { return pid_; }
+
+ // Sets up FDs, forks a subprocess, starts the subprocess manager thread,
+ // and exec's the child. Returns false on failure.
+ bool ForkAndExec();
+
+ private:
+ // Opens the file at |pts_name|.
+ int OpenPtyChildFd(const char* pts_name, ScopedFd* error_sfd);
+
+ static void* ThreadHandler(void* userdata);
+ void WaitForExit();
+
+ const std::string command_;
+ SubprocessType type_;
+
+ pid_t pid_ = -1;
+ ScopedFd local_socket_sfd_;
+
+ DISALLOW_COPY_AND_ASSIGN(Subprocess);
+};
+
+Subprocess::Subprocess(const std::string& command, SubprocessType type)
+ : command_(command), type_(type) {
+}
+
+Subprocess::~Subprocess() {
+}
+
+bool Subprocess::ForkAndExec() {
+ ScopedFd parent_sfd, child_sfd, parent_error_sfd, child_error_sfd;
+ char pts_name[PATH_MAX];
+
+ // Create a socketpair for the fork() child to report any errors back to
+ // the parent. Since we use threads, logging directly from the child could
+ // create a race condition.
+ if (!CreateSocketpair(&parent_error_sfd, &child_error_sfd)) {
+ LOG(ERROR) << "failed to create pipe for subprocess error reporting";
+ }
+
+ if (type_ == SubprocessType::kPty) {
+ int fd;
+ pid_ = forkpty(&fd, pts_name, nullptr, nullptr);
+ parent_sfd.Reset(fd);
+ } else {
+ if (!CreateSocketpair(&parent_sfd, &child_sfd)) {
+ return false;
+ }
+ pid_ = fork();
+ }
+
+ if (pid_ == -1) {
+ PLOG(ERROR) << "fork failed";
+ return false;
+ }
+
+ if (pid_ == 0) {
+ // Subprocess child.
+ init_subproc_child();
+
+ if (type_ == SubprocessType::kPty) {
+ child_sfd.Reset(OpenPtyChildFd(pts_name, &child_error_sfd));
+ }
+
+ dup2(child_sfd.fd(), STDIN_FILENO);
+ dup2(child_sfd.fd(), STDOUT_FILENO);
+ dup2(child_sfd.fd(), STDERR_FILENO);
+
+ // exec doesn't trigger destructors, close the FDs manually.
+ parent_sfd.Reset();
+ child_sfd.Reset();
+ parent_error_sfd.Reset();
+ close_on_exec(child_error_sfd.fd());
+
+ if (is_interactive()) {
+ execl(_PATH_BSHELL, _PATH_BSHELL, "-", nullptr);
+ } else {
+ execl(_PATH_BSHELL, _PATH_BSHELL, "-c", command_.c_str(), nullptr);
+ }
+ WriteFdExactly(child_error_sfd.fd(), "exec '" _PATH_BSHELL "' failed");
+ child_error_sfd.Reset();
+ exit(-1);
+ }
+
+ // Subprocess parent.
+ D("subprocess parent: subprocess FD = %d", parent_sfd.fd());
+
+ // Wait to make sure the subprocess exec'd without error.
+ child_error_sfd.Reset();
+ std::string error_message = ReadAll(parent_error_sfd.fd());
+ if (!error_message.empty()) {
+ LOG(ERROR) << error_message;
+ return false;
+ }
+
+ local_socket_sfd_.Reset(parent_sfd.Release());
+
+ if (!adb_thread_create(ThreadHandler, this)) {
+ PLOG(ERROR) << "failed to create subprocess thread";
+ return false;
+ }
+
+ return true;
+}
+
+int Subprocess::OpenPtyChildFd(const char* pts_name, ScopedFd* error_sfd) {
+ int child_fd = adb_open(pts_name, O_RDWR | O_CLOEXEC);
+ if (child_fd == -1) {
+ // Don't use WriteFdFmt; since we're in the fork() child we don't want
+ // to allocate any heap memory to avoid race conditions.
+ const char* messages[] = {"child failed to open pseudo-term slave ",
+ pts_name, ": ", strerror(errno)};
+ for (const char* message : messages) {
+ WriteFdExactly(error_sfd->fd(), message);
+ }
+ exit(-1);
+ }
+
+ if (!is_interactive()) {
+ termios tattr;
+ if (tcgetattr(child_fd, &tattr) == -1) {
+ WriteFdExactly(error_sfd->fd(), "tcgetattr failed");
+ exit(-1);
+ }
+
+ cfmakeraw(&tattr);
+ if (tcsetattr(child_fd, TCSADRAIN, &tattr) == -1) {
+ WriteFdExactly(error_sfd->fd(), "tcsetattr failed");
+ exit(-1);
+ }
+ }
+
+ return child_fd;
+}
+
+void* Subprocess::ThreadHandler(void* userdata) {
+ Subprocess* subprocess = reinterpret_cast<Subprocess*>(userdata);
+
+ adb_thread_setname(android::base::StringPrintf(
+ "shell srvc %d", subprocess->local_socket_fd()));
+
+ subprocess->WaitForExit();
+
+ D("deleting Subprocess");
+ delete subprocess;
+
+ return nullptr;
+}
+
+void Subprocess::WaitForExit() {
+ D("waiting for pid %d", pid_);
+ while (true) {
+ int status;
+ if (pid_ == waitpid(pid_, &status, 0)) {
+ D("post waitpid (pid=%d) status=%04x", pid_, status);
+ if (WIFSIGNALED(status)) {
+ D("subprocess killed by signal %d", WTERMSIG(status));
+ break;
+ } else if (!WIFEXITED(status)) {
+ D("subprocess didn't exit");
+ break;
+ } else if (WEXITSTATUS(status) >= 0) {
+ D("subprocess exit code = %d", WEXITSTATUS(status));
+ break;
+ }
+ }
+ }
+
+ // Pass the local socket FD to the shell cleanup fdevent.
+ if (SHELL_EXIT_NOTIFY_FD >= 0) {
+ int fd = local_socket_sfd_.fd();
+ if (WriteFdExactly(SHELL_EXIT_NOTIFY_FD, &fd, sizeof(fd))) {
+ D("passed fd %d to SHELL_EXIT_NOTIFY_FD (%d) for pid %d",
+ fd, SHELL_EXIT_NOTIFY_FD, pid_);
+ // The shell exit fdevent now owns the FD and will close it once
+ // the last bit of data flushes through.
+ local_socket_sfd_.Release();
+ } else {
+ PLOG(ERROR) << "failed to write fd " << fd
+ << " to SHELL_EXIT_NOTIFY_FD (" << SHELL_EXIT_NOTIFY_FD
+ << ") for pid " << pid_;
+ }
+ }
+}
+
+} // namespace
+
+int StartSubprocess(const char *name, SubprocessType type) {
+ D("starting %s subprocess: '%s'",
+ type == SubprocessType::kRaw ? "raw" : "PTY", name);
+
+ Subprocess* subprocess = new Subprocess(name, type);
+ if (!subprocess) {
+ LOG(ERROR) << "failed to allocate new subprocess";
+ return -1;
+ }
+
+ if (!subprocess->ForkAndExec()) {
+ LOG(ERROR) << "failed to start subprocess";
+ delete subprocess;
+ return -1;
+ }
+
+ D("subprocess creation successful: local_socket_fd=%d, pid=%d",
+ subprocess->local_socket_fd(), subprocess->pid());
+ return subprocess->local_socket_fd();
+}
+
+#endif // !ADB_HOST
diff --git a/adb/shell_service.h b/adb/shell_service.h
new file mode 100644
index 0000000..c2a048c
--- /dev/null
+++ b/adb/shell_service.h
@@ -0,0 +1,35 @@
+/*
+ * Copyright (C) 2015 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 SHELL_SERVICE_H_
+#define SHELL_SERVICE_H_
+
+#if !ADB_HOST
+
+enum class SubprocessType {
+ kPty,
+ kRaw,
+};
+
+// Forks and starts a new shell subprocess. If |name| is empty an interactive
+// shell is started, otherwise |name| is executed non-interactively.
+//
+// Returns an open FD connected to the subprocess or -1 on failure.
+int StartSubprocess(const char* name, SubprocessType type);
+
+#endif // !ADB_HOST
+
+#endif // SHELL_SERVICE_H_
diff --git a/fs_mgr/Android.mk b/fs_mgr/Android.mk
index 08d0671..cf2965e 100644
--- a/fs_mgr/Android.mk
+++ b/fs_mgr/Android.mk
@@ -3,13 +3,14 @@
LOCAL_PATH:= $(call my-dir)
include $(CLEAR_VARS)
-LOCAL_SRC_FILES:= fs_mgr.c fs_mgr_verity.c fs_mgr_fstab.c
+LOCAL_SRC_FILES:= fs_mgr.c fs_mgr_verity.c fs_mgr_fstab.c fs_mgr_slotselect.c
LOCAL_C_INCLUDES := $(LOCAL_PATH)/include
LOCAL_MODULE:= libfs_mgr
LOCAL_STATIC_LIBRARIES := liblogwrap libmincrypt libext4_utils_static libsquashfs_utils
-LOCAL_C_INCLUDES += system/extras/ext4_utils system/extras/squashfs_utils
+LOCAL_C_INCLUDES += system/extras/ext4_utils system/extras/squashfs_utils \
+ bootable/recovery
LOCAL_EXPORT_C_INCLUDE_DIRS := $(LOCAL_PATH)/include
LOCAL_CFLAGS := -Werror
diff --git a/fs_mgr/fs_mgr_fstab.c b/fs_mgr/fs_mgr_fstab.c
index d77d41f..3379deb 100644
--- a/fs_mgr/fs_mgr_fstab.c
+++ b/fs_mgr/fs_mgr_fstab.c
@@ -20,8 +20,6 @@
#include <string.h>
#include <sys/mount.h>
-#include <cutils/properties.h>
-
#include "fs_mgr_priv.h"
struct fs_mgr_flag_values {
@@ -310,25 +308,12 @@
fstab->recs[cnt].partnum = flag_vals.partnum;
fstab->recs[cnt].swap_prio = flag_vals.swap_prio;
fstab->recs[cnt].zram_size = flag_vals.zram_size;
-
- /* If an A/B partition, modify block device to be the real block device */
- if (fstab->recs[cnt].fs_mgr_flags & MF_SLOTSELECT) {
- char propbuf[PROPERTY_VALUE_MAX];
- char *tmp;
-
- /* use the kernel parameter if set */
- property_get("ro.boot.slot_suffix", propbuf, "");
-
- if (asprintf(&tmp, "%s%s", fstab->recs[cnt].blk_device, propbuf) > 0) {
- free(fstab->recs[cnt].blk_device);
- fstab->recs[cnt].blk_device = tmp;
- } else {
- ERROR("Error updating block device name\n");
- goto err;
- }
- }
cnt++;
}
+ /* If an A/B partition, modify block device to be the real block device */
+ if (fs_mgr_update_for_slotselect(fstab) != 0) {
+ ERROR("Error updating for slotselect\n");
+ }
fclose(fstab_file);
free(line);
return fstab;
diff --git a/fs_mgr/fs_mgr_priv.h b/fs_mgr/fs_mgr_priv.h
index cc02bac..992b544 100644
--- a/fs_mgr/fs_mgr_priv.h
+++ b/fs_mgr/fs_mgr_priv.h
@@ -82,6 +82,7 @@
#define DM_BUF_SIZE 4096
int fs_mgr_set_blk_ro(const char *blockdev);
+int fs_mgr_update_for_slotselect(struct fstab *fstab);
#endif /* __CORE_FS_MGR_PRIV_H */
diff --git a/fs_mgr/fs_mgr_slotselect.c b/fs_mgr/fs_mgr_slotselect.c
new file mode 100644
index 0000000..99dcd0e
--- /dev/null
+++ b/fs_mgr/fs_mgr_slotselect.c
@@ -0,0 +1,147 @@
+/*
+ * Copyright (C) 2015 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 <fcntl.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <unistd.h>
+
+#include <ctype.h>
+#include <errno.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include <cutils/properties.h>
+
+#include "fs_mgr.h"
+#include "fs_mgr_priv.h"
+
+#include "bootloader.h"
+
+// Copies slot_suffix from misc into |out_suffix|. Returns 0 on
+// success, -1 on error or if there is no non-empty slot_suffix.
+static int get_active_slot_suffix_from_misc(struct fstab *fstab,
+ char *out_suffix,
+ size_t suffix_len)
+{
+ int n;
+ int misc_fd;
+ ssize_t num_read;
+ struct bootloader_message msg;
+
+ misc_fd = -1;
+ for (n = 0; n < fstab->num_entries; n++) {
+ if (strcmp(fstab->recs[n].mount_point, "/misc") == 0) {
+ misc_fd = open(fstab->recs[n].blk_device, O_RDONLY);
+ if (misc_fd == -1) {
+ ERROR("Error opening misc partition \"%s\" (%s)\n",
+ fstab->recs[n].blk_device,
+ strerror(errno));
+ return -1;
+ } else {
+ break;
+ }
+ }
+ }
+
+ if (misc_fd == -1) {
+ ERROR("Error finding misc partition\n");
+ return -1;
+ }
+
+ num_read = TEMP_FAILURE_RETRY(read(misc_fd, &msg, sizeof(msg)));
+ // Linux will never return partial reads when reading from block
+ // devices so no need to worry about them.
+ if (num_read != sizeof(msg)) {
+ ERROR("Error reading bootloader_message (%s)\n", strerror(errno));
+ close(misc_fd);
+ return -1;
+ }
+ close(misc_fd);
+ if (msg.slot_suffix[0] == '\0')
+ return -1;
+ strncpy(out_suffix, msg.slot_suffix, suffix_len);
+ return 0;
+}
+
+// Gets slot_suffix from either the kernel cmdline / firmware, the
+// misc partition or built-in fallback.
+static void get_active_slot_suffix(struct fstab *fstab, char *out_suffix,
+ size_t suffix_len)
+{
+ char propbuf[PROPERTY_VALUE_MAX];
+
+ // Get the suffix from the kernel commandline (note that we don't
+ // allow the empty suffix). On bootloaders natively supporting A/B
+ // we'll hit this path every time so don't bother logging it.
+ property_get("ro.boot.slot_suffix", propbuf, "");
+ if (propbuf[0] != '\0') {
+ strncpy(out_suffix, propbuf, suffix_len);
+ return;
+ }
+
+ // If we couldn't get the suffix from the kernel cmdline, try the
+ // the misc partition.
+ if (get_active_slot_suffix_from_misc(fstab, out_suffix, suffix_len) == 0) {
+ INFO("Using slot suffix \"%s\" from misc\n", out_suffix);
+ return;
+ }
+
+ // If that didn't work, fall back to _a. The reasoning here is
+ // that since the fstab has the slotselect option set (otherwise
+ // we wouldn't end up here) we must assume that partitions are
+ // indeed set up for A/B. This corner-case is important because we
+ // may be on this codepath on newly provisioned A/B devices where
+ // misc isn't set up properly (it's just zeroes) and the
+ // bootloader does not (yet) natively support A/B.
+ //
+ // Why '_a'? Because that's what system/extras/boot_control_copy
+ // is using and since the bootloader isn't A/B aware we assume
+ // slots are set up this way.
+ WARNING("Could not determine slot suffix, falling back to \"_a\"\n");
+ strncpy(out_suffix, "_a", suffix_len);
+ return;
+}
+
+// Updates |fstab| for slot_suffix. Returns 0 on success, -1 on error.
+int fs_mgr_update_for_slotselect(struct fstab *fstab)
+{
+ int n;
+ char suffix[PROPERTY_VALUE_MAX];
+ int got_suffix = 0;
+
+ for (n = 0; n < fstab->num_entries; n++) {
+ if (fstab->recs[n].fs_mgr_flags & MF_SLOTSELECT) {
+ char *tmp;
+
+ if (!got_suffix) {
+ memset(suffix, '\0', sizeof(suffix));
+ get_active_slot_suffix(fstab, suffix, sizeof(suffix) - 1);
+ got_suffix = 1;
+ }
+
+ if (asprintf(&tmp, "%s%s", fstab->recs[n].blk_device,
+ suffix) > 0) {
+ free(fstab->recs[n].blk_device);
+ fstab->recs[n].blk_device = tmp;
+ } else {
+ return -1;
+ }
+ }
+ }
+ return 0;
+}
diff --git a/metricsd/Android.mk b/metricsd/Android.mk
index 12dfa18..c5d5281 100644
--- a/metricsd/Android.mk
+++ b/metricsd/Android.mk
@@ -113,7 +113,6 @@
LOCAL_EXPORT_C_INCLUDE_DIRS += \
$(generated_sources_dir)/proto/system/core/metricsd
LOCAL_SRC_FILES := $(call all-proto-files-under,uploader/proto)
-LOCAL_STATIC_LIBRARIES := libprotobuf-cpp-lite
include $(BUILD_STATIC_LIBRARY)
# metrics daemon.