sysdeps.h revision addab3d84dccd01cae9ca7b8a4b274b935f18fd4
1/* 2 * Copyright (C) 2007 The Android Open Source Project 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 17/* this file contains system-dependent definitions used by ADB 18 * they're related to threads, sockets and file descriptors 19 */ 20#ifndef _ADB_SYSDEPS_H 21#define _ADB_SYSDEPS_H 22 23#ifdef __CYGWIN__ 24# undef _WIN32 25#endif 26 27#include <errno.h> 28 29#include <string> 30#include <vector> 31 32// Include this before open/unlink are defined as macros below. 33#include <android-base/errors.h> 34#include <android-base/utf8.h> 35 36/* 37 * TEMP_FAILURE_RETRY is defined by some, but not all, versions of 38 * <unistd.h>. (Alas, it is not as standard as we'd hoped!) So, if it's 39 * not already defined, then define it here. 40 */ 41#ifndef TEMP_FAILURE_RETRY 42/* Used to retry syscalls that can return EINTR. */ 43#define TEMP_FAILURE_RETRY(exp) ({ \ 44 typeof (exp) _rc; \ 45 do { \ 46 _rc = (exp); \ 47 } while (_rc == -1 && errno == EINTR); \ 48 _rc; }) 49#endif 50 51// Some printf-like functions are implemented in terms of 52// android::base::StringAppendV, so they should use the same attribute for 53// compile-time format string checking. On Windows, if the mingw version of 54// vsnprintf is used in StringAppendV, use `gnu_printf' which allows z in %zd 55// and PRIu64 (and related) to be recognized by the compile-time checking. 56#define ADB_FORMAT_ARCHETYPE __printf__ 57#ifdef __USE_MINGW_ANSI_STDIO 58#if __USE_MINGW_ANSI_STDIO 59#undef ADB_FORMAT_ARCHETYPE 60#define ADB_FORMAT_ARCHETYPE gnu_printf 61#endif 62#endif 63 64#ifdef _WIN32 65 66// Clang-only nullability specifiers 67#define _Nonnull 68#define _Nullable 69 70#include <ctype.h> 71#include <direct.h> 72#include <dirent.h> 73#include <errno.h> 74#include <fcntl.h> 75#include <io.h> 76#include <process.h> 77#include <sys/stat.h> 78#include <utime.h> 79#include <winsock2.h> 80#include <windows.h> 81#include <ws2tcpip.h> 82 83#include <memory> // unique_ptr 84#include <string> 85 86#include "fdevent.h" 87 88#define OS_PATH_SEPARATORS "\\/" 89#define OS_PATH_SEPARATOR '\\' 90#define OS_PATH_SEPARATOR_STR "\\" 91#define ENV_PATH_SEPARATOR_STR ";" 92 93static __inline__ bool adb_is_separator(char c) { 94 return c == '\\' || c == '/'; 95} 96 97typedef CRITICAL_SECTION adb_mutex_t; 98 99#define ADB_MUTEX_DEFINE(x) adb_mutex_t x 100 101/* declare all mutexes */ 102/* For win32, adb_sysdeps_init() will do the mutex runtime initialization. */ 103#define ADB_MUTEX(x) extern adb_mutex_t x; 104#include "mutex_list.h" 105 106extern void adb_sysdeps_init(void); 107 108static __inline__ void adb_mutex_lock( adb_mutex_t* lock ) 109{ 110 EnterCriticalSection( lock ); 111} 112 113static __inline__ void adb_mutex_unlock( adb_mutex_t* lock ) 114{ 115 LeaveCriticalSection( lock ); 116} 117 118typedef void (*adb_thread_func_t)(void* arg); 119typedef HANDLE adb_thread_t; 120 121struct adb_winthread_args { 122 adb_thread_func_t func; 123 void* arg; 124}; 125 126static unsigned __stdcall adb_winthread_wrapper(void* heap_args) { 127 // Move the arguments from the heap onto the thread's stack. 128 adb_winthread_args thread_args = *static_cast<adb_winthread_args*>(heap_args); 129 delete static_cast<adb_winthread_args*>(heap_args); 130 thread_args.func(thread_args.arg); 131 return 0; 132} 133 134static __inline__ bool adb_thread_create(adb_thread_func_t func, void* arg, 135 adb_thread_t* thread = nullptr) { 136 adb_winthread_args* args = new adb_winthread_args{.func = func, .arg = arg}; 137 uintptr_t handle = _beginthreadex(nullptr, 0, adb_winthread_wrapper, args, 0, nullptr); 138 if (handle != static_cast<uintptr_t>(0)) { 139 if (thread) { 140 *thread = reinterpret_cast<HANDLE>(handle); 141 } else { 142 CloseHandle(thread); 143 } 144 return true; 145 } 146 return false; 147} 148 149static __inline__ bool adb_thread_join(adb_thread_t thread) { 150 switch (WaitForSingleObject(thread, INFINITE)) { 151 case WAIT_OBJECT_0: 152 CloseHandle(thread); 153 return true; 154 155 case WAIT_FAILED: 156 fprintf(stderr, "adb_thread_join failed: %s\n", 157 android::base::SystemErrorCodeToString(GetLastError()).c_str()); 158 break; 159 160 default: 161 abort(); 162 } 163 164 return false; 165} 166 167static __inline__ bool adb_thread_detach(adb_thread_t thread) { 168 CloseHandle(thread); 169 return true; 170} 171 172static __inline__ void __attribute__((noreturn)) adb_thread_exit() { 173 _endthreadex(0); 174} 175 176static __inline__ int adb_thread_setname(const std::string& name) { 177 // TODO: See https://msdn.microsoft.com/en-us/library/xcb2z8hs.aspx for how to set 178 // the thread name in Windows. Unfortunately, it only works during debugging, but 179 // our build process doesn't generate PDB files needed for debugging. 180 return 0; 181} 182 183static __inline__ adb_thread_t adb_thread_self() { 184 return GetCurrentThread(); 185} 186 187static __inline__ bool adb_thread_equal(adb_thread_t lhs, adb_thread_t rhs) { 188 return GetThreadId(lhs) == GetThreadId(rhs); 189} 190 191static __inline__ unsigned long adb_thread_id() 192{ 193 return GetCurrentThreadId(); 194} 195 196static __inline__ void close_on_exec(int fd) 197{ 198 /* nothing really */ 199} 200 201#define lstat stat /* no symlinks on Win32 */ 202 203#define S_ISLNK(m) 0 /* no symlinks on Win32 */ 204 205extern int adb_unlink(const char* path); 206#undef unlink 207#define unlink ___xxx_unlink 208 209extern int adb_mkdir(const std::string& path, int mode); 210#undef mkdir 211#define mkdir ___xxx_mkdir 212 213// See the comments for the !defined(_WIN32) versions of adb_*(). 214extern int adb_open(const char* path, int options); 215extern int adb_creat(const char* path, int mode); 216extern int adb_read(int fd, void* buf, int len); 217extern int adb_write(int fd, const void* buf, int len); 218extern int adb_lseek(int fd, int pos, int where); 219extern int adb_shutdown(int fd); 220extern int adb_close(int fd); 221 222// See the comments for the !defined(_WIN32) version of unix_close(). 223static __inline__ int unix_close(int fd) 224{ 225 return close(fd); 226} 227#undef close 228#define close ____xxx_close 229 230// Like unix_read(), but may return EINTR. 231extern int unix_read_interruptible(int fd, void* buf, size_t len); 232 233// See the comments for the !defined(_WIN32) version of unix_read(). 234static __inline__ int unix_read(int fd, void* buf, size_t len) { 235 return TEMP_FAILURE_RETRY(unix_read_interruptible(fd, buf, len)); 236} 237 238#undef read 239#define read ___xxx_read 240 241// See the comments for the !defined(_WIN32) version of unix_write(). 242static __inline__ int unix_write(int fd, const void* buf, size_t len) 243{ 244 return write(fd, buf, len); 245} 246#undef write 247#define write ___xxx_write 248 249// See the comments for the !defined(_WIN32) version of adb_open_mode(). 250static __inline__ int adb_open_mode(const char* path, int options, int mode) 251{ 252 return adb_open(path, options); 253} 254 255// See the comments for the !defined(_WIN32) version of unix_open(). 256extern int unix_open(const char* path, int options, ...); 257#define open ___xxx_unix_open 258 259// Checks if |fd| corresponds to a console. 260// Standard Windows isatty() returns 1 for both console FDs and character 261// devices like NUL. unix_isatty() performs some extra checking to only match 262// console FDs. 263// |fd| must be a real file descriptor, meaning STDxx_FILENO or unix_open() FDs 264// will work but adb_open() FDs will not. Additionally the OS handle associated 265// with |fd| must have GENERIC_READ access (which console FDs have by default). 266// Returns 1 if |fd| is a console FD, 0 otherwise. The value of errno after 267// calling this function is unreliable and should not be used. 268int unix_isatty(int fd); 269#define isatty ___xxx_isatty 270 271/* normally provided by <cutils/misc.h> */ 272extern void* load_file(const char* pathname, unsigned* psize); 273 274static __inline__ void adb_sleep_ms( int mseconds ) 275{ 276 Sleep( mseconds ); 277} 278 279int network_loopback_client(int port, int type, std::string* error); 280int network_loopback_server(int port, int type, std::string* error); 281int network_inaddr_any_server(int port, int type, std::string* error); 282int network_connect(const std::string& host, int port, int type, int timeout, 283 std::string* error); 284 285extern int adb_socket_accept(int serverfd, struct sockaddr* addr, socklen_t *addrlen); 286 287#undef accept 288#define accept ___xxx_accept 289 290extern int adb_setsockopt(int fd, int level, int optname, const void* optval, socklen_t optlen); 291 292#undef setsockopt 293#define setsockopt ___xxx_setsockopt 294 295extern int adb_socketpair( int sv[2] ); 296 297struct adb_pollfd { 298 int fd; 299 short events; 300 short revents; 301}; 302extern int adb_poll(adb_pollfd* fds, size_t nfds, int timeout); 303#define poll ___xxx_poll 304 305static __inline__ int adb_is_absolute_host_path(const char* path) { 306 return isalpha(path[0]) && path[1] == ':' && path[2] == '\\'; 307} 308 309// We later define a macro mapping 'stat' to 'adb_stat'. This causes: 310// struct stat s; 311// stat(filename, &s); 312// To turn into the following: 313// struct adb_stat s; 314// adb_stat(filename, &s); 315// To get this to work, we need to make 'struct adb_stat' the same as 316// 'struct stat'. Note that this definition of 'struct adb_stat' uses the 317// *current* macro definition of stat, so it may actually be inheriting from 318// struct _stat32i64 (or some other remapping). 319struct adb_stat : public stat {}; 320 321static_assert(sizeof(struct adb_stat) == sizeof(struct stat), 322 "structures should be the same"); 323 324extern int adb_stat(const char* f, struct adb_stat* s); 325 326// stat is already a macro, undefine it so we can redefine it. 327#undef stat 328#define stat adb_stat 329 330// UTF-8 versions of POSIX APIs. 331extern DIR* adb_opendir(const char* dirname); 332extern struct dirent* adb_readdir(DIR* dir); 333extern int adb_closedir(DIR* dir); 334 335extern int adb_utime(const char *, struct utimbuf *); 336extern int adb_chmod(const char *, int); 337 338extern int adb_vfprintf(FILE *stream, const char *format, va_list ap) 339 __attribute__((__format__(ADB_FORMAT_ARCHETYPE, 2, 0))); 340extern int adb_vprintf(const char *format, va_list ap) 341 __attribute__((__format__(ADB_FORMAT_ARCHETYPE, 1, 0))); 342extern int adb_fprintf(FILE *stream, const char *format, ...) 343 __attribute__((__format__(ADB_FORMAT_ARCHETYPE, 2, 3))); 344extern int adb_printf(const char *format, ...) 345 __attribute__((__format__(ADB_FORMAT_ARCHETYPE, 1, 2))); 346 347extern int adb_fputs(const char* buf, FILE* stream); 348extern int adb_fputc(int ch, FILE* stream); 349extern int adb_putchar(int ch); 350extern int adb_puts(const char* buf); 351extern size_t adb_fwrite(const void* ptr, size_t size, size_t nmemb, 352 FILE* stream); 353 354extern FILE* adb_fopen(const char* f, const char* m); 355 356extern char* adb_getenv(const char* name); 357 358extern char* adb_getcwd(char* buf, int size); 359 360// Remap calls to POSIX APIs to our UTF-8 versions. 361#define opendir adb_opendir 362#define readdir adb_readdir 363#define closedir adb_closedir 364#define rewinddir rewinddir_utf8_not_yet_implemented 365#define telldir telldir_utf8_not_yet_implemented 366// Some compiler's C++ headers have members named seekdir, so we can't do the 367// macro technique and instead cause a link error if seekdir is called. 368inline void seekdir(DIR*, long) { 369 extern int seekdir_utf8_not_yet_implemented; 370 seekdir_utf8_not_yet_implemented = 1; 371} 372 373#define utime adb_utime 374#define chmod adb_chmod 375 376#define vfprintf adb_vfprintf 377#define vprintf adb_vprintf 378#define fprintf adb_fprintf 379#define printf adb_printf 380#define fputs adb_fputs 381#define fputc adb_fputc 382// putc may be a macro, so if so, undefine it, so that we can redefine it. 383#undef putc 384#define putc(c, s) adb_fputc(c, s) 385#define putchar adb_putchar 386#define puts adb_puts 387#define fwrite adb_fwrite 388 389#define fopen adb_fopen 390#define freopen freopen_utf8_not_yet_implemented 391 392#define getenv adb_getenv 393#define putenv putenv_utf8_not_yet_implemented 394#define setenv setenv_utf8_not_yet_implemented 395#define unsetenv unsetenv_utf8_not_yet_implemented 396 397#define getcwd adb_getcwd 398 399char* adb_strerror(int err); 400#define strerror adb_strerror 401 402// Helper class to convert UTF-16 argv from wmain() to UTF-8 args that can be 403// passed to main(). 404class NarrowArgs { 405public: 406 NarrowArgs(int argc, wchar_t** argv); 407 ~NarrowArgs(); 408 409 inline char** data() { 410 return narrow_args; 411 } 412 413private: 414 char** narrow_args; 415}; 416 417// Windows HANDLE values only use 32-bits of the type, even on 64-bit machines, 418// so they can fit in an int. To convert back, we just need to sign-extend. 419// https://msdn.microsoft.com/en-us/library/windows/desktop/aa384203%28v=vs.85%29.aspx 420// Note that this does not make a HANDLE value work with APIs like open(), nor 421// does this make a value from open() passable to APIs taking a HANDLE. This 422// just lets you take a HANDLE, pass it around as an int, and then use it again 423// as a HANDLE. 424inline int cast_handle_to_int(const HANDLE h) { 425 // truncate 426 return static_cast<int>(reinterpret_cast<INT_PTR>(h)); 427} 428 429inline HANDLE cast_int_to_handle(const int fd) { 430 // sign-extend 431 return reinterpret_cast<HANDLE>(static_cast<INT_PTR>(fd)); 432} 433 434// Deleter for unique_handle. Adapted from many sources, including: 435// http://stackoverflow.com/questions/14841396/stdunique-ptr-deleters-and-the-win32-api 436// https://visualstudiomagazine.com/articles/2013/09/01/get-a-handle-on-the-windows-api.aspx 437class handle_deleter { 438public: 439 typedef HANDLE pointer; 440 441 void operator()(HANDLE h); 442}; 443 444// Like std::unique_ptr, but for Windows HANDLE objects that should be 445// CloseHandle()'d. Operator bool() only checks if the handle != nullptr, 446// but does not check if the handle != INVALID_HANDLE_VALUE. 447typedef std::unique_ptr<HANDLE, handle_deleter> unique_handle; 448 449namespace internal { 450 451size_t ParseCompleteUTF8(const char* first, const char* last, std::vector<char>* remaining_bytes); 452 453} 454 455#else /* !_WIN32 a.k.a. Unix */ 456 457#include <cutils/misc.h> 458#include <cutils/sockets.h> 459#include <cutils/threads.h> 460#include <fcntl.h> 461#include <poll.h> 462#include <signal.h> 463#include <sys/stat.h> 464#include <sys/wait.h> 465 466#include <pthread.h> 467#include <unistd.h> 468#include <fcntl.h> 469#include <stdarg.h> 470#include <netdb.h> 471#include <netinet/in.h> 472#include <netinet/tcp.h> 473#include <string.h> 474#include <unistd.h> 475 476#include <string> 477 478#define OS_PATH_SEPARATORS "/" 479#define OS_PATH_SEPARATOR '/' 480#define OS_PATH_SEPARATOR_STR "/" 481#define ENV_PATH_SEPARATOR_STR ":" 482 483static __inline__ bool adb_is_separator(char c) { 484 return c == '/'; 485} 486 487typedef pthread_mutex_t adb_mutex_t; 488 489#define ADB_MUTEX_INITIALIZER PTHREAD_MUTEX_INITIALIZER 490#define adb_mutex_init pthread_mutex_init 491#define adb_mutex_lock pthread_mutex_lock 492#define adb_mutex_unlock pthread_mutex_unlock 493#define adb_mutex_destroy pthread_mutex_destroy 494 495#define ADB_MUTEX_DEFINE(m) adb_mutex_t m = PTHREAD_MUTEX_INITIALIZER 496 497#define adb_cond_t pthread_cond_t 498#define adb_cond_init pthread_cond_init 499#define adb_cond_wait pthread_cond_wait 500#define adb_cond_broadcast pthread_cond_broadcast 501#define adb_cond_signal pthread_cond_signal 502#define adb_cond_destroy pthread_cond_destroy 503 504/* declare all mutexes */ 505#define ADB_MUTEX(x) extern adb_mutex_t x; 506#include "mutex_list.h" 507 508static __inline__ void close_on_exec(int fd) 509{ 510 fcntl( fd, F_SETFD, FD_CLOEXEC ); 511} 512 513// Open a file and return a file descriptor that may be used with unix_read(), 514// unix_write(), unix_close(), but not adb_read(), adb_write(), adb_close(). 515// 516// On Unix, this is based on open(), so the file descriptor is a real OS file 517// descriptor, but the Windows implementation (in sysdeps_win32.cpp) returns a 518// file descriptor that can only be used with C Runtime APIs (which are wrapped 519// by unix_read(), unix_write(), unix_close()). Also, the C Runtime has 520// configurable CR/LF translation which defaults to text mode, but is settable 521// with _setmode(). 522static __inline__ int unix_open(const char* path, int options,...) 523{ 524 if ((options & O_CREAT) == 0) 525 { 526 return TEMP_FAILURE_RETRY( open(path, options) ); 527 } 528 else 529 { 530 int mode; 531 va_list args; 532 va_start( args, options ); 533 mode = va_arg( args, int ); 534 va_end( args ); 535 return TEMP_FAILURE_RETRY( open( path, options, mode ) ); 536 } 537} 538 539// Similar to the two-argument adb_open(), but takes a mode parameter for file 540// creation. See adb_open() for more info. 541static __inline__ int adb_open_mode( const char* pathname, int options, int mode ) 542{ 543 return TEMP_FAILURE_RETRY( open( pathname, options, mode ) ); 544} 545 546 547// Open a file and return a file descriptor that may be used with adb_read(), 548// adb_write(), adb_close(), but not unix_read(), unix_write(), unix_close(). 549// 550// On Unix, this is based on open(), but the Windows implementation (in 551// sysdeps_win32.cpp) uses Windows native file I/O and bypasses the C Runtime 552// and its CR/LF translation. The returned file descriptor should be used with 553// adb_read(), adb_write(), adb_close(), etc. 554static __inline__ int adb_open( const char* pathname, int options ) 555{ 556 int fd = TEMP_FAILURE_RETRY( open( pathname, options ) ); 557 if (fd < 0) 558 return -1; 559 close_on_exec( fd ); 560 return fd; 561} 562#undef open 563#define open ___xxx_open 564 565static __inline__ int adb_shutdown(int fd) 566{ 567 return shutdown(fd, SHUT_RDWR); 568} 569static __inline__ int adb_shutdown(int fd, int direction) 570{ 571 return shutdown(fd, direction); 572} 573#undef shutdown 574#define shutdown ____xxx_shutdown 575 576// Closes a file descriptor that came from adb_open() or adb_open_mode(), but 577// not designed to take a file descriptor from unix_open(). See the comments 578// for adb_open() for more info. 579static __inline__ int adb_close(int fd) 580{ 581 return close(fd); 582} 583#undef close 584#define close ____xxx_close 585 586 587static __inline__ int adb_read(int fd, void* buf, size_t len) 588{ 589 return TEMP_FAILURE_RETRY( read( fd, buf, len ) ); 590} 591 592// Like unix_read(), but does not handle EINTR. 593static __inline__ int unix_read_interruptible(int fd, void* buf, size_t len) { 594 return read(fd, buf, len); 595} 596 597#undef read 598#define read ___xxx_read 599 600static __inline__ int adb_write(int fd, const void* buf, size_t len) 601{ 602 return TEMP_FAILURE_RETRY( write( fd, buf, len ) ); 603} 604#undef write 605#define write ___xxx_write 606 607static __inline__ int adb_lseek(int fd, int pos, int where) 608{ 609 return lseek(fd, pos, where); 610} 611#undef lseek 612#define lseek ___xxx_lseek 613 614static __inline__ int adb_unlink(const char* path) 615{ 616 return unlink(path); 617} 618#undef unlink 619#define unlink ___xxx_unlink 620 621static __inline__ int adb_creat(const char* path, int mode) 622{ 623 int fd = TEMP_FAILURE_RETRY( creat( path, mode ) ); 624 625 if ( fd < 0 ) 626 return -1; 627 628 close_on_exec(fd); 629 return fd; 630} 631#undef creat 632#define creat ___xxx_creat 633 634static __inline__ int unix_isatty(int fd) { 635 return isatty(fd); 636} 637#define isatty ___xxx_isatty 638 639// Helper for network_* functions. 640inline int _fd_set_error_str(int fd, std::string* error) { 641 if (fd == -1) { 642 *error = strerror(errno); 643 } 644 return fd; 645} 646 647inline int network_loopback_client(int port, int type, std::string* error) { 648 return _fd_set_error_str(socket_loopback_client(port, type), error); 649} 650 651inline int network_loopback_server(int port, int type, std::string* error) { 652 return _fd_set_error_str(socket_loopback_server(port, type), error); 653} 654 655inline int network_inaddr_any_server(int port, int type, std::string* error) { 656 return _fd_set_error_str(socket_inaddr_any_server(port, type), error); 657} 658 659inline int network_local_server(const char *name, int namespace_id, int type, 660 std::string* error) { 661 return _fd_set_error_str(socket_local_server(name, namespace_id, type), 662 error); 663} 664 665inline int network_connect(const std::string& host, int port, int type, 666 int timeout, std::string* error) { 667 int getaddrinfo_error = 0; 668 int fd = socket_network_client_timeout(host.c_str(), port, type, timeout, 669 &getaddrinfo_error); 670 if (fd != -1) { 671 return fd; 672 } 673 if (getaddrinfo_error != 0) { 674 *error = gai_strerror(getaddrinfo_error); 675 } else { 676 *error = strerror(errno); 677 } 678 return -1; 679} 680 681static __inline__ int adb_socket_accept(int serverfd, struct sockaddr* addr, socklen_t *addrlen) 682{ 683 int fd; 684 685 fd = TEMP_FAILURE_RETRY( accept( serverfd, addr, addrlen ) ); 686 if (fd >= 0) 687 close_on_exec(fd); 688 689 return fd; 690} 691 692#undef accept 693#define accept ___xxx_accept 694 695// Operate on a file descriptor returned from unix_open() or a well-known file 696// descriptor such as STDIN_FILENO, STDOUT_FILENO, STDERR_FILENO. 697// 698// On Unix, unix_read(), unix_write(), unix_close() map to adb_read(), 699// adb_write(), adb_close() (which all map to Unix system calls), but the 700// Windows implementations (in the ifdef above and in sysdeps_win32.cpp) call 701// into the C Runtime and its configurable CR/LF translation (which is settable 702// via _setmode()). 703#define unix_read adb_read 704#define unix_write adb_write 705#define unix_close adb_close 706 707// Win32 is limited to DWORDs for thread return values; limit the POSIX systems to this as well to 708// ensure compatibility. 709typedef void (*adb_thread_func_t)(void* arg); 710typedef pthread_t adb_thread_t; 711 712struct adb_pthread_args { 713 adb_thread_func_t func; 714 void* arg; 715}; 716 717static void* adb_pthread_wrapper(void* heap_args) { 718 // Move the arguments from the heap onto the thread's stack. 719 adb_pthread_args thread_args = *reinterpret_cast<adb_pthread_args*>(heap_args); 720 delete static_cast<adb_pthread_args*>(heap_args); 721 thread_args.func(thread_args.arg); 722 return nullptr; 723} 724 725static __inline__ bool adb_thread_create(adb_thread_func_t start, void* arg, 726 adb_thread_t* thread = nullptr) { 727 pthread_t temp; 728 pthread_attr_t attr; 729 pthread_attr_init(&attr); 730 pthread_attr_setdetachstate(&attr, thread ? PTHREAD_CREATE_JOINABLE : PTHREAD_CREATE_DETACHED); 731 auto* pthread_args = new adb_pthread_args{.func = start, .arg = arg}; 732 errno = pthread_create(&temp, &attr, adb_pthread_wrapper, pthread_args); 733 if (errno == 0) { 734 if (thread) { 735 *thread = temp; 736 } 737 return true; 738 } 739 return false; 740} 741 742static __inline__ bool adb_thread_join(adb_thread_t thread) { 743 errno = pthread_join(thread, nullptr); 744 return errno == 0; 745} 746 747static __inline__ bool adb_thread_detach(adb_thread_t thread) { 748 errno = pthread_detach(thread); 749 return errno == 0; 750} 751 752static __inline__ void __attribute__((noreturn)) adb_thread_exit() { 753 pthread_exit(nullptr); 754} 755 756static __inline__ int adb_thread_setname(const std::string& name) { 757#ifdef __APPLE__ 758 return pthread_setname_np(name.c_str()); 759#else 760 const char *s = name.c_str(); 761 762 // pthread_setname_np fails rather than truncating long strings. 763 const int max_task_comm_len = 16; // including the null terminator 764 if (name.length() > (max_task_comm_len - 1)) { 765 char buf[max_task_comm_len]; 766 strncpy(buf, name.c_str(), sizeof(buf) - 1); 767 buf[sizeof(buf) - 1] = '\0'; 768 s = buf; 769 } 770 771 return pthread_setname_np(pthread_self(), s) ; 772#endif 773} 774 775static __inline__ int adb_setsockopt( int fd, int level, int optname, const void* optval, socklen_t optlen ) 776{ 777 return setsockopt( fd, level, optname, optval, optlen ); 778} 779 780#undef setsockopt 781#define setsockopt ___xxx_setsockopt 782 783static __inline__ int unix_socketpair( int d, int type, int protocol, int sv[2] ) 784{ 785 return socketpair( d, type, protocol, sv ); 786} 787 788static __inline__ int adb_socketpair( int sv[2] ) 789{ 790 int rc; 791 792 rc = unix_socketpair( AF_UNIX, SOCK_STREAM, 0, sv ); 793 if (rc < 0) 794 return -1; 795 796 close_on_exec( sv[0] ); 797 close_on_exec( sv[1] ); 798 return 0; 799} 800 801#undef socketpair 802#define socketpair ___xxx_socketpair 803 804typedef struct pollfd adb_pollfd; 805static __inline__ int adb_poll(adb_pollfd* fds, size_t nfds, int timeout) { 806 return TEMP_FAILURE_RETRY(poll(fds, nfds, timeout)); 807} 808 809#define poll ___xxx_poll 810 811static __inline__ void adb_sleep_ms( int mseconds ) 812{ 813 usleep( mseconds*1000 ); 814} 815 816static __inline__ int adb_mkdir(const std::string& path, int mode) 817{ 818 return mkdir(path.c_str(), mode); 819} 820 821#undef mkdir 822#define mkdir ___xxx_mkdir 823 824static __inline__ void adb_sysdeps_init(void) 825{ 826} 827 828static __inline__ int adb_is_absolute_host_path(const char* path) { 829 return path[0] == '/'; 830} 831 832static __inline__ unsigned long adb_thread_id() 833{ 834 return (unsigned long)gettid(); 835} 836 837#endif /* !_WIN32 */ 838 839static inline void disable_tcp_nagle(int fd) { 840 int off = 1; 841 adb_setsockopt(fd, IPPROTO_TCP, TCP_NODELAY, &off, sizeof(off)); 842} 843 844#endif /* _ADB_SYSDEPS_H */ 845