Merge "init: Specify the data wipe reason."
diff --git a/adb/adb_trace.h b/adb/adb_trace.h
index 5206a99..aaffa29 100644
--- a/adb/adb_trace.h
+++ b/adb/adb_trace.h
@@ -58,4 +58,8 @@
void adb_trace_init(char**);
void adb_trace_enable(AdbTrace trace_tag);
+#define ATRACE_TAG ATRACE_TAG_ADB
+#include <cutils/trace.h>
+#include <utils/Trace.h>
+
#endif /* __ADB_TRACE_H */
diff --git a/adb/client/main.cpp b/adb/client/main.cpp
index 4ec0fc2..d583516 100644
--- a/adb/client/main.cpp
+++ b/adb/client/main.cpp
@@ -23,6 +23,8 @@
#include <stdlib.h>
#include <unistd.h>
+#include <thread>
+
#include <android-base/errors.h>
#include <android-base/file.h>
#include <android-base/logging.h>
@@ -33,6 +35,7 @@
#include "adb_listeners.h"
#include "adb_utils.h"
#include "commandline.h"
+#include "sysdeps/chrono.h"
#include "transport.h"
static std::string GetLogFilePath() {
@@ -113,8 +116,18 @@
local_init(DEFAULT_ADB_LOCAL_TRANSPORT_PORT);
std::string error;
- if (install_listener(socket_spec, "*smartsocket*", nullptr, 0, nullptr, &error)) {
- fatal("could not install *smartsocket* listener: %s", error.c_str());
+
+ auto start = std::chrono::steady_clock::now();
+
+ // If we told a previous adb server to quit because of version mismatch, we can get to this
+ // point before it's finished exiting. Retry for a while to give it some time.
+ while (install_listener(socket_spec, "*smartsocket*", nullptr, 0, nullptr, &error) !=
+ INSTALL_STATUS_OK) {
+ if (std::chrono::steady_clock::now() - start > 0.5s) {
+ fatal("could not install *smartsocket* listener: %s", error.c_str());
+ }
+
+ std::this_thread::sleep_for(100ms);
}
if (is_daemon) {
diff --git a/adb/file_sync_service.cpp b/adb/file_sync_service.cpp
index 43c877e..e667bf8 100644
--- a/adb/file_sync_service.cpp
+++ b/adb/file_sync_service.cpp
@@ -39,10 +39,13 @@
#include "adb.h"
#include "adb_io.h"
+#include "adb_trace.h"
#include "adb_utils.h"
#include "security_log_tags.h"
#include "sysdeps/errno.h"
+using android::base::StringPrintf;
+
static bool should_use_fs_config(const std::string& path) {
// TODO: use fs_config to configure permissions on /data.
return android::base::StartsWith(path, "/system/") ||
@@ -152,7 +155,7 @@
if (!d) goto done;
while ((de = readdir(d.get()))) {
- std::string filename(android::base::StringPrintf("%s/%s", path, de->d_name));
+ std::string filename(StringPrintf("%s/%s", path, de->d_name));
struct stat st;
if (lstat(filename.c_str(), &st) == 0) {
@@ -191,7 +194,7 @@
}
static bool SendSyncFailErrno(int fd, const std::string& reason) {
- return SendSyncFail(fd, android::base::StringPrintf("%s: %s", reason.c_str(), strerror(errno)));
+ return SendSyncFail(fd, StringPrintf("%s: %s", reason.c_str(), strerror(errno)));
}
static bool handle_send_file(int s, const char* path, uid_t uid, gid_t gid, uint64_t capabilities,
@@ -433,9 +436,31 @@
return WriteFdExactly(s, &msg.data, sizeof(msg.data));
}
+static const char* sync_id_to_name(uint32_t id) {
+ switch (id) {
+ case ID_LSTAT_V1:
+ return "lstat_v1";
+ case ID_LSTAT_V2:
+ return "lstat_v2";
+ case ID_STAT_V2:
+ return "stat_v2";
+ case ID_LIST:
+ return "list";
+ case ID_SEND:
+ return "send";
+ case ID_RECV:
+ return "recv";
+ case ID_QUIT:
+ return "quit";
+ default:
+ return "???";
+ }
+}
+
static bool handle_sync_command(int fd, std::vector<char>& buffer) {
D("sync: waiting for request");
+ ATRACE_CALL();
SyncRequest request;
if (!ReadFdExactly(fd, &request, sizeof(request))) {
SendSyncFail(fd, "command read failure");
@@ -453,9 +478,11 @@
}
name[path_length] = 0;
- const char* id = reinterpret_cast<const char*>(&request.id);
- D("sync: '%.4s' '%s'", id, name);
+ std::string id_name = sync_id_to_name(request.id);
+ std::string trace_name = StringPrintf("%s(%s)", id_name.c_str(), name);
+ ATRACE_NAME(trace_name.c_str());
+ D("sync: %s('%s')", id_name.c_str(), name);
switch (request.id) {
case ID_LSTAT_V1:
if (!do_lstat_v1(fd, name)) return false;
@@ -476,8 +503,7 @@
case ID_QUIT:
return false;
default:
- SendSyncFail(
- fd, android::base::StringPrintf("unknown command '%.4s' (%08x)", id, request.id));
+ SendSyncFail(fd, StringPrintf("unknown command %08x", request.id));
return false;
}
diff --git a/adb/sysdeps_win32_test.cpp b/adb/sysdeps_win32_test.cpp
old mode 100755
new mode 100644
diff --git a/adb/trace.sh b/adb/trace.sh
new file mode 100755
index 0000000..49e5026
--- /dev/null
+++ b/adb/trace.sh
@@ -0,0 +1,17 @@
+set -e
+
+if ! [ -e $ANDROID_BUILD_TOP/external/chromium-trace/systrace.py ]; then
+ echo "error: can't find systrace.py at \$ANDROID_BUILD_TOP/external/chromium-trace/systrace.py"
+ exit 1
+fi
+
+adb shell "sleep 1; atrace -b 65536 --async_start adb sched power freq idle disk mmc load"
+adb shell killall adbd
+adb wait-for-device
+echo "press enter to finish..."
+read
+TRACE_TEMP=`mktemp /tmp/trace.XXXXXX`
+echo Saving trace to ${TRACE_TEMP}, html file to ${TRACE_TEMP}.html
+adb shell atrace --async_stop -z > ${TRACE_TEMP}
+$ANDROID_BUILD_TOP/external/chromium-trace/systrace.py --from-file=${TRACE_TEMP} -o ${TRACE_TEMP}.html
+chrome ${TRACE_TEMP}.html
diff --git a/adb/transport.cpp b/adb/transport.cpp
index 7b82b19..60f3b5c 100644
--- a/adb/transport.cpp
+++ b/adb/transport.cpp
@@ -37,6 +37,7 @@
#include "adb.h"
#include "adb_auth.h"
+#include "adb_trace.h"
#include "adb_utils.h"
#include "diagnose_usb.h"
@@ -52,16 +53,15 @@
const char* const kFeatureStat2 = "stat_v2";
static std::string dump_packet(const char* name, const char* func, apacket* p) {
- unsigned command = p->msg.command;
- int len = p->msg.data_length;
- char cmd[9];
- char arg0[12], arg1[12];
- int n;
+ unsigned command = p->msg.command;
+ int len = p->msg.data_length;
+ char cmd[9];
+ char arg0[12], arg1[12];
+ int n;
for (n = 0; n < 4; n++) {
- int b = (command >> (n*8)) & 255;
- if (b < 32 || b >= 127)
- break;
+ int b = (command >> (n * 8)) & 255;
+ if (b < 32 || b >= 127) break;
cmd[n] = (char)b;
}
if (n == 4) {
@@ -82,25 +82,24 @@
else
snprintf(arg1, sizeof arg1, "0x%x", p->msg.arg1);
- std::string result = android::base::StringPrintf("%s: %s: [%s] arg0=%s arg1=%s (len=%d) ",
- name, func, cmd, arg0, arg1, len);
+ std::string result = android::base::StringPrintf("%s: %s: [%s] arg0=%s arg1=%s (len=%d) ", name,
+ func, cmd, arg0, arg1, len);
result += dump_hex(p->data, len);
return result;
}
-static int
-read_packet(int fd, const char* name, apacket** ppacket)
-{
+static int read_packet(int fd, const char* name, apacket** ppacket) {
+ ATRACE_NAME("read_packet");
char buff[8];
if (!name) {
snprintf(buff, sizeof buff, "fd=%d", fd);
name = buff;
}
- char* p = reinterpret_cast<char*>(ppacket); /* really read a packet address */
+ char* p = reinterpret_cast<char*>(ppacket); /* really read a packet address */
int len = sizeof(apacket*);
- while(len > 0) {
+ while (len > 0) {
int r = adb_read(fd, p, len);
- if(r > 0) {
+ if (r > 0) {
len -= r;
p += r;
} else {
@@ -113,20 +112,19 @@
return 0;
}
-static int
-write_packet(int fd, const char* name, apacket** ppacket)
-{
+static int write_packet(int fd, const char* name, apacket** ppacket) {
+ ATRACE_NAME("write_packet");
char buff[8];
if (!name) {
snprintf(buff, sizeof buff, "fd=%d", fd);
name = buff;
}
VLOG(TRANSPORT) << dump_packet(name, "to remote", *ppacket);
- char* p = reinterpret_cast<char*>(ppacket); /* we really write the packet address */
+ char* p = reinterpret_cast<char*>(ppacket); /* we really write the packet address */
int len = sizeof(apacket*);
- while(len > 0) {
+ while (len > 0) {
int r = adb_write(fd, p, len);
- if(r > 0) {
+ if (r > 0) {
len -= r;
p += r;
} else {
@@ -137,16 +135,15 @@
return 0;
}
-static void transport_socket_events(int fd, unsigned events, void *_t)
-{
- atransport *t = reinterpret_cast<atransport*>(_t);
+static void transport_socket_events(int fd, unsigned events, void* _t) {
+ atransport* t = reinterpret_cast<atransport*>(_t);
D("transport_socket_events(fd=%d, events=%04x,...)", fd, events);
- if(events & FDE_READ){
- apacket *p = 0;
- if(read_packet(fd, t->serial, &p)){
+ if (events & FDE_READ) {
+ apacket* p = 0;
+ if (read_packet(fd, t->serial, &p)) {
D("%s: failed to read packet from transport socket on fd %d", t->serial, fd);
} else {
- handle_packet(p, (atransport *) _t);
+ handle_packet(p, (atransport*)_t);
}
}
}
@@ -180,40 +177,43 @@
// read_transport thread reads data from a transport (representing a usb/tcp connection),
// and makes the main thread call handle_packet().
static void read_transport_thread(void* _t) {
- atransport *t = reinterpret_cast<atransport*>(_t);
- apacket *p;
+ atransport* t = reinterpret_cast<atransport*>(_t);
+ apacket* p;
- adb_thread_setname(android::base::StringPrintf("<-%s",
- (t->serial != nullptr ? t->serial : "transport")));
- D("%s: starting read_transport thread on fd %d, SYNC online (%d)",
- t->serial, t->fd, t->sync_token + 1);
+ adb_thread_setname(
+ android::base::StringPrintf("<-%s", (t->serial != nullptr ? t->serial : "transport")));
+ D("%s: starting read_transport thread on fd %d, SYNC online (%d)", t->serial, t->fd,
+ t->sync_token + 1);
p = get_apacket();
p->msg.command = A_SYNC;
p->msg.arg0 = 1;
p->msg.arg1 = ++(t->sync_token);
p->msg.magic = A_SYNC ^ 0xffffffff;
- if(write_packet(t->fd, t->serial, &p)) {
+ if (write_packet(t->fd, t->serial, &p)) {
put_apacket(p);
D("%s: failed to write SYNC packet", t->serial);
goto oops;
}
D("%s: data pump started", t->serial);
- for(;;) {
+ for (;;) {
+ ATRACE_NAME("read_transport loop");
p = get_apacket();
- if(t->read_from_remote(p, t) == 0){
- D("%s: received remote packet, sending to transport",
- t->serial);
- if(write_packet(t->fd, t->serial, &p)){
+ {
+ ATRACE_NAME("read_transport read_remote");
+ if (t->read_from_remote(p, t) != 0) {
+ D("%s: remote read failed for transport", t->serial);
put_apacket(p);
- D("%s: failed to write apacket to transport", t->serial);
- goto oops;
+ break;
}
- } else {
- D("%s: remote read failed for transport", t->serial);
+ }
+
+ D("%s: received remote packet, sending to transport", t->serial);
+ if (write_packet(t->fd, t->serial, &p)) {
put_apacket(p);
- break;
+ D("%s: failed to write apacket to transport", t->serial);
+ goto oops;
}
}
@@ -223,7 +223,7 @@
p->msg.arg0 = 0;
p->msg.arg1 = 0;
p->msg.magic = A_SYNC ^ 0xffffffff;
- if(write_packet(t->fd, t->serial, &p)) {
+ if (write_packet(t->fd, t->serial, &p)) {
put_apacket(p);
D("%s: failed to write SYNC apacket to transport", t->serial);
}
@@ -237,38 +237,38 @@
// write_transport thread gets packets sent by the main thread (through send_packet()),
// and writes to a transport (representing a usb/tcp connection).
static void write_transport_thread(void* _t) {
- atransport *t = reinterpret_cast<atransport*>(_t);
- apacket *p;
+ atransport* t = reinterpret_cast<atransport*>(_t);
+ apacket* p;
int active = 0;
- adb_thread_setname(android::base::StringPrintf("->%s",
- (t->serial != nullptr ? t->serial : "transport")));
- D("%s: starting write_transport thread, reading from fd %d",
- t->serial, t->fd);
+ adb_thread_setname(
+ android::base::StringPrintf("->%s", (t->serial != nullptr ? t->serial : "transport")));
+ D("%s: starting write_transport thread, reading from fd %d", t->serial, t->fd);
- for(;;){
- if(read_packet(t->fd, t->serial, &p)) {
- D("%s: failed to read apacket from transport on fd %d",
- t->serial, t->fd );
+ for (;;) {
+ ATRACE_NAME("write_transport loop");
+ if (read_packet(t->fd, t->serial, &p)) {
+ D("%s: failed to read apacket from transport on fd %d", t->serial, t->fd);
break;
}
- if(p->msg.command == A_SYNC){
- if(p->msg.arg0 == 0) {
+
+ if (p->msg.command == A_SYNC) {
+ if (p->msg.arg0 == 0) {
D("%s: transport SYNC offline", t->serial);
put_apacket(p);
break;
} else {
- if(p->msg.arg1 == t->sync_token) {
+ if (p->msg.arg1 == t->sync_token) {
D("%s: transport SYNC online", t->serial);
active = 1;
} else {
- D("%s: transport ignoring SYNC %d != %d",
- t->serial, p->msg.arg1, t->sync_token);
+ D("%s: transport ignoring SYNC %d != %d", t->serial, p->msg.arg1, t->sync_token);
}
}
} else {
- if(active) {
+ if (active) {
D("%s: transport got packet, sending to remote", t->serial);
+ ATRACE_NAME("write_transport write_remote");
t->write_to_remote(p, t);
} else {
D("%s: transport ignoring packet while offline", t->serial);
@@ -296,7 +296,6 @@
static int transport_registration_recv = -1;
static fdevent transport_registration_fde;
-
#if ADB_HOST
/* this adds support required by the 'track-devices' service.
@@ -305,19 +304,17 @@
* live TCP connection
*/
struct device_tracker {
- asocket socket;
- int update_needed;
- device_tracker* next;
+ asocket socket;
+ int update_needed;
+ device_tracker* next;
};
/* linked list of all device trackers */
-static device_tracker* device_tracker_list;
+static device_tracker* device_tracker_list;
-static void
-device_tracker_remove( device_tracker* tracker )
-{
- device_tracker** pnode = &device_tracker_list;
- device_tracker* node = *pnode;
+static void device_tracker_remove(device_tracker* tracker) {
+ device_tracker** pnode = &device_tracker_list;
+ device_tracker* node = *pnode;
std::lock_guard<std::mutex> lock(transport_lock);
while (node) {
@@ -326,17 +323,15 @@
break;
}
pnode = &node->next;
- node = *pnode;
+ node = *pnode;
}
}
-static void
-device_tracker_close( asocket* socket )
-{
- device_tracker* tracker = (device_tracker*) socket;
- asocket* peer = socket->peer;
+static void device_tracker_close(asocket* socket) {
+ device_tracker* tracker = (device_tracker*)socket;
+ asocket* peer = socket->peer;
- D( "device tracker %p removed", tracker);
+ D("device tracker %p removed", tracker);
if (peer) {
peer->peer = NULL;
peer->close(peer);
@@ -345,9 +340,7 @@
free(tracker);
}
-static int
-device_tracker_enqueue( asocket* socket, apacket* p )
-{
+static int device_tracker_enqueue(asocket* socket, apacket* p) {
/* you can't read from a device tracker, close immediately */
put_apacket(p);
device_tracker_close(socket);
@@ -377,26 +370,23 @@
}
}
-asocket*
-create_device_tracker(void)
-{
+asocket* create_device_tracker(void) {
device_tracker* tracker = reinterpret_cast<device_tracker*>(calloc(1, sizeof(*tracker)));
if (tracker == nullptr) fatal("cannot allocate device tracker");
- D( "device tracker %p created", tracker);
+ D("device tracker %p created", tracker);
tracker->socket.enqueue = device_tracker_enqueue;
- tracker->socket.ready = device_tracker_ready;
- tracker->socket.close = device_tracker_close;
- tracker->update_needed = 1;
+ tracker->socket.ready = device_tracker_ready;
+ tracker->socket.close = device_tracker_close;
+ tracker->update_needed = 1;
- tracker->next = device_tracker_list;
+ tracker->next = device_tracker_list;
device_tracker_list = tracker;
return &tracker->socket;
}
-
// Call this function each time the transport list has changed.
void update_transports() {
std::string transports = list_transports(false);
@@ -416,26 +406,23 @@
// Nothing to do on the device side.
}
-#endif // ADB_HOST
+#endif // ADB_HOST
-struct tmsg
-{
- atransport *transport;
- int action;
+struct tmsg {
+ atransport* transport;
+ int action;
};
-static int
-transport_read_action(int fd, struct tmsg* m)
-{
- char *p = (char*)m;
- int len = sizeof(*m);
- int r;
+static int transport_read_action(int fd, struct tmsg* m) {
+ char* p = (char*)m;
+ int len = sizeof(*m);
+ int r;
- while(len > 0) {
+ while (len > 0) {
r = adb_read(fd, p, len);
- if(r > 0) {
+ if (r > 0) {
len -= r;
- p += r;
+ p += r;
} else {
D("transport_read_action: on fd %d: %s", fd, strerror(errno));
return -1;
@@ -444,18 +431,16 @@
return 0;
}
-static int
-transport_write_action(int fd, struct tmsg* m)
-{
- char *p = (char*)m;
- int len = sizeof(*m);
- int r;
+static int transport_write_action(int fd, struct tmsg* m) {
+ char* p = (char*)m;
+ int len = sizeof(*m);
+ int r;
- while(len > 0) {
+ while (len > 0) {
r = adb_write(fd, p, len);
- if(r > 0) {
+ if (r > 0) {
len -= r;
- p += r;
+ p += r;
} else {
D("transport_write_action: on fd %d: %s", fd, strerror(errno));
return -1;
@@ -464,17 +449,16 @@
return 0;
}
-static void transport_registration_func(int _fd, unsigned ev, void *data)
-{
+static void transport_registration_func(int _fd, unsigned ev, void* data) {
tmsg m;
int s[2];
- atransport *t;
+ atransport* t;
- if(!(ev & FDE_READ)) {
+ if (!(ev & FDE_READ)) {
return;
}
- if(transport_read_action(_fd, &m)) {
+ if (transport_read_action(_fd, &m)) {
fatal_errno("cannot read transport registration socket");
}
@@ -483,9 +467,9 @@
if (m.action == 0) {
D("transport: %s removing and free'ing %d", t->serial, t->transport_socket);
- /* IMPORTANT: the remove closes one half of the
- ** socket pair. The close closes the other half.
- */
+ /* IMPORTANT: the remove closes one half of the
+ ** socket pair. The close closes the other half.
+ */
fdevent_remove(&(t->transport_fde));
adb_close(t->fd);
@@ -494,16 +478,11 @@
transport_list.remove(t);
}
- if (t->product)
- free(t->product);
- if (t->serial)
- free(t->serial);
- if (t->model)
- free(t->model);
- if (t->device)
- free(t->device);
- if (t->devpath)
- free(t->devpath);
+ if (t->product) free(t->product);
+ if (t->serial) free(t->serial);
+ if (t->model) free(t->model);
+ if (t->device) free(t->device);
+ if (t->devpath) free(t->devpath);
delete t;
@@ -525,10 +504,7 @@
t->transport_socket = s[0];
t->fd = s[1];
- fdevent_install(&(t->transport_fde),
- t->transport_socket,
- transport_socket_events,
- t);
+ fdevent_install(&(t->transport_fde), t->transport_socket, transport_socket_events, t);
fdevent_set(&(t->transport_fde), FDE_READ);
@@ -550,11 +526,10 @@
update_transports();
}
-void init_transport_registration(void)
-{
+void init_transport_registration(void) {
int s[2];
- if(adb_socketpair(s)){
+ if (adb_socketpair(s)) {
fatal_errno("cannot open transport registration socketpair");
}
D("socketpair: (%d,%d)", s[0], s[1]);
@@ -562,38 +537,33 @@
transport_registration_send = s[0];
transport_registration_recv = s[1];
- fdevent_install(&transport_registration_fde,
- transport_registration_recv,
- transport_registration_func,
- 0);
+ fdevent_install(&transport_registration_fde, transport_registration_recv,
+ transport_registration_func, 0);
fdevent_set(&transport_registration_fde, FDE_READ);
}
/* the fdevent select pump is single threaded */
-static void register_transport(atransport *transport)
-{
+static void register_transport(atransport* transport) {
tmsg m;
m.transport = transport;
m.action = 1;
D("transport: %s registered", transport->serial);
- if(transport_write_action(transport_registration_send, &m)) {
+ if (transport_write_action(transport_registration_send, &m)) {
fatal_errno("cannot write transport registration socket\n");
}
}
-static void remove_transport(atransport *transport)
-{
+static void remove_transport(atransport* transport) {
tmsg m;
m.transport = transport;
m.action = 0;
D("transport: %s removed", transport->serial);
- if(transport_write_action(transport_registration_send, &m)) {
+ if (transport_write_action(transport_registration_send, &m)) {
fatal_errno("cannot write transport registration socket\n");
}
}
-
static void transport_unref(atransport* t) {
CHECK(t != nullptr);
@@ -609,37 +579,31 @@
}
}
-static int qual_match(const char *to_test,
- const char *prefix, const char *qual, bool sanitize_qual)
-{
- if (!to_test || !*to_test)
- /* Return true if both the qual and to_test are null strings. */
+static int qual_match(const char* to_test, const char* prefix, const char* qual,
+ bool sanitize_qual) {
+ if (!to_test || !*to_test) /* Return true if both the qual and to_test are null strings. */
return !qual || !*qual;
- if (!qual)
- return 0;
+ if (!qual) return 0;
if (prefix) {
while (*prefix) {
- if (*prefix++ != *to_test++)
- return 0;
+ if (*prefix++ != *to_test++) return 0;
}
}
while (*qual) {
char ch = *qual++;
- if (sanitize_qual && !isalnum(ch))
- ch = '_';
- if (ch != *to_test++)
- return 0;
+ if (sanitize_qual && !isalnum(ch)) ch = '_';
+ if (ch != *to_test++) return 0;
}
/* Everything matched so far. Return true if *to_test is a NUL. */
return !*to_test;
}
-atransport* acquire_one_transport(TransportType type, const char* serial,
- bool* is_ambiguous, std::string* error_out) {
+atransport* acquire_one_transport(TransportType type, const char* serial, bool* is_ambiguous,
+ std::string* error_out) {
atransport* result = nullptr;
if (serial) {
@@ -737,15 +701,24 @@
const std::string atransport::connection_state_name() const {
switch (connection_state) {
- case kCsOffline: return "offline";
- case kCsBootloader: return "bootloader";
- case kCsDevice: return "device";
- case kCsHost: return "host";
- case kCsRecovery: return "recovery";
- case kCsNoPerm: return UsbNoPermissionsShortHelpText();
- case kCsSideload: return "sideload";
- case kCsUnauthorized: return "unauthorized";
- default: return "unknown";
+ case kCsOffline:
+ return "offline";
+ case kCsBootloader:
+ return "bootloader";
+ case kCsDevice:
+ return "device";
+ case kCsHost:
+ return "host";
+ case kCsRecovery:
+ return "recovery";
+ case kCsNoPerm:
+ return UsbNoPermissionsShortHelpText();
+ case kCsSideload:
+ return "sideload";
+ case kCsUnauthorized:
+ return "unauthorized";
+ default:
+ return "unknown";
}
}
@@ -771,9 +744,7 @@
const FeatureSet& supported_features() {
// Local static allocation to avoid global non-POD variables.
static const FeatureSet* features = new FeatureSet{
- kFeatureShell2,
- kFeatureCmd,
- kFeatureStat2,
+ kFeatureShell2, kFeatureCmd, kFeatureStat2,
// Increment ADB_SERVER_VERSION whenever the feature list changes to
// make sure that the adb client and server features stay in sync
// (http://b/24370690).
@@ -791,14 +762,12 @@
return FeatureSet();
}
- auto names = android::base::Split(features_string,
- {kFeatureStringDelimiter});
+ auto names = android::base::Split(features_string, {kFeatureStringDelimiter});
return FeatureSet(names.begin(), names.end());
}
bool CanUseFeature(const FeatureSet& feature_set, const std::string& feature) {
- return feature_set.count(feature) > 0 &&
- supported_features().count(feature) > 0;
+ return feature_set.count(feature) > 0 && supported_features().count(feature) > 0;
}
bool atransport::has_feature(const std::string& feature) const {
@@ -834,21 +803,20 @@
// For fastboot compatibility, ignore protocol prefixes.
if (android::base::StartsWith(target, "tcp:") ||
- android::base::StartsWith(target, "udp:")) {
+ android::base::StartsWith(target, "udp:")) {
local_target_ptr += 4;
}
// Parse our |serial| and the given |target| to check if the hostnames and ports match.
std::string serial_host, error;
int serial_port = -1;
- if (android::base::ParseNetAddress(serial, &serial_host, &serial_port, nullptr,
- &error)) {
+ if (android::base::ParseNetAddress(serial, &serial_host, &serial_port, nullptr, &error)) {
// |target| may omit the port to default to ours.
std::string target_host;
int target_port = serial_port;
if (android::base::ParseNetAddress(local_target_ptr, &target_host, &target_port,
nullptr, &error) &&
- serial_host == target_host && serial_port == target_port) {
+ serial_host == target_host && serial_port == target_port) {
return true;
}
}
@@ -863,8 +831,8 @@
#if ADB_HOST
-static void append_transport_info(std::string* result, const char* key,
- const char* value, bool sanitize) {
+static void append_transport_info(std::string* result, const char* key, const char* value,
+ bool sanitize) {
if (value == nullptr || *value == '\0') {
return;
}
@@ -877,8 +845,7 @@
}
}
-static void append_transport(const atransport* t, std::string* result,
- bool long_listing) {
+static void append_transport(const atransport* t, std::string* result, bool long_listing) {
const char* serial = t->serial;
if (!serial || !serial[0]) {
serial = "(no serial number)";
@@ -889,8 +856,7 @@
*result += '\t';
*result += t->connection_state_name();
} else {
- android::base::StringAppendF(result, "%-22s %s", serial,
- t->connection_state_name().c_str());
+ android::base::StringAppendF(result, "%-22s %s", serial, t->connection_state_name().c_str());
append_transport_info(result, "", t->devpath, false);
append_transport_info(result, "product:", t->product, false);
@@ -923,9 +889,9 @@
void close_usb_devices() {
close_usb_devices([](const atransport*) { return true; });
}
-#endif // ADB_HOST
+#endif // ADB_HOST
-int register_socket_transport(int s, const char *serial, int port, int local) {
+int register_socket_transport(int s, const char* serial, int port, int local) {
atransport* t = new atransport();
if (!serial) {
@@ -944,7 +910,7 @@
for (const auto& transport : pending_list) {
if (transport->serial && strcmp(serial, transport->serial) == 0) {
VLOG(TRANSPORT) << "socket transport " << transport->serial
- << " is already in pending_list and fails to register";
+ << " is already in pending_list and fails to register";
delete t;
return -1;
}
@@ -953,7 +919,7 @@
for (const auto& transport : transport_list) {
if (transport->serial && strcmp(serial, transport->serial) == 0) {
VLOG(TRANSPORT) << "socket transport " << transport->serial
- << " is already in transport_list and fails to register";
+ << " is already in transport_list and fails to register";
delete t;
return -1;
}
@@ -969,7 +935,7 @@
}
#if ADB_HOST
-atransport *find_transport(const char *serial) {
+atransport* find_transport(const char* serial) {
atransport* result = nullptr;
std::lock_guard<std::mutex> lock(transport_lock);
@@ -998,14 +964,13 @@
#endif
-void register_usb_transport(usb_handle* usb, const char* serial,
- const char* devpath, unsigned writeable) {
+void register_usb_transport(usb_handle* usb, const char* serial, const char* devpath,
+ unsigned writeable) {
atransport* t = new atransport();
- D("transport: %p init'ing for usb_handle %p (sn='%s')", t, usb,
- serial ? serial : "");
+ D("transport: %p init'ing for usb_handle %p (sn='%s')", t, usb, serial ? serial : "");
init_usb_transport(t, usb, (writeable ? kCsOffline : kCsNoPerm));
- if(serial) {
+ if (serial) {
t->serial = strdup(serial);
}
@@ -1022,23 +987,21 @@
}
// This should only be used for transports with connection_state == kCsNoPerm.
-void unregister_usb_transport(usb_handle *usb) {
+void unregister_usb_transport(usb_handle* usb) {
std::lock_guard<std::mutex> lock(transport_lock);
- transport_list.remove_if([usb](atransport* t) {
- return t->usb == usb && t->connection_state == kCsNoPerm;
- });
+ transport_list.remove_if(
+ [usb](atransport* t) { return t->usb == usb && t->connection_state == kCsNoPerm; });
}
-int check_header(apacket *p, atransport *t)
-{
- if(p->msg.magic != (p->msg.command ^ 0xffffffff)) {
+int check_header(apacket* p, atransport* t) {
+ if (p->msg.magic != (p->msg.command ^ 0xffffffff)) {
VLOG(RWX) << "check_header(): invalid magic";
return -1;
}
- if(p->msg.data_length > t->get_max_payload()) {
- VLOG(RWX) << "check_header(): " << p->msg.data_length << " atransport::max_payload = "
- << t->get_max_payload();
+ if (p->msg.data_length > t->get_max_payload()) {
+ VLOG(RWX) << "check_header(): " << p->msg.data_length
+ << " atransport::max_payload = " << t->get_max_payload();
return -1;
}
diff --git a/base/include/android-base/memory.h b/base/include/android-base/memory.h
index 3a2f8fa..9971226 100644
--- a/base/include/android-base/memory.h
+++ b/base/include/android-base/memory.h
@@ -20,25 +20,19 @@
namespace android {
namespace base {
-// Use packed structures for access to unaligned data on targets with alignment
+// Use memcpy for access to unaligned data on targets with alignment
// restrictions. The compiler will generate appropriate code to access these
// structures without generating alignment exceptions.
template <typename T>
-static inline T get_unaligned(const T* address) {
- struct unaligned {
- T v;
- } __attribute__((packed));
- const unaligned* p = reinterpret_cast<const unaligned*>(address);
- return p->v;
+static inline T get_unaligned(const void* address) {
+ T result;
+ memcpy(&result, address, sizeof(T));
+ return result;
}
template <typename T>
-static inline void put_unaligned(T* address, T v) {
- struct unaligned {
- T v;
- } __attribute__((packed));
- unaligned* p = reinterpret_cast<unaligned*>(address);
- p->v = v;
+static inline void put_unaligned(void* address, T v) {
+ memcpy(address, &v, sizeof(T));
}
} // namespace base
diff --git a/gatekeeperd/SoftGateKeeper.h b/gatekeeperd/SoftGateKeeper.h
index 8b15d72..cb02a6f 100644
--- a/gatekeeperd/SoftGateKeeper.h
+++ b/gatekeeperd/SoftGateKeeper.h
@@ -152,7 +152,7 @@
}
bool DoVerify(const password_handle_t *expected_handle, const SizedBuffer &password) {
- uint64_t user_id = android::base::get_unaligned(&expected_handle->user_id);
+ uint64_t user_id = android::base::get_unaligned<secure_id_t>(&expected_handle->user_id);
FastHashMap::const_iterator it = fast_hash_map_.find(user_id);
if (it != fast_hash_map_.end() && VerifyFast(it->second, password)) {
return true;
diff --git a/include/cutils/trace.h b/include/cutils/trace.h
index 0f00417..fcbdc9b 100644
--- a/include/cutils/trace.h
+++ b/include/cutils/trace.h
@@ -71,7 +71,8 @@
#define ATRACE_TAG_SYSTEM_SERVER (1<<19)
#define ATRACE_TAG_DATABASE (1<<20)
#define ATRACE_TAG_NETWORK (1<<21)
-#define ATRACE_TAG_LAST ATRACE_TAG_NETWORK
+#define ATRACE_TAG_ADB (1<<22)
+#define ATRACE_TAG_LAST ATRACE_TAG_ADB
// Reserved for initialization.
#define ATRACE_TAG_NOT_READY (1ULL<<63)
diff --git a/include/private/android_filesystem_config.h b/include/private/android_filesystem_config.h
index e9ae6ed..3031562 100644
--- a/include/private/android_filesystem_config.h
+++ b/include/private/android_filesystem_config.h
@@ -167,15 +167,104 @@
#define AID_SHARED_GID_START 50000 /* start of gids for apps in each user to share */
#define AID_SHARED_GID_END 59999 /* start of gids for apps in each user to share */
-/*
- * android_ids has moved to pwd/grp functionality.
- * If you need to add one, the structure is now
- * auto-generated based on the AID_ constraints
- * documented at the top of this header file.
- * Also see build/tools/fs_config for more details.
- */
-
#if !defined(EXCLUDE_FS_CONFIG_STRUCTURES)
+/*
+ * Used in:
+ * bionic/libc/bionic/stubs.cpp
+ * external/libselinux/src/android.c
+ * system/core/logd/LogStatistics.cpp
+ * system/core/init/ueventd.cpp
+ * system/core/init/util.cpp
+ */
+struct android_id_info {
+ const char *name;
+ unsigned aid;
+};
+
+static const struct android_id_info android_ids[] = {
+ { "root", AID_ROOT, },
+
+ { "system", AID_SYSTEM, },
+
+ { "radio", AID_RADIO, },
+ { "bluetooth", AID_BLUETOOTH, },
+ { "graphics", AID_GRAPHICS, },
+ { "input", AID_INPUT, },
+ { "audio", AID_AUDIO, },
+ { "camera", AID_CAMERA, },
+ { "log", AID_LOG, },
+ { "compass", AID_COMPASS, },
+ { "mount", AID_MOUNT, },
+ { "wifi", AID_WIFI, },
+ { "adb", AID_ADB, },
+ { "install", AID_INSTALL, },
+ { "media", AID_MEDIA, },
+ { "dhcp", AID_DHCP, },
+ { "sdcard_rw", AID_SDCARD_RW, },
+ { "vpn", AID_VPN, },
+ { "keystore", AID_KEYSTORE, },
+ { "usb", AID_USB, },
+ { "drm", AID_DRM, },
+ { "mdnsr", AID_MDNSR, },
+ { "gps", AID_GPS, },
+ // AID_UNUSED1
+ { "media_rw", AID_MEDIA_RW, },
+ { "mtp", AID_MTP, },
+ // AID_UNUSED2
+ { "drmrpc", AID_DRMRPC, },
+ { "nfc", AID_NFC, },
+ { "sdcard_r", AID_SDCARD_R, },
+ { "clat", AID_CLAT, },
+ { "loop_radio", AID_LOOP_RADIO, },
+ { "mediadrm", AID_MEDIA_DRM, },
+ { "package_info", AID_PACKAGE_INFO, },
+ { "sdcard_pics", AID_SDCARD_PICS, },
+ { "sdcard_av", AID_SDCARD_AV, },
+ { "sdcard_all", AID_SDCARD_ALL, },
+ { "logd", AID_LOGD, },
+ { "shared_relro", AID_SHARED_RELRO, },
+ { "dbus", AID_DBUS, },
+ { "tlsdate", AID_TLSDATE, },
+ { "mediaex", AID_MEDIA_EX, },
+ { "audioserver", AID_AUDIOSERVER, },
+ { "metrics_coll", AID_METRICS_COLL },
+ { "metricsd", AID_METRICSD },
+ { "webserv", AID_WEBSERV },
+ { "debuggerd", AID_DEBUGGERD, },
+ { "mediacodec", AID_MEDIA_CODEC, },
+ { "cameraserver", AID_CAMERASERVER, },
+ { "firewall", AID_FIREWALL, },
+ { "trunks", AID_TRUNKS, },
+ { "nvram", AID_NVRAM, },
+ { "dns", AID_DNS, },
+ { "dns_tether", AID_DNS_TETHER, },
+ { "webview_zygote", AID_WEBVIEW_ZYGOTE, },
+ { "vehicle_network", AID_VEHICLE_NETWORK, },
+ { "media_audio", AID_MEDIA_AUDIO, },
+ { "media_video", AID_MEDIA_VIDEO, },
+ { "media_image", AID_MEDIA_IMAGE, },
+
+ { "shell", AID_SHELL, },
+ { "cache", AID_CACHE, },
+ { "diag", AID_DIAG, },
+
+ { "net_bt_admin", AID_NET_BT_ADMIN, },
+ { "net_bt", AID_NET_BT, },
+ { "inet", AID_INET, },
+ { "net_raw", AID_NET_RAW, },
+ { "net_admin", AID_NET_ADMIN, },
+ { "net_bw_stats", AID_NET_BW_STATS, },
+ { "net_bw_acct", AID_NET_BW_ACCT, },
+ { "readproc", AID_READPROC, },
+ { "wakelock", AID_WAKELOCK, },
+
+ { "everybody", AID_EVERYBODY, },
+ { "misc", AID_MISC, },
+ { "nobody", AID_NOBODY, },
+};
+
+#define android_id_count \
+ (sizeof(android_ids) / sizeof(android_ids[0]))
struct fs_path_config {
unsigned mode;
diff --git a/include/utils/Trace.h b/include/utils/Trace.h
index 6ba68f6..eeba40d 100644
--- a/include/utils/Trace.h
+++ b/include/utils/Trace.h
@@ -33,10 +33,10 @@
// See <cutils/trace.h> for more ATRACE_* macros.
-// ATRACE_NAME traces the beginning and end of the current scope. To trace
-// the correct start and end times this macro should be declared first in the
-// scope body.
-#define ATRACE_NAME(name) android::ScopedTrace ___tracer(ATRACE_TAG, name)
+// ATRACE_NAME traces from its location until the end of its enclosing scope.
+#define _PASTE(x, y) x ## y
+#define PASTE(x, y) _PASTE(x,y)
+#define ATRACE_NAME(name) android::ScopedTrace PASTE(___tracer, __LINE__) (ATRACE_TAG, name)
// ATRACE_CALL is an ATRACE_NAME that uses the current function name.
#define ATRACE_CALL() ATRACE_NAME(__FUNCTION__)
diff --git a/init/init.cpp b/init/init.cpp
index 95cb62f..2d474c7 100644
--- a/init/init.cpp
+++ b/init/init.cpp
@@ -49,6 +49,7 @@
#include <cutils/sockets.h>
#include <private/android_filesystem_config.h>
+#include <fstream>
#include <memory>
#include "action.h"
@@ -256,6 +257,108 @@
return result;
}
+static void security_failure() {
+ LOG(ERROR) << "Security failure...";
+ panic();
+}
+
+#define MMAP_RND_PATH "/proc/sys/vm/mmap_rnd_bits"
+#define MMAP_RND_COMPAT_PATH "/proc/sys/vm/mmap_rnd_compat_bits"
+
+/* __attribute__((unused)) due to lack of mips support: see mips block
+ * in set_mmap_rnd_bits_action */
+static bool __attribute__((unused)) set_mmap_rnd_bits_min(int start, int min, bool compat) {
+ std::string path;
+ if (compat) {
+ path = MMAP_RND_COMPAT_PATH;
+ } else {
+ path = MMAP_RND_PATH;
+ }
+ std::ifstream inf(path, std::fstream::in);
+ if (!inf) {
+ LOG(ERROR) << "Cannot open for reading: " << path;
+ return false;
+ }
+ while (start >= min) {
+ // try to write out new value
+ std::string str_val = std::to_string(start);
+ std::ofstream of(path, std::fstream::out);
+ if (!of) {
+ LOG(ERROR) << "Cannot open for writing: " << path;
+ return false;
+ }
+ of << str_val << std::endl;
+ of.close();
+
+ // check to make sure it was recorded
+ inf.seekg(0);
+ std::string str_rec;
+ inf >> str_rec;
+ if (str_val.compare(str_rec) == 0) {
+ break;
+ }
+ start--;
+ }
+ inf.close();
+ if (start < min) {
+ LOG(ERROR) << "Unable to set minimum required entropy " << min << " in " << path;
+ return false;
+ }
+ return true;
+}
+
+/*
+ * Set /proc/sys/vm/mmap_rnd_bits and potentially
+ * /proc/sys/vm/mmap_rnd_compat_bits to the maximum supported values.
+ * Returns -1 if unable to set these to an acceptable value.
+ *
+ * To support this sysctl, the following upstream commits are needed:
+ *
+ * d07e22597d1d mm: mmap: add new /proc tunable for mmap_base ASLR
+ * e0c25d958f78 arm: mm: support ARCH_MMAP_RND_BITS
+ * 8f0d3aa9de57 arm64: mm: support ARCH_MMAP_RND_BITS
+ * 9e08f57d684a x86: mm: support ARCH_MMAP_RND_BITS
+ * ec9ee4acd97c drivers: char: random: add get_random_long()
+ * 5ef11c35ce86 mm: ASLR: use get_random_long()
+ */
+static int set_mmap_rnd_bits_action(const std::vector<std::string>& args)
+{
+ int ret = -1;
+
+ /* values are arch-dependent */
+#if defined(__aarch64__)
+ /* arm64 supports 18 - 33 bits depending on pagesize and VA_SIZE */
+ if (set_mmap_rnd_bits_min(33, 24, false)
+ && set_mmap_rnd_bits_min(16, 16, true)) {
+ ret = 0;
+ }
+#elif defined(__x86_64__)
+ /* x86_64 supports 28 - 32 bits */
+ if (set_mmap_rnd_bits_min(32, 32, false)
+ && set_mmap_rnd_bits_min(16, 16, true)) {
+ ret = 0;
+ }
+#elif defined(__arm__) || defined(__i386__)
+ /* check to see if we're running on 64-bit kernel */
+ bool h64 = !access(MMAP_RND_COMPAT_PATH, F_OK);
+ /* supported 32-bit architecture must have 16 bits set */
+ if (set_mmap_rnd_bits_min(16, 16, h64)) {
+ ret = 0;
+ }
+#elif defined(__mips__) || defined(__mips64__)
+ // TODO: add mips support b/27788820
+ ret = 0;
+#else
+ LOG(ERROR) << "Unknown architecture";
+#endif
+
+ if (ret == -1) {
+ LOG(ERROR) << "Unable to set adequate mmap entropy value!";
+ security_failure();
+ }
+ return ret;
+}
+
static int keychord_init_action(const std::vector<std::string>& args)
{
keychord_init();
@@ -414,11 +517,6 @@
return 0;
}
-static void security_failure() {
- LOG(ERROR) << "Security failure...";
- panic();
-}
-
static void selinux_initialize(bool in_kernel_domain) {
Timer t;
@@ -712,6 +810,7 @@
am.QueueBuiltinAction(wait_for_coldboot_done_action, "wait_for_coldboot_done");
// ... so that we can start queuing up actions that require stuff from /dev.
am.QueueBuiltinAction(mix_hwrng_into_linux_rng_action, "mix_hwrng_into_linux_rng");
+ am.QueueBuiltinAction(set_mmap_rnd_bits_action, "set_mmap_rnd_bits");
am.QueueBuiltinAction(keychord_init_action, "keychord_init");
am.QueueBuiltinAction(console_init_action, "console_init");
diff --git a/libappfuse/FuseBuffer.cc b/libappfuse/FuseBuffer.cc
index 3ade31c..882d545 100644
--- a/libappfuse/FuseBuffer.cc
+++ b/libappfuse/FuseBuffer.cc
@@ -34,26 +34,38 @@
"FuseBuffer must be standard layout union.");
template <typename T>
-bool FuseMessage<T>::CheckHeaderLength() const {
+bool FuseMessage<T>::CheckPacketSize(size_t size, const char* name) const {
const auto& header = static_cast<const T*>(this)->header;
- if (sizeof(header) <= header.len && header.len <= sizeof(T)) {
+ if (size >= sizeof(header) && size <= sizeof(T)) {
return true;
} else {
- LOG(ERROR) << "Packet size is invalid=" << header.len;
+ LOG(ERROR) << name << " is invalid=" << size;
return false;
}
}
template <typename T>
-bool FuseMessage<T>::CheckResult(
- int result, const char* operation_name) const {
+bool FuseMessage<T>::CheckResult(int result, const char* operation_name) const {
+ if (result == 0) {
+ // Expected close of other endpoints.
+ return false;
+ }
+ if (result < 0) {
+ PLOG(ERROR) << "Failed to " << operation_name << " a packet";
+ return false;
+ }
+ return true;
+}
+
+template <typename T>
+bool FuseMessage<T>::CheckHeaderLength(int result, const char* operation_name) const {
const auto& header = static_cast<const T*>(this)->header;
- if (result >= 0 && static_cast<uint32_t>(result) == header.len) {
+ if (static_cast<uint32_t>(result) == header.len) {
return true;
} else {
- PLOG(ERROR) << "Failed to " << operation_name
- << " a packet. result=" << result << " header.len="
- << header.len;
+ LOG(ERROR) << "Invalid header length: operation_name=" << operation_name
+ << " result=" << result
+ << " header.len=" << header.len;
return false;
}
}
@@ -61,17 +73,18 @@
template <typename T>
bool FuseMessage<T>::Read(int fd) {
const ssize_t result = TEMP_FAILURE_RETRY(::read(fd, this, sizeof(T)));
- return CheckHeaderLength() && CheckResult(result, "read");
+ return CheckResult(result, "read") && CheckPacketSize(result, "read count") &&
+ CheckHeaderLength(result, "read");
}
template <typename T>
bool FuseMessage<T>::Write(int fd) const {
const auto& header = static_cast<const T*>(this)->header;
- if (!CheckHeaderLength()) {
+ if (!CheckPacketSize(header.len, "header.len")) {
return false;
}
const ssize_t result = TEMP_FAILURE_RETRY(::write(fd, this, header.len));
- return CheckResult(result, "write");
+ return CheckResult(result, "write") && CheckHeaderLength(result, "write");
}
template class FuseMessage<FuseRequest>;
diff --git a/libappfuse/include/libappfuse/FuseBuffer.h b/libappfuse/include/libappfuse/FuseBuffer.h
index e7f620c..276db90 100644
--- a/libappfuse/include/libappfuse/FuseBuffer.h
+++ b/libappfuse/include/libappfuse/FuseBuffer.h
@@ -34,8 +34,9 @@
bool Read(int fd);
bool Write(int fd) const;
private:
- bool CheckHeaderLength() const;
+ bool CheckPacketSize(size_t size, const char* name) const;
bool CheckResult(int result, const char* operation_name) const;
+ bool CheckHeaderLength(int result, const char* operation_name) const;
};
// FuseRequest represents file operation requests from /dev/fuse. It starts
diff --git a/libcutils/uevent.c b/libcutils/uevent.c
index de5d227..f548dca 100644
--- a/libcutils/uevent.c
+++ b/libcutils/uevent.c
@@ -116,7 +116,12 @@
if(s < 0)
return -1;
- setsockopt(s, SOL_SOCKET, SO_RCVBUFFORCE, &buf_sz, sizeof(buf_sz));
+ /* buf_sz should be less than net.core.rmem_max for this to succeed */
+ if (setsockopt(s, SOL_SOCKET, SO_RCVBUF, &buf_sz, sizeof(buf_sz)) < 0) {
+ close(s);
+ return -1;
+ }
+
setsockopt(s, SOL_SOCKET, SO_PASSCRED, &on, sizeof(on));
if(bind(s, (struct sockaddr *) &addr, sizeof(addr)) < 0) {
diff --git a/liblog/tests/liblog_test.cpp b/liblog/tests/liblog_test.cpp
index d80f8b2..d07d774 100644
--- a/liblog/tests/liblog_test.cpp
+++ b/liblog/tests/liblog_test.cpp
@@ -539,6 +539,7 @@
bool set_persist = false;
bool allow_security = false;
+ setuid(AID_SYSTEM); // only one that can read security buffer
if (__android_log_security()) {
allow_security = true;
} else {
@@ -1762,12 +1763,10 @@
#endif
}
-TEST(liblog, android_errorWriteWithInfoLog__android_logger_list_read__typical) {
#ifdef __ANDROID__
- const int TAG = 123456781;
- const char SUBTAG[] = "test-subtag";
- const int UID = -1;
- const int DATA_LEN = 200;
+static void android_errorWriteWithInfoLog_helper(int TAG, const char* SUBTAG,
+ int UID, const char* payload,
+ int DATA_LEN, int& count) {
struct logger_list *logger_list;
pid_t pid = getpid();
@@ -1775,100 +1774,17 @@
ASSERT_TRUE(NULL != (logger_list = android_logger_list_open(
LOG_ID_EVENTS, ANDROID_LOG_RDONLY | ANDROID_LOG_NONBLOCK, 1000, pid)));
- ASSERT_LT(0, android_errorWriteWithInfoLog(
- TAG, SUBTAG, UID, max_payload_buf, DATA_LEN));
-
- sleep(2);
-
- int count = 0;
-
- for (;;) {
- log_msg log_msg;
- if (android_logger_list_read(logger_list, &log_msg) <= 0) {
- break;
- }
-
- char *eventData = log_msg.msg();
- if (!eventData) {
- continue;
- }
-
- // Tag
- int tag = get4LE(eventData);
- eventData += 4;
-
- if (tag != TAG) {
- continue;
- }
-
- // List type
- ASSERT_EQ(EVENT_TYPE_LIST, eventData[0]);
- eventData++;
-
- // Number of elements in list
- ASSERT_EQ(3, eventData[0]);
- eventData++;
-
- // Element #1: string type for subtag
- ASSERT_EQ(EVENT_TYPE_STRING, eventData[0]);
- eventData++;
-
- ASSERT_EQ((int) strlen(SUBTAG), get4LE(eventData));
- eventData +=4;
-
- if (memcmp(SUBTAG, eventData, strlen(SUBTAG))) {
- continue;
- }
- eventData += strlen(SUBTAG);
-
- // Element #2: int type for uid
- ASSERT_EQ(EVENT_TYPE_INT, eventData[0]);
- eventData++;
-
- ASSERT_EQ(UID, get4LE(eventData));
- eventData += 4;
-
- // Element #3: string type for data
- ASSERT_EQ(EVENT_TYPE_STRING, eventData[0]);
- eventData++;
-
- ASSERT_EQ(DATA_LEN, get4LE(eventData));
- eventData += 4;
-
- if (memcmp(max_payload_buf, eventData, DATA_LEN)) {
- continue;
- }
-
- ++count;
+ int retval_android_errorWriteWithinInfoLog = android_errorWriteWithInfoLog(
+ TAG, SUBTAG, UID, payload, DATA_LEN);
+ if (payload) {
+ ASSERT_LT(0, retval_android_errorWriteWithinInfoLog);
+ } else {
+ ASSERT_GT(0, retval_android_errorWriteWithinInfoLog);
}
- EXPECT_EQ(1, count);
-
- android_logger_list_close(logger_list);
-#else
- GTEST_LOG_(INFO) << "This test does nothing.\n";
-#endif
-}
-
-TEST(liblog, android_errorWriteWithInfoLog__android_logger_list_read__data_too_large) {
-#ifdef __ANDROID__
- const int TAG = 123456782;
- const char SUBTAG[] = "test-subtag";
- const int UID = -1;
- const int DATA_LEN = sizeof(max_payload_buf);
- struct logger_list *logger_list;
-
- pid_t pid = getpid();
-
- ASSERT_TRUE(NULL != (logger_list = android_logger_list_open(
- LOG_ID_EVENTS, ANDROID_LOG_RDONLY | ANDROID_LOG_NONBLOCK, 1000, pid)));
-
- ASSERT_LT(0, android_errorWriteWithInfoLog(
- TAG, SUBTAG, UID, max_payload_buf, DATA_LEN));
-
sleep(2);
- int count = 0;
+ count = 0;
for (;;) {
log_msg log_msg;
@@ -1891,6 +1807,12 @@
continue;
}
+ if (!payload) {
+ // This tag should not have been written because the data was null
+ ++count;
+ break;
+ }
+
// List type
ASSERT_EQ(EVENT_TYPE_LIST, eventData[0]);
eventData++;
@@ -1903,13 +1825,15 @@
ASSERT_EQ(EVENT_TYPE_STRING, eventData[0]);
eventData++;
- ASSERT_EQ((int) strlen(SUBTAG), get4LE(eventData));
+ int subtag_len = strlen(SUBTAG);
+ if (subtag_len > 32) subtag_len = 32;
+ ASSERT_EQ(subtag_len, get4LE(eventData));
eventData +=4;
- if (memcmp(SUBTAG, eventData, strlen(SUBTAG))) {
+ if (memcmp(SUBTAG, eventData, subtag_len)) {
continue;
}
- eventData += strlen(SUBTAG);
+ eventData += subtag_len;
// Element #2: int type for uid
ASSERT_EQ(EVENT_TYPE_INT, eventData[0]);
@@ -1924,22 +1848,53 @@
size_t dataLen = get4LE(eventData);
eventData += 4;
+ if (DATA_LEN < 512) ASSERT_EQ(DATA_LEN, (int)dataLen);
- if (memcmp(max_payload_buf, eventData, dataLen)) {
+ if (memcmp(payload, eventData, dataLen)) {
continue;
}
- eventData += dataLen;
- // 4 bytes for the tag, and max_payload_buf should be truncated.
- ASSERT_LE(4 + 512, eventData - original); // worst expectations
- ASSERT_GT(4 + DATA_LEN, eventData - original); // must be truncated
+ if (DATA_LEN >= 512) {
+ eventData += dataLen;
+ // 4 bytes for the tag, and max_payload_buf should be truncated.
+ ASSERT_LE(4 + 512, eventData - original); // worst expectations
+ ASSERT_GT(4 + DATA_LEN, eventData - original); // must be truncated
+ }
++count;
}
- EXPECT_EQ(1, count);
-
android_logger_list_close(logger_list);
+}
+#endif
+
+TEST(liblog, android_errorWriteWithInfoLog__android_logger_list_read__typical) {
+#ifdef __ANDROID__
+ int count;
+ android_errorWriteWithInfoLog_helper(
+ 123456781,
+ "test-subtag",
+ -1,
+ max_payload_buf,
+ 200,
+ count);
+ EXPECT_EQ(1, count);
+#else
+ GTEST_LOG_(INFO) << "This test does nothing.\n";
+#endif
+}
+
+TEST(liblog, android_errorWriteWithInfoLog__android_logger_list_read__data_too_large) {
+#ifdef __ANDROID__
+ int count;
+ android_errorWriteWithInfoLog_helper(
+ 123456782,
+ "test-subtag",
+ -1,
+ max_payload_buf,
+ sizeof(max_payload_buf),
+ count);
+ EXPECT_EQ(1, count);
#else
GTEST_LOG_(INFO) << "This test does nothing.\n";
#endif
@@ -1947,49 +1902,15 @@
TEST(liblog, android_errorWriteWithInfoLog__android_logger_list_read__null_data) {
#ifdef __ANDROID__
- const int TAG = 123456783;
- const char SUBTAG[] = "test-subtag";
- const int UID = -1;
- const int DATA_LEN = 200;
- struct logger_list *logger_list;
-
- pid_t pid = getpid();
-
- ASSERT_TRUE(NULL != (logger_list = android_logger_list_open(
- LOG_ID_EVENTS, ANDROID_LOG_RDONLY | ANDROID_LOG_NONBLOCK, 1000, pid)));
-
- ASSERT_GT(0, android_errorWriteWithInfoLog(
- TAG, SUBTAG, UID, NULL, DATA_LEN));
-
- sleep(2);
-
- int count = 0;
-
- for (;;) {
- log_msg log_msg;
- if (android_logger_list_read(logger_list, &log_msg) <= 0) {
- break;
- }
-
- char *eventData = log_msg.msg();
- if (!eventData) {
- continue;
- }
-
- // Tag
- int tag = get4LE(eventData);
- eventData += 4;
-
- if (tag == TAG) {
- // This tag should not have been written because the data was null
- count++;
- break;
- }
- }
-
+ int count;
+ android_errorWriteWithInfoLog_helper(
+ 123456783,
+ "test-subtag",
+ -1,
+ NULL,
+ 200,
+ count);
EXPECT_EQ(0, count);
-
- android_logger_list_close(logger_list);
#else
GTEST_LOG_(INFO) << "This test does nothing.\n";
#endif
@@ -1997,88 +1918,15 @@
TEST(liblog, android_errorWriteWithInfoLog__android_logger_list_read__subtag_too_long) {
#ifdef __ANDROID__
- const int TAG = 123456784;
- const char SUBTAG[] = "abcdefghijklmnopqrstuvwxyz now i know my abc";
- const int UID = -1;
- const int DATA_LEN = 200;
- struct logger_list *logger_list;
-
- pid_t pid = getpid();
-
- ASSERT_TRUE(NULL != (logger_list = android_logger_list_open(
- LOG_ID_EVENTS, ANDROID_LOG_RDONLY | ANDROID_LOG_NONBLOCK, 1000, pid)));
-
- ASSERT_LT(0, android_errorWriteWithInfoLog(
- TAG, SUBTAG, UID, max_payload_buf, DATA_LEN));
-
- sleep(2);
-
- int count = 0;
-
- for (;;) {
- log_msg log_msg;
- if (android_logger_list_read(logger_list, &log_msg) <= 0) {
- break;
- }
-
- char *eventData = log_msg.msg();
- if (!eventData) {
- continue;
- }
-
- // Tag
- int tag = get4LE(eventData);
- eventData += 4;
-
- if (tag != TAG) {
- continue;
- }
-
- // List type
- ASSERT_EQ(EVENT_TYPE_LIST, eventData[0]);
- eventData++;
-
- // Number of elements in list
- ASSERT_EQ(3, eventData[0]);
- eventData++;
-
- // Element #1: string type for subtag
- ASSERT_EQ(EVENT_TYPE_STRING, eventData[0]);
- eventData++;
-
- // The subtag is longer than 32 and should be truncated to that.
- ASSERT_EQ(32, get4LE(eventData));
- eventData +=4;
-
- if (memcmp(SUBTAG, eventData, 32)) {
- continue;
- }
- eventData += 32;
-
- // Element #2: int type for uid
- ASSERT_EQ(EVENT_TYPE_INT, eventData[0]);
- eventData++;
-
- ASSERT_EQ(UID, get4LE(eventData));
- eventData += 4;
-
- // Element #3: string type for data
- ASSERT_EQ(EVENT_TYPE_STRING, eventData[0]);
- eventData++;
-
- ASSERT_EQ(DATA_LEN, get4LE(eventData));
- eventData += 4;
-
- if (memcmp(max_payload_buf, eventData, DATA_LEN)) {
- continue;
- }
-
- ++count;
- }
-
+ int count;
+ android_errorWriteWithInfoLog_helper(
+ 123456784,
+ "abcdefghijklmnopqrstuvwxyz now i know my abc",
+ -1,
+ max_payload_buf,
+ 200,
+ count);
EXPECT_EQ(1, count);
-
- android_logger_list_close(logger_list);
#else
GTEST_LOG_(INFO) << "This test does nothing.\n";
#endif
@@ -2092,10 +1940,8 @@
buf_write_test(max_payload_buf);
}
-TEST(liblog, android_errorWriteLog__android_logger_list_read__success) {
#ifdef __ANDROID__
- const int TAG = 123456785;
- const char SUBTAG[] = "test-subtag";
+static void android_errorWriteLog_helper(int TAG, const char *SUBTAG, int& count) {
struct logger_list *logger_list;
pid_t pid = getpid();
@@ -2103,11 +1949,16 @@
ASSERT_TRUE(NULL != (logger_list = android_logger_list_open(
LOG_ID_EVENTS, ANDROID_LOG_RDONLY | ANDROID_LOG_NONBLOCK, 1000, pid)));
- ASSERT_LT(0, android_errorWriteLog(TAG, SUBTAG));
+ int retval_android_errorWriteLog = android_errorWriteLog(TAG, SUBTAG);
+ if (SUBTAG) {
+ ASSERT_LT(0, retval_android_errorWriteLog);
+ } else {
+ ASSERT_GT(0, retval_android_errorWriteLog);
+ }
sleep(2);
- int count = 0;
+ count = 0;
for (;;) {
log_msg log_msg;
@@ -2128,6 +1979,12 @@
continue;
}
+ if (!SUBTAG) {
+ // This tag should not have been written because the data was null
+ ++count;
+ break;
+ }
+
// List type
ASSERT_EQ(EVENT_TYPE_LIST, eventData[0]);
eventData++;
@@ -2149,9 +2006,15 @@
++count;
}
- EXPECT_EQ(1, count);
-
android_logger_list_close(logger_list);
+}
+#endif
+
+TEST(liblog, android_errorWriteLog__android_logger_list_read__success) {
+#ifdef __ANDROID__
+ int count;
+ android_errorWriteLog_helper(123456785, "test-subtag", count);
+ EXPECT_EQ(1, count);
#else
GTEST_LOG_(INFO) << "This test does nothing.\n";
#endif
@@ -2159,45 +2022,9 @@
TEST(liblog, android_errorWriteLog__android_logger_list_read__null_subtag) {
#ifdef __ANDROID__
- const int TAG = 123456786;
- struct logger_list *logger_list;
-
- pid_t pid = getpid();
-
- ASSERT_TRUE(NULL != (logger_list = android_logger_list_open(
- LOG_ID_EVENTS, ANDROID_LOG_RDONLY | ANDROID_LOG_NONBLOCK, 1000, pid)));
-
- ASSERT_GT(0, android_errorWriteLog(TAG, NULL));
-
- sleep(2);
-
- int count = 0;
-
- for (;;) {
- log_msg log_msg;
- if (android_logger_list_read(logger_list, &log_msg) <= 0) {
- break;
- }
-
- char *eventData = log_msg.msg();
- if (!eventData) {
- continue;
- }
-
- // Tag
- int tag = get4LE(eventData);
- eventData += 4;
-
- if (tag == TAG) {
- // This tag should not have been written because the data was null
- count++;
- break;
- }
- }
-
+ int count;
+ android_errorWriteLog_helper(123456786, NULL, count);
EXPECT_EQ(0, count);
-
- android_logger_list_close(logger_list);
#else
GTEST_LOG_(INFO) << "This test does nothing.\n";
#endif
diff --git a/libsync/sync.c b/libsync/sync.c
index 169dc36..6281b20 100644
--- a/libsync/sync.c
+++ b/libsync/sync.c
@@ -21,8 +21,6 @@
#include <stdint.h>
#include <string.h>
-#include <linux/sw_sync.h>
-
#include <sys/ioctl.h>
#include <sys/stat.h>
#include <sys/types.h>
@@ -42,6 +40,16 @@
#define SYNC_IOC_MERGE _IOWR(SYNC_IOC_MAGIC, 1, struct sync_merge_data)
#define SYNC_IOC_FENCE_INFO _IOWR(SYNC_IOC_MAGIC, 2, struct sync_fence_info_data)
+struct sw_sync_create_fence_data {
+ __u32 value;
+ char name[32];
+ __s32 fence;
+};
+
+#define SW_SYNC_IOC_MAGIC 'W'
+#define SW_SYNC_IOC_CREATE_FENCE _IOWR(SW_SYNC_IOC_MAGIC, 0, struct sw_sync_create_fence_data)
+#define SW_SYNC_IOC_INC _IOW(SW_SYNC_IOC_MAGIC, 1, __u32)
+
int sync_wait(int fd, int timeout)
{
__s32 to = timeout;
diff --git a/rootdir/init.rc b/rootdir/init.rc
index 8903255..249b9e2 100644
--- a/rootdir/init.rc
+++ b/rootdir/init.rc
@@ -125,6 +125,12 @@
write /proc/sys/kernel/sched_rt_runtime_us 950000
write /proc/sys/kernel/sched_rt_period_us 1000000
+ # Assign reasonable ceiling values for socket rcv/snd buffers.
+ # These should almost always be overridden by the target per the
+ # the corresponding technology maximums.
+ write /proc/sys/net/core/rmem_max 262144
+ write /proc/sys/net/core/wmem_max 262144
+
# reflect fwmark from incoming packets onto generated replies
write /proc/sys/net/ipv4/fwmark_reflect 1
write /proc/sys/net/ipv6/fwmark_reflect 1