sync/ports
1
0
Fork 0
mirror of https://git.freebsd.org/ports.git synced 2025-06-19 03:30:32 -04:00
Code Issues Projects Releases Packages Wiki Activity Actions
ports/devel/android-tools-adb-devel/files/patch-adb_mutex

995 lines
29 KiB
Text
Raw Blame History

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);
}
Reference in a new issue View git blame Copy permalink