Skip to content

Commit

Permalink
Merge remote-tracking branch 'upstream/cm-13.0' into cm-13.0
Browse files Browse the repository at this point in the history
  • Loading branch information
xen0n committed Oct 5, 2016
2 parents 7f015fd + cc607cb commit 265767b
Show file tree
Hide file tree
Showing 15 changed files with 302 additions and 78 deletions.
3 changes: 3 additions & 0 deletions adb/Android.mk
Original file line number Diff line number Diff line change
Expand Up @@ -200,7 +200,10 @@ endif
# will violate ODR
LOCAL_SHARED_LIBRARIES :=

# Don't build the host adb on Windows (this branch should only be used for security updates.)
ifneq ($(HOST_OS),windows)
include $(BUILD_HOST_EXECUTABLE)
endif

$(call dist-for-goals,dist_files sdk,$(LOCAL_BUILT_MODULE))

Expand Down
1 change: 0 additions & 1 deletion adb/mutex_list.h
Original file line number Diff line number Diff line change
Expand Up @@ -6,7 +6,6 @@
#ifndef ADB_MUTEX
#error ADB_MUTEX not defined when including this file
#endif
ADB_MUTEX(socket_list_lock)
ADB_MUTEX(transport_lock)
#if ADB_HOST
ADB_MUTEX(local_transports_lock)
Expand Down
78 changes: 33 additions & 45 deletions adb/sockets.cpp
Original file line number Diff line number Diff line change
Expand Up @@ -25,18 +25,25 @@
#include <string.h>
#include <unistd.h>

#include <algorithm>
#include <mutex>
#include <string>
#include <vector>

#if !ADB_HOST
#include "cutils/properties.h"
#endif

#include "adb.h"
#include "adb_io.h"
#include "sysdeps/mutex.h"
#include "transport.h"

ADB_MUTEX_DEFINE( socket_list_lock );

static void local_socket_close_locked(asocket *s);
#if !defined(__BIONIC__)
using std::recursive_mutex;
#endif

static recursive_mutex& local_socket_list_lock = *new recursive_mutex();
static unsigned local_socket_next_id = 1;

static asocket local_socket_list = {
Expand All @@ -61,7 +68,7 @@ asocket *find_local_socket(unsigned local_id, unsigned peer_id)
asocket *s;
asocket *result = NULL;

adb_mutex_lock(&socket_list_lock);
std::lock_guard<recursive_mutex> lock(local_socket_list_lock);
for (s = local_socket_list.next; s != &local_socket_list; s = s->next) {
if (s->id != local_id)
continue;
Expand All @@ -70,7 +77,6 @@ asocket *find_local_socket(unsigned local_id, unsigned peer_id)
}
break;
}
adb_mutex_unlock(&socket_list_lock);

return result;
}
Expand All @@ -84,20 +90,17 @@ insert_local_socket(asocket* s, asocket* list)
s->next->prev = s;
}


void install_local_socket(asocket *s)
{
adb_mutex_lock(&socket_list_lock);
void install_local_socket(asocket* s) {
std::lock_guard<recursive_mutex> lock(local_socket_list_lock);

s->id = local_socket_next_id++;

// Socket ids should never be 0.
if (local_socket_next_id == 0)
local_socket_next_id = 1;
if (local_socket_next_id == 0) {
fatal("local socket id overflow");
}

insert_local_socket(s, &local_socket_list);

adb_mutex_unlock(&socket_list_lock);
}

void remove_socket(asocket *s)
Expand All @@ -116,19 +119,17 @@ void remove_socket(asocket *s)
void close_all_sockets(atransport *t)
{
asocket *s;

/* this is a little gross, but since s->close() *will* modify
** the list out from under you, your options are limited.
*/
adb_mutex_lock(&socket_list_lock);
/* this is a little gross, but since s->close() *will* modify
** the list out from under you, your options are limited.
*/
std::lock_guard<recursive_mutex> lock(local_socket_list_lock);
restart:
for(s = local_socket_list.next; s != &local_socket_list; s = s->next){
if(s->transport == t || (s->peer && s->peer->transport == t)) {
local_socket_close_locked(s);
for (s = local_socket_list.next; s != &local_socket_list; s = s->next) {
if (s->transport == t || (s->peer && s->peer->transport == t)) {
s->close(s);
goto restart;
}
}
adb_mutex_unlock(&socket_list_lock);
}

static int local_socket_enqueue(asocket *s, apacket *p)
Expand Down Expand Up @@ -191,13 +192,6 @@ static void local_socket_ready(asocket *s)
fdevent_add(&s->fde, FDE_READ);
}

static void local_socket_close(asocket *s)
{
adb_mutex_lock(&socket_list_lock);
local_socket_close_locked(s);
adb_mutex_unlock(&socket_list_lock);
}

// be sure to hold the socket list lock when calling this
static void local_socket_destroy(asocket *s)
{
Expand Down Expand Up @@ -226,27 +220,21 @@ static void local_socket_destroy(asocket *s)
}
}


static void local_socket_close_locked(asocket *s)
{
D("entered local_socket_close_locked. LS(%d) fd=%d\n", s->id, s->fd);
if(s->peer) {
D("LS(%d): closing peer. peer->id=%d peer->fd=%d\n",
s->id, s->peer->id, s->peer->fd);
static void local_socket_close(asocket* s) {
D("entered local_socket_close. LS(%d) fd=%d", s->id, s->fd);
std::lock_guard<recursive_mutex> lock(local_socket_list_lock);
if (s->peer) {
D("LS(%d): closing peer. peer->id=%d peer->fd=%d", s->id, s->peer->id, s->peer->fd);
/* Note: it's important to call shutdown before disconnecting from
* the peer, this ensures that remote sockets can still get the id
* of the local socket they're connected to, to send a CLOSE()
* protocol event. */
if (s->peer->shutdown)
s->peer->shutdown(s->peer);
s->peer->peer = 0;
// tweak to avoid deadlock
if (s->peer->close == local_socket_close) {
local_socket_close_locked(s->peer);
} else {
s->peer->close(s->peer);
if (s->peer->shutdown) {
s->peer->shutdown(s->peer);
}
s->peer = 0;
s->peer->peer = nullptr;
s->peer->close(s->peer);
s->peer = nullptr;
}

/* If we are already closing, or if there are no
Expand Down
143 changes: 143 additions & 0 deletions adb/sysdeps/mutex.h
Original file line number Diff line number Diff line change
@@ -0,0 +1,143 @@
#pragma once

/*
* Copyright (C) 2016 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/

#if defined(_WIN32)

#include <windows.h>

#include <android-base/macros.h>

#include "adb.h"

// The prebuilt version of mingw we use doesn't support mutex or recursive_mutex.
// Therefore, implement our own using the Windows primitives.
// Put them directly into the std namespace, so that when they're actually available, the build
// breaks until they're removed.

#include <mutex>
namespace std {

// CRITICAL_SECTION is recursive, so just wrap it in a Mutex-compatible class.
class recursive_mutex {
public:
recursive_mutex() {
InitializeCriticalSection(&mutex_);
}

~recursive_mutex() {
DeleteCriticalSection(&mutex_);
}

void lock() {
EnterCriticalSection(&mutex_);
}

bool try_lock() {
return TryEnterCriticalSection(&mutex_);
}

void unlock() {
LeaveCriticalSection(&mutex_);
}

private:
CRITICAL_SECTION mutex_;

DISALLOW_COPY_AND_ASSIGN(recursive_mutex);
};

class mutex {
public:
mutex() {
}

~mutex() {
}

void lock() {
mutex_.lock();
if (++lock_count_ != 1) {
fatal("non-recursive mutex locked reentrantly");
}
}

void unlock() {
if (--lock_count_ != 0) {
fatal("non-recursive mutex unlock resulted in unexpected lock count: %d", lock_count_);
}
mutex_.unlock();
}

bool try_lock() {
if (!mutex_.try_lock()) {
return false;
}

if (lock_count_ != 0) {
mutex_.unlock();
return false;
}

++lock_count_;
return true;
}

private:
recursive_mutex mutex_;
size_t lock_count_ = 0;
};

}

#elif defined(__BIONIC__)

// On M, the recovery image uses parts of adb that depends on recursive_mutex, and uses libstdc++,
// which lacks it.

#include <pthread.h>
#include <mutex>

#include <base/macros.h>

class recursive_mutex {
public:
recursive_mutex() {
}

~recursive_mutex() {
}

void lock() {
pthread_mutex_lock(&mutex_);
}

bool try_lock() {
return pthread_mutex_trylock(&mutex_);
}

void unlock() {
pthread_mutex_unlock(&mutex_);
}

private:
pthread_mutex_t mutex_ = PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP;

DISALLOW_COPY_AND_ASSIGN(recursive_mutex);
};

#endif
10 changes: 5 additions & 5 deletions debuggerd/backtrace.cpp
Original file line number Diff line number Diff line change
Expand Up @@ -67,8 +67,8 @@ static void dump_process_footer(log_t* log, pid_t pid) {
_LOG(log, logtype::BACKTRACE, "\n----- end %d -----\n", pid);
}

static void dump_thread(
log_t* log, pid_t tid, bool attached, bool* detach_failed, int* total_sleep_time_usec) {
static void dump_thread(log_t* log, pid_t pid, pid_t tid, bool attached,
bool* detach_failed, int* total_sleep_time_usec) {
char path[PATH_MAX];
char threadnamebuf[1024];
char* threadname = NULL;
Expand All @@ -88,7 +88,7 @@ static void dump_thread(

_LOG(log, logtype::BACKTRACE, "\n\"%s\" sysTid=%d\n", threadname ? threadname : "<unknown>", tid);

if (!attached && ptrace(PTRACE_ATTACH, tid, 0, 0) < 0) {
if (!attached && !ptrace_attach_thread(pid, tid)) {
_LOG(log, logtype::BACKTRACE, "Could not attach to thread: %s\n", strerror(errno));
return;
}
Expand Down Expand Up @@ -117,7 +117,7 @@ void dump_backtrace(int fd, int amfd, pid_t pid, pid_t tid, bool* detach_failed,
log.amfd = amfd;

dump_process_header(&log, pid);
dump_thread(&log, tid, true, detach_failed, total_sleep_time_usec);
dump_thread(&log, pid, tid, true, detach_failed, total_sleep_time_usec);

char task_path[64];
snprintf(task_path, sizeof(task_path), "/proc/%d/task", pid);
Expand All @@ -135,7 +135,7 @@ void dump_backtrace(int fd, int amfd, pid_t pid, pid_t tid, bool* detach_failed,
continue;
}

dump_thread(&log, new_tid, false, detach_failed, total_sleep_time_usec);
dump_thread(&log, pid, new_tid, false, detach_failed, total_sleep_time_usec);
}
closedir(d);
}
Expand Down
Loading

0 comments on commit 265767b

Please sign in to comment.