Merge "Revert "Add BacktraceOffline for offline backtracing.""
diff --git a/adb/Android.mk b/adb/Android.mk
index 67c3eb7..5786d18 100644
--- a/adb/Android.mk
+++ b/adb/Android.mk
@@ -74,9 +74,11 @@
LIBADB_TEST_linux_SRCS := \
fdevent_test.cpp \
+ socket_test.cpp \
LIBADB_TEST_darwin_SRCS := \
fdevent_test.cpp \
+ socket_test.cpp \
LIBADB_TEST_windows_SRCS := \
sysdeps_win32_test.cpp \
@@ -132,8 +134,10 @@
LOCAL_SRC_FILES := \
$(LIBADB_TEST_SRCS) \
$(LIBADB_TEST_linux_SRCS) \
+ shell_service.cpp \
shell_service_protocol.cpp \
shell_service_protocol_test.cpp \
+ shell_service_test.cpp \
LOCAL_SANITIZE := $(adb_target_sanitize)
LOCAL_STATIC_LIBRARIES := libadbd
diff --git a/adb/adb.cpp b/adb/adb.cpp
index 0bd95a3..60966d6 100644
--- a/adb/adb.cpp
+++ b/adb/adb.cpp
@@ -162,6 +162,9 @@
// adbd's comes from the system property persist.adb.trace_mask.
static void setup_trace_mask() {
const std::string trace_setting = get_trace_setting();
+ if (trace_setting.empty()) {
+ return;
+ }
std::unordered_map<std::string, int> trace_flags = {
{"1", 0},
@@ -177,13 +180,14 @@
{"jdwp", TRACE_JDWP},
{"services", TRACE_SERVICES},
{"auth", TRACE_AUTH},
+ {"fdevent", TRACE_FDEVENT},
{"shell", TRACE_SHELL}};
std::vector<std::string> elements = android::base::Split(trace_setting, " ");
for (const auto& elem : elements) {
const auto& flag = trace_flags.find(elem);
if (flag == trace_flags.end()) {
- D("Unknown trace flag: %s", flag->first.c_str());
+ D("Unknown trace flag: %s", elem.c_str());
continue;
}
@@ -501,7 +505,7 @@
if (t->online && p->msg.arg0 != 0 && p->msg.arg1 == 0) {
char *name = (char*) p->data;
name[p->msg.data_length > 0 ? p->msg.data_length - 1 : 0] = 0;
- s = create_local_service_socket(name);
+ s = create_local_service_socket(name, t);
if(s == 0) {
send_close(0, p->msg.arg0, t);
} else {
@@ -581,15 +585,27 @@
#ifdef _WIN32
-static bool _make_handle_noninheritable(HANDLE h) {
+// Try to make a handle non-inheritable and if there is an error, don't output
+// any error info, but leave GetLastError() for the caller to read. This is
+// convenient if the caller is expecting that this may fail and they'd like to
+// ignore such a failure.
+static bool _try_make_handle_noninheritable(HANDLE h) {
if (h != INVALID_HANDLE_VALUE && h != NULL) {
- if (!SetHandleInformation(h, HANDLE_FLAG_INHERIT, 0)) {
- // Show the handle value to give us a clue in case we have problems
- // with pseudo-handle values.
- fprintf(stderr, "Cannot make handle 0x%p non-inheritable: %s\n",
- h, SystemErrorCodeToString(GetLastError()).c_str());
- return false;
- }
+ return SetHandleInformation(h, HANDLE_FLAG_INHERIT, 0) ? true : false;
+ }
+
+ return true;
+}
+
+// Try to make a handle non-inheritable with the expectation that this should
+// succeed, so if this fails, output error info.
+static bool _make_handle_noninheritable(HANDLE h) {
+ if (!_try_make_handle_noninheritable(h)) {
+ // Show the handle value to give us a clue in case we have problems
+ // with pseudo-handle values.
+ fprintf(stderr, "Cannot make handle 0x%p non-inheritable: %s\n",
+ h, SystemErrorCodeToString(GetLastError()).c_str());
+ return false;
}
return true;
@@ -741,16 +757,13 @@
* If we're still having problems with inheriting random handles in the
* future, consider using PROC_THREAD_ATTRIBUTE_HANDLE_LIST to explicitly
* specify which handles should be inherited: http://blogs.msdn.com/b/oldnewthing/archive/2011/12/16/10248328.aspx
+ *
+ * Older versions of Windows return console pseudo-handles that cannot be
+ * made non-inheritable, so ignore those failures.
*/
- if (!_make_handle_noninheritable(GetStdHandle(STD_INPUT_HANDLE))) {
- return -1;
- }
- if (!_make_handle_noninheritable(GetStdHandle(STD_OUTPUT_HANDLE))) {
- return -1;
- }
- if (!_make_handle_noninheritable(GetStdHandle(STD_ERROR_HANDLE))) {
- return -1;
- }
+ _try_make_handle_noninheritable(GetStdHandle(STD_INPUT_HANDLE));
+ _try_make_handle_noninheritable(GetStdHandle(STD_OUTPUT_HANDLE));
+ _try_make_handle_noninheritable(GetStdHandle(STD_ERROR_HANDLE));
STARTUPINFOW startup;
ZeroMemory( &startup, sizeof(startup) );
diff --git a/adb/adb.h b/adb/adb.h
index 8b3359e..037c010 100644
--- a/adb/adb.h
+++ b/adb/adb.h
@@ -26,6 +26,7 @@
#include "adb_trace.h"
#include "fdevent.h"
+#include "socket.h"
constexpr size_t MAX_PAYLOAD_V1 = 4 * 1024;
constexpr size_t MAX_PAYLOAD_V2 = 256 * 1024;
@@ -74,80 +75,6 @@
unsigned char data[MAX_PAYLOAD];
};
-/* An asocket represents one half of a connection between a local and
-** remote entity. A local asocket is bound to a file descriptor. A
-** remote asocket is bound to the protocol engine.
-*/
-struct asocket {
- /* chain pointers for the local/remote list of
- ** asockets that this asocket lives in
- */
- asocket *next;
- asocket *prev;
-
- /* the unique identifier for this asocket
- */
- unsigned id;
-
- /* flag: set when the socket's peer has closed
- ** but packets are still queued for delivery
- */
- int closing;
-
- /* flag: quit adbd when both ends close the
- ** local service socket
- */
- int exit_on_close;
-
- /* the asocket we are connected to
- */
-
- asocket *peer;
-
- /* For local asockets, the fde is used to bind
- ** us to our fd event system. For remote asockets
- ** these fields are not used.
- */
- fdevent fde;
- int fd;
-
- /* queue of apackets waiting to be written
- */
- apacket *pkt_first;
- apacket *pkt_last;
-
- /* enqueue is called by our peer when it has data
- ** for us. It should return 0 if we can accept more
- ** data or 1 if not. If we return 1, we must call
- ** peer->ready() when we once again are ready to
- ** receive data.
- */
- int (*enqueue)(asocket *s, apacket *pkt);
-
- /* ready is called by the peer when it is ready for
- ** us to send data via enqueue again
- */
- void (*ready)(asocket *s);
-
- /* shutdown is called by the peer before it goes away.
- ** the socket should not do any further calls on its peer.
- ** Always followed by a call to close. Optional, i.e. can be NULL.
- */
- void (*shutdown)(asocket *s);
-
- /* close is called by the peer when it has gone away.
- ** we are not allowed to make any further calls on the
- ** peer once our close method is called.
- */
- void (*close)(asocket *s);
-
- /* A socket is bound to atransport */
- atransport *transport;
-
- size_t get_max_payload() const;
-};
-
-
/* the adisconnect structure is used to record a callback that
** will be called whenever a transport is disconnected (e.g. by the user)
** this should be used to cleanup objects that depend on the
@@ -215,17 +142,7 @@
void print_packet(const char *label, apacket *p);
-asocket *find_local_socket(unsigned local_id, unsigned remote_id);
-void install_local_socket(asocket *s);
-void remove_socket(asocket *s);
-void close_all_sockets(atransport *t);
-asocket *create_local_socket(int fd);
-asocket *create_local_service_socket(const char *destination);
-
-asocket *create_remote_socket(unsigned id, atransport *t);
-void connect_to_remote(asocket *s, const char *destination);
-void connect_to_smartsocket(asocket *s);
void fatal(const char *fmt, ...) __attribute__((noreturn));
void fatal_errno(const char *fmt, ...) __attribute__((noreturn));
@@ -247,7 +164,7 @@
atransport* find_emulator_transport_by_adb_port(int adb_port);
#endif
-int service_to_fd(const char *name);
+int service_to_fd(const char* name, const atransport* transport);
#if ADB_HOST
asocket *host_service_to_socket(const char* name, const char *serial);
#endif
diff --git a/adb/commandline.cpp b/adb/commandline.cpp
index 8d50f46..d287480 100644
--- a/adb/commandline.cpp
+++ b/adb/commandline.cpp
@@ -31,8 +31,10 @@
#include <sys/stat.h>
#include <sys/types.h>
+#include <memory>
#include <string>
+#include <base/logging.h>
#include <base/stringprintf.h>
#if !defined(_WIN32)
@@ -46,6 +48,8 @@
#include "adb_io.h"
#include "adb_utils.h"
#include "file_sync_service.h"
+#include "shell_service.h"
+#include "transport.h"
static int install_app(TransportType t, const char* serial, int argc, const char** argv);
static int install_multiple_app(TransportType t, const char* serial, int argc, const char** argv);
@@ -256,19 +260,60 @@
}
#endif
-static void read_and_dump(int fd) {
+// Reads from |fd| and prints received data. If |use_shell_protocol| is true
+// this expects that incoming data will use the shell protocol, in which case
+// stdout/stderr are routed independently and the remote exit code will be
+// returned.
+static int read_and_dump(int fd, bool use_shell_protocol=false) {
+ int exit_code = 0;
+ std::unique_ptr<ShellProtocol> protocol;
+ int length = 0;
+ FILE* outfile = stdout;
+
+ char raw_buffer[BUFSIZ];
+ char* buffer_ptr = raw_buffer;
+ if (use_shell_protocol) {
+ protocol.reset(new ShellProtocol(fd));
+ if (!protocol) {
+ LOG(ERROR) << "failed to allocate memory for ShellProtocol object";
+ return 1;
+ }
+ buffer_ptr = protocol->data();
+ }
+
while (fd >= 0) {
- D("read_and_dump(): pre adb_read(fd=%d)", fd);
- char buf[BUFSIZ];
- int len = adb_read(fd, buf, sizeof(buf));
- D("read_and_dump(): post adb_read(fd=%d): len=%d", fd, len);
- if (len <= 0) {
- break;
+ if (use_shell_protocol) {
+ if (!protocol->Read()) {
+ break;
+ }
+ switch (protocol->id()) {
+ case ShellProtocol::kIdStdout:
+ outfile = stdout;
+ break;
+ case ShellProtocol::kIdStderr:
+ outfile = stderr;
+ break;
+ case ShellProtocol::kIdExit:
+ exit_code = protocol->data()[0];
+ continue;
+ default:
+ continue;
+ }
+ length = protocol->data_length();
+ } else {
+ D("read_and_dump(): pre adb_read(fd=%d)", fd);
+ length = adb_read(fd, raw_buffer, sizeof(raw_buffer));
+ D("read_and_dump(): post adb_read(fd=%d): length=%d", fd, length);
+ if (length <= 0) {
+ break;
+ }
}
- fwrite(buf, 1, len, stdout);
- fflush(stdout);
+ fwrite(buffer_ptr, 1, length, outfile);
+ fflush(outfile);
}
+
+ return exit_code;
}
static void read_status_line(int fd, char* buf, size_t count)
@@ -362,28 +407,41 @@
free(buf);
}
-static void *stdin_read_thread(void *x)
-{
- int fd, fdi;
- unsigned char buf[1024];
- int r, n;
- int state = 0;
+namespace {
- int *fds = (int*) x;
- fd = fds[0];
- fdi = fds[1];
- free(fds);
+// Used to pass multiple values to the stdin read thread.
+struct StdinReadArgs {
+ int stdin_fd, write_fd;
+ std::unique_ptr<ShellProtocol> protocol;
+};
+
+} // namespace
+
+// Loops to read from stdin and push the data to the given FD.
+// The argument should be a pointer to a StdinReadArgs object. This function
+// will take ownership of the object and delete it when finished.
+static void* stdin_read_thread(void* x) {
+ std::unique_ptr<StdinReadArgs> args(reinterpret_cast<StdinReadArgs*>(x));
+ int state = 0;
adb_thread_setname("stdin reader");
+ char raw_buffer[1024];
+ char* buffer_ptr = raw_buffer;
+ size_t buffer_size = sizeof(raw_buffer);
+ if (args->protocol) {
+ buffer_ptr = args->protocol->data();
+ buffer_size = args->protocol->data_capacity();
+ }
+
while (true) {
- /* fdi is really the client's stdin, so use read, not adb_read here */
- D("stdin_read_thread(): pre unix_read(fdi=%d,...)", fdi);
- r = unix_read(fdi, buf, 1024);
- D("stdin_read_thread(): post unix_read(fdi=%d,...)", fdi);
+ // Use unix_read() rather than adb_read() for stdin.
+ D("stdin_read_thread(): pre unix_read(fdi=%d,...)", args->stdin_fd);
+ int r = unix_read(args->stdin_fd, buffer_ptr, buffer_size);
+ D("stdin_read_thread(): post unix_read(fdi=%d,...)", args->stdin_fd);
if (r <= 0) break;
- for (n = 0; n < r; n++){
- switch(buf[n]) {
+ for (int n = 0; n < r; n++){
+ switch(buffer_ptr[n]) {
case '\n':
state = 1;
break;
@@ -396,47 +454,59 @@
case '.':
if(state == 2) {
fprintf(stderr,"\n* disconnect *\n");
- stdin_raw_restore(fdi);
+ stdin_raw_restore(args->stdin_fd);
exit(0);
}
default:
state = 0;
}
}
- r = adb_write(fd, buf, r);
- if(r <= 0) {
- break;
+ if (args->protocol) {
+ if (!args->protocol->Write(ShellProtocol::kIdStdin, r)) {
+ break;
+ }
+ } else {
+ if (!WriteFdExactly(args->write_fd, buffer_ptr, r)) {
+ break;
+ }
}
}
- return 0;
+
+ return nullptr;
}
-static int interactive_shell() {
- int fdi;
-
+static int interactive_shell(bool use_shell_protocol) {
std::string error;
int fd = adb_connect("shell:", &error);
if (fd < 0) {
fprintf(stderr,"error: %s\n", error.c_str());
return 1;
}
- fdi = 0; //dup(0);
- int* fds = reinterpret_cast<int*>(malloc(sizeof(int) * 2));
- if (fds == nullptr) {
- fprintf(stderr, "couldn't allocate fds array: %s\n", strerror(errno));
+ StdinReadArgs* args = new StdinReadArgs;
+ if (!args) {
+ LOG(ERROR) << "couldn't allocate StdinReadArgs object";
return 1;
}
+ args->stdin_fd = 0;
+ args->write_fd = fd;
+ if (use_shell_protocol) {
+ args->protocol.reset(new ShellProtocol(args->write_fd));
+ }
- fds[0] = fd;
- fds[1] = fdi;
+ stdin_raw_init(args->stdin_fd);
- stdin_raw_init(fdi);
+ int exit_code = 0;
+ if (!adb_thread_create(stdin_read_thread, args)) {
+ PLOG(ERROR) << "error starting stdin read thread";
+ exit_code = 1;
+ delete args;
+ } else {
+ exit_code = read_and_dump(fd, use_shell_protocol);
+ }
- adb_thread_create(stdin_read_thread, fds);
- read_and_dump(fd);
- stdin_raw_restore(fdi);
- return 0;
+ stdin_raw_restore(args->stdin_fd);
+ return exit_code;
}
@@ -454,6 +524,20 @@
return android::base::StringPrintf("%s:%s", prefix, command);
}
+// Checks whether the device indicated by |transport_type| and |serial| supports
+// |feature|. Returns the response string, which will be empty if the device
+// could not be found or the feature is not supported.
+static std::string CheckFeature(const std::string& feature,
+ TransportType transport_type,
+ const char* serial) {
+ std::string result, error, command("check-feature:" + feature);
+ if (!adb_query(format_host_command(command.c_str(), transport_type, serial),
+ &result, &error)) {
+ return "";
+ }
+ return result;
+}
+
static int adb_download_buffer(const char *service, const char *fn, const void* data, unsigned sz,
bool show_progress)
{
@@ -713,12 +797,15 @@
wait_for_device("wait-for-device", transport_type, serial);
}
- read_and_dump(fd);
- int rc = adb_close(fd);
- if (rc) {
- perror("close");
+ bool use_shell_protocol = !CheckFeature(kFeatureShell2, transport_type,
+ serial).empty();
+ int exit_code = read_and_dump(fd, use_shell_protocol);
+
+ if (adb_close(fd) < 0) {
+ PLOG(ERROR) << "failure closing FD " << fd;
}
- return rc;
+
+ return exit_code;
}
static int logcat(TransportType transport, const char* serial, int argc, const char** argv) {
@@ -1156,9 +1243,19 @@
fflush(stdout);
}
+ bool use_shell_protocol;
+ if (CheckFeature(kFeatureShell2, transport_type, serial).empty()) {
+ D("shell protocol not supported, using raw data transfer");
+ use_shell_protocol = false;
+ } else {
+ D("using shell protocol");
+ use_shell_protocol = true;
+ }
+
+
if (argc < 2) {
D("starting interactive shell");
- r = interactive_shell();
+ r = interactive_shell(use_shell_protocol);
if (h) {
printf("\x1b[0m");
fflush(stdout);
@@ -1176,16 +1273,15 @@
}
while (true) {
- D("interactive shell loop. cmd=%s", cmd.c_str());
+ D("non-interactive shell loop. cmd=%s", cmd.c_str());
std::string error;
int fd = adb_connect(cmd, &error);
int r;
if (fd >= 0) {
D("about to read_and_dump(fd=%d)", fd);
- read_and_dump(fd);
+ r = read_and_dump(fd, use_shell_protocol);
D("read_and_dump() done.");
adb_close(fd);
- r = 0;
} else {
fprintf(stderr,"error: %s\n", error.c_str());
r = -1;
@@ -1195,7 +1291,7 @@
printf("\x1b[0m");
fflush(stdout);
}
- D("interactive shell loop. return r=%d", r);
+ D("non-interactive shell loop. return r=%d", r);
return r;
}
}
diff --git a/adb/device.py b/adb/device.py
index c5b5eea..516e880 100644
--- a/adb/device.py
+++ b/adb/device.py
@@ -36,6 +36,16 @@
super(NoUniqueDeviceError, self).__init__('No unique device')
+class ShellError(RuntimeError):
+ def __init__(self, cmd, stdout, stderr, exit_code):
+ super(ShellError, self).__init__(
+ '`{0}` exited with code {1}'.format(cmd, exit_code))
+ self.cmd = cmd
+ self.stdout = stdout
+ self.stderr = stderr
+ self.exit_code = exit_code
+
+
def get_devices():
with open(os.devnull, 'wb') as devnull:
subprocess.check_call(['adb', 'start-server'], stdout=devnull,
@@ -146,6 +156,9 @@
# adb on Windows returns \r\n even if adbd returns \n.
_RETURN_CODE_SEARCH_LENGTH = len('{0}255\r\n'.format(_RETURN_CODE_DELIMITER))
+ # Shell protocol feature string.
+ SHELL_PROTOCOL_FEATURE = 'shell_2'
+
def __init__(self, serial, product=None):
self.serial = serial
self.product = product
@@ -155,6 +168,7 @@
if self.product is not None:
self.adb_cmd.extend(['-p', product])
self._linesep = None
+ self._features = None
@property
def linesep(self):
@@ -163,9 +177,20 @@
['shell', 'echo'])
return self._linesep
+ @property
+ def features(self):
+ if self._features is None:
+ try:
+ self._features = self._simple_call(['features']).splitlines()
+ except subprocess.CalledProcessError:
+ self._features = []
+ return self._features
+
def _make_shell_cmd(self, user_cmd):
- return (self.adb_cmd + ['shell'] + user_cmd +
- ['; ' + self._RETURN_CODE_PROBE_STRING])
+ command = self.adb_cmd + ['shell'] + user_cmd
+ if self.SHELL_PROTOCOL_FEATURE not in self.features:
+ command.append('; ' + self._RETURN_CODE_PROBE_STRING)
+ return command
def _parse_shell_output(self, out):
"""Finds the exit code string from shell output.
@@ -201,23 +226,43 @@
self.adb_cmd + cmd, stderr=subprocess.STDOUT)
def shell(self, cmd):
- logging.info(' '.join(self.adb_cmd + ['shell'] + cmd))
- cmd = self._make_shell_cmd(cmd)
- out = _subprocess_check_output(cmd)
- rc, out = self._parse_shell_output(out)
- if rc != 0:
- error = subprocess.CalledProcessError(rc, cmd)
- error.out = out
- raise error
- return out
+ """Calls `adb shell`
+
+ Args:
+ cmd: string shell command to execute.
+
+ Returns:
+ A (stdout, stderr) tuple. Stderr may be combined into stdout
+ if the device doesn't support separate streams.
+
+ Raises:
+ ShellError: the exit code was non-zero.
+ """
+ exit_code, stdout, stderr = self.shell_nocheck(cmd)
+ if exit_code != 0:
+ raise ShellError(cmd, stdout, stderr, exit_code)
+ return stdout, stderr
def shell_nocheck(self, cmd):
+ """Calls `adb shell`
+
+ Args:
+ cmd: string shell command to execute.
+
+ Returns:
+ An (exit_code, stdout, stderr) tuple. Stderr may be combined
+ into stdout if the device doesn't support separate streams.
+ """
cmd = self._make_shell_cmd(cmd)
logging.info(' '.join(cmd))
p = subprocess.Popen(
- cmd, stdout=subprocess.PIPE, stderr=subprocess.STDOUT)
- out, _ = p.communicate()
- return self._parse_shell_output(out)
+ cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+ stdout, stderr = p.communicate()
+ if self.SHELL_PROTOCOL_FEATURE in self.features:
+ exit_code = p.returncode
+ else:
+ exit_code, stdout = self._parse_shell_output(stdout)
+ return exit_code, stdout, stderr
def install(self, filename, replace=False):
cmd = ['install']
@@ -281,7 +326,7 @@
return self._simple_call(['wait-for-device'])
def get_prop(self, prop_name):
- output = self.shell(['getprop', prop_name]).splitlines()
+ output = self.shell(['getprop', prop_name])[0].splitlines()
if len(output) != 1:
raise RuntimeError('Too many lines in getprop output:\n' +
'\n'.join(output))
diff --git a/adb/fdevent.cpp b/adb/fdevent.cpp
index db5157f..666a15f 100644
--- a/adb/fdevent.cpp
+++ b/adb/fdevent.cpp
@@ -20,59 +20,30 @@
#include "sysdeps.h"
#include "fdevent.h"
-#include <errno.h>
#include <fcntl.h>
-#include <stdarg.h>
-#include <stddef.h>
-#include <stdio.h>
+#include <poll.h>
#include <stdlib.h>
#include <string.h>
#include <sys/ioctl.h>
#include <unistd.h>
+#include <list>
+#include <unordered_map>
+#include <vector>
+
+#include <base/logging.h>
+#include <base/stringprintf.h>
+
#include "adb_io.h"
#include "adb_trace.h"
-/* !!! Do not enable DEBUG for the adb that will run as the server:
-** both stdout and stderr are used to communicate between the client
-** and server. Any extra output will cause failures.
-*/
-#define DEBUG 0 /* non-0 will break adb server */
-
+#if !ADB_HOST
// This socket is used when a subproc shell service exists.
// It wakes up the fdevent_loop() and cause the correct handling
// of the shell's pseudo-tty master. I.e. force close it.
-#if !ADB_HOST
int SHELL_EXIT_NOTIFY_FD = -1;
#endif // !ADB_HOST
-static void fatal(const char *fn, const char *fmt, ...)
-{
- va_list ap;
- va_start(ap, fmt);
- fprintf(stderr, "%s:", fn);
- vfprintf(stderr, fmt, ap);
- va_end(ap);
- abort();
-}
-
-#define FATAL(x...) fatal(__FUNCTION__, x)
-
-#if DEBUG
-static void dump_fde(fdevent *fde, const char *info)
-{
- adb_mutex_lock(&D_lock);
- fprintf(stderr,"FDE #%03d %c%c%c %s\n", fde->fd,
- fde->state & FDE_READ ? 'R' : ' ',
- fde->state & FDE_WRITE ? 'W' : ' ',
- fde->state & FDE_ERROR ? 'E' : ' ',
- info);
- adb_mutex_unlock(&D_lock);
-}
-#else
-#define dump_fde(fde, info) do { } while(0)
-#endif
-
#define FDE_EVENTMASK 0x00ff
#define FDE_STATEMASK 0xff00
@@ -80,515 +51,47 @@
#define FDE_PENDING 0x0200
#define FDE_CREATED 0x0400
-static void fdevent_plist_enqueue(fdevent *node);
-static void fdevent_plist_remove(fdevent *node);
-static fdevent *fdevent_plist_dequeue(void);
+struct PollNode {
+ fdevent* fde;
+ pollfd pollfd;
-static fdevent list_pending = {
- .next = &list_pending,
- .prev = &list_pending,
- .fd = -1,
- .force_eof = 0,
- .state = 0,
- .events = 0,
- .func = nullptr,
- .arg = nullptr,
+ PollNode(fdevent* fde) : fde(fde) {
+ memset(&pollfd, 0, sizeof(pollfd));
+ pollfd.fd = fde->fd;
+ }
};
-static fdevent **fd_table = 0;
-static int fd_table_max = 0;
+// All operations to fdevent should happen only in the main thread.
+// That's why we don't need a lock for fdevent.
+static std::unordered_map<int, PollNode> g_poll_node_map;
+static std::list<fdevent*> g_pending_list;
-#ifdef CRAPTASTIC
-//HAVE_EPOLL
-
-#include <sys/epoll.h>
-
-static int epoll_fd = -1;
-
-static void fdevent_init()
-{
- /* XXX: what's a good size for the passed in hint? */
- epoll_fd = epoll_create(256);
-
- if(epoll_fd < 0) {
- perror("epoll_create() failed");
- exit(1);
+static std::string dump_fde(const fdevent* fde) {
+ std::string state;
+ if (fde->state & FDE_ACTIVE) {
+ state += "A";
}
-
- /* mark for close-on-exec */
- fcntl(epoll_fd, F_SETFD, FD_CLOEXEC);
+ if (fde->state & FDE_PENDING) {
+ state += "P";
+ }
+ if (fde->state & FDE_CREATED) {
+ state += "C";
+ }
+ if (fde->state & FDE_READ) {
+ state += "R";
+ }
+ if (fde->state & FDE_WRITE) {
+ state += "W";
+ }
+ if (fde->state & FDE_ERROR) {
+ state += "E";
+ }
+ if (fde->state & FDE_DONT_CLOSE) {
+ state += "D";
+ }
+ return android::base::StringPrintf("(fdevent %d %s)", fde->fd, state.c_str());
}
-static void fdevent_connect(fdevent *fde)
-{
- struct epoll_event ev;
-
- memset(&ev, 0, sizeof(ev));
- ev.events = 0;
- ev.data.ptr = fde;
-
-#if 0
- if(epoll_ctl(epoll_fd, EPOLL_CTL_ADD, fde->fd, &ev)) {
- perror("epoll_ctl() failed\n");
- exit(1);
- }
-#endif
-}
-
-static void fdevent_disconnect(fdevent *fde)
-{
- struct epoll_event ev;
-
- memset(&ev, 0, sizeof(ev));
- ev.events = 0;
- ev.data.ptr = fde;
-
- /* technically we only need to delete if we
- ** were actively monitoring events, but let's
- ** be aggressive and do it anyway, just in case
- ** something's out of sync
- */
- epoll_ctl(epoll_fd, EPOLL_CTL_DEL, fde->fd, &ev);
-}
-
-static void fdevent_update(fdevent *fde, unsigned events)
-{
- struct epoll_event ev;
- int active;
-
- active = (fde->state & FDE_EVENTMASK) != 0;
-
- memset(&ev, 0, sizeof(ev));
- ev.events = 0;
- ev.data.ptr = fde;
-
- if(events & FDE_READ) ev.events |= EPOLLIN;
- if(events & FDE_WRITE) ev.events |= EPOLLOUT;
- if(events & FDE_ERROR) ev.events |= (EPOLLERR | EPOLLHUP);
-
- fde->state = (fde->state & FDE_STATEMASK) | events;
-
- if(active) {
- /* we're already active. if we're changing to *no*
- ** events being monitored, we need to delete, otherwise
- ** we need to just modify
- */
- if(ev.events) {
- if(epoll_ctl(epoll_fd, EPOLL_CTL_MOD, fde->fd, &ev)) {
- perror("epoll_ctl() failed\n");
- exit(1);
- }
- } else {
- if(epoll_ctl(epoll_fd, EPOLL_CTL_DEL, fde->fd, &ev)) {
- perror("epoll_ctl() failed\n");
- exit(1);
- }
- }
- } else {
- /* we're not active. if we're watching events, we need
- ** to add, otherwise we can just do nothing
- */
- if(ev.events) {
- if(epoll_ctl(epoll_fd, EPOLL_CTL_ADD, fde->fd, &ev)) {
- perror("epoll_ctl() failed\n");
- exit(1);
- }
- }
- }
-}
-
-static void fdevent_process()
-{
- struct epoll_event events[256];
- fdevent *fde;
- int i, n;
-
- n = epoll_wait(epoll_fd, events, 256, -1);
-
- if (n < 0) {
- if (errno == EINTR) return;
- perror("epoll_wait");
- exit(1);
- }
-
- for(i = 0; i < n; i++) {
- struct epoll_event *ev = events + i;
- fde = ev->data.ptr;
-
- if(ev->events & EPOLLIN) {
- fde->events |= FDE_READ;
- }
- if(ev->events & EPOLLOUT) {
- fde->events |= FDE_WRITE;
- }
- if(ev->events & (EPOLLERR | EPOLLHUP)) {
- fde->events |= FDE_ERROR;
- }
- if(fde->events) {
- if(fde->state & FDE_PENDING) continue;
- fde->state |= FDE_PENDING;
- fdevent_plist_enqueue(fde);
- }
- }
-}
-
-#else /* USE_SELECT */
-
-#if defined(_WIN32)
-#include <winsock2.h>
-#else
-#include <sys/select.h>
-#endif
-
-static fd_set read_fds;
-static fd_set write_fds;
-static fd_set error_fds;
-
-static int select_n = 0;
-
-static void fdevent_init(void)
-{
- FD_ZERO(&read_fds);
- FD_ZERO(&write_fds);
- FD_ZERO(&error_fds);
-}
-
-static void fdevent_connect(fdevent *fde)
-{
- if(fde->fd >= select_n) {
- select_n = fde->fd + 1;
- }
-}
-
-static void fdevent_disconnect(fdevent *fde)
-{
- int i, n;
-
- FD_CLR(fde->fd, &read_fds);
- FD_CLR(fde->fd, &write_fds);
- FD_CLR(fde->fd, &error_fds);
-
- for(n = 0, i = 0; i < select_n; i++) {
- if(fd_table[i] != 0) n = i;
- }
- select_n = n + 1;
-}
-
-static void fdevent_update(fdevent *fde, unsigned events)
-{
- if(events & FDE_READ) {
- FD_SET(fde->fd, &read_fds);
- } else {
- FD_CLR(fde->fd, &read_fds);
- }
- if(events & FDE_WRITE) {
- FD_SET(fde->fd, &write_fds);
- } else {
- FD_CLR(fde->fd, &write_fds);
- }
- if(events & FDE_ERROR) {
- FD_SET(fde->fd, &error_fds);
- } else {
- FD_CLR(fde->fd, &error_fds);
- }
-
- fde->state = (fde->state & FDE_STATEMASK) | events;
-}
-
-/* Looks at fd_table[] for bad FDs and sets bit in fds.
-** Returns the number of bad FDs.
-*/
-static int fdevent_fd_check(fd_set *fds)
-{
- int i, n = 0;
- fdevent *fde;
-
- for(i = 0; i < select_n; i++) {
- fde = fd_table[i];
- if(fde == 0) continue;
- if(fcntl(i, F_GETFL, NULL) < 0) {
- FD_SET(i, fds);
- n++;
- // fde->state |= FDE_DONT_CLOSE;
-
- }
- }
- return n;
-}
-
-#if !DEBUG
-static inline void dump_all_fds(const char* /* extra_msg */) {}
-#else
-static void dump_all_fds(const char *extra_msg)
-{
-int i;
- fdevent *fde;
- // per fd: 4 digits (but really: log10(FD_SETSIZE)), 1 staus, 1 blank
- char msg_buff[FD_SETSIZE*6 + 1], *pb=msg_buff;
- size_t max_chars = FD_SETSIZE * 6 + 1;
- int printed_out;
-#define SAFE_SPRINTF(...) \
- do { \
- printed_out = snprintf(pb, max_chars, __VA_ARGS__); \
- if (printed_out <= 0) { \
- D("... snprintf failed."); \
- return; \
- } \
- if (max_chars < (unsigned int)printed_out) { \
- D("... snprintf out of space."); \
- return; \
- } \
- pb += printed_out; \
- max_chars -= printed_out; \
- } while(0)
-
- for(i = 0; i < select_n; i++) {
- fde = fd_table[i];
- SAFE_SPRINTF("%d", i);
- if(fde == 0) {
- SAFE_SPRINTF("? ");
- continue;
- }
- if(fcntl(i, F_GETFL, NULL) < 0) {
- SAFE_SPRINTF("b");
- }
- SAFE_SPRINTF(" ");
- }
- D("%s fd_table[]->fd = {%s}", extra_msg, msg_buff);
-}
-#endif
-
-static void fdevent_process()
-{
- int i, n;
- fdevent *fde;
- unsigned events;
- fd_set rfd, wfd, efd;
-
- memcpy(&rfd, &read_fds, sizeof(fd_set));
- memcpy(&wfd, &write_fds, sizeof(fd_set));
- memcpy(&efd, &error_fds, sizeof(fd_set));
-
- dump_all_fds("pre select()");
-
- n = select(select_n, &rfd, &wfd, &efd, NULL);
- int saved_errno = errno;
- D("select() returned n=%d, errno=%d", n, n<0?saved_errno:0);
-
- dump_all_fds("post select()");
-
- if(n < 0) {
- switch(saved_errno) {
- case EINTR: return;
- case EBADF:
- // Can't trust the FD sets after an error.
- FD_ZERO(&wfd);
- FD_ZERO(&efd);
- FD_ZERO(&rfd);
- break;
- default:
- D("Unexpected select() error=%d", saved_errno);
- return;
- }
- }
- if(n <= 0) {
- // We fake a read, as the rest of the code assumes
- // that errors will be detected at that point.
- n = fdevent_fd_check(&rfd);
- }
-
- for(i = 0; (i < select_n) && (n > 0); i++) {
- events = 0;
- if(FD_ISSET(i, &rfd)) { events |= FDE_READ; n--; }
- if(FD_ISSET(i, &wfd)) { events |= FDE_WRITE; n--; }
- if(FD_ISSET(i, &efd)) { events |= FDE_ERROR; n--; }
-
- if(events) {
- fde = fd_table[i];
- if(fde == 0)
- FATAL("missing fde for fd %d\n", i);
-
- fde->events |= events;
-
- D("got events fde->fd=%d events=%04x, state=%04x",
- fde->fd, fde->events, fde->state);
- if(fde->state & FDE_PENDING) continue;
- fde->state |= FDE_PENDING;
- fdevent_plist_enqueue(fde);
- }
- }
-}
-
-#endif
-
-static void fdevent_register(fdevent *fde)
-{
- if(fde->fd < 0) {
- FATAL("bogus negative fd (%d)\n", fde->fd);
- }
-
- if(fde->fd >= fd_table_max) {
- int oldmax = fd_table_max;
- if(fde->fd > 32000) {
- FATAL("bogus huuuuge fd (%d)\n", fde->fd);
- }
- if(fd_table_max == 0) {
- fdevent_init();
- fd_table_max = 256;
- }
- while(fd_table_max <= fde->fd) {
- fd_table_max *= 2;
- }
- fd_table = reinterpret_cast<fdevent**>(
- realloc(fd_table, sizeof(fdevent*) * fd_table_max));
- if(fd_table == 0) {
- FATAL("could not expand fd_table to %d entries\n", fd_table_max);
- }
- memset(fd_table + oldmax, 0, sizeof(int) * (fd_table_max - oldmax));
- }
-
- fd_table[fde->fd] = fde;
-}
-
-static void fdevent_unregister(fdevent *fde)
-{
- if((fde->fd < 0) || (fde->fd >= fd_table_max)) {
- FATAL("fd out of range (%d)\n", fde->fd);
- }
-
- if(fd_table[fde->fd] != fde) {
- FATAL("fd_table out of sync [%d]\n", fde->fd);
- }
-
- fd_table[fde->fd] = 0;
-
- if(!(fde->state & FDE_DONT_CLOSE)) {
- dump_fde(fde, "close");
- adb_close(fde->fd);
- }
-}
-
-static void fdevent_plist_enqueue(fdevent *node)
-{
- fdevent *list = &list_pending;
-
- node->next = list;
- node->prev = list->prev;
- node->prev->next = node;
- list->prev = node;
-}
-
-static void fdevent_plist_remove(fdevent *node)
-{
- node->prev->next = node->next;
- node->next->prev = node->prev;
- node->next = 0;
- node->prev = 0;
-}
-
-static fdevent *fdevent_plist_dequeue(void)
-{
- fdevent *list = &list_pending;
- fdevent *node = list->next;
-
- if(node == list) return 0;
-
- list->next = node->next;
- list->next->prev = list;
- node->next = 0;
- node->prev = 0;
-
- return node;
-}
-
-static void fdevent_call_fdfunc(fdevent* fde)
-{
- unsigned events = fde->events;
- fde->events = 0;
- if(!(fde->state & FDE_PENDING)) return;
- fde->state &= (~FDE_PENDING);
- dump_fde(fde, "callback");
- fde->func(fde->fd, events, fde->arg);
-}
-
-#if !ADB_HOST
-static void fdevent_subproc_event_func(int fd, unsigned ev,
- void* /* userdata */)
-{
-
- D("subproc handling on fd=%d ev=%04x", fd, ev);
-
- // Hook oneself back into the fde's suitable for select() on read.
- if((fd < 0) || (fd >= fd_table_max)) {
- FATAL("fd %d out of range for fd_table \n", fd);
- }
- fdevent *fde = fd_table[fd];
- fdevent_add(fde, FDE_READ);
-
- if(ev & FDE_READ){
- int subproc_fd;
-
- if(!ReadFdExactly(fd, &subproc_fd, sizeof(subproc_fd))) {
- FATAL("Failed to read the subproc's fd from fd=%d\n", fd);
- }
- if((subproc_fd < 0) || (subproc_fd >= fd_table_max)) {
- D("subproc_fd %d out of range 0, fd_table_max=%d",
- subproc_fd, fd_table_max);
- return;
- }
- fdevent *subproc_fde = fd_table[subproc_fd];
- if(!subproc_fde) {
- D("subproc_fd %d cleared from fd_table", subproc_fd);
- return;
- }
- if(subproc_fde->fd != subproc_fd) {
- // Already reallocated?
- D("subproc_fd %d != fd_table[].fd %d", subproc_fd, subproc_fde->fd);
- return;
- }
-
- subproc_fde->force_eof = 1;
-
- int rcount = 0;
- ioctl(subproc_fd, FIONREAD, &rcount);
- D("subproc with fd=%d has rcount=%d err=%d",
- subproc_fd, rcount, errno);
-
- if(rcount) {
- // If there is data left, it will show up in the select().
- // This works because there is no other thread reading that
- // data when in this fd_func().
- return;
- }
-
- D("subproc_fde.state=%04x", subproc_fde->state);
- subproc_fde->events |= FDE_READ;
- if(subproc_fde->state & FDE_PENDING) {
- return;
- }
- subproc_fde->state |= FDE_PENDING;
- fdevent_call_fdfunc(subproc_fde);
- }
-}
-
-void fdevent_subproc_setup()
-{
- int s[2];
-
- if(adb_socketpair(s)) {
- FATAL("cannot create shell-exit socket-pair\n");
- }
- D("socketpair: (%d,%d)", s[0], s[1]);
-
- SHELL_EXIT_NOTIFY_FD = s[0];
- fdevent *fde;
- fde = fdevent_create(s[1], fdevent_subproc_event_func, NULL);
- if(!fde)
- FATAL("cannot create fdevent for shell-exit handler\n");
- fdevent_add(fde, FDE_READ);
-}
-#endif // !ADB_HOST
-
fdevent *fdevent_create(int fd, fd_func func, void *arg)
{
fdevent *fde = (fdevent*) malloc(sizeof(fdevent));
@@ -602,99 +105,247 @@
{
if(fde == 0) return;
if(!(fde->state & FDE_CREATED)) {
- FATAL("fde %p not created by fdevent_create()\n", fde);
+ LOG(FATAL) << "destroying fde not created by fdevent_create(): " << dump_fde(fde);
}
fdevent_remove(fde);
free(fde);
}
-void fdevent_install(fdevent *fde, int fd, fd_func func, void *arg)
-{
+void fdevent_install(fdevent* fde, int fd, fd_func func, void* arg) {
+ CHECK_GE(fd, 0);
memset(fde, 0, sizeof(fdevent));
fde->state = FDE_ACTIVE;
fde->fd = fd;
- fde->force_eof = 0;
fde->func = func;
fde->arg = arg;
-
-#if !defined(_WIN32)
- fcntl(fd, F_SETFL, O_NONBLOCK);
-#endif
- fdevent_register(fde);
- dump_fde(fde, "connect");
- fdevent_connect(fde);
- fde->state |= FDE_ACTIVE;
+ if (fcntl(fd, F_SETFL, O_NONBLOCK) != 0) {
+ // Here is not proper to handle the error. If it fails here, some error is
+ // likely to be detected by poll(), then we can let the callback function
+ // to handle it.
+ LOG(ERROR) << "failed to fcntl(" << fd << ") to be nonblock";
+ }
+ auto pair = g_poll_node_map.emplace(fde->fd, PollNode(fde));
+ CHECK(pair.second) << "install existing fd " << fd;
+ D("fdevent_install %s", dump_fde(fde).c_str());
}
-void fdevent_remove(fdevent *fde)
-{
- if(fde->state & FDE_PENDING) {
- fdevent_plist_remove(fde);
+void fdevent_remove(fdevent* fde) {
+ D("fdevent_remove %s", dump_fde(fde).c_str());
+ if (fde->state & FDE_ACTIVE) {
+ g_poll_node_map.erase(fde->fd);
+ if (fde->state & FDE_PENDING) {
+ g_pending_list.remove(fde);
+ }
+ if (!(fde->state & FDE_DONT_CLOSE)) {
+ adb_close(fde->fd);
+ fde->fd = -1;
+ }
+ fde->state = 0;
+ fde->events = 0;
}
-
- if(fde->state & FDE_ACTIVE) {
- fdevent_disconnect(fde);
- dump_fde(fde, "disconnect");
- fdevent_unregister(fde);
- }
-
- fde->state = 0;
- fde->events = 0;
}
-
-void fdevent_set(fdevent *fde, unsigned events)
-{
- events &= FDE_EVENTMASK;
-
- if((fde->state & FDE_EVENTMASK) == events) return;
-
- if(fde->state & FDE_ACTIVE) {
- fdevent_update(fde, events);
- dump_fde(fde, "update");
+static void fdevent_update(fdevent* fde, unsigned events) {
+ auto it = g_poll_node_map.find(fde->fd);
+ CHECK(it != g_poll_node_map.end());
+ PollNode& node = it->second;
+ if (events & FDE_READ) {
+ node.pollfd.events |= POLLIN;
+ } else {
+ node.pollfd.events &= ~POLLIN;
}
+ if (events & FDE_WRITE) {
+ node.pollfd.events |= POLLOUT;
+ } else {
+ node.pollfd.events &= ~POLLOUT;
+ }
fde->state = (fde->state & FDE_STATEMASK) | events;
+}
- if(fde->state & FDE_PENDING) {
- /* if we're pending, make sure
- ** we don't signal an event that
- ** is no longer wanted.
- */
- fde->events &= (~events);
- if(fde->events == 0) {
- fdevent_plist_remove(fde);
- fde->state &= (~FDE_PENDING);
+void fdevent_set(fdevent* fde, unsigned events) {
+ events &= FDE_EVENTMASK;
+ if ((fde->state & FDE_EVENTMASK) == events) {
+ return;
+ }
+ if (fde->state & FDE_ACTIVE) {
+ fdevent_update(fde, events);
+ D("fdevent_set: %s, events = %u", dump_fde(fde).c_str(), events);
+
+ if (fde->state & FDE_PENDING) {
+ // If we are pending, make sure we don't signal an event that is no longer wanted.
+ fde->events &= ~events;
+ if (fde->events == 0) {
+ g_pending_list.remove(fde);
+ fde->state &= ~FDE_PENDING;
+ }
}
}
}
-void fdevent_add(fdevent *fde, unsigned events)
-{
- fdevent_set(
- fde, (fde->state & FDE_EVENTMASK) | (events & FDE_EVENTMASK));
+void fdevent_add(fdevent* fde, unsigned events) {
+ fdevent_set(fde, (fde->state & FDE_EVENTMASK) | events);
}
-void fdevent_del(fdevent *fde, unsigned events)
-{
- fdevent_set(
- fde, (fde->state & FDE_EVENTMASK) & (~(events & FDE_EVENTMASK)));
+void fdevent_del(fdevent* fde, unsigned events) {
+ fdevent_set(fde, (fde->state & FDE_EVENTMASK) & ~events);
}
+static std::string dump_pollfds(const std::vector<pollfd>& pollfds) {
+ std::string result;
+ for (auto& pollfd : pollfds) {
+ std::string op;
+ if (pollfd.events & POLLIN) {
+ op += "R";
+ }
+ if (pollfd.events & POLLOUT) {
+ op += "W";
+ }
+ android::base::StringAppendF(&result, " %d(%s)", pollfd.fd, op.c_str());
+ }
+ return result;
+}
+
+static void fdevent_process() {
+ std::vector<pollfd> pollfds;
+ for (auto it = g_poll_node_map.begin(); it != g_poll_node_map.end(); ++it) {
+ pollfds.push_back(it->second.pollfd);
+ }
+ CHECK_GT(pollfds.size(), 0u);
+ D("poll(), pollfds = %s", dump_pollfds(pollfds).c_str());
+ int ret = TEMP_FAILURE_RETRY(poll(&pollfds[0], pollfds.size(), -1));
+ if (ret == -1) {
+ PLOG(ERROR) << "poll(), ret = " << ret;
+ return;
+ }
+ for (auto& pollfd : pollfds) {
+ if (pollfd.revents != 0) {
+ D("for fd %d, revents = %x", pollfd.fd, pollfd.revents);
+ }
+ unsigned events = 0;
+ if (pollfd.revents & POLLIN) {
+ events |= FDE_READ;
+ }
+ if (pollfd.revents & POLLOUT) {
+ events |= FDE_WRITE;
+ }
+ if (pollfd.revents & (POLLERR | POLLHUP | POLLNVAL)) {
+ // We fake a read, as the rest of the code assumes that errors will
+ // be detected at that point.
+ events |= FDE_READ | FDE_ERROR;
+ }
+ if (events != 0) {
+ auto it = g_poll_node_map.find(pollfd.fd);
+ CHECK(it != g_poll_node_map.end());
+ fdevent* fde = it->second.fde;
+ CHECK_EQ(fde->fd, pollfd.fd);
+ fde->events |= events;
+ D("%s got events %x", dump_fde(fde).c_str(), events);
+ fde->state |= FDE_PENDING;
+ g_pending_list.push_back(fde);
+ }
+ }
+}
+
+static void fdevent_call_fdfunc(fdevent* fde)
+{
+ unsigned events = fde->events;
+ fde->events = 0;
+ if(!(fde->state & FDE_PENDING)) return;
+ fde->state &= (~FDE_PENDING);
+ D("fdevent_call_fdfunc %s", dump_fde(fde).c_str());
+ fde->func(fde->fd, events, fde->arg);
+}
+
+#if !ADB_HOST
+static void fdevent_subproc_event_func(int fd, unsigned ev,
+ void* /* userdata */)
+{
+
+ D("subproc handling on fd = %d, ev = %x", fd, ev);
+
+ CHECK_GE(fd, 0);
+
+ if (ev & FDE_READ) {
+ int subproc_fd;
+
+ if(!ReadFdExactly(fd, &subproc_fd, sizeof(subproc_fd))) {
+ LOG(FATAL) << "Failed to read the subproc's fd from " << fd;
+ }
+ auto it = g_poll_node_map.find(subproc_fd);
+ if (it == g_poll_node_map.end()) {
+ D("subproc_fd %d cleared from fd_table", subproc_fd);
+ return;
+ }
+ fdevent* subproc_fde = it->second.fde;
+ if(subproc_fde->fd != subproc_fd) {
+ // Already reallocated?
+ D("subproc_fd(%d) != subproc_fde->fd(%d)", subproc_fd, subproc_fde->fd);
+ return;
+ }
+
+ subproc_fde->force_eof = 1;
+
+ int rcount = 0;
+ ioctl(subproc_fd, FIONREAD, &rcount);
+ D("subproc with fd %d has rcount=%d, err=%d", subproc_fd, rcount, errno);
+ if (rcount != 0) {
+ // If there is data left, it will show up in the select().
+ // This works because there is no other thread reading that
+ // data when in this fd_func().
+ return;
+ }
+
+ D("subproc_fde %s", dump_fde(subproc_fde).c_str());
+ subproc_fde->events |= FDE_READ;
+ if(subproc_fde->state & FDE_PENDING) {
+ return;
+ }
+ subproc_fde->state |= FDE_PENDING;
+ fdevent_call_fdfunc(subproc_fde);
+ }
+}
+
+void fdevent_subproc_setup()
+{
+ int s[2];
+
+ if(adb_socketpair(s)) {
+ PLOG(FATAL) << "cannot create shell-exit socket-pair";
+ }
+ D("fdevent_subproc: socket pair (%d, %d)", s[0], s[1]);
+
+ SHELL_EXIT_NOTIFY_FD = s[0];
+ fdevent *fde = fdevent_create(s[1], fdevent_subproc_event_func, NULL);
+ CHECK(fde != nullptr) << "cannot create fdevent for shell-exit handler";
+ fdevent_add(fde, FDE_READ);
+}
+#endif // !ADB_HOST
+
void fdevent_loop()
{
- fdevent *fde;
#if !ADB_HOST
fdevent_subproc_setup();
#endif // !ADB_HOST
while (true) {
- D("--- ---- waiting for events");
+ D("--- --- waiting for events");
fdevent_process();
- while((fde = fdevent_plist_dequeue())) {
+ while (!g_pending_list.empty()) {
+ fdevent* fde = g_pending_list.front();
+ g_pending_list.pop_front();
fdevent_call_fdfunc(fde);
}
}
}
+
+size_t fdevent_installed_count() {
+ return g_poll_node_map.size();
+}
+
+void fdevent_reset() {
+ g_poll_node_map.clear();
+ g_pending_list.clear();
+}
diff --git a/adb/fdevent.h b/adb/fdevent.h
index ca1494c..657fde5 100644
--- a/adb/fdevent.h
+++ b/adb/fdevent.h
@@ -17,6 +17,7 @@
#ifndef __FDEVENT_H
#define __FDEVENT_H
+#include <stddef.h>
#include <stdint.h> /* for int64_t */
/* events that may be observed */
@@ -27,10 +28,22 @@
/* features that may be set (via the events set/add/del interface) */
#define FDE_DONT_CLOSE 0x0080
-struct fdevent;
-
typedef void (*fd_func)(int fd, unsigned events, void *userdata);
+struct fdevent {
+ fdevent *next;
+ fdevent *prev;
+
+ int fd;
+ int force_eof;
+
+ uint16_t state;
+ uint16_t events;
+
+ fd_func func;
+ void *arg;
+};
+
/* Allocate and initialize a new fdevent object
* Note: use FD_TIMER as 'fd' to create a fd-less object
* (used to implement timers).
@@ -63,18 +76,9 @@
*/
void fdevent_loop();
-struct fdevent {
- fdevent *next;
- fdevent *prev;
-
- int fd;
- int force_eof;
-
- uint16_t state;
- uint16_t events;
-
- fd_func func;
- void *arg;
-};
+// For debugging only.
+size_t fdevent_installed_count();
+// For debugging only.
+void fdevent_reset();
#endif
diff --git a/adb/fdevent_test.cpp b/adb/fdevent_test.cpp
index f7622b5..7457712 100644
--- a/adb/fdevent_test.cpp
+++ b/adb/fdevent_test.cpp
@@ -18,6 +18,7 @@
#include <gtest/gtest.h>
+#include <limits>
#include <queue>
#include <string>
#include <vector>
@@ -27,32 +28,17 @@
#include "adb_io.h"
-class SignalHandlerRegister {
- public:
- SignalHandlerRegister(const std::vector<int>& signums, void (*handler)(int)) {
- for (auto& sig : signums) {
- sig_t old_handler = signal(sig, handler);
- saved_signal_handlers_.push_back(std::make_pair(sig, old_handler));
- }
- }
-
- ~SignalHandlerRegister() {
- for (auto& pair : saved_signal_handlers_) {
- signal(pair.first, pair.second);
- }
- }
-
- private:
- std::vector<std::pair<int, sig_t>> saved_signal_handlers_;
-};
-
class FdHandler {
public:
FdHandler(int read_fd, int write_fd) : read_fd_(read_fd), write_fd_(write_fd) {
fdevent_install(&read_fde_, read_fd_, FdEventCallback, this);
- fdevent_add(&read_fde_, FDE_READ | FDE_ERROR);
+ fdevent_add(&read_fde_, FDE_READ);
fdevent_install(&write_fde_, write_fd_, FdEventCallback, this);
- fdevent_add(&write_fde_, FDE_ERROR);
+ }
+
+ ~FdHandler() {
+ fdevent_remove(&read_fde_);
+ fdevent_remove(&write_fde_);
}
private:
@@ -90,6 +76,19 @@
pthread_exit(nullptr);
}
+class FdeventTest : public ::testing::Test {
+ protected:
+ static void SetUpTestCase() {
+ ASSERT_NE(SIG_ERR, signal(SIGUSR1, signal_handler));
+ ASSERT_NE(SIG_ERR, signal(SIGPIPE, SIG_IGN));
+ }
+
+ virtual void SetUp() {
+ fdevent_reset();
+ ASSERT_EQ(0u, fdevent_installed_count());
+ }
+};
+
struct ThreadArg {
int first_read_fd;
int last_write_fd;
@@ -97,8 +96,6 @@
};
static void FdEventThreadFunc(ThreadArg* arg) {
- SignalHandlerRegister signal_handler_register({SIGUSR1}, signal_handler);
-
std::vector<int> read_fds;
std::vector<int> write_fds;
@@ -119,7 +116,7 @@
fdevent_loop();
}
-TEST(fdevent, smoke) {
+TEST_F(FdeventTest, smoke) {
const size_t PIPE_COUNT = 10;
const size_t MESSAGE_LOOP_COUNT = 100;
const std::string MESSAGE = "fdevent_test";
@@ -149,4 +146,47 @@
ASSERT_EQ(0, pthread_kill(thread, SIGUSR1));
ASSERT_EQ(0, pthread_join(thread, nullptr));
+ ASSERT_EQ(0, close(writer));
+ ASSERT_EQ(0, close(reader));
+}
+
+struct InvalidFdArg {
+ fdevent fde;
+ unsigned expected_events;
+ size_t* happened_event_count;
+};
+
+static void InvalidFdEventCallback(int fd, unsigned events, void* userdata) {
+ InvalidFdArg* arg = reinterpret_cast<InvalidFdArg*>(userdata);
+ ASSERT_EQ(arg->expected_events, events);
+ fdevent_remove(&arg->fde);
+ if (++*(arg->happened_event_count) == 2) {
+ pthread_exit(nullptr);
+ }
+}
+
+static void InvalidFdThreadFunc(void*) {
+ const int INVALID_READ_FD = std::numeric_limits<int>::max() - 1;
+ size_t happened_event_count = 0;
+ InvalidFdArg read_arg;
+ read_arg.expected_events = FDE_READ | FDE_ERROR;
+ read_arg.happened_event_count = &happened_event_count;
+ fdevent_install(&read_arg.fde, INVALID_READ_FD, InvalidFdEventCallback, &read_arg);
+ fdevent_add(&read_arg.fde, FDE_READ);
+
+ const int INVALID_WRITE_FD = std::numeric_limits<int>::max();
+ InvalidFdArg write_arg;
+ write_arg.expected_events = FDE_READ | FDE_ERROR;
+ write_arg.happened_event_count = &happened_event_count;
+ fdevent_install(&write_arg.fde, INVALID_WRITE_FD, InvalidFdEventCallback, &write_arg);
+ fdevent_add(&write_arg.fde, FDE_WRITE);
+ fdevent_loop();
+}
+
+TEST_F(FdeventTest, invalid_fd) {
+ pthread_t thread;
+ ASSERT_EQ(0, pthread_create(&thread, nullptr,
+ reinterpret_cast<void* (*)(void*)>(InvalidFdThreadFunc),
+ nullptr));
+ ASSERT_EQ(0, pthread_join(thread, nullptr));
}
diff --git a/adb/services.cpp b/adb/services.cpp
index 561431c..d128efc 100644
--- a/adb/services.cpp
+++ b/adb/services.cpp
@@ -225,7 +225,7 @@
return s[0];
}
-int service_to_fd(const char* name) {
+int service_to_fd(const char* name, const atransport* transport) {
int ret = -1;
if(!strncmp(name, "tcp:", 4)) {
@@ -267,15 +267,15 @@
ret = create_jdwp_connection_fd(atoi(name+5));
} else if(!strncmp(name, "shell:", 6)) {
const char* args = name + 6;
- if (*args) {
- // Non-interactive session uses a raw subprocess.
- ret = StartSubprocess(args, SubprocessType::kRaw);
- } else {
- // Interactive session uses a PTY subprocess.
- ret = StartSubprocess(args, SubprocessType::kPty);
- }
+ // Use raw for non-interactive, PTY for interactive.
+ SubprocessType type = (*args ? SubprocessType::kRaw : SubprocessType::kPty);
+ SubprocessProtocol protocol =
+ (transport->CanUseFeature(kFeatureShell2) ? SubprocessProtocol::kShell
+ : SubprocessProtocol::kNone);
+ ret = StartSubprocess(args, type, protocol);
} else if(!strncmp(name, "exec:", 5)) {
- ret = StartSubprocess(name + 5, SubprocessType::kRaw);
+ ret = StartSubprocess(name + 5, SubprocessType::kRaw,
+ SubprocessProtocol::kNone);
} else if(!strncmp(name, "sync:", 5)) {
ret = create_service_thread(file_sync_service, NULL);
} else if(!strncmp(name, "remount:", 8)) {
@@ -291,9 +291,10 @@
} else if(!strncmp(name, "backup:", 7)) {
ret = StartSubprocess(android::base::StringPrintf("/system/bin/bu backup %s",
(name + 7)).c_str(),
- SubprocessType::kRaw);
+ SubprocessType::kRaw, SubprocessProtocol::kNone);
} else if(!strncmp(name, "restore:", 8)) {
- ret = StartSubprocess("/system/bin/bu restore", SubprocessType::kRaw);
+ ret = StartSubprocess("/system/bin/bu restore", SubprocessType::kRaw,
+ SubprocessProtocol::kNone);
} 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
index 5f80a59..f1bc36d 100644
--- a/adb/shell_service.cpp
+++ b/adb/shell_service.cpp
@@ -14,6 +14,67 @@
* limitations under the License.
*/
+// Functionality for launching and managing shell subprocesses.
+//
+// There are two types of subprocesses, PTY or raw. PTY is typically used for
+// an interactive session, raw for non-interactive. There are also two methods
+// of communication with the subprocess, passing raw data or using a simple
+// protocol to wrap packets. The protocol allows separating stdout/stderr and
+// passing the exit code back, but is not backwards compatible.
+// ----------------+--------------------------------------
+// Type Protocol | Exit code? Separate stdout/stderr?
+// ----------------+--------------------------------------
+// PTY No | No No
+// Raw No | No No
+// PTY Yes | Yes No
+// Raw Yes | Yes Yes
+// ----------------+--------------------------------------
+//
+// Non-protocol subprocesses work by passing subprocess stdin/out/err through
+// a single pipe which is registered with a local socket in adbd. The local
+// socket uses the fdevent loop to pass raw data between this pipe and the
+// transport, which then passes data back to the adb client. Cleanup is done by
+// waiting in a separate thread for the subprocesses to exit and then signaling
+// a separate fdevent to close out the local socket from the main loop.
+//
+// ------------------+-------------------------+------------------------------
+// Subprocess | adbd subprocess thread | adbd main fdevent loop
+// ------------------+-------------------------+------------------------------
+// | |
+// stdin/out/err <-----------------------------> LocalSocket
+// | | |
+// | | Block on exit |
+// | | * |
+// v | * |
+// Exit ---> Unblock |
+// | | |
+// | v |
+// | Notify shell exit FD ---> Close LocalSocket
+// ------------------+-------------------------+------------------------------
+//
+// The protocol requires the thread to intercept stdin/out/err in order to
+// wrap/unwrap data with shell protocol packets.
+//
+// ------------------+-------------------------+------------------------------
+// Subprocess | adbd subprocess thread | adbd main fdevent loop
+// ------------------+-------------------------+------------------------------
+// | |
+// stdin/out <---> Protocol <---> LocalSocket
+// stderr ---> Protocol ---> LocalSocket
+// | | |
+// v | |
+// Exit ---> Exit code protocol ---> LocalSocket
+// | | |
+// | v |
+// | Notify shell exit FD ---> Close LocalSocket
+// ------------------+-------------------------+------------------------------
+//
+// An alternate approach is to put the protocol wrapping/unwrapping in the main
+// fdevent loop, which has the advantage of being able to re-use the existing
+// select() code for handling data streams. However, implementation turned out
+// to be more complex due to partial reads and non-blocking I/O so this model
+// was chosen instead.
+
#define TRACE_TAG TRACE_SHELL
#include "shell_service.h"
@@ -22,8 +83,11 @@
#include <errno.h>
#include <pty.h>
+#include <sys/select.h>
#include <termios.h>
+#include <memory>
+
#include <base/logging.h>
#include <base/stringprintf.h>
#include <paths.h>
@@ -110,7 +174,8 @@
class Subprocess {
public:
- Subprocess(const std::string& command, SubprocessType type);
+ Subprocess(const std::string& command, SubprocessType type,
+ SubprocessProtocol protocol);
~Subprocess();
const std::string& command() const { return command_; }
@@ -129,26 +194,42 @@
int OpenPtyChildFd(const char* pts_name, ScopedFd* error_sfd);
static void* ThreadHandler(void* userdata);
+ void PassDataStreams();
void WaitForExit();
+ ScopedFd* SelectLoop(fd_set* master_read_set_ptr,
+ fd_set* master_write_set_ptr);
+
+ // Input/output stream handlers. Success returns nullptr, failure returns
+ // a pointer to the failed FD.
+ ScopedFd* PassInput();
+ ScopedFd* PassOutput(ScopedFd* sfd, ShellProtocol::Id id);
+
const std::string command_;
SubprocessType type_;
-
+ SubprocessProtocol protocol_;
pid_t pid_ = -1;
ScopedFd local_socket_sfd_;
+ // Shell protocol variables.
+ ScopedFd stdinout_sfd_, stderr_sfd_, protocol_sfd_;
+ std::unique_ptr<ShellProtocol> input_, output_;
+ size_t input_bytes_left_ = 0;
+
DISALLOW_COPY_AND_ASSIGN(Subprocess);
};
-Subprocess::Subprocess(const std::string& command, SubprocessType type)
- : command_(command), type_(type) {
+Subprocess::Subprocess(const std::string& command, SubprocessType type,
+ SubprocessProtocol protocol)
+ : command_(command), type_(type), protocol_(protocol) {
}
Subprocess::~Subprocess() {
}
bool Subprocess::ForkAndExec() {
- ScopedFd parent_sfd, child_sfd, parent_error_sfd, child_error_sfd;
+ ScopedFd child_stdinout_sfd, child_stderr_sfd;
+ ScopedFd parent_error_sfd, child_error_sfd;
char pts_name[PATH_MAX];
// Create a socketpair for the fork() child to report any errors back to
@@ -161,9 +242,14 @@
if (type_ == SubprocessType::kPty) {
int fd;
pid_ = forkpty(&fd, pts_name, nullptr, nullptr);
- parent_sfd.Reset(fd);
+ stdinout_sfd_.Reset(fd);
} else {
- if (!CreateSocketpair(&parent_sfd, &child_sfd)) {
+ if (!CreateSocketpair(&stdinout_sfd_, &child_stdinout_sfd)) {
+ return false;
+ }
+ // Raw subprocess + shell protocol allows for splitting stderr.
+ if (protocol_ == SubprocessProtocol::kShell &&
+ !CreateSocketpair(&stderr_sfd_, &child_stderr_sfd)) {
return false;
}
pid_ = fork();
@@ -179,16 +265,19 @@
init_subproc_child();
if (type_ == SubprocessType::kPty) {
- child_sfd.Reset(OpenPtyChildFd(pts_name, &child_error_sfd));
+ child_stdinout_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);
+ dup2(child_stdinout_sfd.fd(), STDIN_FILENO);
+ dup2(child_stdinout_sfd.fd(), STDOUT_FILENO);
+ dup2(child_stderr_sfd.valid() ? child_stderr_sfd.fd() : child_stdinout_sfd.fd(),
+ STDERR_FILENO);
// exec doesn't trigger destructors, close the FDs manually.
- parent_sfd.Reset();
- child_sfd.Reset();
+ stdinout_sfd_.Reset();
+ stderr_sfd_.Reset();
+ child_stdinout_sfd.Reset();
+ child_stderr_sfd.Reset();
parent_error_sfd.Reset();
close_on_exec(child_error_sfd.fd());
@@ -203,7 +292,8 @@
}
// Subprocess parent.
- D("subprocess parent: subprocess FD = %d", parent_sfd.fd());
+ D("subprocess parent: stdin/stdout FD = %d, stderr FD = %d",
+ stdinout_sfd_.fd(), stderr_sfd_.fd());
// Wait to make sure the subprocess exec'd without error.
child_error_sfd.Reset();
@@ -213,7 +303,38 @@
return false;
}
- local_socket_sfd_.Reset(parent_sfd.Release());
+ if (protocol_ == SubprocessProtocol::kNone) {
+ // No protocol: all streams pass through the stdinout FD and hook
+ // directly into the local socket for raw data transfer.
+ local_socket_sfd_.Reset(stdinout_sfd_.Release());
+ } else {
+ // Shell protocol: create another socketpair to intercept data.
+ if (!CreateSocketpair(&protocol_sfd_, &local_socket_sfd_)) {
+ return false;
+ }
+ D("protocol FD = %d", protocol_sfd_.fd());
+
+ input_.reset(new ShellProtocol(protocol_sfd_.fd()));
+ output_.reset(new ShellProtocol(protocol_sfd_.fd()));
+ if (!input_ || !output_) {
+ LOG(ERROR) << "failed to allocate shell protocol objects";
+ return false;
+ }
+
+ // Don't let reads/writes to the subprocess block our thread. This isn't
+ // likely but could happen under unusual circumstances, such as if we
+ // write a ton of data to stdin but the subprocess never reads it and
+ // the pipe fills up.
+ for (int fd : {stdinout_sfd_.fd(), stderr_sfd_.fd()}) {
+ if (fd >= 0) {
+ int flags = fcntl(fd, F_GETFL, 0);
+ if (flags < 0 || fcntl(fd, F_SETFL, flags | O_NONBLOCK) < 0) {
+ PLOG(ERROR) << "error making FD " << fd << " non-blocking";
+ return false;
+ }
+ }
+ }
+ }
if (!adb_thread_create(ThreadHandler, this)) {
PLOG(ERROR) << "failed to create subprocess thread";
@@ -259,6 +380,7 @@
adb_thread_setname(android::base::StringPrintf(
"shell srvc %d", subprocess->local_socket_fd()));
+ subprocess->PassDataStreams();
subprocess->WaitForExit();
D("deleting Subprocess");
@@ -267,25 +389,200 @@
return nullptr;
}
+void Subprocess::PassDataStreams() {
+ if (!protocol_sfd_.valid()) {
+ return;
+ }
+
+ // Start by trying to read from the protocol FD, stdout, and stderr.
+ fd_set master_read_set, master_write_set;
+ FD_ZERO(&master_read_set);
+ FD_ZERO(&master_write_set);
+ for (ScopedFd* sfd : {&protocol_sfd_, &stdinout_sfd_, &stderr_sfd_}) {
+ if (sfd->valid()) {
+ FD_SET(sfd->fd(), &master_read_set);
+ }
+ }
+
+ // Pass data until the protocol FD or both the subprocess pipes die, at
+ // which point we can't pass any more data.
+ while (protocol_sfd_.valid() &&
+ (stdinout_sfd_.valid() || stderr_sfd_.valid())) {
+ ScopedFd* dead_sfd = SelectLoop(&master_read_set, &master_write_set);
+ if (dead_sfd) {
+ D("closing FD %d", dead_sfd->fd());
+ FD_CLR(dead_sfd->fd(), &master_read_set);
+ FD_CLR(dead_sfd->fd(), &master_write_set);
+ if (dead_sfd == &protocol_sfd_) {
+ // Using SIGHUP is a decent general way to indicate that the
+ // controlling process is going away. If specific signals are
+ // needed (e.g. SIGINT), pass those through the shell protocol
+ // and only fall back on this for unexpected closures.
+ D("protocol FD died, sending SIGHUP to pid %d", pid_);
+ kill(pid_, SIGHUP);
+ }
+ dead_sfd->Reset();
+ }
+ }
+}
+
+namespace {
+
+inline bool ValidAndInSet(const ScopedFd& sfd, fd_set* set) {
+ return sfd.valid() && FD_ISSET(sfd.fd(), set);
+}
+
+} // namespace
+
+ScopedFd* Subprocess::SelectLoop(fd_set* master_read_set_ptr,
+ fd_set* master_write_set_ptr) {
+ fd_set read_set, write_set;
+ int select_n = std::max(std::max(protocol_sfd_.fd(), stdinout_sfd_.fd()),
+ stderr_sfd_.fd()) + 1;
+ ScopedFd* dead_sfd = nullptr;
+
+ // Keep calling select() and passing data until an FD closes/errors.
+ while (!dead_sfd) {
+ memcpy(&read_set, master_read_set_ptr, sizeof(read_set));
+ memcpy(&write_set, master_write_set_ptr, sizeof(write_set));
+ if (select(select_n, &read_set, &write_set, nullptr, nullptr) < 0) {
+ if (errno == EINTR) {
+ continue;
+ } else {
+ PLOG(ERROR) << "select failed, closing subprocess pipes";
+ stdinout_sfd_.Reset();
+ stderr_sfd_.Reset();
+ return nullptr;
+ }
+ }
+
+ // Read stdout, write to protocol FD.
+ if (ValidAndInSet(stdinout_sfd_, &read_set)) {
+ dead_sfd = PassOutput(&stdinout_sfd_, ShellProtocol::kIdStdout);
+ }
+
+ // Read stderr, write to protocol FD.
+ if (!dead_sfd && ValidAndInSet(stderr_sfd_, &read_set)) {
+ dead_sfd = PassOutput(&stderr_sfd_, ShellProtocol::kIdStderr);
+ }
+
+ // Read protocol FD, write to stdin.
+ if (!dead_sfd && ValidAndInSet(protocol_sfd_, &read_set)) {
+ dead_sfd = PassInput();
+ // If we didn't finish writing, block on stdin write.
+ if (input_bytes_left_) {
+ FD_CLR(protocol_sfd_.fd(), master_read_set_ptr);
+ FD_SET(stdinout_sfd_.fd(), master_write_set_ptr);
+ }
+ }
+
+ // Continue writing to stdin; only happens if a previous write blocked.
+ if (!dead_sfd && ValidAndInSet(stdinout_sfd_, &write_set)) {
+ dead_sfd = PassInput();
+ // If we finished writing, go back to blocking on protocol read.
+ if (!input_bytes_left_) {
+ FD_SET(protocol_sfd_.fd(), master_read_set_ptr);
+ FD_CLR(stdinout_sfd_.fd(), master_write_set_ptr);
+ }
+ }
+ } // while (!dead_sfd)
+
+ return dead_sfd;
+}
+
+ScopedFd* Subprocess::PassInput() {
+ // Only read a new packet if we've finished writing the last one.
+ if (!input_bytes_left_) {
+ if (!input_->Read()) {
+ // Read() uses ReadFdExactly() which sets errno to 0 on EOF.
+ if (errno != 0) {
+ PLOG(ERROR) << "error reading protocol FD "
+ << protocol_sfd_.fd();
+ }
+ return &protocol_sfd_;
+ }
+
+ // We only care about stdin packets.
+ if (stdinout_sfd_.valid() && input_->id() == ShellProtocol::kIdStdin) {
+ input_bytes_left_ = input_->data_length();
+ } else {
+ input_bytes_left_ = 0;
+ }
+ }
+
+ if (input_bytes_left_ > 0) {
+ int index = input_->data_length() - input_bytes_left_;
+ int bytes = adb_write(stdinout_sfd_.fd(), input_->data() + index,
+ input_bytes_left_);
+ if (bytes == 0 || (bytes < 0 && errno != EAGAIN)) {
+ if (bytes < 0) {
+ PLOG(ERROR) << "error reading stdin FD " << stdinout_sfd_.fd();
+ }
+ // stdin is done, mark this packet as finished and we'll just start
+ // dumping any further data received from the protocol FD.
+ input_bytes_left_ = 0;
+ return &stdinout_sfd_;
+ } else if (bytes > 0) {
+ input_bytes_left_ -= bytes;
+ }
+ }
+
+ return nullptr;
+}
+
+ScopedFd* Subprocess::PassOutput(ScopedFd* sfd, ShellProtocol::Id id) {
+ int bytes = adb_read(sfd->fd(), output_->data(), output_->data_capacity());
+ if (bytes == 0 || (bytes < 0 && errno != EAGAIN)) {
+ if (bytes < 0) {
+ PLOG(ERROR) << "error reading output FD " << sfd->fd();
+ }
+ return sfd;
+ }
+
+ if (bytes > 0 && !output_->Write(id, bytes)) {
+ if (errno != 0) {
+ PLOG(ERROR) << "error reading protocol FD " << protocol_sfd_.fd();
+ }
+ return &protocol_sfd_;
+ }
+
+ return nullptr;
+}
+
void Subprocess::WaitForExit() {
+ int exit_code = 1;
+
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)) {
+ exit_code = 0x80 | WTERMSIG(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) {
+ exit_code = WEXITSTATUS(status);
D("subprocess exit code = %d", WEXITSTATUS(status));
break;
}
}
}
+ // If we have an open protocol FD send an exit packet.
+ if (protocol_sfd_.valid()) {
+ output_->data()[0] = exit_code;
+ if (output_->Write(ShellProtocol::kIdExit, 1)) {
+ D("wrote the exit code packet: %d", exit_code);
+ } else {
+ PLOG(ERROR) << "failed to write the exit code packet";
+ }
+ protocol_sfd_.Reset();
+ }
+
// Pass the local socket FD to the shell cleanup fdevent.
if (SHELL_EXIT_NOTIFY_FD >= 0) {
int fd = local_socket_sfd_.fd();
@@ -305,11 +602,13 @@
} // namespace
-int StartSubprocess(const char *name, SubprocessType type) {
- D("starting %s subprocess: '%s'",
- type == SubprocessType::kRaw ? "raw" : "PTY", name);
+int StartSubprocess(const char *name, SubprocessType type,
+ SubprocessProtocol protocol) {
+ D("starting %s subprocess (protocol=%s): '%s'",
+ type == SubprocessType::kRaw ? "raw" : "PTY",
+ protocol == SubprocessProtocol::kNone ? "none" : "shell", name);
- Subprocess* subprocess = new Subprocess(name, type);
+ Subprocess* subprocess = new Subprocess(name, type, protocol);
if (!subprocess) {
LOG(ERROR) << "failed to allocate new subprocess";
return -1;
diff --git a/adb/shell_service.h b/adb/shell_service.h
index 81d7036..8868f10 100644
--- a/adb/shell_service.h
+++ b/adb/shell_service.h
@@ -124,11 +124,17 @@
kRaw,
};
+enum class SubprocessProtocol {
+ kNone,
+ kShell,
+};
+
// 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);
+int StartSubprocess(const char* name, SubprocessType type,
+ SubprocessProtocol protocol);
#endif // !ADB_HOST
diff --git a/adb/shell_service_test.cpp b/adb/shell_service_test.cpp
new file mode 100644
index 0000000..20efd84
--- /dev/null
+++ b/adb/shell_service_test.cpp
@@ -0,0 +1,270 @@
+/*
+ * 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 "shell_service.h"
+
+#include <gtest/gtest.h>
+
+#include <signal.h>
+
+#include <string>
+#include <vector>
+
+#include <base/strings.h>
+
+#include "adb.h"
+#include "adb_io.h"
+#include "sysdeps.h"
+
+class ShellServiceTest : public ::testing::Test {
+ public:
+ static void SetUpTestCase() {
+ // This is normally done in main.cpp.
+ saved_sigpipe_handler_ = signal(SIGPIPE, SIG_IGN);
+
+ }
+
+ static void TearDownTestCase() {
+ signal(SIGPIPE, saved_sigpipe_handler_);
+ }
+
+ // Helpers to start and cleanup a subprocess. Cleanup normally does not
+ // need to be called manually unless multiple subprocesses are run from
+ // a single test.
+ void StartTestSubprocess(const char* command, SubprocessType type,
+ SubprocessProtocol protocol);
+ void CleanupTestSubprocess();
+
+ virtual void TearDown() override {
+ void CleanupTestSubprocess();
+ }
+
+ static sighandler_t saved_sigpipe_handler_;
+
+ int subprocess_fd_ = -1;
+ int shell_exit_receiver_fd_ = -1, saved_shell_exit_fd_;
+};
+
+sighandler_t ShellServiceTest::saved_sigpipe_handler_ = nullptr;
+
+void ShellServiceTest::StartTestSubprocess(
+ const char* command, SubprocessType type, SubprocessProtocol protocol) {
+ // We want to intercept the shell exit message to make sure it's sent.
+ saved_shell_exit_fd_ = SHELL_EXIT_NOTIFY_FD;
+ int fd[2];
+ ASSERT_TRUE(adb_socketpair(fd) >= 0);
+ SHELL_EXIT_NOTIFY_FD = fd[0];
+ shell_exit_receiver_fd_ = fd[1];
+
+ subprocess_fd_ = StartSubprocess(command, type, protocol);
+ ASSERT_TRUE(subprocess_fd_ >= 0);
+}
+
+void ShellServiceTest::CleanupTestSubprocess() {
+ if (subprocess_fd_ >= 0) {
+ // Subprocess should send its FD to SHELL_EXIT_NOTIFY_FD for cleanup.
+ int notified_fd = -1;
+ ASSERT_TRUE(ReadFdExactly(shell_exit_receiver_fd_, ¬ified_fd,
+ sizeof(notified_fd)));
+ ASSERT_EQ(notified_fd, subprocess_fd_);
+
+ adb_close(subprocess_fd_);
+ subprocess_fd_ = -1;
+
+ // Restore SHELL_EXIT_NOTIFY_FD.
+ adb_close(SHELL_EXIT_NOTIFY_FD);
+ adb_close(shell_exit_receiver_fd_);
+ shell_exit_receiver_fd_ = -1;
+ SHELL_EXIT_NOTIFY_FD = saved_shell_exit_fd_;
+ }
+}
+
+namespace {
+
+// Reads raw data from |fd| until it closes or errors.
+std::string ReadRaw(int fd) {
+ char buffer[1024];
+ char *cur_ptr = buffer, *end_ptr = buffer + sizeof(buffer);
+
+ while (1) {
+ int bytes = adb_read(fd, cur_ptr, end_ptr - cur_ptr);
+ if (bytes <= 0) {
+ return std::string(buffer, cur_ptr);
+ }
+ cur_ptr += bytes;
+ }
+}
+
+// Reads shell protocol data from |fd| until it closes or errors. Fills
+// |stdout| and |stderr| with their respective data, and returns the exit code
+// read from the protocol or -1 if an exit code packet was not received.
+int ReadShellProtocol(int fd, std::string* stdout, std::string* stderr) {
+ int exit_code = -1;
+ stdout->clear();
+ stderr->clear();
+
+ ShellProtocol* protocol = new ShellProtocol(fd);
+ while (protocol->Read()) {
+ switch (protocol->id()) {
+ case ShellProtocol::kIdStdout:
+ stdout->append(protocol->data(), protocol->data_length());
+ break;
+ case ShellProtocol::kIdStderr:
+ stderr->append(protocol->data(), protocol->data_length());
+ break;
+ case ShellProtocol::kIdExit:
+ EXPECT_EQ(-1, exit_code) << "Multiple exit packets received";
+ EXPECT_EQ(1u, protocol->data_length());
+ exit_code = protocol->data()[0];
+ break;
+ default:
+ ADD_FAILURE() << "Unidentified packet ID: " << protocol->id();
+ }
+ }
+ delete protocol;
+
+ return exit_code;
+}
+
+// Checks if each line in |lines| exists in the same order in |output|. Blank
+// lines in |output| are ignored for simplicity.
+bool ExpectLinesEqual(const std::string& output,
+ const std::vector<std::string>& lines) {
+ auto output_lines = android::base::Split(output, "\r\n");
+ size_t i = 0;
+
+ for (const std::string& line : lines) {
+ // Skip empty lines in output.
+ while (i < output_lines.size() && output_lines[i].empty()) {
+ ++i;
+ }
+ if (i >= output_lines.size()) {
+ ADD_FAILURE() << "Ran out of output lines";
+ return false;
+ }
+ EXPECT_EQ(line, output_lines[i]);
+ ++i;
+ }
+
+ while (i < output_lines.size() && output_lines[i].empty()) {
+ ++i;
+ }
+ EXPECT_EQ(i, output_lines.size()) << "Found unmatched output lines";
+ return true;
+}
+
+} // namespace
+
+// Tests a raw subprocess with no protocol.
+TEST_F(ShellServiceTest, RawNoProtocolSubprocess) {
+ // [ -t 0 ] checks if stdin is connected to a terminal.
+ ASSERT_NO_FATAL_FAILURE(StartTestSubprocess(
+ "echo foo; echo bar >&2; [ -t 0 ]; echo $?",
+ SubprocessType::kRaw, SubprocessProtocol::kNone));
+
+ // [ -t 0 ] == 1 means no terminal (raw).
+ ExpectLinesEqual(ReadRaw(subprocess_fd_), {"foo", "bar", "1"});
+}
+
+// Tests a PTY subprocess with no protocol.
+TEST_F(ShellServiceTest, PtyNoProtocolSubprocess) {
+ // [ -t 0 ] checks if stdin is connected to a terminal.
+ ASSERT_NO_FATAL_FAILURE(StartTestSubprocess(
+ "echo foo; echo bar >&2; [ -t 0 ]; echo $?",
+ SubprocessType::kPty, SubprocessProtocol::kNone));
+
+ // [ -t 0 ] == 0 means we have a terminal (PTY).
+ ExpectLinesEqual(ReadRaw(subprocess_fd_), {"foo", "bar", "0"});
+}
+
+// Tests a raw subprocess with the shell protocol.
+TEST_F(ShellServiceTest, RawShellProtocolSubprocess) {
+ ASSERT_NO_FATAL_FAILURE(StartTestSubprocess(
+ "echo foo; echo bar >&2; echo baz; exit 24",
+ SubprocessType::kRaw, SubprocessProtocol::kShell));
+
+ std::string stdout, stderr;
+ EXPECT_EQ(24, ReadShellProtocol(subprocess_fd_, &stdout, &stderr));
+ ExpectLinesEqual(stdout, {"foo", "baz"});
+ ExpectLinesEqual(stderr, {"bar"});
+}
+
+// Tests a PTY subprocess with the shell protocol.
+TEST_F(ShellServiceTest, PtyShellProtocolSubprocess) {
+ ASSERT_NO_FATAL_FAILURE(StartTestSubprocess(
+ "echo foo; echo bar >&2; echo baz; exit 50",
+ SubprocessType::kPty, SubprocessProtocol::kShell));
+
+ // PTY always combines stdout and stderr but the shell protocol should
+ // still give us an exit code.
+ std::string stdout, stderr;
+ EXPECT_EQ(50, ReadShellProtocol(subprocess_fd_, &stdout, &stderr));
+ ExpectLinesEqual(stdout, {"foo", "bar", "baz"});
+ ExpectLinesEqual(stderr, {});
+}
+
+// Tests an interactive PTY session.
+TEST_F(ShellServiceTest, InteractivePtySubprocess) {
+ ASSERT_NO_FATAL_FAILURE(StartTestSubprocess(
+ "", SubprocessType::kPty, SubprocessProtocol::kShell));
+
+ // Use variable substitution so echoed input is different from output.
+ const char* commands[] = {"TEST_STR=abc123",
+ "echo --${TEST_STR}--",
+ "exit"};
+
+ ShellProtocol* protocol = new ShellProtocol(subprocess_fd_);
+ for (std::string command : commands) {
+ // Interactive shell requires a newline to complete each command.
+ command.push_back('\n');
+ memcpy(protocol->data(), command.data(), command.length());
+ ASSERT_TRUE(protocol->Write(ShellProtocol::kIdStdin, command.length()));
+ }
+ delete protocol;
+
+ std::string stdout, stderr;
+ EXPECT_EQ(0, ReadShellProtocol(subprocess_fd_, &stdout, &stderr));
+ // An unpredictable command prompt makes parsing exact output difficult but
+ // it should at least contain echoed input and the expected output.
+ for (const char* command : commands) {
+ EXPECT_FALSE(stdout.find(command) == std::string::npos);
+ }
+ EXPECT_FALSE(stdout.find("--abc123--") == std::string::npos);
+}
+
+// Tests that nothing breaks when the stdin/stdout pipe closes.
+TEST_F(ShellServiceTest, CloseStdinStdoutSubprocess) {
+ ASSERT_NO_FATAL_FAILURE(StartTestSubprocess(
+ "exec 0<&-; exec 1>&-; echo bar >&2",
+ SubprocessType::kRaw, SubprocessProtocol::kShell));
+
+ std::string stdout, stderr;
+ EXPECT_EQ(0, ReadShellProtocol(subprocess_fd_, &stdout, &stderr));
+ ExpectLinesEqual(stdout, {});
+ ExpectLinesEqual(stderr, {"bar"});
+}
+
+// Tests that nothing breaks when the stderr pipe closes.
+TEST_F(ShellServiceTest, CloseStderrSubprocess) {
+ ASSERT_NO_FATAL_FAILURE(StartTestSubprocess(
+ "exec 2>&-; echo foo",
+ SubprocessType::kRaw, SubprocessProtocol::kShell));
+
+ std::string stdout, stderr;
+ EXPECT_EQ(0, ReadShellProtocol(subprocess_fd_, &stdout, &stderr));
+ ExpectLinesEqual(stdout, {"foo"});
+ ExpectLinesEqual(stderr, {});
+}
diff --git a/adb/socket.h b/adb/socket.h
new file mode 100644
index 0000000..4083036
--- /dev/null
+++ b/adb/socket.h
@@ -0,0 +1,117 @@
+/*
+ * 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 __ADB_SOCKET_H
+#define __ADB_SOCKET_H
+
+#include <stddef.h>
+
+#include "fdevent.h"
+
+struct apacket;
+class atransport;
+
+/* An asocket represents one half of a connection between a local and
+** remote entity. A local asocket is bound to a file descriptor. A
+** remote asocket is bound to the protocol engine.
+*/
+struct asocket {
+ /* chain pointers for the local/remote list of
+ ** asockets that this asocket lives in
+ */
+ asocket *next;
+ asocket *prev;
+
+ /* the unique identifier for this asocket
+ */
+ unsigned id;
+
+ /* flag: set when the socket's peer has closed
+ ** but packets are still queued for delivery
+ */
+ int closing;
+
+ // flag: set when the socket failed to write, so the socket will not wait to
+ // write packets and close directly.
+ bool has_write_error;
+
+ /* flag: quit adbd when both ends close the
+ ** local service socket
+ */
+ int exit_on_close;
+
+ /* the asocket we are connected to
+ */
+
+ asocket *peer;
+
+ /* For local asockets, the fde is used to bind
+ ** us to our fd event system. For remote asockets
+ ** these fields are not used.
+ */
+ fdevent fde;
+ int fd;
+
+ /* queue of apackets waiting to be written
+ */
+ apacket *pkt_first;
+ apacket *pkt_last;
+
+ /* enqueue is called by our peer when it has data
+ ** for us. It should return 0 if we can accept more
+ ** data or 1 if not. If we return 1, we must call
+ ** peer->ready() when we once again are ready to
+ ** receive data.
+ */
+ int (*enqueue)(asocket *s, apacket *pkt);
+
+ /* ready is called by the peer when it is ready for
+ ** us to send data via enqueue again
+ */
+ void (*ready)(asocket *s);
+
+ /* shutdown is called by the peer before it goes away.
+ ** the socket should not do any further calls on its peer.
+ ** Always followed by a call to close. Optional, i.e. can be NULL.
+ */
+ void (*shutdown)(asocket *s);
+
+ /* close is called by the peer when it has gone away.
+ ** we are not allowed to make any further calls on the
+ ** peer once our close method is called.
+ */
+ void (*close)(asocket *s);
+
+ /* A socket is bound to atransport */
+ atransport *transport;
+
+ size_t get_max_payload() const;
+};
+
+asocket *find_local_socket(unsigned local_id, unsigned remote_id);
+void install_local_socket(asocket *s);
+void remove_socket(asocket *s);
+void close_all_sockets(atransport *t);
+
+asocket *create_local_socket(int fd);
+asocket *create_local_service_socket(const char* destination,
+ const atransport* transport);
+
+asocket *create_remote_socket(unsigned id, atransport *t);
+void connect_to_remote(asocket *s, const char *destination);
+void connect_to_smartsocket(asocket *s);
+
+#endif // __ADB_SOCKET_H
diff --git a/adb/socket_test.cpp b/adb/socket_test.cpp
new file mode 100644
index 0000000..8f395d1
--- /dev/null
+++ b/adb/socket_test.cpp
@@ -0,0 +1,300 @@
+/*
+ * 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 "fdevent.h"
+
+#include <gtest/gtest.h>
+
+#include <limits>
+#include <queue>
+#include <string>
+#include <vector>
+
+#include <pthread.h>
+#include <signal.h>
+#include <unistd.h>
+
+#include "adb.h"
+#include "adb_io.h"
+#include "socket.h"
+#include "sysdeps.h"
+
+static void signal_handler(int) {
+ ASSERT_EQ(1u, fdevent_installed_count());
+ pthread_exit(nullptr);
+}
+
+// On host, register a dummy socket, so fdevet_loop() will not abort when previously
+// registered local sockets are all closed. On device, fdevent_subproc_setup() installs
+// one fdevent which can be considered as dummy socket.
+static void InstallDummySocket() {
+#if ADB_HOST
+ int dummy_fds[2];
+ ASSERT_EQ(0, pipe(dummy_fds));
+ asocket* dummy_socket = create_local_socket(dummy_fds[0]);
+ ASSERT_TRUE(dummy_socket != nullptr);
+ dummy_socket->ready(dummy_socket);
+#endif
+}
+
+struct ThreadArg {
+ int first_read_fd;
+ int last_write_fd;
+ size_t middle_pipe_count;
+};
+
+static void FdEventThreadFunc(ThreadArg* arg) {
+ std::vector<int> read_fds;
+ std::vector<int> write_fds;
+
+ read_fds.push_back(arg->first_read_fd);
+ for (size_t i = 0; i < arg->middle_pipe_count; ++i) {
+ int fds[2];
+ ASSERT_EQ(0, adb_socketpair(fds));
+ read_fds.push_back(fds[0]);
+ write_fds.push_back(fds[1]);
+ }
+ write_fds.push_back(arg->last_write_fd);
+
+ for (size_t i = 0; i < read_fds.size(); ++i) {
+ asocket* reader = create_local_socket(read_fds[i]);
+ ASSERT_TRUE(reader != nullptr);
+ asocket* writer = create_local_socket(write_fds[i]);
+ ASSERT_TRUE(writer != nullptr);
+ reader->peer = writer;
+ writer->peer = reader;
+ reader->ready(reader);
+ }
+
+ InstallDummySocket();
+ fdevent_loop();
+}
+
+class LocalSocketTest : public ::testing::Test {
+ protected:
+ static void SetUpTestCase() {
+ ASSERT_NE(SIG_ERR, signal(SIGUSR1, signal_handler));
+ ASSERT_NE(SIG_ERR, signal(SIGPIPE, SIG_IGN));
+ }
+
+ virtual void SetUp() {
+ fdevent_reset();
+ ASSERT_EQ(0u, fdevent_installed_count());
+ }
+};
+
+TEST_F(LocalSocketTest, smoke) {
+ const size_t PIPE_COUNT = 100;
+ const size_t MESSAGE_LOOP_COUNT = 100;
+ const std::string MESSAGE = "socket_test";
+ int fd_pair1[2];
+ int fd_pair2[2];
+ ASSERT_EQ(0, adb_socketpair(fd_pair1));
+ ASSERT_EQ(0, adb_socketpair(fd_pair2));
+ pthread_t thread;
+ ThreadArg thread_arg;
+ thread_arg.first_read_fd = fd_pair1[0];
+ thread_arg.last_write_fd = fd_pair2[1];
+ thread_arg.middle_pipe_count = PIPE_COUNT;
+ int writer = fd_pair1[1];
+ int reader = fd_pair2[0];
+
+ ASSERT_EQ(0, pthread_create(&thread, nullptr,
+ reinterpret_cast<void* (*)(void*)>(FdEventThreadFunc),
+ &thread_arg));
+
+ usleep(1000);
+ for (size_t i = 0; i < MESSAGE_LOOP_COUNT; ++i) {
+ std::string read_buffer = MESSAGE;
+ std::string write_buffer(MESSAGE.size(), 'a');
+ ASSERT_TRUE(WriteFdExactly(writer, read_buffer.c_str(), read_buffer.size()));
+ ASSERT_TRUE(ReadFdExactly(reader, &write_buffer[0], write_buffer.size()));
+ ASSERT_EQ(read_buffer, write_buffer);
+ }
+ ASSERT_EQ(0, adb_close(writer));
+ ASSERT_EQ(0, adb_close(reader));
+ // Wait until the local sockets are closed.
+ sleep(1);
+
+ ASSERT_EQ(0, pthread_kill(thread, SIGUSR1));
+ ASSERT_EQ(0, pthread_join(thread, nullptr));
+}
+
+struct CloseWithPacketArg {
+ int socket_fd;
+ size_t bytes_written;
+ int cause_close_fd;
+};
+
+static void CloseWithPacketThreadFunc(CloseWithPacketArg* arg) {
+ asocket* s = create_local_socket(arg->socket_fd);
+ ASSERT_TRUE(s != nullptr);
+ arg->bytes_written = 0;
+ while (true) {
+ apacket* p = get_apacket();
+ p->len = sizeof(p->data);
+ arg->bytes_written += p->len;
+ int ret = s->enqueue(s, p);
+ if (ret == 1) {
+ // The writer has one packet waiting to send.
+ break;
+ }
+ }
+
+ asocket* cause_close_s = create_local_socket(arg->cause_close_fd);
+ ASSERT_TRUE(cause_close_s != nullptr);
+ cause_close_s->peer = s;
+ s->peer = cause_close_s;
+ cause_close_s->ready(cause_close_s);
+
+ InstallDummySocket();
+ fdevent_loop();
+}
+
+// This test checks if we can close local socket in the following situation:
+// The socket is closing but having some packets, so it is not closed. Then
+// some write error happens in the socket's file handler, e.g., the file
+// handler is closed.
+TEST_F(LocalSocketTest, close_with_packet) {
+ int socket_fd[2];
+ ASSERT_EQ(0, adb_socketpair(socket_fd));
+ int cause_close_fd[2];
+ ASSERT_EQ(0, adb_socketpair(cause_close_fd));
+ CloseWithPacketArg arg;
+ arg.socket_fd = socket_fd[1];
+ arg.cause_close_fd = cause_close_fd[1];
+ pthread_t thread;
+ ASSERT_EQ(0, pthread_create(&thread, nullptr,
+ reinterpret_cast<void* (*)(void*)>(CloseWithPacketThreadFunc),
+ &arg));
+ // Wait until the fdevent_loop() starts.
+ sleep(1);
+ ASSERT_EQ(0, adb_close(cause_close_fd[0]));
+ sleep(1);
+ ASSERT_EQ(2u, fdevent_installed_count());
+ ASSERT_EQ(0, adb_close(socket_fd[0]));
+ // Wait until the socket is closed.
+ sleep(1);
+
+ ASSERT_EQ(0, pthread_kill(thread, SIGUSR1));
+ ASSERT_EQ(0, pthread_join(thread, nullptr));
+}
+
+#undef shutdown
+
+// This test checks if we can read packets from a closing local socket.
+// The socket's file handler may be non readable if the other side has
+// called shutdown(SHUT_WR). But we should always write packets
+// successfully to the other side.
+TEST_F(LocalSocketTest, half_close_with_packet) {
+ int socket_fd[2];
+ ASSERT_EQ(0, adb_socketpair(socket_fd));
+ int cause_close_fd[2];
+ ASSERT_EQ(0, adb_socketpair(cause_close_fd));
+ CloseWithPacketArg arg;
+ arg.socket_fd = socket_fd[1];
+ arg.cause_close_fd = cause_close_fd[1];
+
+ pthread_t thread;
+ ASSERT_EQ(0, pthread_create(&thread, nullptr,
+ reinterpret_cast<void* (*)(void*)>(CloseWithPacketThreadFunc),
+ &arg));
+ // Wait until the fdevent_loop() starts.
+ sleep(1);
+ ASSERT_EQ(0, adb_close(cause_close_fd[0]));
+ sleep(1);
+ ASSERT_EQ(2u, fdevent_installed_count());
+ ASSERT_EQ(0, shutdown(socket_fd[0], SHUT_WR));
+
+ // Verify if we can read successfully.
+ std::vector<char> buf(arg.bytes_written);
+ ASSERT_EQ(true, ReadFdExactly(socket_fd[0], buf.data(), buf.size()));
+ ASSERT_EQ(0, adb_close(socket_fd[0]));
+
+ // Wait until the socket is closed.
+ sleep(1);
+
+ ASSERT_EQ(0, pthread_kill(thread, SIGUSR1));
+ ASSERT_EQ(0, pthread_join(thread, nullptr));
+}
+
+// This test checks if we can close local socket in the following situation:
+// The socket is not closed and has some packets. When it fails to write to
+// the socket's file handler because the other end is closed, we check if the
+// socket is closed.
+TEST_F(LocalSocketTest, write_error_when_having_packets) {
+ int socket_fd[2];
+ ASSERT_EQ(0, adb_socketpair(socket_fd));
+ int cause_close_fd[2];
+ ASSERT_EQ(0, adb_socketpair(cause_close_fd));
+ CloseWithPacketArg arg;
+ arg.socket_fd = socket_fd[1];
+ arg.cause_close_fd = cause_close_fd[1];
+
+ pthread_t thread;
+ ASSERT_EQ(0, pthread_create(&thread, nullptr,
+ reinterpret_cast<void* (*)(void*)>(CloseWithPacketThreadFunc),
+ &arg));
+ // Wait until the fdevent_loop() starts.
+ sleep(1);
+ ASSERT_EQ(3u, fdevent_installed_count());
+ ASSERT_EQ(0, adb_close(socket_fd[0]));
+
+ // Wait until the socket is closed.
+ sleep(1);
+
+ ASSERT_EQ(0, pthread_kill(thread, SIGUSR1));
+ ASSERT_EQ(0, pthread_join(thread, nullptr));
+}
+
+struct CloseNoEventsArg {
+ int socket_fd;
+};
+
+static void CloseNoEventsThreadFunc(CloseNoEventsArg* arg) {
+ asocket* s = create_local_socket(arg->socket_fd);
+ ASSERT_TRUE(s != nullptr);
+
+ InstallDummySocket();
+ fdevent_loop();
+}
+
+// This test checks when a local socket doesn't enable FDE_READ/FDE_WRITE/FDE_ERROR, it
+// can still be closed when some error happens on its file handler.
+// This test successes on linux but fails on mac because of different implementation of
+// poll(). I think the function tested here is useful to make adb server more stable on
+// linux.
+TEST_F(LocalSocketTest, close_with_no_events_installed) {
+ int socket_fd[2];
+ ASSERT_EQ(0, adb_socketpair(socket_fd));
+
+ CloseNoEventsArg arg;
+ arg.socket_fd = socket_fd[1];
+ pthread_t thread;
+ ASSERT_EQ(0, pthread_create(&thread, nullptr,
+ reinterpret_cast<void* (*)(void*)>(CloseNoEventsThreadFunc),
+ &arg));
+ // Wait until the fdevent_loop() starts.
+ sleep(1);
+ ASSERT_EQ(2u, fdevent_installed_count());
+ ASSERT_EQ(0, adb_close(socket_fd[0]));
+
+ // Wait until the socket is closed.
+ sleep(1);
+
+ ASSERT_EQ(0, pthread_kill(thread, SIGUSR1));
+ ASSERT_EQ(0, pthread_join(thread, nullptr));
+}
diff --git a/adb/sockets.cpp b/adb/sockets.cpp
index f8c22cc..bd33d79 100644
--- a/adb/sockets.cpp
+++ b/adb/sockets.cpp
@@ -157,6 +157,8 @@
}
if((r == 0) || (errno != EAGAIN)) {
D( "LS(%d): not ready, errno=%d: %s", s->id, errno, strerror(errno) );
+ put_apacket(p);
+ s->has_write_error = true;
s->close(s);
return 1; /* not ready (error) */
} else {
@@ -252,7 +254,7 @@
/* If we are already closing, or if there are no
** pending packets, destroy immediately
*/
- if (s->closing || s->pkt_first == NULL) {
+ if (s->closing || s->has_write_error || s->pkt_first == NULL) {
int id = s->id;
local_socket_destroy(s);
D("LS(%d): closed", id);
@@ -267,6 +269,7 @@
remove_socket(s);
D("LS(%d): put on socket_closing_list fd=%d", s->id, s->fd);
insert_local_socket(s, &local_socket_closing_list);
+ CHECK_EQ(FDE_WRITE, s->fde.state & FDE_WRITE);
}
static void local_socket_event_func(int fd, unsigned ev, void* _s)
@@ -296,6 +299,7 @@
}
D(" closing after write because r=%d and errno is %d", r, errno);
+ s->has_write_error = true;
s->close(s);
return;
}
@@ -392,6 +396,7 @@
D(" closing because is_eof=%d r=%d s->fde.force_eof=%d",
is_eof, r, s->fde.force_eof);
s->close(s);
+ return;
}
}
@@ -401,7 +406,6 @@
** bytes of readable data.
*/
D("LS(%d): FDE_ERROR (fd=%d)", s->id, s->fd);
-
return;
}
}
@@ -422,7 +426,8 @@
return s;
}
-asocket *create_local_service_socket(const char *name)
+asocket *create_local_service_socket(const char *name,
+ const atransport* transport)
{
#if !ADB_HOST
if (!strcmp(name,"jdwp")) {
@@ -432,7 +437,7 @@
return create_jdwp_tracker_service_socket();
}
#endif
- int fd = service_to_fd(name);
+ int fd = service_to_fd(name, transport);
if(fd < 0) return 0;
asocket* s = create_local_socket(fd);
diff --git a/adb/test_adb.py b/adb/test_adb.py
index 59aa14d..5bda22f 100644
--- a/adb/test_adb.py
+++ b/adb/test_adb.py
@@ -21,8 +21,10 @@
"""
from __future__ import print_function
+import os
import random
import subprocess
+import threading
import unittest
import adb
@@ -63,6 +65,80 @@
self.assertEqual(1, p.returncode)
self.assertIn('error', out)
+ # Helper method that reads a pipe until it is closed, then sets the event.
+ def _read_pipe_and_set_event(self, pipe, event):
+ x = pipe.read()
+ event.set()
+
+ # Test that launch_server() does not let the adb server inherit
+ # stdin/stdout/stderr handles which can cause callers of adb.exe to hang.
+ # This test also runs fine on unix even though the impetus is an issue
+ # unique to Windows.
+ def test_handle_inheritance(self):
+ # This test takes 5 seconds to run on Windows: if there is no adb server
+ # running on the the port used below, adb kill-server tries to make a
+ # TCP connection to a closed port and that takes 1 second on Windows;
+ # adb start-server does the same TCP connection which takes another
+ # second, and it waits 3 seconds after starting the server.
+
+ # Start adb client with redirected stdin/stdout/stderr to check if it
+ # passes those redirections to the adb server that it starts. To do
+ # this, run an instance of the adb server on a non-default port so we
+ # don't conflict with a pre-existing adb server that may already be
+ # setup with adb TCP/emulator connections. If there is a pre-existing
+ # adb server, this also tests whether multiple instances of the adb
+ # server conflict on adb.log.
+
+ port = 5038
+ # Kill any existing server on this non-default port.
+ subprocess.check_output(['adb', '-P', str(port), 'kill-server'],
+ stderr=subprocess.STDOUT)
+
+ try:
+ # Run the adb client and have it start the adb server.
+ p = subprocess.Popen(['adb', '-P', str(port), 'start-server'],
+ stdin=subprocess.PIPE, stdout=subprocess.PIPE,
+ stderr=subprocess.PIPE)
+
+ # Start threads that set events when stdout/stderr are closed.
+ stdout_event = threading.Event()
+ stdout_thread = threading.Thread(
+ target=self._read_pipe_and_set_event,
+ args=(p.stdout, stdout_event))
+ stdout_thread.daemon = True
+ stdout_thread.start()
+
+ stderr_event = threading.Event()
+ stderr_thread = threading.Thread(
+ target=self._read_pipe_and_set_event,
+ args=(p.stderr, stderr_event))
+ stderr_thread.daemon = True
+ stderr_thread.start()
+
+ # Wait for the adb client to finish. Once that has occurred, if
+ # stdin/stderr/stdout are still open, it must be open in the adb
+ # server.
+ p.wait()
+
+ # Try to write to stdin which we expect is closed. If it isn't
+ # closed, we should get an IOError. If we don't get an IOError,
+ # stdin must still be open in the adb server. The adb client is
+ # probably letting the adb server inherit stdin which would be
+ # wrong.
+ with self.assertRaises(IOError):
+ p.stdin.write('x')
+
+ # Wait a few seconds for stdout/stderr to be closed (in the success
+ # case, this won't wait at all). If there is a timeout, that means
+ # stdout/stderr were not closed and and they must be open in the adb
+ # server, suggesting that the adb client is letting the adb server
+ # inherit stdout/stderr which would be wrong.
+ self.assertTrue(stdout_event.wait(5), "adb stdout not closed")
+ self.assertTrue(stderr_event.wait(5), "adb stderr not closed")
+ finally:
+ # If we started a server, kill it.
+ subprocess.check_output(['adb', '-P', str(port), 'kill-server'],
+ stderr=subprocess.STDOUT)
def main():
random.seed(0)
diff --git a/adb/test_device.py b/adb/test_device.py
index 2006937..d033a01 100644
--- a/adb/test_device.py
+++ b/adb/test_device.py
@@ -23,6 +23,7 @@
import random
import shlex
import shutil
+import signal
import subprocess
import tempfile
import unittest
@@ -37,7 +38,7 @@
if self.device.get_prop('ro.debuggable') != '1':
raise unittest.SkipTest('requires rootable build')
- was_root = self.device.shell(['id', '-un']).strip() == 'root'
+ was_root = self.device.shell(['id', '-un'])[0].strip() == 'root'
if not was_root:
self.device.root()
self.device.wait()
@@ -113,7 +114,7 @@
class ShellTest(DeviceTest):
def test_cat(self):
"""Check that we can at least cat a file."""
- out = self.device.shell(['cat', '/proc/uptime']).strip()
+ out = self.device.shell(['cat', '/proc/uptime'])[0].strip()
elements = out.split()
self.assertEqual(len(elements), 2)
@@ -122,20 +123,19 @@
self.assertGreater(float(idle), 0.0)
def test_throws_on_failure(self):
- self.assertRaises(subprocess.CalledProcessError,
- self.device.shell, ['false'])
+ self.assertRaises(adb.ShellError, self.device.shell, ['false'])
def test_output_not_stripped(self):
- out = self.device.shell(['echo', 'foo'])
+ out = self.device.shell(['echo', 'foo'])[0]
self.assertEqual(out, 'foo' + self.device.linesep)
def test_shell_nocheck_failure(self):
- rc, out = self.device.shell_nocheck(['false'])
+ rc, out, _ = self.device.shell_nocheck(['false'])
self.assertNotEqual(rc, 0)
self.assertEqual(out, '')
def test_shell_nocheck_output_not_stripped(self):
- rc, out = self.device.shell_nocheck(['echo', 'foo'])
+ rc, out, _ = self.device.shell_nocheck(['echo', 'foo'])
self.assertEqual(rc, 0)
self.assertEqual(out, 'foo' + self.device.linesep)
@@ -143,7 +143,7 @@
# If result checking on ADB shell is naively implemented as
# `adb shell <cmd>; echo $?`, we would be unable to distinguish the
# output from the result for a cmd of `echo -n 1`.
- rc, out = self.device.shell_nocheck(['echo', '-n', '1'])
+ rc, out, _ = self.device.shell_nocheck(['echo', '-n', '1'])
self.assertEqual(rc, 0)
self.assertEqual(out, '1')
@@ -152,7 +152,7 @@
Bug: http://b/19735063
"""
- output = self.device.shell(['uname'])
+ output = self.device.shell(['uname'])[0]
self.assertEqual(output, 'Linux' + self.device.linesep)
def test_pty_logic(self):
@@ -180,6 +180,51 @@
exit_code = self.device.shell_nocheck(['[ -t 0 ]'])[0]
self.assertEqual(exit_code, 1)
+ def test_shell_protocol(self):
+ """Tests the shell protocol on the device.
+
+ If the device supports shell protocol, this gives us the ability
+ to separate stdout/stderr and return the exit code directly.
+
+ Bug: http://b/19734861
+ """
+ if self.device.SHELL_PROTOCOL_FEATURE not in self.device.features:
+ raise unittest.SkipTest('shell protocol unsupported on this device')
+ result = self.device.shell_nocheck(
+ shlex.split('echo foo; echo bar >&2; exit 17'))
+
+ self.assertEqual(17, result[0])
+ self.assertEqual('foo' + self.device.linesep, result[1])
+ self.assertEqual('bar' + self.device.linesep, result[2])
+
+ def test_non_interactive_sigint(self):
+ """Tests that SIGINT in a non-interactive shell kills the process.
+
+ This requires the shell protocol in order to detect the broken
+ pipe; raw data transfer mode will only see the break once the
+ subprocess tries to read or write.
+
+ Bug: http://b/23825725
+ """
+ if self.device.SHELL_PROTOCOL_FEATURE not in self.device.features:
+ raise unittest.SkipTest('shell protocol unsupported on this device')
+
+ # Start a long-running process.
+ sleep_proc = subprocess.Popen(
+ self.device.adb_cmd + shlex.split('shell echo $$; sleep 60'),
+ stdin=subprocess.PIPE, stdout=subprocess.PIPE,
+ stderr=subprocess.STDOUT)
+ remote_pid = sleep_proc.stdout.readline().strip()
+ self.assertIsNone(sleep_proc.returncode, 'subprocess terminated early')
+ proc_query = shlex.split('ps {0} | grep {0}'.format(remote_pid))
+
+ # Verify that the process is running, send signal, verify it stopped.
+ self.device.shell(proc_query)
+ os.kill(sleep_proc.pid, signal.SIGINT)
+ sleep_proc.communicate()
+ self.assertEqual(1, self.device.shell_nocheck(proc_query)[0],
+ 'subprocess failed to terminate')
+
class ArgumentEscapingTest(DeviceTest):
def test_shell_escaping(self):
@@ -191,25 +236,26 @@
# as `sh -c echo` (with an argument to that shell of "hello"),
# and then `echo world` back in the first shell.
result = self.device.shell(
- shlex.split("sh -c 'echo hello; echo world'"))
+ shlex.split("sh -c 'echo hello; echo world'"))[0]
result = result.splitlines()
self.assertEqual(['', 'world'], result)
# If you really wanted "hello" and "world", here's what you'd do:
result = self.device.shell(
- shlex.split(r'echo hello\;echo world')).splitlines()
+ shlex.split(r'echo hello\;echo world'))[0].splitlines()
self.assertEqual(['hello', 'world'], result)
# http://b/15479704
- result = self.device.shell(shlex.split("'true && echo t'")).strip()
+ result = self.device.shell(shlex.split("'true && echo t'"))[0].strip()
self.assertEqual('t', result)
result = self.device.shell(
- shlex.split("sh -c 'true && echo t'")).strip()
+ shlex.split("sh -c 'true && echo t'"))[0].strip()
self.assertEqual('t', result)
# http://b/20564385
- result = self.device.shell(shlex.split('FOO=a BAR=b echo t')).strip()
+ result = self.device.shell(shlex.split('FOO=a BAR=b echo t'))[0].strip()
self.assertEqual('t', result)
- result = self.device.shell(shlex.split(r'echo -n 123\;uname')).strip()
+ result = self.device.shell(
+ shlex.split(r'echo -n 123\;uname'))[0].strip()
self.assertEqual('123Linux', result)
def test_install_argument_escaping(self):
@@ -235,19 +281,19 @@
if 'adbd cannot run as root in production builds' in message:
return
self.device.wait()
- self.assertEqual('root', self.device.shell(['id', '-un']).strip())
+ self.assertEqual('root', self.device.shell(['id', '-un'])[0].strip())
def _test_unroot(self):
self.device.unroot()
self.device.wait()
- self.assertEqual('shell', self.device.shell(['id', '-un']).strip())
+ self.assertEqual('shell', self.device.shell(['id', '-un'])[0].strip())
def test_root_unroot(self):
"""Make sure that adb root and adb unroot work, using id(1)."""
if self.device.get_prop('ro.debuggable') != '1':
raise unittest.SkipTest('requires rootable build')
- original_user = self.device.shell(['id', '-un']).strip()
+ original_user = self.device.shell(['id', '-un'])[0].strip()
try:
if original_user == 'root':
self._test_unroot()
@@ -286,7 +332,7 @@
self.device.set_prop(prop_name, 'qux')
self.assertEqual(
- self.device.shell(['getprop', prop_name]).strip(), 'qux')
+ self.device.shell(['getprop', prop_name])[0].strip(), 'qux')
def compute_md5(string):
@@ -351,7 +397,7 @@
device.shell(['dd', 'if=/dev/urandom', 'of={}'.format(full_path),
'bs={}'.format(size), 'count=1'])
- dev_md5, _ = device.shell([get_md5_prog(device), full_path]).split()
+ dev_md5, _ = device.shell([get_md5_prog(device), full_path])[0].split()
files.append(DeviceFile(dev_md5, full_path))
return files
@@ -366,7 +412,7 @@
self.device.shell(['rm', '-rf', self.DEVICE_TEMP_FILE])
self.device.push(local=local_file, remote=self.DEVICE_TEMP_FILE)
dev_md5, _ = self.device.shell([get_md5_prog(self.device),
- self.DEVICE_TEMP_FILE]).split()
+ self.DEVICE_TEMP_FILE])[0].split()
self.assertEqual(checksum, dev_md5)
self.device.shell(['rm', '-f', self.DEVICE_TEMP_FILE])
@@ -401,7 +447,7 @@
'count={}'.format(kbytes)]
self.device.shell(cmd)
dev_md5, _ = self.device.shell(
- [get_md5_prog(self.device), self.DEVICE_TEMP_FILE]).split()
+ [get_md5_prog(self.device), self.DEVICE_TEMP_FILE])[0].split()
self._test_pull(self.DEVICE_TEMP_FILE, dev_md5)
self.device.shell_nocheck(['rm', self.DEVICE_TEMP_FILE])
@@ -449,11 +495,12 @@
device_full_path = posixpath.join(self.DEVICE_TEMP_DIR,
temp_file.base_name)
dev_md5, _ = device.shell(
- [get_md5_prog(self.device), device_full_path]).split()
+ [get_md5_prog(self.device), device_full_path])[0].split()
self.assertEqual(temp_file.checksum, dev_md5)
self.device.shell(['rm', '-rf', self.DEVICE_TEMP_DIR])
- shutil.rmtree(base_dir + self.DEVICE_TEMP_DIR)
+ if base_dir is not None:
+ shutil.rmtree(base_dir)
def test_unicode_paths(self):
"""Ensure that we can support non-ASCII paths, even on Windows."""
diff --git a/adb/transport.cpp b/adb/transport.cpp
index e97c479..db9236e 100644
--- a/adb/transport.cpp
+++ b/adb/transport.cpp
@@ -779,10 +779,15 @@
return max_payload;
}
+// Do not use any of [:;=,] in feature strings, they have special meaning
+// in the connection banner.
+// TODO(dpursell): add this in once we can pass features through to the client.
+const char kFeatureShell2[] = "shell_2";
+
// The list of features supported by the current system. Will be sent to the
// other side of the connection in the banner.
static const FeatureSet gSupportedFeatures = {
- // None yet.
+ kFeatureShell2,
};
const FeatureSet& supported_features() {
diff --git a/adb/transport.h b/adb/transport.h
index 3b56c55..999922a 100644
--- a/adb/transport.h
+++ b/adb/transport.h
@@ -29,6 +29,8 @@
const FeatureSet& supported_features();
+const extern char kFeatureShell2[];
+
class atransport {
public:
// TODO(danalbert): We expose waaaaaaay too much stuff because this was
diff --git a/crash_reporter/Android.mk b/crash_reporter/Android.mk
index 467432a..6cd34ab 100644
--- a/crash_reporter/Android.mk
+++ b/crash_reporter/Android.mk
@@ -81,7 +81,7 @@
LOCAL_MODULE := crash_sender
LOCAL_MODULE_CLASS := EXECUTABLES
LOCAL_MODULE_PATH := $(TARGET_OUT_EXECUTABLES)
-LOCAL_REQUIRED_MODULES := curl periodic_scheduler
+LOCAL_REQUIRED_MODULES := curl grep periodic_scheduler
LOCAL_SRC_FILES := crash_sender
include $(BUILD_PREBUILT)
diff --git a/crash_reporter/crash_reporter.cc b/crash_reporter/crash_reporter.cc
index 72eeeda..7872f7b 100644
--- a/crash_reporter/crash_reporter.cc
+++ b/crash_reporter/crash_reporter.cc
@@ -20,6 +20,7 @@
#include <vector>
#include <base/files/file_util.h>
+#include <base/guid.h>
#include <base/logging.h>
#include <base/strings/string_split.h>
#include <base/strings/string_util.h>
@@ -41,6 +42,7 @@
static const char kKernelCrashDetected[] = "/var/run/kernel-crash-detected";
static const char kUncleanShutdownDetected[] =
"/var/run/unclean-shutdown-detected";
+static const char kGUIDFileName[] = "/data/misc/crash_reporter/guid";
// Enumeration of kinds of crashes to be used in the CrashCounter histogram.
enum CrashKinds {
@@ -122,6 +124,21 @@
const bool clean_shutdown) {
CHECK(!clean_shutdown) << "Incompatible options";
+ // Try to read the GUID from kGUIDFileName. If the file doesn't exist, is
+ // blank, or the read fails, generate a new GUID and write it to the file.
+ std::string guid;
+ base::FilePath filepath(kGUIDFileName);
+ if (!base::ReadFileToString(filepath, &guid) || guid.empty()) {
+ guid = base::GenerateGUID();
+ // If we can't read or write the file, log an error. However it is not
+ // a fatal error, as the crash server will assign a random GUID based
+ // on a hash of the IP address if one is not provided in the report.
+ if (base::WriteFile(filepath, guid.c_str(), guid.size()) <= 0) {
+ LOG(ERROR) << "Could not write guid " << guid << " to file "
+ << filepath.value();
+ }
+ }
+
bool was_kernel_crash = false;
bool was_unclean_shutdown = false;
kernel_collector->Enable();
diff --git a/crash_reporter/crash_sender b/crash_reporter/crash_sender
index 7f9062a..29a1229 100755
--- a/crash_reporter/crash_sender
+++ b/crash_reporter/crash_sender
@@ -22,9 +22,8 @@
# Base directory that contains any crash reporter state files.
CRASH_STATE_DIR="/data/misc/crash_reporter"
-# File whose existence implies crash reports may be sent, and whose
-# contents includes our machine's anonymized guid.
-CONSENT_ID="/data/misc/metrics/enabled"
+# File containing crash_reporter's anonymized guid.
+GUID_FILE="${CRASH_STATE_DIR}/guid"
# Crash sender lock in case the sender is already running.
CRASH_SENDER_LOCK="${CRASH_STATE_DIR}/lock/crash_sender"
@@ -63,11 +62,8 @@
# Must be stateful to enable testing kernel crashes.
PAUSE_CRASH_SENDING="${CRASH_STATE_DIR}/lock/crash_sender_paused"
-# URL to send official build crash reports to.
-REPORT_UPLOAD_PROD_URL="https://clients2.google.com/cr/report"
-
# Path to a directory of restricted certificates which includes
-# a certificate for ${REPORT_UPLOAD_PROD_URL}.
+# a certificate for the crash server.
RESTRICTED_CERTIFICATES_PATH="/system/etc/security/cacerts"
# File whose existence implies we're running and not to start again.
@@ -79,6 +75,9 @@
# Set this to 1 to allow uploading of device coredumps.
DEVCOREDUMP_UPLOAD_FLAG_FILE="${CRASH_STATE_DIR}/device_coredump_upload_allowed"
+# The weave configuration file.
+WEAVE_CONF_FILE="/etc/weaved/weaved.conf"
+
# The syslog tag for all logging we emit.
TAG="$(basename $0)[$$]"
@@ -180,10 +179,21 @@
}
# Generate a uniform random number in 0..max-1.
+# POSIX arithmetic expansion requires support of at least signed long integers.
+# On 32-bit systems, that may mean 32-bit signed integers, in which case the
+# 32-bit random number read from /dev/urandom may be interpreted as negative
+# when used inside an arithmetic expansion (since the high bit might be set).
+# mksh at least is known to behave this way.
+# For this case, simply take the absolute value, which will still give a
+# roughly uniform random distribution for the modulo (as we are merely ignoring
+# the high/sign bit).
+# See corresponding Arithmetic Expansion and Arithmetic Expression sections:
+# POSIX: http://pubs.opengroup.org/onlinepubs/009695399/utilities/xcu_chap02.html#tag_02_06_04
+# mksh: http://linux.die.net/man/1/mksh
generate_uniform_random() {
local max=$1
local random="$(od -An -N4 -tu /dev/urandom)"
- echo $((random % max))
+ echo $(((random < 0 ? -random : random) % max))
}
# Check if sending a crash now does not exceed the maximum 24hr rate and
@@ -277,7 +287,7 @@
local report_payload="$(get_key_value "${meta_path}" "payload")"
local kind="$(get_kind "${meta_path}")"
local exec_name="$(get_key_value "${meta_path}" "exec_name")"
- local url="${REPORT_UPLOAD_PROD_URL}"
+ local url="$(getprop crash_reporter.server)"
local brillo_version="$(get_key_value "${meta_path}" "ver")"
local hwclass="$(get_hardware_class)"
local write_payload_size="$(get_key_value "${meta_path}" "payload_size")"
@@ -288,6 +298,13 @@
local version="$(get_key_value "${meta_path}" "upload_var_ver")"
local upload_prefix="$(get_key_value "${meta_path}" "upload_prefix")"
local guid
+ local model_manifest_id="$(get_key_value "${WEAVE_CONF_FILE}" "model_id")"
+
+ # If crash_reporter.server is not set return with an error.
+ if [ -z "${url}" ]; then
+ lecho "Configuration error: crash_reporter.server not set."
+ return 1
+ fi
set -- \
-F "write_payload_size=${write_payload_size}" \
@@ -375,7 +392,7 @@
# Need to strip dashes ourselves as Chrome preserves it in the file
# nowadays. This is also what the Chrome breakpad client does.
- guid=$(tr -d '-' < "${CONSENT_ID}")
+ guid=$(tr -d '-' < "${GUID_FILE}")
local error_type="$(get_key_value "${meta_path}" "error_type")"
[ "${error_type}" = "undefined" ] && error_type=
@@ -441,6 +458,7 @@
-F "ver=${version}" \
-F "hwclass=${hwclass}" \
-F "exec_name=${exec_name}" \
+ -F "model_manifest_id=${model_manifest_id}" \
${image_type:+-F "image_type=${image_type}"} \
${boot_mode:+-F "boot_mode=${boot_mode}"} \
${error_type:+-F "error_type=${error_type}"} \
diff --git a/crash_reporter/init.crash_reporter.rc b/crash_reporter/init.crash_reporter.rc
index db9bb6f..30e87f5 100644
--- a/crash_reporter/init.crash_reporter.rc
+++ b/crash_reporter/init.crash_reporter.rc
@@ -27,3 +27,4 @@
service crash_sender /system/bin/periodic_scheduler 3600 14400 crash_sender \
/system/bin/crash_sender
class late_start
+ group system
diff --git a/crash_reporter/periodic_scheduler b/crash_reporter/periodic_scheduler
index 7fdb5c9..5408da7 100755
--- a/crash_reporter/periodic_scheduler
+++ b/crash_reporter/periodic_scheduler
@@ -22,8 +22,7 @@
set -e -u
SCRIPT_NAME="$(basename "$0")"
-#CHECK_DELAY=300 # Check every 5 minutes.
-CHECK_DELAY=15 # Check every 5 minutes.
+CHECK_DELAY=300 # Check every 5 minutes.
KILL_DELAY=10 # How long to let the job clean up after a timeout.
# Let the unittests override.
: ${SPOOL_DIR:=/data/misc/crash_reporter/spool/cron-lite}
diff --git a/fs_mgr/fs_mgr_slotselect.c b/fs_mgr/fs_mgr_slotselect.c
index 99dcd0e..ca07b18 100644
--- a/fs_mgr/fs_mgr_slotselect.c
+++ b/fs_mgr/fs_mgr_slotselect.c
@@ -78,10 +78,11 @@
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)
+// Gets slot_suffix from either the kernel cmdline / firmware or the
+// misc partition. Sets |out_suffix| on success and returns 0. Returns
+// -1 if slot_suffix could not be determined.
+static int get_active_slot_suffix(struct fstab *fstab, char *out_suffix,
+ size_t suffix_len)
{
char propbuf[PROPERTY_VALUE_MAX];
@@ -91,30 +92,19 @@
property_get("ro.boot.slot_suffix", propbuf, "");
if (propbuf[0] != '\0') {
strncpy(out_suffix, propbuf, suffix_len);
- return;
+ return 0;
}
// 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;
+ return 0;
}
- // 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;
+ ERROR("Error determining slot_suffix\n");
+
+ return -1;
}
// Updates |fstab| for slot_suffix. Returns 0 on success, -1 on error.
@@ -130,7 +120,10 @@
if (!got_suffix) {
memset(suffix, '\0', sizeof(suffix));
- get_active_slot_suffix(fstab, suffix, sizeof(suffix) - 1);
+ if (get_active_slot_suffix(fstab, suffix,
+ sizeof(suffix) - 1) != 0) {
+ return -1;
+ }
got_suffix = 1;
}
diff --git a/include/binderwrapper/binder_test_base.h b/include/binderwrapper/binder_test_base.h
new file mode 100644
index 0000000..06543de
--- /dev/null
+++ b/include/binderwrapper/binder_test_base.h
@@ -0,0 +1,45 @@
+/*
+ * 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 SYSTEM_CORE_INCLUDE_BINDERWRAPPER_BINDER_TEST_BASE_H_
+#define SYSTEM_CORE_INCLUDE_BINDERWRAPPER_BINDER_TEST_BASE_H_
+
+#include <base/macros.h>
+#include <gtest/gtest.h>
+
+namespace android {
+
+class StubBinderWrapper;
+
+// Class that can be inherited from (or aliased via typedef/using) when writing
+// tests that use StubBinderManager.
+class BinderTestBase : public ::testing::Test {
+ public:
+ BinderTestBase();
+ ~BinderTestBase() override;
+
+ StubBinderWrapper* binder_wrapper() { return binder_wrapper_; }
+
+ protected:
+ StubBinderWrapper* binder_wrapper_; // Not owned.
+
+ private:
+ DISALLOW_COPY_AND_ASSIGN(BinderTestBase);
+};
+
+} // namespace android
+
+#endif // SYSTEM_CORE_INCLUDE_BINDERWRAPPER_BINDER_TEST_BASE_H_
diff --git a/include/binderwrapper/binder_wrapper.h b/include/binderwrapper/binder_wrapper.h
new file mode 100644
index 0000000..e57cf83
--- /dev/null
+++ b/include/binderwrapper/binder_wrapper.h
@@ -0,0 +1,77 @@
+/*
+ * 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 SYSTEM_CORE_INCLUDE_BINDERWRAPPER_BINDER_WRAPPER_H_
+#define SYSTEM_CORE_INCLUDE_BINDERWRAPPER_BINDER_WRAPPER_H_
+
+#include <string>
+
+#include <base/callback.h>
+#include <utils/StrongPointer.h>
+
+namespace android {
+
+class BBinder;
+class IBinder;
+
+// Wraps libbinder to make it testable.
+class BinderWrapper {
+ public:
+ virtual ~BinderWrapper() {}
+
+ // Creates and initializes the singleton (using a wrapper that communicates
+ // with the real binder system).
+ static void Create();
+
+ // Initializes |wrapper| as the singleton, taking ownership of it. Tests that
+ // want to inject their own wrappers should call this instead of Create().
+ static void InitForTesting(BinderWrapper* wrapper);
+
+ // Destroys the singleton. Must be called before calling Create() or
+ // InitForTesting() a second time.
+ static void Destroy();
+
+ // Returns the singleton instance previously created by Create() or set by
+ // InitForTesting().
+ static BinderWrapper* Get();
+
+ // Gets the binder for communicating with the service identified by
+ // |service_name|, returning null immediately if it doesn't exist.
+ virtual sp<IBinder> GetService(const std::string& service_name) = 0;
+
+ // Registers |binder| as |service_name| with the service manager.
+ virtual bool RegisterService(const std::string& service_name,
+ const sp<IBinder>& binder) = 0;
+
+ // Creates a local binder object.
+ virtual sp<BBinder> CreateLocalBinder() = 0;
+
+ // Registers |callback| to be invoked when |binder| dies. If another callback
+ // is currently registered for |binder|, it will be replaced.
+ virtual bool RegisterForDeathNotifications(
+ const sp<IBinder>& binder,
+ const base::Closure& callback) = 0;
+
+ // Unregisters the callback, if any, for |binder|.
+ virtual bool UnregisterForDeathNotifications(const sp<IBinder>& binder) = 0;
+
+ private:
+ static BinderWrapper* instance_;
+};
+
+} // namespace android
+
+#endif // SYSTEM_CORE_INCLUDE_BINDERWRAPPER_BINDER_WRAPPER_H_
diff --git a/include/binderwrapper/stub_binder_wrapper.h b/include/binderwrapper/stub_binder_wrapper.h
new file mode 100644
index 0000000..6e198ae
--- /dev/null
+++ b/include/binderwrapper/stub_binder_wrapper.h
@@ -0,0 +1,124 @@
+/*
+ * 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 SYSTEM_CORE_INCLUDE_BINDERWRAPPER_STUB_BINDER_WRAPPER_H_
+#define SYSTEM_CORE_INCLUDE_BINDERWRAPPER_STUB_BINDER_WRAPPER_H_
+
+#include <map>
+#include <string>
+#include <vector>
+
+#include <base/macros.h>
+#include <binder/Binder.h>
+#include <binder/IBinder.h>
+#include <binderwrapper/binder_wrapper.h>
+
+namespace android {
+
+// Stub implementation of BinderWrapper for testing.
+//
+// Example usage:
+//
+// First, assuming a base IFoo binder interface, create a stub class that
+// derives from BnFoo to implement the receiver side of the communication:
+//
+// class StubFoo : public BnFoo {
+// public:
+// ...
+// status_t doSomething(int arg) override {
+// // e.g. save passed-in value for later inspection by tests.
+// return OK;
+// }
+// };
+//
+// Next, from your test code, inject a StubBinderManager either directly or by
+// inheriting from the BinderTestBase class:
+//
+// StubBinderWrapper* wrapper = new StubBinderWrapper();
+// BinderWrapper::InitForTesting(wrapper); // Takes ownership.
+//
+// Also from your test, create a StubFoo and register it with the wrapper:
+//
+// StubFoo* foo = new StubFoo();
+// sp<IBinder> binder(foo);
+// wrapper->SetBinderForService("foo", binder);
+//
+// The code being tested can now use the wrapper to get the stub and call it:
+//
+// sp<IBinder> binder = BinderWrapper::Get()->GetService("foo");
+// CHECK(binder.get());
+// sp<IFoo> foo = interface_cast<IFoo>(binder);
+// CHECK_EQ(foo->doSomething(3), OK);
+//
+// To create a local BBinder object, production code can call
+// CreateLocalBinder(). Then, a test can get the BBinder's address via
+// local_binders() to check that they're passed as expected in binder calls.
+//
+class StubBinderWrapper : public BinderWrapper {
+ public:
+ StubBinderWrapper();
+ ~StubBinderWrapper() override;
+
+ const std::vector<sp<BBinder>>& local_binders() const {
+ return local_binders_;
+ }
+ void clear_local_binders() { local_binders_.clear(); }
+
+ // Sets the binder to return when |service_name| is passed to GetService() or
+ // WaitForService().
+ void SetBinderForService(const std::string& service_name,
+ const sp<IBinder>& binder);
+
+ // Returns the binder previously registered for |service_name| via
+ // RegisterService(), or null if the service hasn't been registered.
+ sp<IBinder> GetRegisteredService(const std::string& service_name) const;
+
+ // Run the calback in |death_callbacks_| corresponding to |binder|.
+ void NotifyAboutBinderDeath(const sp<IBinder>& binder);
+
+ // BinderWrapper:
+ sp<IBinder> GetService(const std::string& service_name) override;
+ bool RegisterService(const std::string& service_name,
+ const sp<IBinder>& binder) override;
+ sp<BBinder> CreateLocalBinder() override;
+ bool RegisterForDeathNotifications(const sp<IBinder>& binder,
+ const base::Closure& callback) override;
+ bool UnregisterForDeathNotifications(const sp<IBinder>& binder) override;
+
+ private:
+ using ServiceMap = std::map<std::string, sp<IBinder>>;
+
+ // Map from service name to associated binder handle. Used by GetService() and
+ // WaitForService().
+ ServiceMap services_to_return_;
+
+ // Map from service name to associated binder handle. Updated by
+ // RegisterService().
+ ServiceMap registered_services_;
+
+ // Local binders returned by CreateLocalBinder().
+ std::vector<sp<BBinder>> local_binders_;
+
+ // Map from binder handle to the callback that should be invoked on binder
+ // death.
+ std::map<sp<IBinder>, base::Closure> death_callbacks_;
+
+ DISALLOW_COPY_AND_ASSIGN(StubBinderWrapper);
+};
+
+} // namespace android
+
+#endif // SYSTEM_CORE_INCLUDE_BINDERWRAPPER_STUB_BINDER_WRAPPER_H_
diff --git a/init/perfboot.py b/init/perfboot.py
index 2a17ab6..91e6c2b 100755
--- a/init/perfboot.py
+++ b/init/perfboot.py
@@ -92,7 +92,7 @@
self._interval = interval
self._device = device
self._temp_paths = device.shell(
- ['ls', '/sys/class/thermal/thermal_zone*/temp']).splitlines()
+ ['ls', '/sys/class/thermal/thermal_zone*/temp'])[0].splitlines()
self._product = device.get_prop('ro.build.product')
self._waited = False
@@ -109,7 +109,7 @@
def _get_cpu_temp(self, threshold):
max_temp = 0
for temp_path in self._temp_paths:
- temp = int(self._device.shell(['cat', temp_path]).rstrip())
+ temp = int(self._device.shell(['cat', temp_path])[0].rstrip())
max_temp = max(max_temp, temp)
if temp >= threshold:
return temp
@@ -173,7 +173,7 @@
device.wait()
device.shell(['rm', '-rf', '/system/data/dropbox'])
original_dropbox_max_files = device.shell(
- ['settings', 'get', 'global', 'dropbox_max_files']).rstrip()
+ ['settings', 'get', 'global', 'dropbox_max_files'])[0].rstrip()
device.shell(['settings', 'put', 'global', 'dropbox_max_files', '0'])
return original_dropbox_max_files
@@ -244,7 +244,8 @@
"""Drop unknown tags not listed in device's event-log-tags file."""
device.wait()
supported_tags = set()
- for l in device.shell(['cat', '/system/etc/event-log-tags']).splitlines():
+ for l in device.shell(
+ ['cat', '/system/etc/event-log-tags'])[0].splitlines():
tokens = l.split(' ')
if len(tokens) >= 2:
supported_tags.add(tokens[1])
diff --git a/libbinderwrapper/Android.mk b/libbinderwrapper/Android.mk
new file mode 100644
index 0000000..23c2246
--- /dev/null
+++ b/libbinderwrapper/Android.mk
@@ -0,0 +1,62 @@
+#
+# 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.
+#
+
+LOCAL_PATH := $(call my-dir)
+
+binderwrapperCommonCFlags := -Wall -Werror -Wno-unused-parameter
+binderwrapperCommonCFlags += -Wno-sign-promo # for libchrome
+binderwrapperCommonExportCIncludeDirs := $(LOCAL_PATH)/../include
+binderwrapperCommonCIncludes := $(LOCAL_PATH)/../include
+binderwrapperCommonSharedLibraries := \
+ libbinder \
+ libchrome \
+ libutils \
+
+# libbinderwrapper shared library
+# ========================================================
+
+include $(CLEAR_VARS)
+LOCAL_MODULE := libbinderwrapper
+LOCAL_CPP_EXTENSION := .cc
+LOCAL_CFLAGS := $(binderwrapperCommonCFlags)
+LOCAL_EXPORT_C_INCLUDE_DIRS := $(binderwrapperCommonExportCIncludeDirs)
+LOCAL_C_INCLUDES := $(binderwrapperCommonCIncludes)
+LOCAL_SHARED_LIBRARIES := $(binderwrapperCommonSharedLibraries)
+LOCAL_SRC_FILES := \
+ binder_wrapper.cc \
+ real_binder_wrapper.cc \
+
+include $(BUILD_SHARED_LIBRARY)
+
+# libbinderwrapper_test_support shared library
+# ========================================================
+
+include $(CLEAR_VARS)
+LOCAL_MODULE := libbinderwrapper_test_support
+LOCAL_CPP_EXTENSION := .cc
+LOCAL_CFLAGS := $(binderwrapperCommonCFlags)
+LOCAL_EXPORT_C_INCLUDE_DIRS := $(binderwrapperCommonExportCIncludeDirs)
+LOCAL_C_INCLUDES := $(binderwrapperCommonCIncludes)
+LOCAL_STATIC_LIBRARIES := libgtest
+LOCAL_SHARED_LIBRARIES := \
+ $(binderwrapperCommonSharedLibraries) \
+ libbinderwrapper \
+
+LOCAL_SRC_FILES := \
+ binder_test_base.cc \
+ stub_binder_wrapper.cc \
+
+include $(BUILD_SHARED_LIBRARY)
diff --git a/libbinderwrapper/binder_test_base.cc b/libbinderwrapper/binder_test_base.cc
new file mode 100644
index 0000000..af93a04
--- /dev/null
+++ b/libbinderwrapper/binder_test_base.cc
@@ -0,0 +1,33 @@
+/*
+ * 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 <binderwrapper/binder_test_base.h>
+
+#include <binderwrapper/binder_wrapper.h>
+#include <binderwrapper/stub_binder_wrapper.h>
+
+namespace android {
+
+BinderTestBase::BinderTestBase() : binder_wrapper_(new StubBinderWrapper()) {
+ // Pass ownership.
+ BinderWrapper::InitForTesting(binder_wrapper_);
+}
+
+BinderTestBase::~BinderTestBase() {
+ BinderWrapper::Destroy();
+}
+
+} // namespace android
diff --git a/libbinderwrapper/binder_wrapper.cc b/libbinderwrapper/binder_wrapper.cc
new file mode 100644
index 0000000..0b5ff96
--- /dev/null
+++ b/libbinderwrapper/binder_wrapper.cc
@@ -0,0 +1,53 @@
+/*
+ * 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 <binderwrapper/binder_wrapper.h>
+
+#include <base/logging.h>
+
+#include "real_binder_wrapper.h"
+
+namespace android {
+
+// Singleton instance.
+BinderWrapper* BinderWrapper::instance_ = nullptr;
+
+// static
+void BinderWrapper::Create() {
+ CHECK(!instance_) << "Already initialized; missing call to Destroy()?";
+ instance_ = new RealBinderWrapper();
+}
+
+// static
+void BinderWrapper::InitForTesting(BinderWrapper* wrapper) {
+ CHECK(!instance_) << "Already initialized; missing call to Destroy()?";
+ instance_ = wrapper;
+}
+
+// static
+void BinderWrapper::Destroy() {
+ CHECK(instance_) << "Not initialized; missing call to Create()?";
+ delete instance_;
+ instance_ = nullptr;
+}
+
+// static
+BinderWrapper* BinderWrapper::Get() {
+ CHECK(instance_) << "Not initialized; missing call to Create()?";
+ return instance_;
+}
+
+} // namespace android
diff --git a/libbinderwrapper/real_binder_wrapper.cc b/libbinderwrapper/real_binder_wrapper.cc
new file mode 100644
index 0000000..adff19b
--- /dev/null
+++ b/libbinderwrapper/real_binder_wrapper.cc
@@ -0,0 +1,114 @@
+/*
+ * 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 "real_binder_wrapper.h"
+
+#include <base/logging.h>
+#include <binder/Binder.h>
+#include <binder/IBinder.h>
+#include <binder/IServiceManager.h>
+
+namespace android {
+
+// Class that handles binder death notifications. libbinder wants the recipient
+// to be wrapped in sp<>, so registering RealBinderWrapper as a recipient would
+// be awkward.
+class RealBinderWrapper::DeathRecipient : public IBinder::DeathRecipient {
+ public:
+ explicit DeathRecipient(const base::Closure& callback)
+ : callback_(callback) {}
+ ~DeathRecipient() = default;
+
+ // IBinder::DeathRecipient:
+ void binderDied(const wp<IBinder>& who) override {
+ callback_.Run();
+ }
+
+ private:
+ // Callback to run in response to binder death.
+ base::Closure callback_;
+
+ DISALLOW_COPY_AND_ASSIGN(DeathRecipient);
+};
+
+RealBinderWrapper::RealBinderWrapper() = default;
+
+RealBinderWrapper::~RealBinderWrapper() = default;
+
+sp<IBinder> RealBinderWrapper::GetService(const std::string& service_name) {
+ sp<IServiceManager> service_manager = defaultServiceManager();
+ if (!service_manager.get()) {
+ LOG(ERROR) << "Unable to get service manager";
+ return sp<IBinder>();
+ }
+ sp<IBinder> binder =
+ service_manager->checkService(String16(service_name.c_str()));
+ if (!binder.get())
+ LOG(ERROR) << "Unable to get \"" << service_name << "\" service";
+ return binder;
+}
+
+bool RealBinderWrapper::RegisterService(const std::string& service_name,
+ const sp<IBinder>& binder) {
+ sp<IServiceManager> service_manager = defaultServiceManager();
+ if (!service_manager.get()) {
+ LOG(ERROR) << "Unable to get service manager";
+ return false;
+ }
+ status_t status = defaultServiceManager()->addService(
+ String16(service_name.c_str()), binder);
+ if (status != OK) {
+ LOG(ERROR) << "Failed to register \"" << service_name << "\" with service "
+ << "manager";
+ return false;
+ }
+ return true;
+}
+
+sp<BBinder> RealBinderWrapper::CreateLocalBinder() {
+ return sp<BBinder>(new BBinder());
+}
+
+bool RealBinderWrapper::RegisterForDeathNotifications(
+ const sp<IBinder>& binder,
+ const base::Closure& callback) {
+ sp<DeathRecipient> recipient(new DeathRecipient(callback));
+ if (binder->linkToDeath(recipient) != OK) {
+ LOG(ERROR) << "Failed to register for death notifications on "
+ << binder.get();
+ return false;
+ }
+ death_recipients_[binder] = recipient;
+ return true;
+}
+
+bool RealBinderWrapper::UnregisterForDeathNotifications(
+ const sp<IBinder>& binder) {
+ auto it = death_recipients_.find(binder);
+ if (it == death_recipients_.end()) {
+ LOG(ERROR) << "Not registered for death notifications on " << binder.get();
+ return false;
+ }
+ if (binder->unlinkToDeath(it->second) != OK) {
+ LOG(ERROR) << "Failed to unregister for death notifications on "
+ << binder.get();
+ return false;
+ }
+ death_recipients_.erase(it);
+ return true;
+}
+
+} // namespace android
diff --git a/libbinderwrapper/real_binder_wrapper.h b/libbinderwrapper/real_binder_wrapper.h
new file mode 100644
index 0000000..8e281f2
--- /dev/null
+++ b/libbinderwrapper/real_binder_wrapper.h
@@ -0,0 +1,54 @@
+/*
+ * 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 SYSTEM_CORE_LIBBINDERWRAPPER_REAL_BINDER_WRAPPER_H_
+#define SYSTEM_CORE_LIBBINDERWRAPPER_REAL_BINDER_WRAPPER_H_
+
+#include <base/macros.h>
+#include <binderwrapper/binder_wrapper.h>
+
+namespace android {
+
+class IBinder;
+
+// Real implementation of BinderWrapper.
+class RealBinderWrapper : public BinderWrapper {
+ public:
+ RealBinderWrapper();
+ ~RealBinderWrapper() override;
+
+ // BinderWrapper:
+ sp<IBinder> GetService(const std::string& service_name) override;
+ bool RegisterService(const std::string& service_name,
+ const sp<IBinder>& binder) override;
+ sp<BBinder> CreateLocalBinder() override;
+ bool RegisterForDeathNotifications(const sp<IBinder>& binder,
+ const base::Closure& callback) override;
+ bool UnregisterForDeathNotifications(const sp<IBinder>& binder) override;
+
+ private:
+ class DeathRecipient;
+
+ // Map from binder handle to object that should be notified of the binder's
+ // death.
+ std::map<sp<IBinder>, sp<DeathRecipient>> death_recipients_;
+
+ DISALLOW_COPY_AND_ASSIGN(RealBinderWrapper);
+};
+
+} // namespace android
+
+#endif // SYSTEM_CORE_LIBBINDER_WRAPPER_REAL_BINDER_WRAPPER_H_
diff --git a/libbinderwrapper/stub_binder_wrapper.cc b/libbinderwrapper/stub_binder_wrapper.cc
new file mode 100644
index 0000000..1d24681
--- /dev/null
+++ b/libbinderwrapper/stub_binder_wrapper.cc
@@ -0,0 +1,76 @@
+/*
+ * 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 <binderwrapper/stub_binder_wrapper.h>
+
+#include <base/logging.h>
+#include <binder/Binder.h>
+#include <binder/IBinder.h>
+
+namespace android {
+
+StubBinderWrapper::StubBinderWrapper() = default;
+
+StubBinderWrapper::~StubBinderWrapper() = default;
+
+void StubBinderWrapper::SetBinderForService(const std::string& service_name,
+ const sp<IBinder>& binder) {
+ services_to_return_[service_name] = binder;
+}
+
+sp<IBinder> StubBinderWrapper::GetRegisteredService(
+ const std::string& service_name) const {
+ const auto it = registered_services_.find(service_name);
+ return it != registered_services_.end() ? it->second : sp<IBinder>();
+}
+
+void StubBinderWrapper::NotifyAboutBinderDeath(const sp<IBinder>& binder) {
+ const auto it = death_callbacks_.find(binder);
+ if (it != death_callbacks_.end())
+ it->second.Run();
+}
+
+sp<IBinder> StubBinderWrapper::GetService(const std::string& service_name) {
+ const auto it = services_to_return_.find(service_name);
+ return it != services_to_return_.end() ? it->second : sp<IBinder>();
+}
+
+bool StubBinderWrapper::RegisterService(const std::string& service_name,
+ const sp<IBinder>& binder) {
+ registered_services_[service_name] = binder;
+ return true;
+}
+
+sp<BBinder> StubBinderWrapper::CreateLocalBinder() {
+ sp<BBinder> binder(new BBinder());
+ local_binders_.push_back(binder);
+ return binder;
+}
+
+bool StubBinderWrapper::RegisterForDeathNotifications(
+ const sp<IBinder>& binder,
+ const base::Closure& callback) {
+ death_callbacks_[binder] = callback;
+ return true;
+}
+
+bool StubBinderWrapper::UnregisterForDeathNotifications(
+ const sp<IBinder>& binder) {
+ death_callbacks_.erase(binder);
+ return true;
+}
+
+} // namespace android
diff --git a/liblog/Android.bp b/liblog/Android.bp
new file mode 100644
index 0000000..ee394fd
--- /dev/null
+++ b/liblog/Android.bp
@@ -0,0 +1,76 @@
+//
+// Copyright (C) 2008-2014 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.
+//
+
+liblog_host_sources = [
+ "logd_write.c",
+ "log_event_write.c",
+ "fake_log_device.c",
+ //"event.logtags",
+]
+liblog_target_sources = [
+ "logd_write.c",
+ "log_event_write.c",
+ "event_tag_map.c",
+ "log_time.cpp",
+ "log_is_loggable.c",
+ "logprint.c",
+ "log_read.c",
+]
+
+// Shared and static library for host and device
+// ========================================================
+cc_library {
+ name: "liblog",
+ host_supported: true,
+
+ target: {
+ host: {
+ srcs: liblog_host_sources,
+ cflags: ["-DFAKE_LOG_DEVICE=1"],
+ },
+ android: {
+ srcs: liblog_target_sources,
+ // AddressSanitizer runtime library depends on liblog.
+ sanitize: ["never"],
+ },
+ android_arm: {
+ // TODO: This is to work around b/19059885. Remove after root cause is fixed
+ ldflags: ["-Wl,--hash-style=both"],
+ },
+ windows: {
+ srcs: ["uio.c"],
+ },
+ not_windows: {
+ srcs: ["event_tag_map.c"],
+ },
+ linux: {
+ host_ldlibs: ["-lrt"],
+ },
+ },
+
+ cflags: [
+ "-Werror",
+ // This is what we want to do:
+ // liblog_cflags := $(shell \
+ // sed -n \
+ // 's/^\([0-9]*\)[ \t]*liblog[ \t].*/-DLIBLOG_LOG_TAG=\1/p' \
+ // $(LOCAL_PATH)/event.logtags)
+ // so make sure we do not regret hard-coding it as follows:
+ "-DLIBLOG_LOG_TAG=1005",
+ ],
+ compile_multilib: "both",
+ stl: "none",
+}
diff --git a/metricsd/Android.mk b/metricsd/Android.mk
index c5d5281..8a0a8b4 100644
--- a/metricsd/Android.mk
+++ b/metricsd/Android.mk
@@ -23,7 +23,8 @@
c_metrics_library.cc \
metrics_library.cc \
serialization/metric_sample.cc \
- serialization/serialization_utils.cc
+ serialization/serialization_utils.cc \
+ timer.cc
metrics_client_sources := \
metrics_client.cc
@@ -84,6 +85,7 @@
LOCAL_MODULE := libmetrics
LOCAL_C_INCLUDES := $(metrics_includes)
LOCAL_CFLAGS := $(metrics_CFLAGS)
+LOCAL_CLANG := true
LOCAL_CPP_EXTENSION := $(metrics_cpp_extension)
LOCAL_CPPFLAGS := $(metrics_CPPFLAGS)
LOCAL_EXPORT_C_INCLUDE_DIRS := $(LOCAL_PATH)/include
@@ -97,6 +99,7 @@
LOCAL_MODULE := metrics_client
LOCAL_C_INCLUDES := $(metrics_includes)
LOCAL_CFLAGS := $(metrics_CFLAGS)
+LOCAL_CLANG := true
LOCAL_CPP_EXTENSION := $(metrics_cpp_extension)
LOCAL_CPPFLAGS := $(metrics_CPPFLAGS)
LOCAL_SHARED_LIBRARIES := $(metrics_shared_libraries) \
@@ -132,7 +135,10 @@
libchromeos-http \
libchromeos-dbus \
libcutils \
- libdbus
+ libdbus \
+ librootdev
+
+LOCAL_CLANG := true
LOCAL_SRC_FILES := $(metrics_daemon_sources)
LOCAL_STATIC_LIBRARIES := metrics_daemon_protos
include $(BUILD_EXECUTABLE)
diff --git a/metricsd/constants.h b/metricsd/constants.h
index 15c15d9..717e5d2 100644
--- a/metricsd/constants.h
+++ b/metricsd/constants.h
@@ -19,10 +19,12 @@
namespace metrics {
static const char kMetricsDirectory[] = "/data/misc/metrics/";
-static const char kMetricsEventsFilePath[] = "/data/misc/metrics/uma-events";
-static const char kMetricsGUIDFilePath[] = "/data/misc/metrics/Sysinfo.GUID";
+static const char kMetricsEventsFileName[] = "uma-events";
+static const char kMetricsGUIDFileName[] = "Sysinfo.GUID";
static const char kMetricsServer[] = "https://clients4.google.com/uma/v2";
-static const char kConsentFilePath[] = "/data/misc/metrics/enabled";
+static const char kConsentFileName[] = "enabled";
+static const char kStagedLogName[] = "staged_log";
+static const char kFailedUploadCountName[] = "failed_upload_count";
static const char kDefaultVersion[] = "0.0.0.0";
// System properties used.
diff --git a/metricsd/include/metrics/metrics_library.h b/metricsd/include/metrics/metrics_library.h
index a956b69..26df2f4 100644
--- a/metricsd/include/metrics/metrics_library.h
+++ b/metricsd/include/metrics/metrics_library.h
@@ -22,6 +22,7 @@
#include <unistd.h>
#include <base/compiler_specific.h>
+#include <base/files/file_path.h>
#include <base/macros.h>
#include <base/memory/scoped_ptr.h>
#include <gtest/gtest_prod.h> // for FRIEND_TEST
@@ -122,6 +123,7 @@
private:
friend class CMetricsLibraryTest;
friend class MetricsLibraryTest;
+ friend class UploadServiceTest;
FRIEND_TEST(MetricsLibraryTest, AreMetricsEnabled);
FRIEND_TEST(MetricsLibraryTest, FormatChromeMessage);
FRIEND_TEST(MetricsLibraryTest, FormatChromeMessageTooLong);
@@ -129,8 +131,7 @@
FRIEND_TEST(MetricsLibraryTest, SendMessageToChrome);
FRIEND_TEST(MetricsLibraryTest, SendMessageToChromeUMAEventsBadFileLocation);
- void InitForTest(const std::string& uma_events_file,
- const std::string& consent_file);
+ void InitForTest(const base::FilePath& metrics_directory);
// Sets |*result| to whether or not the |mounts_file| indicates that
// the |device_name| is currently mounted. Uses |buffer| of
@@ -146,8 +147,8 @@
// Cached state of whether or not metrics were enabled.
static bool cached_enabled_;
- std::string uma_events_file_;
- std::string consent_file_;
+ base::FilePath uma_events_file_;
+ base::FilePath consent_file_;
DISALLOW_COPY_AND_ASSIGN(MetricsLibrary);
};
diff --git a/metricsd/timer.h b/metricsd/include/metrics/timer.h
similarity index 100%
rename from metricsd/timer.h
rename to metricsd/include/metrics/timer.h
diff --git a/metricsd/metrics_client.cc b/metricsd/metrics_client.cc
index f658b22..78174ef 100644
--- a/metricsd/metrics_client.cc
+++ b/metricsd/metrics_client.cc
@@ -140,11 +140,13 @@
}
static int DumpLogs() {
- printf("Metrics from %s\n\n", metrics::kMetricsEventsFilePath);
+ base::FilePath events_file = base::FilePath(
+ metrics::kMetricsDirectory).Append(metrics::kMetricsEventsFileName);
+ printf("Metrics from %s\n\n", events_file.value().data());
ScopedVector<metrics::MetricSample> metrics;
- metrics::SerializationUtils::ReadMetricsFromFile(
- metrics::kMetricsEventsFilePath, &metrics);
+ metrics::SerializationUtils::ReadMetricsFromFile(events_file.value(),
+ &metrics);
for (ScopedVector<metrics::MetricSample>::const_iterator i = metrics.begin();
i != metrics.end(); ++i) {
diff --git a/metricsd/metrics_daemon.cc b/metricsd/metrics_daemon.cc
index 2838119..b0e4b2f 100644
--- a/metricsd/metrics_daemon.cc
+++ b/metricsd/metrics_daemon.cc
@@ -84,6 +84,8 @@
const int kMetricStatsShortInterval = 1; // seconds
const int kMetricStatsLongInterval = 30; // seconds
+const int kMetricMeminfoInterval = 30; // seconds
+
// Assume a max rate of 250Mb/s for reads (worse for writes) and 512 byte
// sectors.
const int kMetricSectorsIOMax = 500000; // sectors/second
@@ -110,6 +112,7 @@
const char kVmStatFileName[] = "/proc/vmstat";
const char kMeminfoFileName[] = "/proc/meminfo";
const int kMetricsProcStatFirstLineItemsCount = 11;
+const int kDiskMetricsStatItemCount = 11;
// Thermal CPU throttling.
@@ -184,10 +187,10 @@
void MetricsDaemon::RunUploaderTest() {
upload_service_.reset(new UploadService(
- new SystemProfileCache(true, base::FilePath(config_root_)),
+ new SystemProfileCache(true, metrics_directory_),
metrics_lib_,
server_));
- upload_service_->Init(upload_interval_, metrics_file_);
+ upload_service_->Init(upload_interval_, metrics_directory_);
upload_service_->UploadEvent();
}
@@ -215,22 +218,21 @@
bool uploader_active,
bool dbus_enabled,
MetricsLibraryInterface* metrics_lib,
+ const string& diskstats_path,
const string& scaling_max_freq_path,
const string& cpuinfo_max_freq_path,
const base::TimeDelta& upload_interval,
const string& server,
- const string& metrics_file,
- const string& config_root) {
+ const base::FilePath& metrics_directory) {
CHECK(metrics_lib);
testing_ = testing;
uploader_active_ = uploader_active;
dbus_enabled_ = dbus_enabled;
- config_root_ = config_root;
+ metrics_directory_ = metrics_directory;
metrics_lib_ = metrics_lib;
upload_interval_ = upload_interval;
server_ = server;
- metrics_file_ = metrics_file;
// Get ticks per second (HZ) on this system.
// Sysconf cannot fail, so no sanity checks are needed.
@@ -239,7 +241,7 @@
daily_active_use_.reset(
new PersistentInteger("Platform.DailyUseTime"));
version_cumulative_active_use_.reset(
- new PersistentInteger("Platform.CumulativeDailyUseTime"));
+ new PersistentInteger("Platform.CumulativeUseTime"));
version_cumulative_cpu_use_.reset(
new PersistentInteger("Platform.CumulativeCpuTime"));
@@ -273,8 +275,13 @@
weekly_cycle_.reset(new PersistentInteger("weekly.cycle"));
version_cycle_.reset(new PersistentInteger("version.cycle"));
+ diskstats_path_ = diskstats_path;
scaling_max_freq_path_ = scaling_max_freq_path;
cpuinfo_max_freq_path_ = cpuinfo_max_freq_path;
+
+ // If testing, initialize Stats Reporter without connecting DBus
+ if (testing_)
+ StatsReporterInit();
}
int MetricsDaemon::OnInit() {
@@ -283,6 +290,13 @@
if (return_code != EX_OK)
return return_code;
+ StatsReporterInit();
+
+ // Start collecting meminfo stats.
+ ScheduleMeminfoCallback(kMetricMeminfoInterval);
+ memuse_final_time_ = GetActiveTime() + kMemuseIntervals[0];
+ ScheduleMemuseCallback(kMemuseIntervals[0]);
+
if (testing_)
return EX_OK;
@@ -313,10 +327,15 @@
}
}
+ base::MessageLoop::current()->PostDelayedTask(FROM_HERE,
+ base::Bind(&MetricsDaemon::HandleUpdateStatsTimeout,
+ base::Unretained(this)),
+ base::TimeDelta::FromMilliseconds(kUpdateStatsIntervalMs));
+
if (uploader_active_) {
upload_service_.reset(
new UploadService(new SystemProfileCache(), metrics_lib_, server_));
- upload_service_->Init(upload_interval_, metrics_file_);
+ upload_service_->Init(upload_interval_, metrics_directory_);
}
return EX_OK;
@@ -425,7 +444,7 @@
UpdateStats(TimeTicks::Now(), Time::Now());
// Reports the active use time since the last crash and resets it.
- SendCrashIntervalSample(user_crash_interval_);
+ SendAndResetCrashIntervalSample(user_crash_interval_);
any_crashes_daily_count_->Add(1);
any_crashes_weekly_count_->Add(1);
@@ -438,7 +457,7 @@
UpdateStats(TimeTicks::Now(), Time::Now());
// Reports the active use time since the last crash and resets it.
- SendCrashIntervalSample(kernel_crash_interval_);
+ SendAndResetCrashIntervalSample(kernel_crash_interval_);
any_crashes_daily_count_->Add(1);
any_crashes_weekly_count_->Add(1);
@@ -453,7 +472,7 @@
UpdateStats(TimeTicks::Now(), Time::Now());
// Reports the active use time since the last crash and resets it.
- SendCrashIntervalSample(unclean_shutdown_interval_);
+ SendAndResetCrashIntervalSample(unclean_shutdown_interval_);
unclean_shutdowns_daily_count_->Add(1);
unclean_shutdowns_weekly_count_->Add(1);
@@ -494,6 +513,40 @@
base::TimeDelta::FromSeconds(wait));
}
+bool MetricsDaemon::DiskStatsReadStats(uint64_t* read_sectors,
+ uint64_t* write_sectors) {
+ CHECK(read_sectors);
+ CHECK(write_sectors);
+ std::string line;
+ if (diskstats_path_.empty()) {
+ return false;
+ }
+
+ if (!base::ReadFileToString(base::FilePath(diskstats_path_), &line)) {
+ PLOG(WARNING) << "Could not read disk stats from " << diskstats_path_;
+ return false;
+ }
+
+ std::vector<std::string> parts = base::SplitString(
+ line, " ", base::TRIM_WHITESPACE, base::SPLIT_WANT_NONEMPTY);
+ if (parts.size() != kDiskMetricsStatItemCount) {
+ LOG(ERROR) << "Could not parse disk stat correctly. Expected "
+ << kDiskMetricsStatItemCount << " elements but got "
+ << parts.size();
+ return false;
+ }
+ if (!base::StringToUint64(parts[2], read_sectors)) {
+ LOG(ERROR) << "Couldn't convert read sectors " << parts[2] << " to uint64";
+ return false;
+ }
+ if (!base::StringToUint64(parts[6], write_sectors)) {
+ LOG(ERROR) << "Couldn't convert write sectors " << parts[6] << " to uint64";
+ return false;
+ }
+
+ return true;
+}
+
bool MetricsDaemon::VmStatsParseStats(const char* stats,
struct VmstatRecord* record) {
CHECK(stats);
@@ -712,11 +765,7 @@
return;
}
// Make both calls even if the first one fails.
- bool success = ProcessMeminfo(meminfo_raw);
- bool reschedule =
- ReportZram(base::FilePath(FILE_PATH_LITERAL("/sys/block/zram0"))) &&
- success;
- if (reschedule) {
+ if (ProcessMeminfo(meminfo_raw)) {
base::MessageLoop::current()->PostDelayedTask(FROM_HERE,
base::Bind(&MetricsDaemon::MeminfoCallback, base::Unretained(this),
wait),
@@ -984,7 +1033,7 @@
int64_t active_use_seconds = version_cumulative_active_use_->Get();
if (active_use_seconds > 0) {
SendSample(version_cumulative_active_use_->Name(),
- active_use_seconds / 1000, // stat is in seconds
+ active_use_seconds,
1, // device may be used very little...
8 * 1000 * 1000, // ... or a lot (about 90 days)
100);
@@ -997,7 +1046,7 @@
}
}
-void MetricsDaemon::SendDailyUseSample(
+void MetricsDaemon::SendAndResetDailyUseSample(
const scoped_ptr<PersistentInteger>& use) {
SendSample(use->Name(),
use->GetAndClear(),
@@ -1006,7 +1055,7 @@
50); // number of buckets
}
-void MetricsDaemon::SendCrashIntervalSample(
+void MetricsDaemon::SendAndResetCrashIntervalSample(
const scoped_ptr<PersistentInteger>& interval) {
SendSample(interval->Name(),
interval->GetAndClear(),
@@ -1015,7 +1064,7 @@
50); // number of buckets
}
-void MetricsDaemon::SendCrashFrequencySample(
+void MetricsDaemon::SendAndResetCrashFrequencySample(
const scoped_ptr<PersistentInteger>& frequency) {
SendSample(frequency->Name(),
frequency->GetAndClear(),
@@ -1048,21 +1097,20 @@
if (daily_cycle_->Get() != day) {
daily_cycle_->Set(day);
- SendDailyUseSample(daily_active_use_);
- SendDailyUseSample(version_cumulative_active_use_);
- SendCrashFrequencySample(any_crashes_daily_count_);
- SendCrashFrequencySample(user_crashes_daily_count_);
- SendCrashFrequencySample(kernel_crashes_daily_count_);
- SendCrashFrequencySample(unclean_shutdowns_daily_count_);
+ SendAndResetDailyUseSample(daily_active_use_);
+ SendAndResetCrashFrequencySample(any_crashes_daily_count_);
+ SendAndResetCrashFrequencySample(user_crashes_daily_count_);
+ SendAndResetCrashFrequencySample(kernel_crashes_daily_count_);
+ SendAndResetCrashFrequencySample(unclean_shutdowns_daily_count_);
SendKernelCrashesCumulativeCountStats();
}
if (weekly_cycle_->Get() != week) {
weekly_cycle_->Set(week);
- SendCrashFrequencySample(any_crashes_weekly_count_);
- SendCrashFrequencySample(user_crashes_weekly_count_);
- SendCrashFrequencySample(kernel_crashes_weekly_count_);
- SendCrashFrequencySample(unclean_shutdowns_weekly_count_);
+ SendAndResetCrashFrequencySample(any_crashes_weekly_count_);
+ SendAndResetCrashFrequencySample(user_crashes_weekly_count_);
+ SendAndResetCrashFrequencySample(kernel_crashes_weekly_count_);
+ SendAndResetCrashFrequencySample(unclean_shutdowns_weekly_count_);
}
}
diff --git a/metricsd/metrics_daemon.h b/metricsd/metrics_daemon.h
index 9180e23..fbb871e 100644
--- a/metricsd/metrics_daemon.h
+++ b/metricsd/metrics_daemon.h
@@ -45,12 +45,12 @@
bool uploader_active,
bool dbus_enabled,
MetricsLibraryInterface* metrics_lib,
+ const std::string& diskstats_path,
const std::string& cpuinfo_max_freq_path,
const std::string& scaling_max_freq_path,
const base::TimeDelta& upload_interval,
const std::string& server,
- const std::string& metrics_file,
- const std::string& config_root);
+ const base::FilePath& metrics_directory);
// Initializes DBus and MessageLoop variables before running the MessageLoop.
int OnInit() override;
@@ -78,6 +78,7 @@
FRIEND_TEST(MetricsDaemonTest, GetHistogramPath);
FRIEND_TEST(MetricsDaemonTest, IsNewEpoch);
FRIEND_TEST(MetricsDaemonTest, MessageFilter);
+ FRIEND_TEST(MetricsDaemonTest, ParseDiskStats);
FRIEND_TEST(MetricsDaemonTest, ParseVmStats);
FRIEND_TEST(MetricsDaemonTest, ProcessKernelCrash);
FRIEND_TEST(MetricsDaemonTest, ProcessMeminfo);
@@ -86,7 +87,6 @@
FRIEND_TEST(MetricsDaemonTest, ProcessUserCrash);
FRIEND_TEST(MetricsDaemonTest, ReportCrashesDailyFrequency);
FRIEND_TEST(MetricsDaemonTest, ReadFreqToInt);
- FRIEND_TEST(MetricsDaemonTest, ReportDiskStats);
FRIEND_TEST(MetricsDaemonTest, ReportKernelCrashInterval);
FRIEND_TEST(MetricsDaemonTest, ReportUncleanShutdownInterval);
FRIEND_TEST(MetricsDaemonTest, ReportUserCrashInterval);
@@ -171,15 +171,19 @@
base::TimeDelta GetIncrementalCpuUse();
// Sends a sample representing the number of seconds of active use
- // for a 24-hour period.
- void SendDailyUseSample(const scoped_ptr<PersistentInteger>& use);
+ // for a 24-hour period and reset |use|.
+ void SendAndResetDailyUseSample(
+ const scoped_ptr<PersistentInteger>& use);
// Sends a sample representing a time interval between two crashes of the
- // same type.
- void SendCrashIntervalSample(const scoped_ptr<PersistentInteger>& interval);
+ // same type and reset |interval|.
+ void SendAndResetCrashIntervalSample(
+ const scoped_ptr<PersistentInteger>& interval);
- // Sends a sample representing a frequency of crashes of some type.
- void SendCrashFrequencySample(const scoped_ptr<PersistentInteger>& frequency);
+ // Sends a sample representing a frequency of crashes of some type and reset
+ // |frequency|.
+ void SendAndResetCrashFrequencySample(
+ const scoped_ptr<PersistentInteger>& frequency);
// Initializes vm and disk stats reporting.
void StatsReporterInit();
@@ -267,7 +271,7 @@
bool dbus_enabled_;
// Root of the configuration files to use.
- std::string config_root_;
+ base::FilePath metrics_directory_;
// The metrics library handle.
MetricsLibraryInterface* metrics_lib_;
@@ -324,12 +328,12 @@
scoped_ptr<PersistentInteger> unclean_shutdowns_daily_count_;
scoped_ptr<PersistentInteger> unclean_shutdowns_weekly_count_;
+ std::string diskstats_path_;
std::string scaling_max_freq_path_;
std::string cpuinfo_max_freq_path_;
base::TimeDelta upload_interval_;
std::string server_;
- std::string metrics_file_;
scoped_ptr<UploadService> upload_service_;
};
diff --git a/metricsd/metrics_daemon_main.cc b/metricsd/metrics_daemon_main.cc
index 7f9ec43..c2e794e 100644
--- a/metricsd/metrics_daemon_main.cc
+++ b/metricsd/metrics_daemon_main.cc
@@ -20,6 +20,7 @@
#include <base/strings/string_util.h>
#include <chromeos/flag_helper.h>
#include <chromeos/syslog_logging.h>
+#include <rootdev.h>
#include "constants.h"
#include "metrics_daemon.h"
@@ -29,6 +30,28 @@
const char kCpuinfoMaxFreqPath[] =
"/sys/devices/system/cpu/cpu0/cpufreq/cpuinfo_max_freq";
+// Returns the path to the disk stats in the sysfs. Returns the null string if
+// it cannot find the disk stats file.
+static
+const std::string MetricsMainDiskStatsPath() {
+ char dev_path_cstr[PATH_MAX];
+ std::string dev_prefix = "/dev/block/";
+ std::string dev_path;
+
+ int ret = rootdev(dev_path_cstr, sizeof(dev_path_cstr), true, true);
+ if (ret != 0) {
+ LOG(WARNING) << "error " << ret << " determining root device";
+ return "";
+ }
+ dev_path = dev_path_cstr;
+ // Check that rootdev begins with "/dev/block/".
+ if (!base::StartsWithASCII(dev_path, dev_prefix, false)) {
+ LOG(WARNING) << "unexpected root device " << dev_path;
+ return "";
+ }
+ return "/sys/class/block/" + dev_path.substr(dev_prefix.length()) + "/stat";
+}
+
int main(int argc, char** argv) {
DEFINE_bool(daemon, true, "run as daemon (use -nodaemon for debugging)");
@@ -52,11 +75,9 @@
DEFINE_string(server,
metrics::kMetricsServer,
"Server to upload the metrics to. (needs -uploader)");
- DEFINE_string(metrics_file,
- metrics::kMetricsEventsFilePath,
- "File to use as a proxy for uploading the metrics");
- DEFINE_string(config_root,
- "/", "Root of the configuration files (testing only)");
+ DEFINE_string(metrics_directory,
+ metrics::kMetricsDirectory,
+ "Root of the configuration files (testing only)");
chromeos::FlagHelper::Init(argc, argv, "Chromium OS Metrics Daemon");
@@ -75,12 +96,12 @@
FLAGS_uploader | FLAGS_uploader_test,
FLAGS_withdbus,
&metrics_lib,
+ MetricsMainDiskStatsPath(),
kScalingMaxFreqPath,
kCpuinfoMaxFreqPath,
base::TimeDelta::FromSeconds(FLAGS_upload_interval_secs),
FLAGS_server,
- FLAGS_metrics_file,
- FLAGS_config_root);
+ base::FilePath(FLAGS_metrics_directory));
if (FLAGS_uploader_test) {
daemon.RunUploaderTest();
diff --git a/metricsd/metrics_daemon_test.cc b/metricsd/metrics_daemon_test.cc
index 0d2229c..476d0f3 100644
--- a/metricsd/metrics_daemon_test.cc
+++ b/metricsd/metrics_daemon_test.cc
@@ -82,12 +82,12 @@
false,
true,
&metrics_lib_,
+ disk_stats_path_.value(),
scaling_max_freq_path_.value(),
cpu_max_freq_path_.value(),
base::TimeDelta::FromMinutes(30),
metrics::kMetricsServer,
- metrics::kMetricsEventsFilePath,
- "/");
+ temp_dir_.path());
}
// Adds a metrics library mock expectation that the specified metric
@@ -198,6 +198,21 @@
/* min */ 1, /* max */ 100, /* buckets */ 50);
}
+TEST_F(MetricsDaemonTest, ParseDiskStats) {
+ uint64_t read_sectors_now, write_sectors_now;
+ CreateFakeDiskStatsFile(kFakeDiskStats0);
+ ASSERT_TRUE(daemon_.DiskStatsReadStats(&read_sectors_now,
+ &write_sectors_now));
+ EXPECT_EQ(read_sectors_now, kFakeReadSectors[0]);
+ EXPECT_EQ(write_sectors_now, kFakeWriteSectors[0]);
+
+ CreateFakeDiskStatsFile(kFakeDiskStats1);
+ ASSERT_TRUE(daemon_.DiskStatsReadStats(&read_sectors_now,
+ &write_sectors_now));
+ EXPECT_EQ(read_sectors_now, kFakeReadSectors[1]);
+ EXPECT_EQ(write_sectors_now, kFakeWriteSectors[1]);
+}
+
TEST_F(MetricsDaemonTest, ProcessMeminfo) {
string meminfo =
"MemTotal: 2000000 kB\nMemFree: 500000 kB\n"
diff --git a/metricsd/metrics_library.cc b/metricsd/metrics_library.cc
index 5687f1b..6449a24 100644
--- a/metricsd/metrics_library.cc
+++ b/metricsd/metrics_library.cc
@@ -56,7 +56,7 @@
time_t MetricsLibrary::cached_enabled_time_ = 0;
bool MetricsLibrary::cached_enabled_ = false;
-MetricsLibrary::MetricsLibrary() : consent_file_(metrics::kConsentFilePath) {}
+MetricsLibrary::MetricsLibrary() {}
MetricsLibrary::~MetricsLibrary() {}
// We take buffer and buffer_size as parameters in order to simplify testing
@@ -131,19 +131,20 @@
time_t this_check_time = time(nullptr);
if (this_check_time != cached_enabled_time_) {
cached_enabled_time_ = this_check_time;
- cached_enabled_ = stat(consent_file_.c_str(), &stat_buffer) >= 0;
+ cached_enabled_ = stat(consent_file_.value().data(), &stat_buffer) >= 0;
}
return cached_enabled_;
}
void MetricsLibrary::Init() {
- uma_events_file_ = metrics::kMetricsEventsFilePath;
+ base::FilePath dir = base::FilePath(metrics::kMetricsDirectory);
+ uma_events_file_ = dir.Append(metrics::kMetricsEventsFileName);
+ consent_file_ = dir.Append(metrics::kConsentFileName);
}
-void MetricsLibrary::InitForTest(const std::string& uma_events_file,
- const std::string& consent_file) {
- uma_events_file_ = uma_events_file;
- consent_file_ = consent_file;
+void MetricsLibrary::InitForTest(const base::FilePath& metrics_directory) {
+ uma_events_file_ = metrics_directory.Append(metrics::kMetricsEventsFileName);
+ consent_file_ = metrics_directory.Append(metrics::kConsentFileName);
}
bool MetricsLibrary::SendToUMA(const std::string& name,
@@ -154,30 +155,32 @@
return metrics::SerializationUtils::WriteMetricToFile(
*metrics::MetricSample::HistogramSample(name, sample, min, max, nbuckets)
.get(),
- metrics::kMetricsEventsFilePath);
+ uma_events_file_.value());
}
bool MetricsLibrary::SendEnumToUMA(const std::string& name, int sample,
int max) {
return metrics::SerializationUtils::WriteMetricToFile(
*metrics::MetricSample::LinearHistogramSample(name, sample, max).get(),
- metrics::kMetricsEventsFilePath);
+ uma_events_file_.value());
}
bool MetricsLibrary::SendSparseToUMA(const std::string& name, int sample) {
return metrics::SerializationUtils::WriteMetricToFile(
*metrics::MetricSample::SparseHistogramSample(name, sample).get(),
- metrics::kMetricsEventsFilePath);
+ uma_events_file_.value());
}
bool MetricsLibrary::SendUserActionToUMA(const std::string& action) {
return metrics::SerializationUtils::WriteMetricToFile(
- *metrics::MetricSample::UserActionSample(action).get(), metrics::kMetricsEventsFilePath);
+ *metrics::MetricSample::UserActionSample(action).get(),
+ uma_events_file_.value());
}
bool MetricsLibrary::SendCrashToUMA(const char *crash_kind) {
return metrics::SerializationUtils::WriteMetricToFile(
- *metrics::MetricSample::CrashSample(crash_kind).get(), metrics::kMetricsEventsFilePath);
+ *metrics::MetricSample::CrashSample(crash_kind).get(),
+ uma_events_file_.value());
}
bool MetricsLibrary::SendCrosEventToUMA(const std::string& event) {
diff --git a/metricsd/metrics_library_test.cc b/metricsd/metrics_library_test.cc
index 7ade6ee..f300d17 100644
--- a/metricsd/metrics_library_test.cc
+++ b/metricsd/metrics_library_test.cc
@@ -28,19 +28,17 @@
protected:
virtual void SetUp() {
ASSERT_TRUE(temp_dir_.CreateUniqueTempDir());
- consent_file_ = temp_dir_.path().Append("consent");
- uma_events_file_ = temp_dir_.path().Append("events");
- lib_.InitForTest(uma_events_file_.value(), consent_file_.value());
- EXPECT_EQ(0, WriteFile(uma_events_file_, "", 0));
+ lib_.InitForTest(temp_dir_.path());
+ EXPECT_EQ(0, WriteFile(lib_.uma_events_file_, "", 0));
// Defeat metrics enabled caching between tests.
lib_.cached_enabled_time_ = 0;
}
void SetMetricsConsent(bool enabled) {
if (enabled) {
- ASSERT_EQ(base::WriteFile(consent_file_, "", 0), 0);
+ ASSERT_EQ(base::WriteFile(lib_.consent_file_, "", 0), 0);
} else {
- ASSERT_TRUE(base::DeleteFile(consent_file_, false));
+ ASSERT_TRUE(base::DeleteFile(lib_.consent_file_, false));
}
}
@@ -49,8 +47,6 @@
MetricsLibrary lib_;
base::ScopedTempDir temp_dir_;
- base::FilePath consent_file_;
- base::FilePath uma_events_file_;
};
TEST_F(MetricsLibraryTest, AreMetricsEnabledFalse) {
diff --git a/metricsd/timer.cc b/metricsd/timer.cc
index 7b00cc0..0c2c119 100644
--- a/metricsd/timer.cc
+++ b/metricsd/timer.cc
@@ -14,7 +14,7 @@
* limitations under the License.
*/
-#include "timer.h"
+#include "metrics/timer.h"
#include <string>
diff --git a/metricsd/timer_mock.h b/metricsd/timer_mock.h
index 8c9e8d8..200ee9a 100644
--- a/metricsd/timer_mock.h
+++ b/metricsd/timer_mock.h
@@ -21,7 +21,7 @@
#include <gmock/gmock.h>
-#include "timer.h"
+#include "metrics/timer.h"
namespace chromeos_metrics {
diff --git a/metricsd/timer_test.cc b/metricsd/timer_test.cc
index ab027d4..432c3d2 100644
--- a/metricsd/timer_test.cc
+++ b/metricsd/timer_test.cc
@@ -20,8 +20,8 @@
#include <gmock/gmock.h>
#include <gtest/gtest.h>
+#include "metrics/timer.h"
#include "metrics_library_mock.h"
-#include "timer.h"
#include "timer_mock.h"
using ::testing::_;
diff --git a/metricsd/uploader/system_profile_cache.cc b/metricsd/uploader/system_profile_cache.cc
index 8635fb0..e3f6339 100644
--- a/metricsd/uploader/system_profile_cache.cc
+++ b/metricsd/uploader/system_profile_cache.cc
@@ -55,16 +55,16 @@
SystemProfileCache::SystemProfileCache()
: initialized_(false),
testing_(false),
- config_root_("/"),
+ metrics_directory_(metrics::kMetricsDirectory),
session_id_(new chromeos_metrics::PersistentInteger(
kPersistentSessionIdFilename)) {
}
SystemProfileCache::SystemProfileCache(bool testing,
- const base::FilePath& config_root)
+ const base::FilePath& metrics_directory)
: initialized_(false),
testing_(testing),
- config_root_(config_root),
+ metrics_directory_(metrics_directory),
session_id_(new chromeos_metrics::PersistentInteger(
kPersistentSessionIdFilename)) {
}
@@ -91,9 +91,11 @@
channel = "";
profile_.version = metrics::kDefaultVersion;
}
- profile_.client_id =
- testing_ ? "client_id_test" :
- GetPersistentGUID(metrics::kMetricsGUIDFilePath);
+ std::string guid_path = metrics_directory_.Append(
+ metrics::kMetricsGUIDFileName).value();
+ profile_.client_id = testing_ ?
+ "client_id_test" :
+ GetPersistentGUID(guid_path);
profile_.hardware_class = "unknown";
profile_.channel = ProtoChannelFromString(channel);
@@ -155,7 +157,7 @@
std::string SystemProfileCache::GetProperty(const std::string& name) {
if (testing_) {
std::string content;
- base::ReadFileToString(config_root_.Append(name), &content);
+ base::ReadFileToString(metrics_directory_.Append(name), &content);
return content;
} else {
char value[PROPERTY_VALUE_MAX];
diff --git a/metricsd/uploader/system_profile_cache.h b/metricsd/uploader/system_profile_cache.h
index 7157810..1d22fa1 100644
--- a/metricsd/uploader/system_profile_cache.h
+++ b/metricsd/uploader/system_profile_cache.h
@@ -50,7 +50,7 @@
public:
SystemProfileCache();
- SystemProfileCache(bool testing, const base::FilePath& config_root);
+ SystemProfileCache(bool testing, const base::FilePath& metrics_directory);
// Populates the ProfileSystem protobuf with system information.
bool Populate(metrics::ChromeUserMetricsExtension* metrics_proto) override;
@@ -77,13 +77,13 @@
bool InitializeOrCheck();
// Gets a system property as a string.
- // When |testing_| is true, reads the value from |config_root_|/|name|
+ // When |testing_| is true, reads the value from |metrics_directory_|/|name|
// instead.
std::string GetProperty(const std::string& name);
bool initialized_;
bool testing_;
- base::FilePath config_root_;
+ base::FilePath metrics_directory_;
scoped_ptr<chromeos_metrics::PersistentInteger> session_id_;
SystemProfile profile_;
};
diff --git a/metricsd/uploader/upload_service.cc b/metricsd/uploader/upload_service.cc
index 2335630..b630cec 100644
--- a/metricsd/uploader/upload_service.cc
+++ b/metricsd/uploader/upload_service.cc
@@ -19,6 +19,7 @@
#include <string>
#include <base/bind.h>
+#include <base/files/file_util.h>
#include <base/logging.h>
#include <base/memory/scoped_vector.h>
#include <base/message_loop/message_loop.h>
@@ -29,6 +30,7 @@
#include <base/metrics/statistics_recorder.h>
#include <base/sha1.h>
+#include "constants.h"
#include "serialization/metric_sample.h"
#include "serialization/serialization_utils.h"
#include "uploader/metrics_log.h"
@@ -44,6 +46,7 @@
metrics_lib_(metrics_lib),
histogram_snapshot_manager_(this),
sender_(new HttpSender(server)),
+ failed_upload_count_(metrics::kFailedUploadCountName),
testing_(false) {
}
@@ -56,9 +59,10 @@
}
void UploadService::Init(const base::TimeDelta& upload_interval,
- const std::string& metrics_file) {
+ const base::FilePath& metrics_directory) {
base::StatisticsRecorder::Initialize();
- metrics_file_ = metrics_file;
+ metrics_file_ = metrics_directory.Append(metrics::kMetricsEventsFileName);
+ staged_log_path_ = metrics_directory.Append(metrics::kStagedLogName);
if (!testing_) {
base::MessageLoop::current()->PostDelayedTask(FROM_HERE,
@@ -70,8 +74,8 @@
}
void UploadService::StartNewLog() {
- CHECK(!staged_log_) << "the staged log should be discarded before starting "
- "a new metrics log";
+ CHECK(!HasStagedLog()) << "the staged log should be discarded before "
+ << "starting a new metrics log";
MetricsLog* log = new MetricsLog();
current_log_.reset(log);
}
@@ -87,7 +91,11 @@
}
void UploadService::UploadEvent() {
- if (staged_log_) {
+ // If the system shutdown or crashed while uploading a report, we may not have
+ // deleted an old log.
+ RemoveFailedLog();
+
+ if (HasStagedLog()) {
// Previous upload failed, retry sending the logs.
SendStagedLog();
return;
@@ -99,51 +107,48 @@
StageCurrentLog();
// If a log is available for upload, upload it.
- if (staged_log_) {
+ if (HasStagedLog()) {
SendStagedLog();
}
}
void UploadService::SendStagedLog() {
- CHECK(staged_log_) << "staged_log_ must exist to be sent";
-
// If metrics are not enabled, discard the log and exit.
if (!metrics_lib_->AreMetricsEnabled()) {
LOG(INFO) << "Metrics disabled. Don't upload metrics samples.";
- staged_log_.reset();
+ base::DeleteFile(staged_log_path_, false);
return;
}
- std::string log_text;
- staged_log_->GetEncodedLog(&log_text);
- if (!sender_->Send(log_text, base::SHA1HashString(log_text))) {
- ++failed_upload_count_;
- if (failed_upload_count_ <= kMaxFailedUpload) {
- LOG(WARNING) << "log upload failed " << failed_upload_count_
- << " times. It will be retried later.";
- return;
- }
- LOG(WARNING) << "log failed more than " << kMaxFailedUpload << " times.";
+ std::string staged_log;
+ CHECK(base::ReadFileToString(staged_log_path_, &staged_log));
+
+ // Increase the failed count in case the daemon crashes while sending the log.
+ failed_upload_count_.Add(1);
+
+ if (!sender_->Send(staged_log, base::SHA1HashString(staged_log))) {
+ LOG(WARNING) << "log failed to upload";
} else {
- LOG(INFO) << "uploaded " << log_text.length() << " bytes";
+ VLOG(1) << "uploaded " << staged_log.length() << " bytes";
+ base::DeleteFile(staged_log_path_, false);
}
- // Discard staged log.
- staged_log_.reset();
+
+ RemoveFailedLog();
}
void UploadService::Reset() {
- staged_log_.reset();
+ base::DeleteFile(staged_log_path_, false);
current_log_.reset();
- failed_upload_count_ = 0;
+ failed_upload_count_.Set(0);
}
void UploadService::ReadMetrics() {
- CHECK(!staged_log_)
- << "cannot read metrics until the old logs have been discarded";
+ CHECK(!HasStagedLog()) << "cannot read metrics until the old logs have been "
+ << "discarded";
ScopedVector<metrics::MetricSample> vector;
metrics::SerializationUtils::ReadAndTruncateMetricsFromFile(
- metrics_file_, &vector);
+ metrics_file_.value(), &vector);
int i = 0;
for (ScopedVector<metrics::MetricSample>::iterator it = vector.begin();
@@ -152,7 +157,7 @@
AddSample(*sample);
i++;
}
- DLOG(INFO) << i << " samples read";
+ VLOG(1) << i << " samples read";
}
void UploadService::AddSample(const metrics::MetricSample& sample) {
@@ -216,19 +221,27 @@
}
void UploadService::StageCurrentLog() {
- CHECK(!staged_log_)
- << "staged logs must be discarded before another log can be staged";
+ // If we haven't logged anything since the last upload, don't upload an empty
+ // report.
+ if (!current_log_)
+ return;
- if (!current_log_) return;
-
- staged_log_.swap(current_log_);
- staged_log_->CloseLog();
- if (!staged_log_->PopulateSystemProfile(system_profile_setter_.get())) {
+ scoped_ptr<MetricsLog> staged_log;
+ staged_log.swap(current_log_);
+ staged_log->CloseLog();
+ if (!staged_log->PopulateSystemProfile(system_profile_setter_.get())) {
LOG(WARNING) << "Error while adding metadata to the log. Discarding the "
<< "log.";
- staged_log_.reset();
+ return;
}
- failed_upload_count_ = 0;
+ std::string encoded_log;
+ staged_log->GetEncodedLog(&encoded_log);
+
+ failed_upload_count_.Set(0);
+ if (static_cast<int>(encoded_log.size()) != base::WriteFile(
+ staged_log_path_, encoded_log.data(), encoded_log.size())) {
+ LOG(ERROR) << "failed to persist to " << staged_log_path_.value();
+ }
}
MetricsLog* UploadService::GetOrCreateCurrentLog() {
@@ -237,3 +250,16 @@
}
return current_log_.get();
}
+
+bool UploadService::HasStagedLog() {
+ return base::PathExists(staged_log_path_);
+}
+
+void UploadService::RemoveFailedLog() {
+ if (failed_upload_count_.Get() > kMaxFailedUpload) {
+ LOG(INFO) << "log failed more than " << kMaxFailedUpload << " times.";
+ CHECK(base::DeleteFile(staged_log_path_, false))
+ << "failed to delete staged log at " << staged_log_path_.value();
+ failed_upload_count_.Set(0);
+ }
+}
diff --git a/metricsd/uploader/upload_service.h b/metricsd/uploader/upload_service.h
index 7f2f413..a4d0a1e 100644
--- a/metricsd/uploader/upload_service.h
+++ b/metricsd/uploader/upload_service.h
@@ -24,6 +24,7 @@
#include "base/metrics/histogram_snapshot_manager.h"
#include "metrics/metrics_library.h"
+#include "persistent_integer.h"
#include "uploader/metrics_log.h"
#include "uploader/sender.h"
#include "uploader/system_profile_cache.h"
@@ -73,7 +74,7 @@
const std::string& server);
void Init(const base::TimeDelta& upload_interval,
- const std::string& metrics_file);
+ const base::FilePath& metrics_directory);
// Starts a new log. The log needs to be regenerated after each successful
// launch as it is destroyed when staging the log.
@@ -106,6 +107,7 @@
FRIEND_TEST(UploadServiceTest, LogContainsAggregatedValues);
FRIEND_TEST(UploadServiceTest, LogEmptyAfterUpload);
FRIEND_TEST(UploadServiceTest, LogEmptyByDefault);
+ FRIEND_TEST(UploadServiceTest, LogFromTheMetricsLibrary);
FRIEND_TEST(UploadServiceTest, LogKernelCrash);
FRIEND_TEST(UploadServiceTest, LogUncleanShutdown);
FRIEND_TEST(UploadServiceTest, LogUserCrash);
@@ -146,6 +148,12 @@
// system information.
void StageCurrentLog();
+ // Returns true iff a log is staged.
+ bool HasStagedLog();
+
+ // Remove the staged log iff the upload failed more than |kMaxFailedUpload|.
+ void RemoveFailedLog();
+
// Returns the current log. If there is no current log, creates it first.
MetricsLog* GetOrCreateCurrentLog();
@@ -153,11 +161,11 @@
MetricsLibraryInterface* metrics_lib_;
base::HistogramSnapshotManager histogram_snapshot_manager_;
scoped_ptr<Sender> sender_;
- int failed_upload_count_;
+ chromeos_metrics::PersistentInteger failed_upload_count_;
scoped_ptr<MetricsLog> current_log_;
- scoped_ptr<MetricsLog> staged_log_;
- std::string metrics_file_;
+ base::FilePath metrics_file_;
+ base::FilePath staged_log_path_;
bool testing_;
};
diff --git a/metricsd/uploader/upload_service_test.cc b/metricsd/uploader/upload_service_test.cc
index 40c235d..873953e 100644
--- a/metricsd/uploader/upload_service_test.cc
+++ b/metricsd/uploader/upload_service_test.cc
@@ -24,6 +24,7 @@
#include "constants.h"
#include "metrics_library_mock.h"
+#include "persistent_integer.h"
#include "serialization/metric_sample.h"
#include "uploader/metrics_log.h"
#include "uploader/mock/mock_system_profile_setter.h"
@@ -38,17 +39,16 @@
protected:
virtual void SetUp() {
CHECK(dir_.CreateUniqueTempDir());
+ chromeos_metrics::PersistentInteger::SetMetricsDirectory(
+ dir_.path().value());
+ metrics_lib_.InitForTest(dir_.path());
upload_service_.reset(new UploadService(new MockSystemProfileSetter(),
&metrics_lib_, "", true));
upload_service_->sender_.reset(new SenderMock);
- event_file_ = dir_.path().Append("event");
- upload_service_->Init(base::TimeDelta::FromMinutes(30), event_file_.value());
+ upload_service_->Init(base::TimeDelta::FromMinutes(30), dir_.path());
upload_service_->GatherHistograms();
upload_service_->Reset();
-
- chromeos_metrics::PersistentInteger::SetMetricsDirectory(
- dir_.path().value());
}
scoped_ptr<metrics::MetricSample> Crash(const std::string& name) {
@@ -61,11 +61,9 @@
base::WriteFile(dir_.path().Append(name), value.data(), value.size()));
}
- base::FilePath event_file_;
-
base::ScopedTempDir dir_;
scoped_ptr<UploadService> upload_service_;
- MetricsLibraryMock metrics_lib_;
+ MetricsLibrary metrics_lib_;
scoped_ptr<base::AtExitManager> exit_manager_;
};
@@ -135,9 +133,17 @@
upload_service_->UploadEvent();
}
- EXPECT_TRUE(upload_service_->staged_log_);
+ EXPECT_TRUE(upload_service_->HasStagedLog());
upload_service_->UploadEvent();
- EXPECT_FALSE(upload_service_->staged_log_);
+ EXPECT_FALSE(upload_service_->HasStagedLog());
+
+ // Log a new sample. The failed upload counter should be reset.
+ upload_service_->AddSample(*Crash("user"));
+ for (int i = 0; i < UploadService::kMaxFailedUpload; i++) {
+ upload_service_->UploadEvent();
+ }
+ // The log is not discarded after multiple failed uploads.
+ EXPECT_TRUE(upload_service_->HasStagedLog());
}
TEST_F(UploadServiceTest, EmptyLogsAreNotSent) {
@@ -269,3 +275,18 @@
cache.Initialize();
EXPECT_EQ(cache.profile_.session_id, session_id + 1);
}
+
+// Test that we can log metrics from the metrics library and have the uploader
+// upload them.
+TEST_F(UploadServiceTest, LogFromTheMetricsLibrary) {
+ SenderMock* sender = new SenderMock();
+ upload_service_->sender_.reset(sender);
+
+ upload_service_->UploadEvent();
+ EXPECT_EQ(0, sender->send_call_count());
+
+ metrics_lib_.SendEnumToUMA("testname", 2, 10);
+ upload_service_->UploadEvent();
+
+ EXPECT_EQ(1, sender->send_call_count());
+}
diff --git a/toolbox/Android.mk b/toolbox/Android.mk
index f4a03fe..579d26e 100644
--- a/toolbox/Android.mk
+++ b/toolbox/Android.mk
@@ -24,18 +24,11 @@
LOCAL_MODULE := libtoolbox_dd
include $(BUILD_STATIC_LIBRARY)
-include $(CLEAR_VARS)
-LOCAL_SRC_FILES := upstream-netbsd/usr.bin/du/du.c
-LOCAL_CFLAGS += $(common_cflags) -Dmain=du_main
-LOCAL_MODULE := libtoolbox_du
-include $(BUILD_STATIC_LIBRARY)
-
include $(CLEAR_VARS)
BSD_TOOLS := \
dd \
- du \
OUR_TOOLS := \
df \
diff --git a/toolbox/upstream-netbsd/usr.bin/du/du.c b/toolbox/upstream-netbsd/usr.bin/du/du.c
deleted file mode 100644
index 086ac4a..0000000
--- a/toolbox/upstream-netbsd/usr.bin/du/du.c
+++ /dev/null
@@ -1,364 +0,0 @@
-/* $NetBSD: du.c,v 1.36 2012/03/11 11:23:20 shattered Exp $ */
-
-/*
- * Copyright (c) 1989, 1993, 1994
- * The Regents of the University of California. All rights reserved.
- *
- * This code is derived from software contributed to Berkeley by
- * Chris Newcomb.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- * notice, this list of conditions and the following disclaimer in the
- * documentation and/or other materials provided with the distribution.
- * 3. Neither the name of the University nor the names of its contributors
- * may be used to endorse or promote products derived from this software
- * without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
- * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
- * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
- * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
- * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
- * SUCH DAMAGE.
- */
-
-#include <sys/cdefs.h>
-#ifndef lint
-__COPYRIGHT("@(#) Copyright (c) 1989, 1993, 1994\
- The Regents of the University of California. All rights reserved.");
-#endif /* not lint */
-
-#ifndef lint
-#if 0
-static char sccsid[] = "@(#)du.c 8.5 (Berkeley) 5/4/95";
-#else
-__RCSID("$NetBSD: du.c,v 1.36 2012/03/11 11:23:20 shattered Exp $");
-#endif
-#endif /* not lint */
-
-#include <sys/param.h>
-#include <sys/types.h>
-#include <sys/stat.h>
-
-#include <dirent.h>
-#include <err.h>
-#include <errno.h>
-#include <fts.h>
-#include <inttypes.h>
-#include <util.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-#include <unistd.h>
-#include <limits.h>
-
-/* Count inodes or file size */
-#define COUNT (iflag ? 1 : p->fts_statp->st_blocks)
-
-static int linkchk(dev_t, ino_t);
-static void prstat(const char *, int64_t);
-__dead static void usage(void);
-
-static int hflag, iflag;
-static long blocksize;
-
-int
-main(int argc, char *argv[])
-{
- FTS *fts;
- FTSENT *p;
- int64_t totalblocks;
- int ftsoptions, listfiles;
- int depth;
- int Hflag, Lflag, aflag, ch, cflag, dflag, gkmflag, nflag, rval, sflag;
- const char *noargv[2];
-
- Hflag = Lflag = aflag = cflag = dflag = gkmflag = nflag = sflag = 0;
- totalblocks = 0;
- ftsoptions = FTS_PHYSICAL;
- depth = INT_MAX;
- while ((ch = getopt(argc, argv, "HLPacd:ghikmnrsx")) != -1)
- switch (ch) {
- case 'H':
- Hflag = 1;
- Lflag = 0;
- break;
- case 'L':
- Lflag = 1;
- Hflag = 0;
- break;
- case 'P':
- Hflag = Lflag = 0;
- break;
- case 'a':
- aflag = 1;
- break;
- case 'c':
- cflag = 1;
- break;
- case 'd':
- dflag = 1;
- depth = atoi(optarg);
- if (depth < 0 || depth > SHRT_MAX) {
- warnx("invalid argument to option d: %s",
- optarg);
- usage();
- }
- break;
- case 'g':
- blocksize = 1024 * 1024 * 1024;
- gkmflag = 1;
- break;
- case 'h':
- hflag = 1;
- break;
- case 'i':
- iflag = 1;
- break;
- case 'k':
- blocksize = 1024;
- gkmflag = 1;
- break;
- case 'm':
- blocksize = 1024 * 1024;
- gkmflag = 1;
- break;
- case 'n':
- nflag = 1;
- break;
- case 'r':
- break;
- case 's':
- sflag = 1;
- break;
- case 'x':
- ftsoptions |= FTS_XDEV;
- break;
- case '?':
- default:
- usage();
- }
- argc -= optind;
- argv += optind;
-
- /*
- * XXX
- * Because of the way that fts(3) works, logical walks will not count
- * the blocks actually used by symbolic links. We rationalize this by
- * noting that users computing logical sizes are likely to do logical
- * copies, so not counting the links is correct. The real reason is
- * that we'd have to re-implement the kernel's symbolic link traversing
- * algorithm to get this right. If, for example, you have relative
- * symbolic links referencing other relative symbolic links, it gets
- * very nasty, very fast. The bottom line is that it's documented in
- * the man page, so it's a feature.
- */
- if (Hflag)
- ftsoptions |= FTS_COMFOLLOW;
- if (Lflag) {
- ftsoptions &= ~FTS_PHYSICAL;
- ftsoptions |= FTS_LOGICAL;
- }
-
- listfiles = 0;
- if (aflag) {
- if (sflag || dflag)
- usage();
- listfiles = 1;
- } else if (sflag) {
- if (dflag)
- usage();
- depth = 0;
- }
-
- if (!*argv) {
- noargv[0] = ".";
- noargv[1] = NULL;
- argv = __UNCONST(noargv);
- }
-
- if (!gkmflag)
- (void)getbsize(NULL, &blocksize);
- blocksize /= 512;
-
- if ((fts = fts_open(argv, ftsoptions, NULL)) == NULL)
- err(1, "fts_open `%s'", *argv);
-
- for (rval = 0; (p = fts_read(fts)) != NULL;) {
-#ifndef __ANDROID__
- if (nflag) {
- switch (p->fts_info) {
- case FTS_NS:
- case FTS_SLNONE:
- /* nothing */
- break;
- default:
- if (p->fts_statp->st_flags & UF_NODUMP) {
- fts_set(fts, p, FTS_SKIP);
- continue;
- }
- }
- }
-#endif
- switch (p->fts_info) {
- case FTS_D: /* Ignore. */
- break;
- case FTS_DP:
- p->fts_parent->fts_number +=
- p->fts_number += COUNT;
- if (cflag)
- totalblocks += COUNT;
- /*
- * If listing each directory, or not listing files
- * or directories and this is post-order of the
- * root of a traversal, display the total.
- */
- if (p->fts_level <= depth
- || (!listfiles && !p->fts_level))
- prstat(p->fts_path, p->fts_number);
- break;
- case FTS_DC: /* Ignore. */
- break;
- case FTS_DNR: /* Warn, continue. */
- case FTS_ERR:
- case FTS_NS:
- warnx("%s: %s", p->fts_path, strerror(p->fts_errno));
- rval = 1;
- break;
- default:
- if (p->fts_statp->st_nlink > 1 &&
- linkchk(p->fts_statp->st_dev, p->fts_statp->st_ino))
- break;
- /*
- * If listing each file, or a non-directory file was
- * the root of a traversal, display the total.
- */
- if (listfiles || !p->fts_level)
- prstat(p->fts_path, COUNT);
- p->fts_parent->fts_number += COUNT;
- if (cflag)
- totalblocks += COUNT;
- }
- }
- if (errno)
- err(1, "fts_read");
- if (cflag)
- prstat("total", totalblocks);
- exit(rval);
-}
-
-static void
-prstat(const char *fname, int64_t blocks)
-{
- if (iflag) {
- (void)printf("%" PRId64 "\t%s\n", blocks, fname);
- return;
- }
-
- if (hflag) {
- char buf[5];
- int64_t sz = blocks * 512;
-
- humanize_number(buf, sizeof(buf), sz, "", HN_AUTOSCALE,
- HN_B | HN_NOSPACE | HN_DECIMAL);
-
- (void)printf("%s\t%s\n", buf, fname);
- } else
- (void)printf("%" PRId64 "\t%s\n",
- howmany(blocks, (int64_t)blocksize),
- fname);
-}
-
-static int
-linkchk(dev_t dev, ino_t ino)
-{
- static struct entry {
- dev_t dev;
- ino_t ino;
- } *htable;
- static int htshift; /* log(allocated size) */
- static int htmask; /* allocated size - 1 */
- static int htused; /* 2*number of insertions */
- static int sawzero; /* Whether zero is in table or not */
- int h, h2;
- uint64_t tmp;
- /* this constant is (1<<64)/((1+sqrt(5))/2)
- * aka (word size)/(golden ratio)
- */
- const uint64_t HTCONST = 11400714819323198485ULL;
- const int HTBITS = CHAR_BIT * sizeof(tmp);
-
- /* Never store zero in hashtable */
- if (dev == 0 && ino == 0) {
- h = sawzero;
- sawzero = 1;
- return h;
- }
-
- /* Extend hash table if necessary, keep load under 0.5 */
- if (htused<<1 >= htmask) {
- struct entry *ohtable;
-
- if (!htable)
- htshift = 10; /* starting hashtable size */
- else
- htshift++; /* exponential hashtable growth */
-
- htmask = (1 << htshift) - 1;
- htused = 0;
-
- ohtable = htable;
- htable = calloc(htmask+1, sizeof(*htable));
- if (!htable)
- err(1, "calloc");
-
- /* populate newly allocated hashtable */
- if (ohtable) {
- int i;
- for (i = 0; i <= htmask>>1; i++)
- if (ohtable[i].ino || ohtable[i].dev)
- linkchk(ohtable[i].dev, ohtable[i].ino);
- free(ohtable);
- }
- }
-
- /* multiplicative hashing */
- tmp = dev;
- tmp <<= HTBITS>>1;
- tmp |= ino;
- tmp *= HTCONST;
- h = tmp >> (HTBITS - htshift);
- h2 = 1 | ( tmp >> (HTBITS - (htshift<<1) - 1)); /* must be odd */
-
- /* open address hashtable search with double hash probing */
- while (htable[h].ino || htable[h].dev) {
- if ((htable[h].ino == ino) && (htable[h].dev == dev))
- return 1;
- h = (h + h2) & htmask;
- }
-
- /* Insert the current entry into hashtable */
- htable[h].dev = dev;
- htable[h].ino = ino;
- htused++;
- return 0;
-}
-
-static void
-usage(void)
-{
-
- (void)fprintf(stderr,
- "usage: du [-H | -L | -P] [-a | -d depth | -s] [-cghikmnrx] [file ...]\n");
- exit(1);
-}
diff --git a/trusty/libtrusty/Android.mk b/trusty/libtrusty/Android.mk
new file mode 100644
index 0000000..45fc079
--- /dev/null
+++ b/trusty/libtrusty/Android.mk
@@ -0,0 +1,36 @@
+# 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.
+
+LOCAL_PATH := $(call my-dir)
+
+# == libtrusty Static library ==
+include $(CLEAR_VARS)
+
+LOCAL_MODULE := libtrusty
+LOCAL_MODULE_TAGS := optional
+LOCAL_SRC_FILES := trusty.c
+LOCAL_EXPORT_C_INCLUDE_DIRS := $(LOCAL_PATH)/include
+
+include $(BUILD_STATIC_LIBRARY)
+
+# == libtrusty shared library ==
+include $(CLEAR_VARS)
+
+LOCAL_MODULE := libtrusty
+LOCAL_MODULE_TAGS := optional
+LOCAL_SRC_FILES := trusty.c
+LOCAL_EXPORT_C_INCLUDE_DIRS := $(LOCAL_PATH)/include
+LOCAL_SHARED_LIBRARIES := liblog
+
+include $(BUILD_SHARED_LIBRARY)
diff --git a/trusty/libtrusty/include/trusty/tipc.h b/trusty/libtrusty/include/trusty/tipc.h
new file mode 100644
index 0000000..a3f2a3f
--- /dev/null
+++ b/trusty/libtrusty/include/trusty/tipc.h
@@ -0,0 +1,31 @@
+/*
+ * 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 _LIB_TIPC_H
+#define _LIB_TIPC_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+int tipc_connect(const char *dev_name, const char *srv_name);
+int tipc_close(int fd);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
diff --git a/trusty/libtrusty/tipc-test/Android.mk b/trusty/libtrusty/tipc-test/Android.mk
new file mode 100644
index 0000000..80030fe
--- /dev/null
+++ b/trusty/libtrusty/tipc-test/Android.mk
@@ -0,0 +1,29 @@
+# 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.
+
+LOCAL_PATH := $(call my-dir)
+
+include $(CLEAR_VARS)
+
+LOCAL_MODULE := tipc-test
+LOCAL_FORCE_STATIC_EXECUTABLE := true
+LOCAL_MODULE_PATH := $(TARGET_OUT_OPTIONAL_EXECUTABLES)
+LOCAL_MODULE_TAGS := optional
+LOCAL_SRC_FILES := tipc_test.c
+LOCAL_STATIC_LIBRARIES := libc libtrusty liblog
+LOCAL_MULTILIB := both
+LOCAL_MODULE_STEM_32 := $(LOCAL_MODULE)32
+LOCAL_MODULE_STEM_64 := $(LOCAL_MODULE)64
+
+include $(BUILD_EXECUTABLE)
diff --git a/trusty/libtrusty/tipc-test/tipc_test.c b/trusty/libtrusty/tipc-test/tipc_test.c
new file mode 100644
index 0000000..55d5ee6
--- /dev/null
+++ b/trusty/libtrusty/tipc-test/tipc_test.c
@@ -0,0 +1,744 @@
+/*
+ * 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 <stdio.h>
+#include <errno.h>
+#include <stdbool.h>
+#include <string.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <getopt.h>
+
+#include <trusty/tipc.h>
+
+#define TIPC_DEFAULT_DEVNAME "/dev/trusty-ipc-dev0"
+
+static const char *dev_name = NULL;
+static const char *test_name = NULL;
+
+static const char *uuid_name = "com.android.ipc-unittest.srv.uuid";
+static const char *echo_name = "com.android.ipc-unittest.srv.echo";
+static const char *ta_only_name = "com.android.ipc-unittest.srv.ta_only";
+static const char *ns_only_name = "com.android.ipc-unittest.srv.ns_only";
+static const char *datasink_name = "com.android.ipc-unittest.srv.datasink";
+static const char *closer1_name = "com.android.ipc-unittest.srv.closer1";
+static const char *closer2_name = "com.android.ipc-unittest.srv.closer2";
+static const char *closer3_name = "com.android.ipc-unittest.srv.closer3";
+static const char *main_ctrl_name = "com.android.ipc-unittest.ctrl";
+
+static const char *_sopts = "hsvD:t:r:m:b:";
+static const struct option _lopts[] = {
+ {"help", no_argument, 0, 'h'},
+ {"silent", no_argument, 0, 's'},
+ {"variable",no_argument, 0, 'v'},
+ {"dev", required_argument, 0, 'D'},
+ {"repeat", required_argument, 0, 'r'},
+ {"burst", required_argument, 0, 'b'},
+ {"msgsize", required_argument, 0, 'm'},
+ {0, 0, 0, 0}
+};
+
+static const char *usage =
+"Usage: %s [options]\n"
+"\n"
+"options:\n"
+" -h, --help prints this message and exit\n"
+" -D, --dev name device name\n"
+" -t, --test name test to run\n"
+" -r, --repeat cnt repeat count\n"
+" -m, --msgsize size max message size\n"
+" -v, --variable variable message size\n"
+" -s, --silent silent\n"
+"\n"
+;
+
+static const char *usage_long =
+"\n"
+"The following tests are available:\n"
+" connect - connect to datasink service\n"
+" connect_foo - connect to non existing service\n"
+" burst_write - send messages to datasink service\n"
+" echo - send/receive messages to echo service\n"
+" select - test select call\n"
+" blocked_read - test blocked read\n"
+" closer1 - connection closed by remote (test1)\n"
+" closer2 - connection closed by remote (test2)\n"
+" closer3 - connection closed by remote (test3)\n"
+" ta2ta-ipc - execute TA to TA unittest\n"
+" dev-uuid - print device uuid\n"
+" ta-access - test ta-access flags\n"
+"\n"
+;
+
+static uint opt_repeat = 1;
+static uint opt_msgsize = 32;
+static uint opt_msgburst = 32;
+static bool opt_variable = false;
+static bool opt_silent = false;
+
+static void print_usage_and_exit(const char *prog, int code, bool verbose)
+{
+ fprintf (stderr, usage, prog);
+ if (verbose)
+ fprintf (stderr, usage_long);
+ exit(code);
+}
+
+static void parse_options(int argc, char **argv)
+{
+ int c;
+ int oidx = 0;
+
+ while (1)
+ {
+ c = getopt_long (argc, argv, _sopts, _lopts, &oidx);
+ if (c == -1)
+ break; /* done */
+
+ switch (c) {
+
+ case 'D':
+ dev_name = strdup(optarg);
+ break;
+
+ case 't':
+ test_name = strdup(optarg);
+ break;
+
+ case 'v':
+ opt_variable = true;
+ break;
+
+ case 'r':
+ opt_repeat = atoi(optarg);
+ break;
+
+ case 'm':
+ opt_msgsize = atoi(optarg);
+ break;
+
+ case 'b':
+ opt_msgburst = atoi(optarg);
+ break;
+
+ case 's':
+ opt_silent = true;
+ break;
+
+ case 'h':
+ print_usage_and_exit(argv[0], EXIT_SUCCESS, true);
+ break;
+
+ default:
+ print_usage_and_exit(argv[0], EXIT_FAILURE, false);
+ }
+ }
+}
+
+static int connect_test(uint repeat)
+{
+ uint i;
+ int echo_fd;
+ int dsink_fd;
+
+ if (!opt_silent) {
+ printf("%s: repeat = %u\n", __func__, repeat);
+ }
+
+ for (i = 0; i < repeat; i++) {
+ echo_fd = tipc_connect(dev_name, echo_name);
+ if (echo_fd < 0) {
+ fprintf(stderr, "Failed to connect to '%s' service\n",
+ "echo");
+ }
+ dsink_fd = tipc_connect(dev_name, datasink_name);
+ if (dsink_fd < 0) {
+ fprintf(stderr, "Failed to connect to '%s' service\n",
+ "datasink");
+ }
+
+ if (echo_fd >= 0) {
+ tipc_close(echo_fd);
+ }
+ if (dsink_fd >= 0) {
+ tipc_close(dsink_fd);
+ }
+ }
+
+ if (!opt_silent) {
+ printf("%s: done\n", __func__);
+ }
+
+ return 0;
+}
+
+static int connect_foo(uint repeat)
+{
+ uint i;
+ int fd;
+
+ if (!opt_silent) {
+ printf("%s: repeat = %u\n", __func__, repeat);
+ }
+
+ for (i = 0; i < repeat; i++) {
+ fd = tipc_connect(dev_name, "foo");
+ if (fd >= 0) {
+ fprintf(stderr, "succeeded to connect to '%s' service\n",
+ "foo");
+ tipc_close(fd);
+ }
+ }
+
+ if (!opt_silent) {
+ printf("%s: done\n", __func__);
+ }
+
+ return 0;
+}
+
+
+static int closer1_test(uint repeat)
+{
+ uint i;
+ int fd;
+
+ if (!opt_silent) {
+ printf("%s: repeat = %u\n", __func__, repeat);
+ }
+
+ for (i = 0; i < repeat; i++) {
+ fd = tipc_connect(dev_name, closer1_name);
+ if (fd < 0) {
+ fprintf(stderr, "Failed to connect to '%s' service\n",
+ "closer1");
+ continue;
+ }
+ if (!opt_silent) {
+ printf("%s: connected\n", __func__);
+ }
+ tipc_close(fd);
+ }
+
+ if (!opt_silent) {
+ printf("%s: done\n", __func__);
+ }
+
+ return 0;
+}
+
+static int closer2_test(uint repeat)
+{
+ uint i;
+ int fd;
+
+ if (!opt_silent) {
+ printf("%s: repeat = %u\n", __func__, repeat);
+ }
+
+ for (i = 0; i < repeat; i++) {
+ fd = tipc_connect(dev_name, closer2_name);
+ if (fd < 0) {
+ if (!opt_silent) {
+ printf("failed to connect to '%s' service\n", "closer2");
+ }
+ } else {
+ /* this should always fail */
+ fprintf(stderr, "connected to '%s' service\n", "closer2");
+ tipc_close(fd);
+ }
+ }
+
+ if (!opt_silent) {
+ printf("%s: done\n", __func__);
+ }
+
+ return 0;
+}
+
+static int closer3_test(uint repeat)
+{
+ uint i, j;
+ ssize_t rc;
+ int fd[4];
+ char buf[64];
+
+ if (!opt_silent) {
+ printf("%s: repeat = %u\n", __func__, repeat);
+ }
+
+ for (i = 0; i < repeat; i++) {
+
+ /* open 4 connections to closer3 service */
+ for (j = 0; j < 4; j++) {
+ fd[j] = tipc_connect(dev_name, closer3_name);
+ if (fd[j] < 0) {
+ fprintf(stderr, "fd[%d]: failed to connect to '%s' service\n", j, "closer3");
+ } else {
+ if (!opt_silent) {
+ printf("%s: fd[%d]=%d: connected\n", __func__, j, fd[j]);
+ }
+ memset(buf, i + j, sizeof(buf));
+ rc = write(fd[j], buf, sizeof(buf));
+ if (rc != sizeof(buf)) {
+ if (!opt_silent) {
+ printf("%s: fd[%d]=%d: write returned = %zd\n",
+ __func__, j, fd[j], rc);
+ }
+ perror("closer3_test: write");
+ }
+ }
+ }
+
+ /* sleep a bit */
+ sleep(1);
+
+ /* It is expected that they will be closed by remote */
+ for (j = 0; j < 4; j++) {
+ if (fd[j] < 0)
+ continue;
+ rc = write(fd[j], buf, sizeof(buf));
+ if (rc != sizeof(buf)) {
+ if (!opt_silent) {
+ printf("%s: fd[%d]=%d: write returned = %zd\n",
+ __func__, j, fd[j], rc);
+ }
+ perror("closer3_test: write");
+ }
+ }
+
+ /* then they have to be closed by remote */
+ for (j = 0; j < 4; j++) {
+ if (fd[j] >= 0) {
+ tipc_close(fd[j]);
+ }
+ }
+ }
+
+ if (!opt_silent) {
+ printf("%s: done\n", __func__);
+ }
+
+ return 0;
+}
+
+
+static int echo_test(uint repeat, uint msgsz, bool var)
+{
+ uint i;
+ ssize_t rc;
+ size_t msg_len;
+ int echo_fd =-1;
+ char tx_buf[msgsz];
+ char rx_buf[msgsz];
+
+ if (!opt_silent) {
+ printf("%s: repeat %u: msgsz %u: variable %s\n",
+ __func__, repeat, msgsz, var ? "true" : "false");
+ }
+
+ echo_fd = tipc_connect(dev_name, echo_name);
+ if (echo_fd < 0) {
+ fprintf(stderr, "Failed to connect to service\n");
+ return echo_fd;
+ }
+
+ for (i = 0; i < repeat; i++) {
+
+ msg_len = msgsz;
+ if (opt_variable && msgsz) {
+ msg_len = rand() % msgsz;
+ }
+
+ memset(tx_buf, i + 1, msg_len);
+
+ rc = write(echo_fd, tx_buf, msg_len);
+ if ((size_t)rc != msg_len) {
+ perror("echo_test: write");
+ break;
+ }
+
+ rc = read(echo_fd, rx_buf, msg_len);
+ if (rc < 0) {
+ perror("echo_test: read");
+ break;
+ }
+
+ if ((size_t)rc != msg_len) {
+ fprintf(stderr, "data truncated (%zu vs. %zu)\n",
+ rc, msg_len);
+ continue;
+ }
+
+ if (memcmp(tx_buf, rx_buf, (size_t) rc)) {
+ fprintf(stderr, "data mismatch\n");
+ continue;
+ }
+ }
+
+ tipc_close(echo_fd);
+
+ if (!opt_silent) {
+ printf("%s: done\n",__func__);
+ }
+
+ return 0;
+}
+
+static int burst_write_test(uint repeat, uint msgburst, uint msgsz, bool var)
+{
+ int fd;
+ uint i, j;
+ ssize_t rc;
+ size_t msg_len;
+ char tx_buf[msgsz];
+
+ if (!opt_silent) {
+ printf("%s: repeat %u: burst %u: msgsz %u: variable %s\n",
+ __func__, repeat, msgburst, msgsz,
+ var ? "true" : "false");
+ }
+
+ for (i = 0; i < repeat; i++) {
+
+ fd = tipc_connect(dev_name, datasink_name);
+ if (fd < 0) {
+ fprintf(stderr, "Failed to connect to '%s' service\n",
+ "datasink");
+ break;
+ }
+
+ for (j = 0; j < msgburst; j++) {
+ msg_len = msgsz;
+ if (var && msgsz) {
+ msg_len = rand() % msgsz;
+ }
+
+ memset(tx_buf, i + 1, msg_len);
+ rc = write(fd, tx_buf, msg_len);
+ if ((size_t)rc != msg_len) {
+ perror("burst_test: write");
+ break;
+ }
+ }
+
+ tipc_close(fd);
+ }
+
+ if (!opt_silent) {
+ printf("%s: done\n",__func__);
+ }
+
+ return 0;
+}
+
+
+static int _wait_for_msg(int fd, uint msgsz, int timeout)
+{
+ int rc;
+ fd_set rfds;
+ uint msgcnt = 0;
+ char rx_buf[msgsz];
+ struct timeval tv;
+
+ if (!opt_silent) {
+ printf("waiting (%d) for msg\n", timeout);
+ }
+
+ FD_ZERO(&rfds);
+ FD_SET(fd, &rfds);
+
+ tv.tv_sec = timeout;
+ tv.tv_usec = 0;
+
+ for(;;) {
+ rc = select(fd+1, &rfds, NULL, NULL, &tv);
+
+ if (rc == 0) {
+ if (!opt_silent) {
+ printf("select timedout\n");
+ }
+ break;
+ }
+
+ if (rc == -1) {
+ perror("select_test: select");
+ return rc;
+ }
+
+ rc = read(fd, rx_buf, sizeof(rx_buf));
+ if (rc < 0) {
+ perror("select_test: read");
+ return rc;
+ } else {
+ if (rc > 0) {
+ msgcnt++;
+ }
+ }
+ }
+
+ if (!opt_silent) {
+ printf("got %u messages\n", msgcnt);
+ }
+
+ return 0;
+}
+
+
+static int select_test(uint repeat, uint msgburst, uint msgsz)
+{
+ int fd;
+ uint i, j;
+ ssize_t rc;
+ char tx_buf[msgsz];
+
+ if (!opt_silent) {
+ printf("%s: repeat %u\n", __func__, repeat);
+ }
+
+ fd = tipc_connect(dev_name, echo_name);
+ if (fd < 0) {
+ fprintf(stderr, "Failed to connect to '%s' service\n",
+ "echo");
+ return fd;
+ }
+
+ for (i = 0; i < repeat; i++) {
+
+ _wait_for_msg(fd, msgsz, 1);
+
+ if (!opt_silent) {
+ printf("sending burst: %u msg\n", msgburst);
+ }
+
+ for (j = 0; j < msgburst; j++) {
+ memset(tx_buf, i + j, msgsz);
+ rc = write(fd, tx_buf, msgsz);
+ if ((size_t)rc != msgsz) {
+ perror("burst_test: write");
+ break;
+ }
+ }
+ }
+
+ tipc_close(fd);
+
+ if (!opt_silent) {
+ printf("%s: done\n",__func__);
+ }
+
+ return 0;
+}
+
+static int blocked_read_test(uint repeat)
+{
+ int fd;
+ uint i;
+ ssize_t rc;
+ char rx_buf[512];
+
+ if (!opt_silent) {
+ printf("%s: repeat %u\n", __func__, repeat);
+ }
+
+ fd = tipc_connect(dev_name, echo_name);
+ if (fd < 0) {
+ fprintf(stderr, "Failed to connect to '%s' service\n",
+ "echo");
+ return fd;
+ }
+
+ for (i = 0; i < repeat; i++) {
+ rc = read(fd, rx_buf, sizeof(rx_buf));
+ if (rc < 0) {
+ perror("select_test: read");
+ break;
+ } else {
+ if (!opt_silent) {
+ printf("got %zd bytes\n", rc);
+ }
+ }
+ }
+
+ tipc_close(fd);
+
+ if (!opt_silent) {
+ printf("%s: done\n",__func__);
+ }
+
+ return 0;
+}
+
+static int ta2ta_ipc_test(void)
+{
+ int fd;
+ char rx_buf[64];
+
+ if (!opt_silent) {
+ printf("%s:\n", __func__);
+ }
+
+ fd = tipc_connect(dev_name, main_ctrl_name);
+ if (fd < 0) {
+ fprintf(stderr, "Failed to connect to '%s' service\n",
+ "main_ctrl");
+ return fd;
+ }
+
+ /* wait for test to complete */
+ (void) read(fd, rx_buf, sizeof(rx_buf));
+
+ tipc_close(fd);
+
+ return 0;
+}
+
+typedef struct uuid
+{
+ uint32_t time_low;
+ uint16_t time_mid;
+ uint16_t time_hi_and_version;
+ uint8_t clock_seq_and_node[8];
+} uuid_t;
+
+static void print_uuid(const char *dev, uuid_t *uuid)
+{
+ printf("%s:", dev);
+ printf("uuid: %08x-%04x-%04x-%02x%02x-%02x%02x%02x%02x%02x%02x\n",
+ uuid->time_low,
+ uuid->time_mid,
+ uuid->time_hi_and_version,
+ uuid->clock_seq_and_node[0],
+ uuid->clock_seq_and_node[1],
+ uuid->clock_seq_and_node[2],
+ uuid->clock_seq_and_node[3],
+ uuid->clock_seq_and_node[4],
+ uuid->clock_seq_and_node[5],
+ uuid->clock_seq_and_node[6],
+ uuid->clock_seq_and_node[7]
+ );
+}
+
+static int dev_uuid_test(void)
+{
+ int fd;
+ ssize_t rc;
+ uuid_t uuid;
+
+ fd = tipc_connect(dev_name, uuid_name);
+ if (fd < 0) {
+ fprintf(stderr, "Failed to connect to '%s' service\n",
+ "uuid");
+ return fd;
+ }
+
+ /* wait for test to complete */
+ rc = read(fd, &uuid, sizeof(uuid));
+ if (rc < 0) {
+ perror("dev_uuid_test: read");
+ } else if (rc != sizeof(uuid)) {
+ fprintf(stderr, "unexpected uuid size (%d vs. %d)\n",
+ (int)rc, (int)sizeof(uuid));
+ } else {
+ print_uuid(dev_name, &uuid);
+ }
+
+ tipc_close(fd);
+
+ return 0;
+}
+
+static int ta_access_test(void)
+{
+ int fd;
+
+ if (!opt_silent) {
+ printf("%s:\n", __func__);
+ }
+
+ fd = tipc_connect(dev_name, ta_only_name);
+ if (fd >= 0) {
+ fprintf(stderr, "Succeed to connect to '%s' service\n",
+ "ta_only");
+ tipc_close(fd);
+ }
+
+ fd = tipc_connect(dev_name, ns_only_name);
+ if (fd < 0) {
+ fprintf(stderr, "Failed to connect to '%s' service\n",
+ "ns_only");
+ return fd;
+ }
+ tipc_close(fd);
+
+ if (!opt_silent) {
+ printf("%s: done\n",__func__);
+ }
+
+ return 0;
+}
+
+
+int main(int argc, char **argv)
+{
+ int rc = 0;
+
+ if (argc <= 1) {
+ print_usage_and_exit(argv[0], EXIT_FAILURE, false);
+ }
+
+ parse_options(argc, argv);
+
+ if (!dev_name) {
+ dev_name = TIPC_DEFAULT_DEVNAME;
+ }
+
+ if (!test_name) {
+ fprintf(stderr, "need a Test to run\n");
+ print_usage_and_exit(argv[0], EXIT_FAILURE, true);
+ }
+
+ if (strcmp(test_name, "connect") == 0) {
+ rc = connect_test(opt_repeat);
+ } else if (strcmp(test_name, "connect_foo") == 0) {
+ rc = connect_foo(opt_repeat);
+ } else if (strcmp(test_name, "burst_write") == 0) {
+ rc = burst_write_test(opt_repeat, opt_msgburst, opt_msgsize, opt_variable);
+ } else if (strcmp(test_name, "select") == 0) {
+ rc = select_test(opt_repeat, opt_msgburst, opt_msgsize);
+ } else if (strcmp(test_name, "blocked_read") == 0) {
+ rc = blocked_read_test(opt_repeat);
+ } else if (strcmp(test_name, "closer1") == 0) {
+ rc = closer1_test(opt_repeat);
+ } else if (strcmp(test_name, "closer2") == 0) {
+ rc = closer2_test(opt_repeat);
+ } else if (strcmp(test_name, "closer3") == 0) {
+ rc = closer3_test(opt_repeat);
+ } else if (strcmp(test_name, "echo") == 0) {
+ rc = echo_test(opt_repeat, opt_msgsize, opt_variable);
+ } else if(strcmp(test_name, "ta2ta-ipc") == 0) {
+ rc = ta2ta_ipc_test();
+ } else if (strcmp(test_name, "dev-uuid") == 0) {
+ rc = dev_uuid_test();
+ } else if (strcmp(test_name, "ta-access") == 0) {
+ rc = ta_access_test();
+ } else {
+ fprintf(stderr, "Unrecognized test name '%s'\n", test_name);
+ print_usage_and_exit(argv[0], EXIT_FAILURE, true);
+ }
+
+ return rc == 0 ? EXIT_SUCCESS : EXIT_FAILURE;
+}
diff --git a/trusty/libtrusty/tipc_ioctl.h b/trusty/libtrusty/tipc_ioctl.h
new file mode 100644
index 0000000..27da56a
--- /dev/null
+++ b/trusty/libtrusty/tipc_ioctl.h
@@ -0,0 +1,26 @@
+/*
+ * 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 _TIPC_IOCTL_H
+#define _TIPC_IOCTL_H
+
+#include <linux/ioctl.h>
+#include <linux/types.h>
+
+#define TIPC_IOC_MAGIC 'r'
+#define TIPC_IOC_CONNECT _IOW(TIPC_IOC_MAGIC, 0x80, char *)
+
+#endif
diff --git a/trusty/libtrusty/trusty.c b/trusty/libtrusty/trusty.c
new file mode 100644
index 0000000..b6897ce
--- /dev/null
+++ b/trusty/libtrusty/trusty.c
@@ -0,0 +1,59 @@
+/*
+ * 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 LOG_TAG "libtrusty"
+
+#include <errno.h>
+#include <fcntl.h>
+#include <stdbool.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include <cutils/log.h>
+
+#include "tipc_ioctl.h"
+
+int tipc_connect(const char *dev_name, const char *srv_name)
+{
+ int fd;
+ int rc;
+
+ fd = open(dev_name, O_RDWR);
+ if (fd < 0) {
+ rc = -errno;
+ ALOGE("%s: cannot open tipc device \"%s\": %s\n",
+ __func__, dev_name, strerror(errno));
+ return rc < 0 ? rc : -1;
+ }
+
+ rc = ioctl(fd, TIPC_IOC_CONNECT, srv_name);
+ if (rc < 0) {
+ rc = -errno;
+ ALOGE("%s: can't connect to tipc service \"%s\" (err=%d)\n",
+ __func__, srv_name, errno);
+ close(fd);
+ return rc < 0 ? rc : -1;
+ }
+
+ ALOGV("%s: connected to \"%s\" fd %d\n", __func__, srv_name, fd);
+ return fd;
+}
+
+void tipc_close(int fd)
+{
+ close(fd);
+}