mirror of
https://git.freebsd.org/ports.git
synced 2025-06-12 00:00:33 -04:00
995 lines
29 KiB
Text
995 lines
29 KiB
Text
Revert 0cd3ae1c281f until usb_libusb.cpp adopts 812f030477bc.
|
|
|
|
diff --git adb/adb_utils.cpp adb/adb_utils.cpp
|
|
index db39ef4..5a3b401 100644
|
|
--- adb/adb_utils.cpp
|
|
+++ adb/adb_utils.cpp
|
|
@@ -26,7 +26,6 @@
|
|
#include <unistd.h>
|
|
|
|
#include <algorithm>
|
|
-#include <mutex>
|
|
#include <vector>
|
|
|
|
#include <android-base/logging.h>
|
|
@@ -48,6 +47,8 @@
|
|
#include <pwd.h>
|
|
#endif
|
|
|
|
+ADB_MUTEX_DEFINE(basename_lock);
|
|
+ADB_MUTEX_DEFINE(dirname_lock);
|
|
|
|
#if defined(_WIN32)
|
|
constexpr char kNullFileName[] = "NUL";
|
|
@@ -101,15 +102,13 @@
|
|
}
|
|
|
|
std::string adb_basename(const std::string& path) {
|
|
- static std::mutex& basename_lock = *new std::mutex();
|
|
-
|
|
// Copy path because basename may modify the string passed in.
|
|
std::string result(path);
|
|
|
|
// Use lock because basename() may write to a process global and return a
|
|
// pointer to that. Note that this locking strategy only works if all other
|
|
- // callers to basename in the process also grab this same lock.
|
|
- std::lock_guard<std::mutex> lock(basename_lock);
|
|
+ // callers to dirname in the process also grab this same lock.
|
|
+ adb_mutex_lock(&basename_lock);
|
|
|
|
// Note that if std::string uses copy-on-write strings, &str[0] will cause
|
|
// the copy to be made, so there is no chance of us accidentally writing to
|
|
@@ -120,19 +119,19 @@
|
|
// before leaving the lock.
|
|
result.assign(name);
|
|
|
|
+ adb_mutex_unlock(&basename_lock);
|
|
+
|
|
return result;
|
|
}
|
|
|
|
std::string adb_dirname(const std::string& path) {
|
|
- static std::mutex& dirname_lock = *new std::mutex();
|
|
-
|
|
// Copy path because dirname may modify the string passed in.
|
|
std::string result(path);
|
|
|
|
// Use lock because dirname() may write to a process global and return a
|
|
// pointer to that. Note that this locking strategy only works if all other
|
|
// callers to dirname in the process also grab this same lock.
|
|
- std::lock_guard<std::mutex> lock(dirname_lock);
|
|
+ adb_mutex_lock(&dirname_lock);
|
|
|
|
// Note that if std::string uses copy-on-write strings, &str[0] will cause
|
|
// the copy to be made, so there is no chance of us accidentally writing to
|
|
@@ -143,6 +142,8 @@
|
|
// before leaving the lock.
|
|
result.assign(parent);
|
|
|
|
+ adb_mutex_unlock(&dirname_lock);
|
|
+
|
|
return result;
|
|
}
|
|
|
|
diff --git adb/client/main.cpp adb/client/main.cpp
|
|
index 571c227..279bb70 100644
|
|
--- adb/client/main.cpp
|
|
+++ adb/client/main.cpp
|
|
@@ -170,6 +170,7 @@
|
|
}
|
|
|
|
int main(int argc, char** argv) {
|
|
+ adb_sysdeps_init();
|
|
adb_trace_init(argv);
|
|
return adb_commandline(argc - 1, const_cast<const char**>(argv + 1));
|
|
}
|
|
diff --git adb/mutex_list.h adb/mutex_list.h
|
|
deleted file mode 100644
|
|
index 4a188ee..0000000
|
|
--- /dev/null
|
|
+++ adb/mutex_list.h
|
|
@@ -0,0 +1,17 @@
|
|
+/* the list of mutexes used by adb */
|
|
+/* #ifndef __MUTEX_LIST_H
|
|
+ * Do not use an include-guard. This file is included once to declare the locks
|
|
+ * and once in win32 to actually do the runtime initialization.
|
|
+ */
|
|
+#ifndef ADB_MUTEX
|
|
+#error ADB_MUTEX not defined when including this file
|
|
+#endif
|
|
+ADB_MUTEX(basename_lock)
|
|
+ADB_MUTEX(dirname_lock)
|
|
+ADB_MUTEX(transport_lock)
|
|
+#if ADB_HOST
|
|
+ADB_MUTEX(local_transports_lock)
|
|
+#endif
|
|
+ADB_MUTEX(usb_lock)
|
|
+
|
|
+#undef ADB_MUTEX
|
|
diff --git adb/sysdeps.h adb/sysdeps.h
|
|
index 8d99722..3ed589c 100644
|
|
--- adb/sysdeps.h
|
|
+++ adb/sysdeps.h
|
|
@@ -97,6 +97,27 @@
|
|
return c == '\\' || c == '/';
|
|
}
|
|
|
|
+typedef CRITICAL_SECTION adb_mutex_t;
|
|
+
|
|
+#define ADB_MUTEX_DEFINE(x) adb_mutex_t x
|
|
+
|
|
+/* declare all mutexes */
|
|
+/* For win32, adb_sysdeps_init() will do the mutex runtime initialization. */
|
|
+#define ADB_MUTEX(x) extern adb_mutex_t x;
|
|
+#include "mutex_list.h"
|
|
+
|
|
+extern void adb_sysdeps_init(void);
|
|
+
|
|
+static __inline__ void adb_mutex_lock( adb_mutex_t* lock )
|
|
+{
|
|
+ EnterCriticalSection( lock );
|
|
+}
|
|
+
|
|
+static __inline__ void adb_mutex_unlock( adb_mutex_t* lock )
|
|
+{
|
|
+ LeaveCriticalSection( lock );
|
|
+}
|
|
+
|
|
typedef void (*adb_thread_func_t)(void* arg);
|
|
typedef HANDLE adb_thread_t;
|
|
|
|
@@ -455,6 +476,27 @@
|
|
return c == '/';
|
|
}
|
|
|
|
+typedef pthread_mutex_t adb_mutex_t;
|
|
+
|
|
+#define ADB_MUTEX_INITIALIZER PTHREAD_MUTEX_INITIALIZER
|
|
+#define adb_mutex_init pthread_mutex_init
|
|
+#define adb_mutex_lock pthread_mutex_lock
|
|
+#define adb_mutex_unlock pthread_mutex_unlock
|
|
+#define adb_mutex_destroy pthread_mutex_destroy
|
|
+
|
|
+#define ADB_MUTEX_DEFINE(m) adb_mutex_t m = PTHREAD_MUTEX_INITIALIZER
|
|
+
|
|
+#define adb_cond_t pthread_cond_t
|
|
+#define adb_cond_init pthread_cond_init
|
|
+#define adb_cond_wait pthread_cond_wait
|
|
+#define adb_cond_broadcast pthread_cond_broadcast
|
|
+#define adb_cond_signal pthread_cond_signal
|
|
+#define adb_cond_destroy pthread_cond_destroy
|
|
+
|
|
+/* declare all mutexes */
|
|
+#define ADB_MUTEX(x) extern adb_mutex_t x;
|
|
+#include "mutex_list.h"
|
|
+
|
|
static __inline__ void close_on_exec(int fd)
|
|
{
|
|
fcntl( fd, F_SETFD, FD_CLOEXEC );
|
|
@@ -776,6 +818,10 @@
|
|
#undef mkdir
|
|
#define mkdir ___xxx_mkdir
|
|
|
|
+static __inline__ void adb_sysdeps_init(void)
|
|
+{
|
|
+}
|
|
+
|
|
static __inline__ int adb_is_absolute_host_path(const char* path) {
|
|
return path[0] == '/';
|
|
}
|
|
diff --git adb/sysdeps_test.cpp adb/sysdeps_test.cpp
|
|
index f871675..9f77942 100644
|
|
--- adb/sysdeps_test.cpp
|
|
+++ adb/sysdeps_test.cpp
|
|
@@ -269,6 +269,17 @@
|
|
m.unlock();
|
|
}
|
|
|
|
+// Our implementation on Windows aborts on double lock.
|
|
+#if defined(_WIN32)
|
|
+TEST(sysdeps_mutex, mutex_reentrant_lock) {
|
|
+ std::mutex &m = *new std::mutex();
|
|
+
|
|
+ m.lock();
|
|
+ ASSERT_FALSE(m.try_lock());
|
|
+ EXPECT_DEATH(m.lock(), "non-recursive mutex locked reentrantly");
|
|
+}
|
|
+#endif
|
|
+
|
|
TEST(sysdeps_mutex, recursive_mutex_smoke) {
|
|
static std::recursive_mutex &m = *new std::recursive_mutex();
|
|
|
|
diff --git adb/sysdeps_win32.cpp adb/sysdeps_win32.cpp
|
|
index 5fda27b..4dd549d 100644
|
|
--- adb/sysdeps_win32.cpp
|
|
+++ adb/sysdeps_win32.cpp
|
|
@@ -27,7 +27,6 @@
|
|
|
|
#include <algorithm>
|
|
#include <memory>
|
|
-#include <mutex>
|
|
#include <string>
|
|
#include <unordered_map>
|
|
#include <vector>
|
|
@@ -138,7 +137,7 @@
|
|
#define WIN32_FH_BASE 2048
|
|
#define WIN32_MAX_FHS 2048
|
|
|
|
-static std::mutex& _win32_lock = *new std::mutex();
|
|
+static adb_mutex_t _win32_lock;
|
|
static FHRec _win32_fhs[ WIN32_MAX_FHS ];
|
|
static int _win32_fh_next; // where to start search for free FHRec
|
|
|
|
@@ -183,24 +182,27 @@
|
|
{
|
|
FH f = NULL;
|
|
|
|
- std::lock_guard<std::mutex> lock(_win32_lock);
|
|
+ adb_mutex_lock( &_win32_lock );
|
|
|
|
for (int i = _win32_fh_next; i < WIN32_MAX_FHS; ++i) {
|
|
if (_win32_fhs[i].clazz == NULL) {
|
|
f = &_win32_fhs[i];
|
|
_win32_fh_next = i + 1;
|
|
- f->clazz = clazz;
|
|
- f->used = 1;
|
|
- f->eof = 0;
|
|
- f->name[0] = '\0';
|
|
- clazz->_fh_init(f);
|
|
- return f;
|
|
+ goto Exit;
|
|
}
|
|
}
|
|
-
|
|
- D("_fh_alloc: no more free file descriptors");
|
|
- errno = EMFILE; // Too many open files
|
|
- return nullptr;
|
|
+ D( "_fh_alloc: no more free file descriptors" );
|
|
+ errno = EMFILE; // Too many open files
|
|
+Exit:
|
|
+ if (f) {
|
|
+ f->clazz = clazz;
|
|
+ f->used = 1;
|
|
+ f->eof = 0;
|
|
+ f->name[0] = '\0';
|
|
+ clazz->_fh_init(f);
|
|
+ }
|
|
+ adb_mutex_unlock( &_win32_lock );
|
|
+ return f;
|
|
}
|
|
|
|
|
|
@@ -209,7 +211,7 @@
|
|
{
|
|
// Use lock so that closing only happens once and so that _fh_alloc can't
|
|
// allocate a FH that we're in the middle of closing.
|
|
- std::lock_guard<std::mutex> lock(_win32_lock);
|
|
+ adb_mutex_lock(&_win32_lock);
|
|
|
|
int offset = f - _win32_fhs;
|
|
if (_win32_fh_next > offset) {
|
|
@@ -223,6 +225,7 @@
|
|
f->used = 0;
|
|
f->clazz = NULL;
|
|
}
|
|
+ adb_mutex_unlock(&_win32_lock);
|
|
return 0;
|
|
}
|
|
|
|
@@ -1231,6 +1234,17 @@
|
|
return true;
|
|
}
|
|
|
|
+static adb_mutex_t g_console_output_buffer_lock;
|
|
+
|
|
+void
|
|
+adb_sysdeps_init( void )
|
|
+{
|
|
+#define ADB_MUTEX(x) InitializeCriticalSection( & x );
|
|
+#include "mutex_list.h"
|
|
+ InitializeCriticalSection( &_win32_lock );
|
|
+ InitializeCriticalSection( &g_console_output_buffer_lock );
|
|
+}
|
|
+
|
|
/**************************************************************************/
|
|
/**************************************************************************/
|
|
/***** *****/
|
|
@@ -2423,13 +2437,12 @@
|
|
// Bytes that have not yet been output to the console because they are incomplete UTF-8 sequences.
|
|
// Note that we use only one buffer even though stderr and stdout are logically separate streams.
|
|
// This matches the behavior of Linux.
|
|
+// Protected by g_console_output_buffer_lock.
|
|
+static auto& g_console_output_buffer = *new std::vector<char>();
|
|
|
|
// Internal helper function to write UTF-8 bytes to a console. Returns -1 on error.
|
|
static int _console_write_utf8(const char* const buf, const size_t buf_size, FILE* stream,
|
|
HANDLE console) {
|
|
- static std::mutex& console_output_buffer_lock = *new std::mutex();
|
|
- static auto& console_output_buffer = *new std::vector<char>();
|
|
-
|
|
const int saved_errno = errno;
|
|
std::vector<char> combined_buffer;
|
|
|
|
@@ -2437,25 +2450,24 @@
|
|
const char* utf8;
|
|
size_t utf8_size;
|
|
|
|
- {
|
|
- std::lock_guard<std::mutex> lock(console_output_buffer_lock);
|
|
- if (console_output_buffer.empty()) {
|
|
- // If console_output_buffer doesn't have a buffered up incomplete UTF-8 sequence (the
|
|
- // common case with plain ASCII), parse buf directly.
|
|
- utf8 = buf;
|
|
- utf8_size = internal::ParseCompleteUTF8(buf, buf + buf_size, &console_output_buffer);
|
|
- } else {
|
|
- // If console_output_buffer has a buffered up incomplete UTF-8 sequence, move it to
|
|
- // combined_buffer (and effectively clear console_output_buffer) and append buf to
|
|
- // combined_buffer, then parse it all together.
|
|
- combined_buffer.swap(console_output_buffer);
|
|
- combined_buffer.insert(combined_buffer.end(), buf, buf + buf_size);
|
|
-
|
|
- utf8 = combined_buffer.data();
|
|
- utf8_size = internal::ParseCompleteUTF8(utf8, utf8 + combined_buffer.size(),
|
|
- &console_output_buffer);
|
|
- }
|
|
+ adb_mutex_lock(&g_console_output_buffer_lock);
|
|
+ if (g_console_output_buffer.empty()) {
|
|
+ // If g_console_output_buffer doesn't have a buffered up incomplete UTF-8 sequence (the
|
|
+ // common case with plain ASCII), parse buf directly.
|
|
+ utf8 = buf;
|
|
+ utf8_size = internal::ParseCompleteUTF8(buf, buf + buf_size, &g_console_output_buffer);
|
|
+ } else {
|
|
+ // If g_console_output_buffer has a buffered up incomplete UTF-8 sequence, move it to
|
|
+ // combined_buffer (and effectively clear g_console_output_buffer) and append buf to
|
|
+ // combined_buffer, then parse it all together.
|
|
+ combined_buffer.swap(g_console_output_buffer);
|
|
+ combined_buffer.insert(combined_buffer.end(), buf, buf + buf_size);
|
|
+
|
|
+ utf8 = combined_buffer.data();
|
|
+ utf8_size = internal::ParseCompleteUTF8(utf8, utf8 + combined_buffer.size(),
|
|
+ &g_console_output_buffer);
|
|
}
|
|
+ adb_mutex_unlock(&g_console_output_buffer_lock);
|
|
|
|
std::wstring utf16;
|
|
|
|
diff --git adb/transport.cpp adb/transport.cpp
|
|
index 3eaeb06..87712fc 100644
|
|
--- adb/transport.cpp
|
|
+++ adb/transport.cpp
|
|
@@ -28,7 +28,6 @@
|
|
|
|
#include <algorithm>
|
|
#include <list>
|
|
-#include <mutex>
|
|
|
|
#include <android-base/logging.h>
|
|
#include <android-base/parsenetaddress.h>
|
|
@@ -45,7 +44,7 @@
|
|
static auto& transport_list = *new std::list<atransport*>();
|
|
static auto& pending_list = *new std::list<atransport*>();
|
|
|
|
-static std::mutex& transport_lock = *new std::mutex();
|
|
+ADB_MUTEX_DEFINE( transport_lock );
|
|
|
|
const char* const kFeatureShell2 = "shell_v2";
|
|
const char* const kFeatureCmd = "cmd";
|
|
@@ -298,12 +297,13 @@
|
|
}
|
|
|
|
void kick_transport(atransport* t) {
|
|
- std::lock_guard<std::mutex> lock(transport_lock);
|
|
+ adb_mutex_lock(&transport_lock);
|
|
// As kick_transport() can be called from threads without guarantee that t is valid,
|
|
// check if the transport is in transport_list first.
|
|
if (std::find(transport_list.begin(), transport_list.end(), t) != transport_list.end()) {
|
|
t->Kick();
|
|
}
|
|
+ adb_mutex_unlock(&transport_lock);
|
|
}
|
|
|
|
static int transport_registration_send = -1;
|
|
@@ -333,7 +333,7 @@
|
|
device_tracker** pnode = &device_tracker_list;
|
|
device_tracker* node = *pnode;
|
|
|
|
- std::lock_guard<std::mutex> lock(transport_lock);
|
|
+ adb_mutex_lock( &transport_lock );
|
|
while (node) {
|
|
if (node == tracker) {
|
|
*pnode = node->next;
|
|
@@ -342,6 +342,7 @@
|
|
pnode = &node->next;
|
|
node = *pnode;
|
|
}
|
|
+ adb_mutex_unlock( &transport_lock );
|
|
}
|
|
|
|
static void
|
|
@@ -503,10 +504,9 @@
|
|
fdevent_remove(&(t->transport_fde));
|
|
adb_close(t->fd);
|
|
|
|
- {
|
|
- std::lock_guard<std::mutex> lock(transport_lock);
|
|
- transport_list.remove(t);
|
|
- }
|
|
+ adb_mutex_lock(&transport_lock);
|
|
+ transport_list.remove(t);
|
|
+ adb_mutex_unlock(&transport_lock);
|
|
|
|
if (t->product)
|
|
free(t->product);
|
|
@@ -555,11 +555,10 @@
|
|
}
|
|
}
|
|
|
|
- {
|
|
- std::lock_guard<std::mutex> lock(transport_lock);
|
|
- pending_list.remove(t);
|
|
- transport_list.push_front(t);
|
|
- }
|
|
+ adb_mutex_lock(&transport_lock);
|
|
+ pending_list.remove(t);
|
|
+ transport_list.push_front(t);
|
|
+ adb_mutex_unlock(&transport_lock);
|
|
|
|
update_transports();
|
|
}
|
|
@@ -610,8 +609,7 @@
|
|
|
|
static void transport_unref(atransport* t) {
|
|
CHECK(t != nullptr);
|
|
-
|
|
- std::lock_guard<std::mutex> lock(transport_lock);
|
|
+ adb_mutex_lock(&transport_lock);
|
|
CHECK_GT(t->ref_count, 0u);
|
|
t->ref_count--;
|
|
if (t->ref_count == 0) {
|
|
@@ -621,6 +619,7 @@
|
|
} else {
|
|
D("transport: %s unref (count=%zu)", t->serial, t->ref_count);
|
|
}
|
|
+ adb_mutex_unlock(&transport_lock);
|
|
}
|
|
|
|
static int qual_match(const char *to_test,
|
|
@@ -666,7 +665,7 @@
|
|
*error_out = "no devices found";
|
|
}
|
|
|
|
- std::unique_lock<std::mutex> lock(transport_lock);
|
|
+ adb_mutex_lock(&transport_lock);
|
|
for (const auto& t : transport_list) {
|
|
if (t->connection_state == kCsNoPerm) {
|
|
#if ADB_HOST
|
|
@@ -714,7 +713,7 @@
|
|
}
|
|
}
|
|
}
|
|
- lock.unlock();
|
|
+ adb_mutex_unlock(&transport_lock);
|
|
|
|
// Don't return unauthorized devices; the caller can't do anything with them.
|
|
if (result && result->connection_state == kCsUnauthorized) {
|
|
@@ -915,20 +914,21 @@
|
|
|
|
std::string list_transports(bool long_listing) {
|
|
std::string result;
|
|
-
|
|
- std::lock_guard<std::mutex> lock(transport_lock);
|
|
+ adb_mutex_lock(&transport_lock);
|
|
for (const auto& t : transport_list) {
|
|
append_transport(t, &result, long_listing);
|
|
}
|
|
+ adb_mutex_unlock(&transport_lock);
|
|
return result;
|
|
}
|
|
|
|
/* hack for osx */
|
|
void close_usb_devices() {
|
|
- std::lock_guard<std::mutex> lock(transport_lock);
|
|
+ adb_mutex_lock(&transport_lock);
|
|
for (const auto& t : transport_list) {
|
|
t->Kick();
|
|
}
|
|
+ adb_mutex_unlock(&transport_lock);
|
|
}
|
|
#endif // ADB_HOST
|
|
|
|
@@ -947,9 +947,10 @@
|
|
return -1;
|
|
}
|
|
|
|
- std::unique_lock<std::mutex> lock(transport_lock);
|
|
+ adb_mutex_lock(&transport_lock);
|
|
for (const auto& transport : pending_list) {
|
|
if (transport->serial && strcmp(serial, transport->serial) == 0) {
|
|
+ adb_mutex_unlock(&transport_lock);
|
|
VLOG(TRANSPORT) << "socket transport " << transport->serial
|
|
<< " is already in pending_list and fails to register";
|
|
delete t;
|
|
@@ -959,6 +960,7 @@
|
|
|
|
for (const auto& transport : transport_list) {
|
|
if (transport->serial && strcmp(serial, transport->serial) == 0) {
|
|
+ adb_mutex_unlock(&transport_lock);
|
|
VLOG(TRANSPORT) << "socket transport " << transport->serial
|
|
<< " is already in transport_list and fails to register";
|
|
delete t;
|
|
@@ -968,8 +970,7 @@
|
|
|
|
pending_list.push_front(t);
|
|
t->serial = strdup(serial);
|
|
-
|
|
- lock.unlock();
|
|
+ adb_mutex_unlock(&transport_lock);
|
|
|
|
register_transport(t);
|
|
return 0;
|
|
@@ -979,19 +980,20 @@
|
|
atransport *find_transport(const char *serial) {
|
|
atransport* result = nullptr;
|
|
|
|
- std::lock_guard<std::mutex> lock(transport_lock);
|
|
+ adb_mutex_lock(&transport_lock);
|
|
for (auto& t : transport_list) {
|
|
if (t->serial && strcmp(serial, t->serial) == 0) {
|
|
result = t;
|
|
break;
|
|
}
|
|
}
|
|
+ adb_mutex_unlock(&transport_lock);
|
|
|
|
return result;
|
|
}
|
|
|
|
void kick_all_tcp_devices() {
|
|
- std::lock_guard<std::mutex> lock(transport_lock);
|
|
+ adb_mutex_lock(&transport_lock);
|
|
for (auto& t : transport_list) {
|
|
if (t->IsTcpDevice()) {
|
|
// Kicking breaks the read_transport thread of this transport out of any read, then
|
|
@@ -1001,6 +1003,7 @@
|
|
t->Kick();
|
|
}
|
|
}
|
|
+ adb_mutex_unlock(&transport_lock);
|
|
}
|
|
|
|
#endif
|
|
@@ -1020,20 +1023,20 @@
|
|
t->devpath = strdup(devpath);
|
|
}
|
|
|
|
- {
|
|
- std::lock_guard<std::mutex> lock(transport_lock);
|
|
- pending_list.push_front(t);
|
|
- }
|
|
+ adb_mutex_lock(&transport_lock);
|
|
+ pending_list.push_front(t);
|
|
+ adb_mutex_unlock(&transport_lock);
|
|
|
|
register_transport(t);
|
|
}
|
|
|
|
// This should only be used for transports with connection_state == kCsNoPerm.
|
|
void unregister_usb_transport(usb_handle *usb) {
|
|
- std::lock_guard<std::mutex> lock(transport_lock);
|
|
+ adb_mutex_lock(&transport_lock);
|
|
transport_list.remove_if([usb](atransport* t) {
|
|
return t->usb == usb && t->connection_state == kCsNoPerm;
|
|
});
|
|
+ adb_mutex_unlock(&transport_lock);
|
|
}
|
|
|
|
int check_header(apacket *p, atransport *t)
|
|
diff --git adb/transport_local.cpp adb/transport_local.cpp
|
|
index 89e950d..f895943 100644
|
|
--- adb/transport_local.cpp
|
|
+++ adb/transport_local.cpp
|
|
@@ -26,7 +26,6 @@
|
|
#include <sys/types.h>
|
|
|
|
#include <condition_variable>
|
|
-#include <mutex>
|
|
#include <vector>
|
|
|
|
#include <android-base/stringprintf.h>
|
|
@@ -48,7 +47,7 @@
|
|
// connected.
|
|
#define ADB_LOCAL_TRANSPORT_MAX 16
|
|
|
|
-static std::mutex& local_transports_lock = *new std::mutex();
|
|
+ADB_MUTEX_DEFINE(local_transports_lock);
|
|
|
|
/* we keep a list of opened transports. The atransport struct knows to which
|
|
* local transport it is connected. The list is used to detect when we're
|
|
@@ -385,13 +384,14 @@
|
|
|
|
#if ADB_HOST
|
|
int nn;
|
|
- std::lock_guard<std::mutex> lock(local_transports_lock);
|
|
+ adb_mutex_lock( &local_transports_lock );
|
|
for (nn = 0; nn < ADB_LOCAL_TRANSPORT_MAX; nn++) {
|
|
if (local_transports[nn] == t) {
|
|
local_transports[nn] = NULL;
|
|
break;
|
|
}
|
|
}
|
|
+ adb_mutex_unlock( &local_transports_lock );
|
|
#endif
|
|
}
|
|
|
|
@@ -435,8 +435,9 @@
|
|
|
|
atransport* find_emulator_transport_by_adb_port(int adb_port)
|
|
{
|
|
- std::lock_guard<std::mutex> lock(local_transports_lock);
|
|
+ adb_mutex_lock( &local_transports_lock );
|
|
atransport* result = find_emulator_transport_by_adb_port_locked(adb_port);
|
|
+ adb_mutex_unlock( &local_transports_lock );
|
|
return result;
|
|
}
|
|
|
|
@@ -454,8 +455,9 @@
|
|
|
|
int get_available_local_transport_index()
|
|
{
|
|
- std::lock_guard<std::mutex> lock(local_transports_lock);
|
|
+ adb_mutex_lock( &local_transports_lock );
|
|
int result = get_available_local_transport_index_locked();
|
|
+ adb_mutex_unlock( &local_transports_lock );
|
|
return result;
|
|
}
|
|
#endif
|
|
@@ -475,20 +477,26 @@
|
|
|
|
#if ADB_HOST
|
|
if (local) {
|
|
- std::lock_guard<std::mutex> lock(local_transports_lock);
|
|
- t->SetLocalPortForEmulator(adb_port);
|
|
- atransport* existing_transport = find_emulator_transport_by_adb_port_locked(adb_port);
|
|
- int index = get_available_local_transport_index_locked();
|
|
- if (existing_transport != NULL) {
|
|
- D("local transport for port %d already registered (%p)?", adb_port, existing_transport);
|
|
- fail = -1;
|
|
- } else if (index < 0) {
|
|
- // Too many emulators.
|
|
- D("cannot register more emulators. Maximum is %d", ADB_LOCAL_TRANSPORT_MAX);
|
|
- fail = -1;
|
|
- } else {
|
|
- local_transports[index] = t;
|
|
- }
|
|
+ adb_mutex_lock( &local_transports_lock );
|
|
+ {
|
|
+ t->SetLocalPortForEmulator(adb_port);
|
|
+ atransport* existing_transport =
|
|
+ find_emulator_transport_by_adb_port_locked(adb_port);
|
|
+ int index = get_available_local_transport_index_locked();
|
|
+ if (existing_transport != NULL) {
|
|
+ D("local transport for port %d already registered (%p)?",
|
|
+ adb_port, existing_transport);
|
|
+ fail = -1;
|
|
+ } else if (index < 0) {
|
|
+ // Too many emulators.
|
|
+ D("cannot register more emulators. Maximum is %d",
|
|
+ ADB_LOCAL_TRANSPORT_MAX);
|
|
+ fail = -1;
|
|
+ } else {
|
|
+ local_transports[index] = t;
|
|
+ }
|
|
+ }
|
|
+ adb_mutex_unlock( &local_transports_lock );
|
|
}
|
|
#endif
|
|
return fail;
|
|
diff --git adb/transport_test.cpp adb/transport_test.cpp
|
|
index a6db07a..8b38e03 100644
|
|
--- adb/transport_test.cpp
|
|
+++ adb/transport_test.cpp
|
|
@@ -20,6 +20,27 @@
|
|
|
|
#include "adb.h"
|
|
|
|
+class TransportSetup {
|
|
+public:
|
|
+ TransportSetup() {
|
|
+#ifdef _WIN32
|
|
+ // Use extern instead of including sysdeps.h which brings in various macros
|
|
+ // that conflict with APIs used in this file.
|
|
+ extern void adb_sysdeps_init(void);
|
|
+ adb_sysdeps_init();
|
|
+#else
|
|
+ // adb_sysdeps_init() is an inline function that we cannot link against.
|
|
+#endif
|
|
+ }
|
|
+};
|
|
+
|
|
+// Static initializer will call adb_sysdeps_init() before main() to initialize
|
|
+// the transport mutex before it is used in the tests. Alternatives would be to
|
|
+// use __attribute__((constructor)) here or to use that or a static initializer
|
|
+// for adb_sysdeps_init() itself in sysdeps_win32.cpp (caveats of unclear
|
|
+// init order), or to use a test fixture whose SetUp() could do the init once.
|
|
+static TransportSetup g_TransportSetup;
|
|
+
|
|
TEST(transport, kick_transport) {
|
|
atransport t;
|
|
static size_t kick_count;
|
|
diff --git adb/usb_linux_client.cpp adb/usb_linux_client.cpp
|
|
index 0ba6b4b..1b05439 100644
|
|
--- adb/usb_linux_client.cpp
|
|
+++ adb/usb_linux_client.cpp
|
|
@@ -32,8 +32,6 @@
|
|
|
|
#include <algorithm>
|
|
#include <atomic>
|
|
-#include <condition_variable>
|
|
-#include <mutex>
|
|
|
|
#include <android-base/logging.h>
|
|
|
|
@@ -56,14 +54,12 @@
|
|
|
|
static int dummy_fd = -1;
|
|
|
|
-struct usb_handle {
|
|
- usb_handle() : kicked(false) {
|
|
- }
|
|
-
|
|
- std::condition_variable notify;
|
|
- std::mutex lock;
|
|
+struct usb_handle
|
|
+{
|
|
+ adb_cond_t notify;
|
|
+ adb_mutex_t lock;
|
|
+ bool open_new_connection;
|
|
std::atomic<bool> kicked;
|
|
- bool open_new_connection = true;
|
|
|
|
int (*write)(usb_handle *h, const void *data, int len);
|
|
int (*read)(usb_handle *h, void *data, int len);
|
|
@@ -71,12 +67,12 @@
|
|
void (*close)(usb_handle *h);
|
|
|
|
// Legacy f_adb
|
|
- int fd = -1;
|
|
+ int fd;
|
|
|
|
// FunctionFS
|
|
- int control = -1;
|
|
- int bulk_out = -1; /* "out" from the host's perspective => source for adbd */
|
|
- int bulk_in = -1; /* "in" from the host's perspective => sink for adbd */
|
|
+ int control;
|
|
+ int bulk_out; /* "out" from the host's perspective => source for adbd */
|
|
+ int bulk_in; /* "in" from the host's perspective => sink for adbd */
|
|
};
|
|
|
|
struct func_desc {
|
|
@@ -252,12 +248,12 @@
|
|
|
|
while (true) {
|
|
// wait until the USB device needs opening
|
|
- std::unique_lock<std::mutex> lock(usb->lock);
|
|
+ adb_mutex_lock(&usb->lock);
|
|
while (!usb->open_new_connection) {
|
|
- usb->notify.wait(lock);
|
|
+ adb_cond_wait(&usb->notify, &usb->lock);
|
|
}
|
|
usb->open_new_connection = false;
|
|
- lock.unlock();
|
|
+ adb_mutex_unlock(&usb->lock);
|
|
|
|
D("[ usb_thread - opening device ]");
|
|
do {
|
|
@@ -343,20 +339,27 @@
|
|
h->kicked = false;
|
|
adb_close(h->fd);
|
|
// Notify usb_adb_open_thread to open a new connection.
|
|
- h->lock.lock();
|
|
+ adb_mutex_lock(&h->lock);
|
|
h->open_new_connection = true;
|
|
- h->lock.unlock();
|
|
- h->notify.notify_one();
|
|
+ adb_cond_signal(&h->notify);
|
|
+ adb_mutex_unlock(&h->lock);
|
|
}
|
|
|
|
static void usb_adb_init()
|
|
{
|
|
- usb_handle* h = new usb_handle();
|
|
+ usb_handle* h = reinterpret_cast<usb_handle*>(calloc(1, sizeof(usb_handle)));
|
|
+ if (h == nullptr) fatal("couldn't allocate usb_handle");
|
|
|
|
h->write = usb_adb_write;
|
|
h->read = usb_adb_read;
|
|
h->kick = usb_adb_kick;
|
|
h->close = usb_adb_close;
|
|
+ h->kicked = false;
|
|
+ h->fd = -1;
|
|
+
|
|
+ h->open_new_connection = true;
|
|
+ adb_cond_init(&h->notify, 0);
|
|
+ adb_mutex_init(&h->lock, 0);
|
|
|
|
// Open the file /dev/android_adb_enable to trigger
|
|
// the enabling of the adb USB function in the kernel.
|
|
@@ -465,12 +468,12 @@
|
|
|
|
while (true) {
|
|
// wait until the USB device needs opening
|
|
- std::unique_lock<std::mutex> lock(usb->lock);
|
|
+ adb_mutex_lock(&usb->lock);
|
|
while (!usb->open_new_connection) {
|
|
- usb->notify.wait(lock);
|
|
+ adb_cond_wait(&usb->notify, &usb->lock);
|
|
}
|
|
usb->open_new_connection = false;
|
|
- lock.unlock();
|
|
+ adb_mutex_unlock(&usb->lock);
|
|
|
|
while (true) {
|
|
if (init_functionfs(usb)) {
|
|
@@ -554,22 +557,31 @@
|
|
adb_close(h->bulk_out);
|
|
adb_close(h->bulk_in);
|
|
// Notify usb_adb_open_thread to open a new connection.
|
|
- h->lock.lock();
|
|
+ adb_mutex_lock(&h->lock);
|
|
h->open_new_connection = true;
|
|
- h->lock.unlock();
|
|
- h->notify.notify_one();
|
|
+ adb_cond_signal(&h->notify);
|
|
+ adb_mutex_unlock(&h->lock);
|
|
}
|
|
|
|
static void usb_ffs_init()
|
|
{
|
|
D("[ usb_init - using FunctionFS ]");
|
|
|
|
- usb_handle* h = new usb_handle();
|
|
+ usb_handle* h = reinterpret_cast<usb_handle*>(calloc(1, sizeof(usb_handle)));
|
|
+ if (h == nullptr) fatal("couldn't allocate usb_handle");
|
|
|
|
h->write = usb_ffs_write;
|
|
h->read = usb_ffs_read;
|
|
h->kick = usb_ffs_kick;
|
|
h->close = usb_ffs_close;
|
|
+ h->kicked = false;
|
|
+ h->control = -1;
|
|
+ h->bulk_out = -1;
|
|
+ h->bulk_out = -1;
|
|
+
|
|
+ h->open_new_connection = true;
|
|
+ adb_cond_init(&h->notify, 0);
|
|
+ adb_mutex_init(&h->lock, 0);
|
|
|
|
D("[ usb_init - starting thread ]");
|
|
if (!adb_thread_create(usb_ffs_open_thread, h)) {
|
|
@@ -596,7 +608,6 @@
|
|
{
|
|
return h->read(h, data, len);
|
|
}
|
|
-
|
|
int usb_close(usb_handle *h)
|
|
{
|
|
h->close(h);
|
|
diff --git adb/usb_windows.cpp adb/usb_windows.cpp
|
|
index 8ecca37..4649454 100644
|
|
--- adb/usb_windows.cpp
|
|
+++ adb/usb_windows.cpp
|
|
@@ -19,17 +19,13 @@
|
|
#include "sysdeps.h"
|
|
|
|
#include <winsock2.h> // winsock.h *must* be included before windows.h.
|
|
-#include <windows.h>
|
|
-#include <usb100.h>
|
|
-#include <winerror.h>
|
|
-
|
|
+#include <adb_api.h>
|
|
#include <errno.h>
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
-
|
|
-#include <mutex>
|
|
-
|
|
-#include <adb_api.h>
|
|
+#include <usb100.h>
|
|
+#include <windows.h>
|
|
+#include <winerror.h>
|
|
|
|
#include <android-base/errors.h>
|
|
|
|
@@ -77,7 +73,7 @@
|
|
};
|
|
|
|
/// Locker for the list of opened usb handles
|
|
-static std::mutex& usb_lock = *new std::mutex();
|
|
+ADB_MUTEX_DEFINE( usb_lock );
|
|
|
|
/// Checks if there is opened usb handle in handle_list for this device.
|
|
int known_device(const wchar_t* dev_name);
|
|
@@ -145,8 +141,9 @@
|
|
int ret = 0;
|
|
|
|
if (NULL != dev_name) {
|
|
- std::lock_guard<std::mutex> lock(usb_lock);
|
|
+ adb_mutex_lock(&usb_lock);
|
|
ret = known_device_locked(dev_name);
|
|
+ adb_mutex_unlock(&usb_lock);
|
|
}
|
|
|
|
return ret;
|
|
@@ -156,10 +153,11 @@
|
|
if (NULL == handle)
|
|
return 0;
|
|
|
|
- std::lock_guard<std::mutex> lock(usb_lock);
|
|
+ adb_mutex_lock(&usb_lock);
|
|
|
|
// Check if device is already in the list
|
|
if (known_device_locked(handle->interface_name)) {
|
|
+ adb_mutex_unlock(&usb_lock);
|
|
return 0;
|
|
}
|
|
|
|
@@ -169,6 +167,8 @@
|
|
handle->prev->next = handle;
|
|
handle->next->prev = handle;
|
|
|
|
+ adb_mutex_unlock(&usb_lock);
|
|
+
|
|
return 1;
|
|
}
|
|
|
|
@@ -493,8 +493,11 @@
|
|
void usb_kick(usb_handle* handle) {
|
|
D("usb_kick");
|
|
if (NULL != handle) {
|
|
- std::lock_guard<std::mutex> lock(usb_lock);
|
|
+ adb_mutex_lock(&usb_lock);
|
|
+
|
|
usb_kick_locked(handle);
|
|
+
|
|
+ adb_mutex_unlock(&usb_lock);
|
|
} else {
|
|
errno = EINVAL;
|
|
}
|
|
@@ -505,17 +508,17 @@
|
|
|
|
if (NULL != handle) {
|
|
// Remove handle from the list
|
|
- {
|
|
- std::lock_guard<std::mutex> lock(usb_lock);
|
|
-
|
|
- if ((handle->next != handle) && (handle->prev != handle)) {
|
|
- handle->next->prev = handle->prev;
|
|
- handle->prev->next = handle->next;
|
|
- handle->prev = handle;
|
|
- handle->next = handle;
|
|
- }
|
|
+ adb_mutex_lock(&usb_lock);
|
|
+
|
|
+ if ((handle->next != handle) && (handle->prev != handle)) {
|
|
+ handle->next->prev = handle->prev;
|
|
+ handle->prev->next = handle->next;
|
|
+ handle->prev = handle;
|
|
+ handle->next = handle;
|
|
}
|
|
|
|
+ adb_mutex_unlock(&usb_lock);
|
|
+
|
|
// Cleanup handle
|
|
usb_cleanup_handle(handle);
|
|
free(handle);
|
|
@@ -648,8 +651,9 @@
|
|
static void kick_devices() {
|
|
// Need to acquire lock to safely walk the list which might be modified
|
|
// by another thread.
|
|
- std::lock_guard<std::mutex> lock(usb_lock);
|
|
+ adb_mutex_lock(&usb_lock);
|
|
for (usb_handle* usb = handle_list.next; usb != &handle_list; usb = usb->next) {
|
|
usb_kick_locked(usb);
|
|
}
|
|
+ adb_mutex_unlock(&usb_lock);
|
|
}
|