From 39d58e2f49f4b073ded3dbf639fd55730fa520a0 Mon Sep 17 00:00:00 2001 From: Ingo Weinhold Date: Sun, 22 Mar 2009 15:43:03 +0000 Subject: [PATCH] Experimental approach to tackle the problem with Be's negative error codes and ported software: * If the macro B_USE_POSITIVE_POSIX_ERRORS is defined the POSIX error code constants (ENOMEM, EINTR,...) will have positive values. * Introduced the macros B_TO_{POSITIVE,NEGATIVE}_ERROR() which do convert a given error code to a positive/negative value. * Added static library libposix_error_mapper.a that overrides all POSIX functions (save the ones I forgot to add :-)) directly meddling with error codes (having them as parameter or returning them) dealing with the positive<->negative error code conversions. The functions have hidden visibility, so they affect only the shared object they are linked into. * So ideally all one has to do is to build a ported software with -DB_USE_POSITIVE_POSIX_ERRORS and -lposix_error_mapper and be good with respect to error code problems. * Potential issues: - When mixing ported and Haiku native code, i.e. using Haiku native code in a ported software or using a ported library in a Haiku native application care must be taken to convert error codes where the two interface. That's what the B_TO_{POSITIVE,NEGATIVE}_ERROR() macros are supposed to be used for. - A ported static library can obviously not be linked directly against -lposix_error_mapper. The shared object linking a against the ported static library has to do that. The previous point applies when that causes mixing with Haiku native code. - When dependent ported libraries are used probably all of them should use the error mapping. Comments welcome. git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@29653 a95241bf-73f2-0310-859d-f6bbb57e9c96 --- build/jam/OptionalPackages | 3 + headers/os/support/Errors.h | 211 ++++++++------ src/libs/Jamfile | 1 + src/libs/posix_error_mapper/Jamfile | 15 + src/libs/posix_error_mapper/misc.cpp | 57 ++++ .../posix_error_mapper/posix_error_mapper.h | 28 ++ src/libs/posix_error_mapper/pthread_attr.cpp | 60 ++++ src/libs/posix_error_mapper/pthread_cond.cpp | 267 ++++++++++++++++++ .../posix_error_mapper/pthread_condattr.cpp | 34 +++ src/libs/posix_error_mapper/pthread_misc.cpp | 20 ++ src/libs/posix_error_mapper/pthread_mutex.cpp | 55 ++++ .../posix_error_mapper/pthread_mutexattr.cpp | 76 +++++ .../posix_error_mapper/pthread_rwlock.cpp | 56 ++++ .../posix_error_mapper/pthread_rwlockattr.cpp | 34 +++ .../posix_error_mapper/pthread_specific.cpp | 25 ++ .../posix_error_mapper/pthread_thread.cpp | 52 ++++ src/system/libroot/posix/errno.c | 20 +- src/system/libroot/posix/string/strerror.c | 1 + 18 files changed, 924 insertions(+), 91 deletions(-) create mode 100644 src/libs/posix_error_mapper/Jamfile create mode 100644 src/libs/posix_error_mapper/misc.cpp create mode 100644 src/libs/posix_error_mapper/posix_error_mapper.h create mode 100644 src/libs/posix_error_mapper/pthread_attr.cpp create mode 100644 src/libs/posix_error_mapper/pthread_cond.cpp create mode 100644 src/libs/posix_error_mapper/pthread_condattr.cpp create mode 100644 src/libs/posix_error_mapper/pthread_misc.cpp create mode 100644 src/libs/posix_error_mapper/pthread_mutex.cpp create mode 100644 src/libs/posix_error_mapper/pthread_mutexattr.cpp create mode 100644 src/libs/posix_error_mapper/pthread_rwlock.cpp create mode 100644 src/libs/posix_error_mapper/pthread_rwlockattr.cpp create mode 100644 src/libs/posix_error_mapper/pthread_specific.cpp create mode 100644 src/libs/posix_error_mapper/pthread_thread.cpp diff --git a/build/jam/OptionalPackages b/build/jam/OptionalPackages index cf9facd56d..57564c0464 100644 --- a/build/jam/OptionalPackages +++ b/build/jam/OptionalPackages @@ -194,6 +194,9 @@ if [ IsOptionalHaikuImagePackageAdded Development ] && $(TARGET_ARCH) = x86 { # static libraries AddFilesToHaikuImage develop lib x86 : libncurses.a ; + # the POSIX error code mapper library + AddFilesToHaikuImage develop lib x86 : libposix_error_mapper.a ; + # cc and c++ wrapper scripts AddFilesToHaikuImage beos bin : cc c++ ; diff --git a/headers/os/support/Errors.h b/headers/os/support/Errors.h index a8a0064f16..dabeacee8d 100644 --- a/headers/os/support/Errors.h +++ b/headers/os/support/Errors.h @@ -114,100 +114,115 @@ #define B_PARTITION_TOO_SMALL (B_STORAGE_ERROR_BASE + 15) /* POSIX Errors */ -#define E2BIG (B_POSIX_ERROR_BASE + 1) -#define ECHILD (B_POSIX_ERROR_BASE + 2) -#define EDEADLK (B_POSIX_ERROR_BASE + 3) -#define EFBIG (B_POSIX_ERROR_BASE + 4) -#define EMLINK (B_POSIX_ERROR_BASE + 5) -#define ENFILE (B_POSIX_ERROR_BASE + 6) -#define ENODEV (B_POSIX_ERROR_BASE + 7) -#define ENOLCK (B_POSIX_ERROR_BASE + 8) -#define ENOSYS (B_POSIX_ERROR_BASE + 9) -#define ENOTTY (B_POSIX_ERROR_BASE + 10) -#define ENXIO (B_POSIX_ERROR_BASE + 11) -#define ESPIPE (B_POSIX_ERROR_BASE + 12) -#define ESRCH (B_POSIX_ERROR_BASE + 13) -#define EFPOS (B_POSIX_ERROR_BASE + 14) -#define ESIGPARM (B_POSIX_ERROR_BASE + 15) -#define EDOM (B_POSIX_ERROR_BASE + 16) -#define ERANGE (B_POSIX_ERROR_BASE + 17) -#define EPROTOTYPE (B_POSIX_ERROR_BASE + 18) -#define EPROTONOSUPPORT (B_POSIX_ERROR_BASE + 19) -#define EPFNOSUPPORT (B_POSIX_ERROR_BASE + 20) -#define EAFNOSUPPORT (B_POSIX_ERROR_BASE + 21) -#define EADDRINUSE (B_POSIX_ERROR_BASE + 22) -#define EADDRNOTAVAIL (B_POSIX_ERROR_BASE + 23) -#define ENETDOWN (B_POSIX_ERROR_BASE + 24) -#define ENETUNREACH (B_POSIX_ERROR_BASE + 25) -#define ENETRESET (B_POSIX_ERROR_BASE + 26) -#define ECONNABORTED (B_POSIX_ERROR_BASE + 27) -#define ECONNRESET (B_POSIX_ERROR_BASE + 28) -#define EISCONN (B_POSIX_ERROR_BASE + 29) -#define ENOTCONN (B_POSIX_ERROR_BASE + 30) -#define ESHUTDOWN (B_POSIX_ERROR_BASE + 31) -#define ECONNREFUSED (B_POSIX_ERROR_BASE + 32) -#define EHOSTUNREACH (B_POSIX_ERROR_BASE + 33) -#define ENOPROTOOPT (B_POSIX_ERROR_BASE + 34) -#define ENOBUFS (B_POSIX_ERROR_BASE + 35) -#define EINPROGRESS (B_POSIX_ERROR_BASE + 36) -#define EALREADY (B_POSIX_ERROR_BASE + 37) -#define EILSEQ (B_POSIX_ERROR_BASE + 38) -#define ENOMSG (B_POSIX_ERROR_BASE + 39) -#define ESTALE (B_POSIX_ERROR_BASE + 40) -#define EOVERFLOW (B_POSIX_ERROR_BASE + 41) -#define EMSGSIZE (B_POSIX_ERROR_BASE + 42) -#define EOPNOTSUPP (B_POSIX_ERROR_BASE + 43) -#define ENOTSOCK (B_POSIX_ERROR_BASE + 44) -#define EHOSTDOWN (B_POSIX_ERROR_BASE + 45) -#define EBADMSG (B_POSIX_ERROR_BASE + 46) -#define ECANCELED (B_POSIX_ERROR_BASE + 47) -#define EDESTADDRREQ (B_POSIX_ERROR_BASE + 48) -#define EDQUOT (B_POSIX_ERROR_BASE + 49) -#define EIDRM (B_POSIX_ERROR_BASE + 50) -#define EMULTIHOP (B_POSIX_ERROR_BASE + 51) -#define ENODATA (B_POSIX_ERROR_BASE + 52) -#define ENOLINK (B_POSIX_ERROR_BASE + 53) -#define ENOSR (B_POSIX_ERROR_BASE + 54) -#define ENOSTR (B_POSIX_ERROR_BASE + 55) -#define ENOTSUP (B_POSIX_ERROR_BASE + 56) -#define EPROTO (B_POSIX_ERROR_BASE + 57) -#define ETIME (B_POSIX_ERROR_BASE + 58) -#define ETXTBSY (B_POSIX_ERROR_BASE + 59) +#ifdef B_USE_POSITIVE_POSIX_ERRORS +# define B_TO_POSIX_ERROR(error) (-(error)) +# define B_FROM_POSIX_ERROR(error) (-(error)) +#else +# define B_TO_POSIX_ERROR(error) (error) +# define B_FROM_POSIX_ERROR(error) (error) +#endif + +#define B_POSIX_ENOMEM B_TO_POSIX_ERROR(B_POSIX_ERROR_BASE + 0) +#define E2BIG B_TO_POSIX_ERROR(B_POSIX_ERROR_BASE + 1) +#define ECHILD B_TO_POSIX_ERROR(B_POSIX_ERROR_BASE + 2) +#define EDEADLK B_TO_POSIX_ERROR(B_POSIX_ERROR_BASE + 3) +#define EFBIG B_TO_POSIX_ERROR(B_POSIX_ERROR_BASE + 4) +#define EMLINK B_TO_POSIX_ERROR(B_POSIX_ERROR_BASE + 5) +#define ENFILE B_TO_POSIX_ERROR(B_POSIX_ERROR_BASE + 6) +#define ENODEV B_TO_POSIX_ERROR(B_POSIX_ERROR_BASE + 7) +#define ENOLCK B_TO_POSIX_ERROR(B_POSIX_ERROR_BASE + 8) +#define ENOSYS B_TO_POSIX_ERROR(B_POSIX_ERROR_BASE + 9) +#define ENOTTY B_TO_POSIX_ERROR(B_POSIX_ERROR_BASE + 10) +#define ENXIO B_TO_POSIX_ERROR(B_POSIX_ERROR_BASE + 11) +#define ESPIPE B_TO_POSIX_ERROR(B_POSIX_ERROR_BASE + 12) +#define ESRCH B_TO_POSIX_ERROR(B_POSIX_ERROR_BASE + 13) +#define EFPOS B_TO_POSIX_ERROR(B_POSIX_ERROR_BASE + 14) +#define ESIGPARM B_TO_POSIX_ERROR(B_POSIX_ERROR_BASE + 15) +#define EDOM B_TO_POSIX_ERROR(B_POSIX_ERROR_BASE + 16) +#define ERANGE B_TO_POSIX_ERROR(B_POSIX_ERROR_BASE + 17) +#define EPROTOTYPE B_TO_POSIX_ERROR(B_POSIX_ERROR_BASE + 18) +#define EPROTONOSUPPORT B_TO_POSIX_ERROR(B_POSIX_ERROR_BASE + 19) +#define EPFNOSUPPORT B_TO_POSIX_ERROR(B_POSIX_ERROR_BASE + 20) +#define EAFNOSUPPORT B_TO_POSIX_ERROR(B_POSIX_ERROR_BASE + 21) +#define EADDRINUSE B_TO_POSIX_ERROR(B_POSIX_ERROR_BASE + 22) +#define EADDRNOTAVAIL B_TO_POSIX_ERROR(B_POSIX_ERROR_BASE + 23) +#define ENETDOWN B_TO_POSIX_ERROR(B_POSIX_ERROR_BASE + 24) +#define ENETUNREACH B_TO_POSIX_ERROR(B_POSIX_ERROR_BASE + 25) +#define ENETRESET B_TO_POSIX_ERROR(B_POSIX_ERROR_BASE + 26) +#define ECONNABORTED B_TO_POSIX_ERROR(B_POSIX_ERROR_BASE + 27) +#define ECONNRESET B_TO_POSIX_ERROR(B_POSIX_ERROR_BASE + 28) +#define EISCONN B_TO_POSIX_ERROR(B_POSIX_ERROR_BASE + 29) +#define ENOTCONN B_TO_POSIX_ERROR(B_POSIX_ERROR_BASE + 30) +#define ESHUTDOWN B_TO_POSIX_ERROR(B_POSIX_ERROR_BASE + 31) +#define ECONNREFUSED B_TO_POSIX_ERROR(B_POSIX_ERROR_BASE + 32) +#define EHOSTUNREACH B_TO_POSIX_ERROR(B_POSIX_ERROR_BASE + 33) +#define ENOPROTOOPT B_TO_POSIX_ERROR(B_POSIX_ERROR_BASE + 34) +#define ENOBUFS B_TO_POSIX_ERROR(B_POSIX_ERROR_BASE + 35) +#define EINPROGRESS B_TO_POSIX_ERROR(B_POSIX_ERROR_BASE + 36) +#define EALREADY B_TO_POSIX_ERROR(B_POSIX_ERROR_BASE + 37) +#define EILSEQ B_TO_POSIX_ERROR(B_POSIX_ERROR_BASE + 38) +#define ENOMSG B_TO_POSIX_ERROR(B_POSIX_ERROR_BASE + 39) +#define ESTALE B_TO_POSIX_ERROR(B_POSIX_ERROR_BASE + 40) +#define EOVERFLOW B_TO_POSIX_ERROR(B_POSIX_ERROR_BASE + 41) +#define EMSGSIZE B_TO_POSIX_ERROR(B_POSIX_ERROR_BASE + 42) +#define EOPNOTSUPP B_TO_POSIX_ERROR(B_POSIX_ERROR_BASE + 43) +#define ENOTSOCK B_TO_POSIX_ERROR(B_POSIX_ERROR_BASE + 44) +#define EHOSTDOWN B_TO_POSIX_ERROR(B_POSIX_ERROR_BASE + 45) +#define EBADMSG B_TO_POSIX_ERROR(B_POSIX_ERROR_BASE + 46) +#define ECANCELED B_TO_POSIX_ERROR(B_POSIX_ERROR_BASE + 47) +#define EDESTADDRREQ B_TO_POSIX_ERROR(B_POSIX_ERROR_BASE + 48) +#define EDQUOT B_TO_POSIX_ERROR(B_POSIX_ERROR_BASE + 49) +#define EIDRM B_TO_POSIX_ERROR(B_POSIX_ERROR_BASE + 50) +#define EMULTIHOP B_TO_POSIX_ERROR(B_POSIX_ERROR_BASE + 51) +#define ENODATA B_TO_POSIX_ERROR(B_POSIX_ERROR_BASE + 52) +#define ENOLINK B_TO_POSIX_ERROR(B_POSIX_ERROR_BASE + 53) +#define ENOSR B_TO_POSIX_ERROR(B_POSIX_ERROR_BASE + 54) +#define ENOSTR B_TO_POSIX_ERROR(B_POSIX_ERROR_BASE + 55) +#define ENOTSUP B_TO_POSIX_ERROR(B_POSIX_ERROR_BASE + 56) +#define EPROTO B_TO_POSIX_ERROR(B_POSIX_ERROR_BASE + 57) +#define ETIME B_TO_POSIX_ERROR(B_POSIX_ERROR_BASE + 58) +#define ETXTBSY B_TO_POSIX_ERROR(B_POSIX_ERROR_BASE + 59) + +/* B_NO_MEMORY (0x80000000) can't be negated, so it needs special handling */ +#ifdef B_USE_POSITIVE_POSIX_ERRORS +# define ENOMEM B_POSIX_ENOMEM +#else +# define ENOMEM B_NO_MEMORY +#endif /* POSIX errors that can be mapped to BeOS error codes */ -#define ENOMEM B_NO_MEMORY -#define EACCES B_PERMISSION_DENIED -#define EINTR B_INTERRUPTED -#define EIO B_IO_ERROR -#define EBUSY B_BUSY -#define EFAULT B_BAD_ADDRESS -#define ETIMEDOUT B_TIMED_OUT -#define EAGAIN B_WOULD_BLOCK /* SysV compatibility */ -#define EWOULDBLOCK B_WOULD_BLOCK /* BSD compatibility */ -#define EBADF B_FILE_ERROR -#define EEXIST B_FILE_EXISTS -#define EINVAL B_BAD_VALUE -#define ENAMETOOLONG B_NAME_TOO_LONG -#define ENOENT B_ENTRY_NOT_FOUND -#define EPERM B_NOT_ALLOWED -#define ENOTDIR B_NOT_A_DIRECTORY -#define EISDIR B_IS_A_DIRECTORY -#define ENOTEMPTY B_DIRECTORY_NOT_EMPTY -#define ENOSPC B_DEVICE_FULL -#define EROFS B_READ_ONLY_DEVICE -#define EMFILE B_NO_MORE_FDS -#define EXDEV B_CROSS_DEVICE_LINK -#define ELOOP B_LINK_LIMIT -#define ENOEXEC B_NOT_AN_EXECUTABLE -#define EPIPE B_BUSTED_PIPE +#define EACCES B_TO_POSIX_ERROR(B_PERMISSION_DENIED) +#define EINTR B_TO_POSIX_ERROR(B_INTERRUPTED) +#define EIO B_TO_POSIX_ERROR(B_IO_ERROR) +#define EBUSY B_TO_POSIX_ERROR(B_BUSY) +#define EFAULT B_TO_POSIX_ERROR(B_BAD_ADDRESS) +#define ETIMEDOUT B_TO_POSIX_ERROR(B_TIMED_OUT) +#define EAGAIN B_TO_POSIX_ERROR(B_WOULD_BLOCK) /* SysV compatibility */ +#define EWOULDBLOCK B_TO_POSIX_ERROR(B_WOULD_BLOCK) /* BSD compatibility */ +#define EBADF B_TO_POSIX_ERROR(B_FILE_ERROR) +#define EEXIST B_TO_POSIX_ERROR(B_FILE_EXISTS) +#define EINVAL B_TO_POSIX_ERROR(B_BAD_VALUE) +#define ENAMETOOLONG B_TO_POSIX_ERROR(B_NAME_TOO_LONG) +#define ENOENT B_TO_POSIX_ERROR(B_ENTRY_NOT_FOUND) +#define EPERM B_TO_POSIX_ERROR(B_NOT_ALLOWED) +#define ENOTDIR B_TO_POSIX_ERROR(B_NOT_A_DIRECTORY) +#define EISDIR B_TO_POSIX_ERROR(B_IS_A_DIRECTORY) +#define ENOTEMPTY B_TO_POSIX_ERROR(B_DIRECTORY_NOT_EMPTY) +#define ENOSPC B_TO_POSIX_ERROR(B_DEVICE_FULL) +#define EROFS B_TO_POSIX_ERROR(B_READ_ONLY_DEVICE) +#define EMFILE B_TO_POSIX_ERROR(B_NO_MORE_FDS) +#define EXDEV B_TO_POSIX_ERROR(B_CROSS_DEVICE_LINK) +#define ELOOP B_TO_POSIX_ERROR(B_LINK_LIMIT) +#define ENOEXEC B_TO_POSIX_ERROR(B_NOT_AN_EXECUTABLE) +#define EPIPE B_TO_POSIX_ERROR(B_BUSTED_PIPE) /* new error codes that can be mapped to POSIX errors */ -#define B_BUFFER_OVERFLOW EOVERFLOW -#define B_TOO_MANY_ARGS E2BIG -#define B_FILE_TOO_LARGE EFBIG -#define B_RESULT_NOT_REPRESENTABLE ERANGE -#define B_DEVICE_NOT_FOUND ENODEV -#define B_NOT_SUPPORTED EOPNOTSUPP +#define B_BUFFER_OVERFLOW B_FROM_POSIX_ERROR(EOVERFLOW) +#define B_TOO_MANY_ARGS B_FROM_POSIX_ERROR(E2BIG) +#define B_FILE_TOO_LARGE B_FROM_POSIX_ERROR(EFBIG) +#define B_RESULT_NOT_REPRESENTABLE B_FROM_POSIX_ERROR(ERANGE) +#define B_DEVICE_NOT_FOUND B_FROM_POSIX_ERROR(ENODEV) +#define B_NOT_SUPPORTED B_FROM_POSIX_ERROR(EOPNOTSUPP) /* Media Kit Errors */ #define B_STREAM_NOT_FOUND (B_MEDIA_ERROR_BASE + 0) @@ -266,4 +281,20 @@ #define B_DEV_MULTIPLE_ERRORS (B_DEVICE_ERROR_BASE + 29) #define B_DEV_TOO_LATE (B_DEVICE_ERROR_BASE + 30) + +#define B_TO_POSITIVE_ERROR(error) _to_positive_error(error) +#define B_TO_NEGATIVE_ERROR(error) _to_negative_error(error) + + +#ifdef __cplusplus +extern "C" { +#endif + +int _to_positive_error(int error); +int _to_negative_error(int error); + +#ifdef __cplusplus +} +#endif + #endif /* _ERRORS_H */ diff --git a/src/libs/Jamfile b/src/libs/Jamfile index 448ee7f115..0f067234a2 100644 --- a/src/libs/Jamfile +++ b/src/libs/Jamfile @@ -17,6 +17,7 @@ SubInclude HAIKU_TOP src libs lp_solve ; SubInclude HAIKU_TOP src libs ncurses ; SubInclude HAIKU_TOP src libs pdflib ; SubInclude HAIKU_TOP src libs png ; +SubInclude HAIKU_TOP src libs posix_error_mapper ; SubInclude HAIKU_TOP src libs print ; SubInclude HAIKU_TOP src libs stdc++ ; SubInclude HAIKU_TOP src libs termcap ; diff --git a/src/libs/posix_error_mapper/Jamfile b/src/libs/posix_error_mapper/Jamfile new file mode 100644 index 0000000000..0218cf86aa --- /dev/null +++ b/src/libs/posix_error_mapper/Jamfile @@ -0,0 +1,15 @@ +SubDir HAIKU_TOP src libs posix_error_mapper ; + +StaticLibrary libposix_error_mapper.a : + misc.cpp + pthread_attr.cpp + pthread_condattr.cpp + pthread_cond.cpp + pthread_misc.cpp + pthread_mutexattr.cpp + pthread_mutex.cpp + pthread_rwlockattr.cpp + pthread_rwlock.cpp + pthread_specific.cpp + pthread_thread.cpp +; diff --git a/src/libs/posix_error_mapper/misc.cpp b/src/libs/posix_error_mapper/misc.cpp new file mode 100644 index 0000000000..53ed5c1df8 --- /dev/null +++ b/src/libs/posix_error_mapper/misc.cpp @@ -0,0 +1,57 @@ +/* + * Copyright 2009, Ingo Weinhold, ingo_weinhold@gmx.de. + * Distributed under the terms of the MIT License. + */ + +#include +#include + +#include "posix_error_mapper.h" + + +static int* +real_errnop() +{ + GET_REAL_FUNCTION(int*, _errnop, (void)); + return sReal__errnop(); +} + + +int* +_errnop(void) +{ + HIDDEN_FUNCTION(_errnop); + + // convert errno to positive error code + int* error = real_errnop(); + if (*error < 0) + *error = B_TO_POSITIVE_ERROR(*error); + return error; +} + + + +WRAPPER_FUNCTION(char*, strerror, (int errorCode), + return sReal_strerror(B_TO_NEGATIVE_ERROR(errorCode)); +) + + +WRAPPER_FUNCTION(int, strerror_r, + (int errorCode, char* buffer, size_t bufferSize), + return sReal_strerror_r(B_TO_NEGATIVE_ERROR(errorCode), buffer, bufferSize); +) + + +WRAPPER_FUNCTION(void, perror, (const char* errorPrefix), + // convert errno to negative error code + int* error = real_errnop(); + int oldError = *error; + if (*error < 0) + *error = B_TO_NEGATIVE_ERROR(*error); + + // call the real perror() + sReal_perror(errorPrefix); + + // reset errno + *error = oldError; +) diff --git a/src/libs/posix_error_mapper/posix_error_mapper.h b/src/libs/posix_error_mapper/posix_error_mapper.h new file mode 100644 index 0000000000..c7bf6e024c --- /dev/null +++ b/src/libs/posix_error_mapper/posix_error_mapper.h @@ -0,0 +1,28 @@ +/* + * Copyright 2009, Ingo Weinhold, ingo_weinhold@gmx.de. + * Distributed under the terms of the MIT License. + */ +#ifndef POSIX_ERROR_MAPPER_H +#define POSIX_ERROR_MAPPER_H + +#include +#include + +#include + + +#define GET_REAL_FUNCTION(returnValue, function, parameters) \ + static returnValue (*sReal_##function)parameters \ + = (returnValue (*)parameters)dlsym(RTLD_DEFAULT, #function) + +#define HIDDEN_FUNCTION(function) asm volatile(".hidden " #function) + +#define WRAPPER_FUNCTION(returnValue, function, parameters, body) \ +returnValue function parameters \ +{ \ + HIDDEN_FUNCTION(function); \ + GET_REAL_FUNCTION(returnValue, function, parameters); \ + body \ +} + +#endif // POSIX_ERROR_MAPPER_H diff --git a/src/libs/posix_error_mapper/pthread_attr.cpp b/src/libs/posix_error_mapper/pthread_attr.cpp new file mode 100644 index 0000000000..5436eb6f1f --- /dev/null +++ b/src/libs/posix_error_mapper/pthread_attr.cpp @@ -0,0 +1,60 @@ +/* + * Copyright 2009, Ingo Weinhold, ingo_weinhold@gmx.de. + * Distributed under the terms of the MIT License. + */ + +#include + +#include "posix_error_mapper.h" + + +WRAPPER_FUNCTION(int, pthread_attr_destroy, (pthread_attr_t *attr), + return B_TO_POSITIVE_ERROR(sReal_pthread_attr_destroy(attr)); +) + + +WRAPPER_FUNCTION(int, pthread_attr_init, (pthread_attr_t *attr), + return B_TO_POSITIVE_ERROR(sReal_pthread_attr_init(attr)); +) + + +WRAPPER_FUNCTION(int, pthread_attr_getdetachstate, + (const pthread_attr_t *attr, int *detachstate), + return B_TO_POSITIVE_ERROR(sReal_pthread_attr_getdetachstate(attr, + detachstate)); +) + + +WRAPPER_FUNCTION(int, pthread_attr_setdetachstate, + (pthread_attr_t *attr, int detachstate), + return B_TO_POSITIVE_ERROR(sReal_pthread_attr_setdetachstate(attr, + detachstate)); +) + + +WRAPPER_FUNCTION(int, pthread_attr_getstacksize, + (const pthread_attr_t *attr, size_t *stacksize), + return B_TO_POSITIVE_ERROR(sReal_pthread_attr_getstacksize(attr, + stacksize)); +) + + +WRAPPER_FUNCTION(int, pthread_attr_setstacksize, + (pthread_attr_t *attr, size_t stacksize), + return B_TO_POSITIVE_ERROR(sReal_pthread_attr_setstacksize(attr, + stacksize)); +) + + +WRAPPER_FUNCTION(int, pthread_attr_getscope, + (const pthread_attr_t *attr, int *contentionScope), + return B_TO_POSITIVE_ERROR(sReal_pthread_attr_getscope(attr, + contentionScope)); +) + + +WRAPPER_FUNCTION(int, pthread_attr_setscope, + (pthread_attr_t *attr, int contentionScope), + return B_TO_POSITIVE_ERROR(sReal_pthread_attr_setscope(attr, + contentionScope)); +) diff --git a/src/libs/posix_error_mapper/pthread_cond.cpp b/src/libs/posix_error_mapper/pthread_cond.cpp new file mode 100644 index 0000000000..c404207541 --- /dev/null +++ b/src/libs/posix_error_mapper/pthread_cond.cpp @@ -0,0 +1,267 @@ +/* + * Copyright 2009, Ingo Weinhold, ingo_weinhold@gmx.de. + * Distributed under the terms of the MIT License. + */ + +#include + +#include "posix_error_mapper.h" + + +WRAPPER_FUNCTION(int, pthread_cond_destroy, (pthread_cond_t *cond), + return B_TO_POSITIVE_ERROR(sReal_pthread_cond_destroy(cond)); +) + + +WRAPPER_FUNCTION(int, pthread_cond_init, (pthread_cond_t *cond, + const pthread_condattr_t *attr), + return B_TO_POSITIVE_ERROR(sReal_pthread_cond_init(cond, attr)); +) + + +WRAPPER_FUNCTION(int, pthread_cond_broadcast, (pthread_cond_t *cond), + return B_TO_POSITIVE_ERROR(sReal_pthread_cond_broadcast(cond)); +) + + +WRAPPER_FUNCTION(int, pthread_cond_signal, (pthread_cond_t *cond), + return B_TO_POSITIVE_ERROR(sReal_pthread_cond_signal(cond)); +) + + +WRAPPER_FUNCTION(int, pthread_cond_timedwait, (pthread_cond_t *cond, + pthread_mutex_t *mutex, const struct timespec *abstime), + return B_TO_POSITIVE_ERROR(sReal_pthread_cond_timedwait(cond, mutex, + abstime)); +) + + +WRAPPER_FUNCTION(int, pthread_cond_wait, (pthread_cond_t *cond, + pthread_mutex_t *mutex), + return B_TO_POSITIVE_ERROR(sReal_pthread_cond_wait(cond, mutex)); +) + + +WRAPPER_FUNCTION(int, pthread_condattr_destroy, + (pthread_condattr_t *condAttr), + return B_TO_POSITIVE_ERROR(sReal_pthread_condattr_destroy(condAttr)); +) + + +WRAPPER_FUNCTION(int, pthread_condattr_init, + (pthread_condattr_t *condAttr), + return B_TO_POSITIVE_ERROR(sReal_pthread_condattr_init(condAttr)); +) + + +WRAPPER_FUNCTION(int, pthread_condattr_getpshared, + (const pthread_condattr_t *condAttr, int *processShared), + return B_TO_POSITIVE_ERROR(sReal_pthread_condattr_getpshared(condAttr, + processShared)); +) + + +WRAPPER_FUNCTION(int, pthread_condattr_setpshared, + (pthread_condattr_t *condAttr, int processShared), + return B_TO_POSITIVE_ERROR(sReal_pthread_condattr_setpshared(condAttr, + processShared)); +) + + +WRAPPER_FUNCTION(int, pthread_rwlock_init, + (pthread_rwlock_t *lock, const pthread_rwlockattr_t *attr), + return B_TO_POSITIVE_ERROR(sReal_pthread_rwlock_init(lock, attr)); +) + + +WRAPPER_FUNCTION(int, pthread_rwlock_destroy, (pthread_rwlock_t *lock), + return B_TO_POSITIVE_ERROR(sReal_pthread_rwlock_destroy(lock)); +) + + +WRAPPER_FUNCTION(int, pthread_rwlock_rdlock, (pthread_rwlock_t *lock), + return B_TO_POSITIVE_ERROR(sReal_pthread_rwlock_rdlock(lock)); +) + + +WRAPPER_FUNCTION(int, pthread_rwlock_tryrdlock, (pthread_rwlock_t *lock), + return B_TO_POSITIVE_ERROR(sReal_pthread_rwlock_tryrdlock(lock)); +) + + +WRAPPER_FUNCTION(int, pthread_rwlock_timedrdlock, + (pthread_rwlock_t *lock, const struct timespec *timeout), + return B_TO_POSITIVE_ERROR(sReal_pthread_rwlock_timedrdlock(lock, timeout)); +) + + +WRAPPER_FUNCTION(int, pthread_rwlock_wrlock, (pthread_rwlock_t *lock), + return B_TO_POSITIVE_ERROR(sReal_pthread_rwlock_wrlock(lock)); +) + + +WRAPPER_FUNCTION(int, pthread_rwlock_trywrlock, (pthread_rwlock_t *lock), + return B_TO_POSITIVE_ERROR(sReal_pthread_rwlock_trywrlock(lock)); +) + + +WRAPPER_FUNCTION(int, pthread_rwlock_timedwrlock, + (pthread_rwlock_t *lock, const struct timespec *timeout), + return B_TO_POSITIVE_ERROR(sReal_pthread_rwlock_timedwrlock(lock, timeout)); +) + + +WRAPPER_FUNCTION(int, pthread_rwlock_unlock, (pthread_rwlock_t *lock), + return B_TO_POSITIVE_ERROR(sReal_pthread_rwlock_unlock(lock)); +) + + +WRAPPER_FUNCTION(int, pthread_rwlockattr_init, + (pthread_rwlockattr_t *attr), + return B_TO_POSITIVE_ERROR(sReal_pthread_rwlockattr_init(attr)); +) + + +WRAPPER_FUNCTION(int, pthread_rwlockattr_destroy, + (pthread_rwlockattr_t *attr), + return B_TO_POSITIVE_ERROR(sReal_pthread_rwlockattr_destroy(attr)); +) + + +WRAPPER_FUNCTION(int, pthread_rwlockattr_getpshared, + (const pthread_rwlockattr_t *attr, int *shared), + return B_TO_POSITIVE_ERROR(sReal_pthread_rwlockattr_getpshared(attr, + shared)); +) + + +WRAPPER_FUNCTION(int, pthread_rwlockattr_setpshared, + (pthread_rwlockattr_t *attr, int shared), + return B_TO_POSITIVE_ERROR(sReal_pthread_rwlockattr_setpshared(attr, + shared)); +) + + +WRAPPER_FUNCTION(int, pthread_atfork, + (void (*prepare)(void), void (*parent)(void), void (*child)(void)), + return B_TO_POSITIVE_ERROR(sReal_pthread_atfork(prepare, parent, child)); +) + + +WRAPPER_FUNCTION(int, pthread_once, + (pthread_once_t *once_control, void (*init_routine)(void)), + return B_TO_POSITIVE_ERROR(sReal_pthread_once(once_control, init_routine)); +) + + +WRAPPER_FUNCTION(int, pthread_attr_destroy, (pthread_attr_t *attr), + return B_TO_POSITIVE_ERROR(sReal_pthread_attr_destroy(attr)); +) + + +WRAPPER_FUNCTION(int, pthread_attr_init, (pthread_attr_t *attr), + return B_TO_POSITIVE_ERROR(sReal_pthread_attr_init(attr)); +) + + +WRAPPER_FUNCTION(int, pthread_attr_getdetachstate, + (const pthread_attr_t *attr, int *detachstate), + return B_TO_POSITIVE_ERROR(sReal_pthread_attr_getdetachstate(attr, + detachstate)); +) + + +WRAPPER_FUNCTION(int, pthread_attr_setdetachstate, + (pthread_attr_t *attr, int detachstate), + return B_TO_POSITIVE_ERROR(sReal_pthread_attr_setdetachstate(attr, + detachstate)); +) + + +WRAPPER_FUNCTION(int, pthread_attr_getstacksize, + (const pthread_attr_t *attr, size_t *stacksize), + return B_TO_POSITIVE_ERROR(sReal_pthread_attr_getstacksize(attr, + stacksize)); +) + + +WRAPPER_FUNCTION(int, pthread_attr_setstacksize, + (pthread_attr_t *attr, size_t stacksize), + return B_TO_POSITIVE_ERROR(sReal_pthread_attr_setstacksize(attr, + stacksize)); +) + + +WRAPPER_FUNCTION(int, pthread_attr_getscope, + (const pthread_attr_t *attr, int *contentionScope), + return B_TO_POSITIVE_ERROR(sReal_pthread_attr_getscope(attr, + contentionScope)); +) + + +WRAPPER_FUNCTION(int, pthread_attr_setscope, + (pthread_attr_t *attr, int contentionScope), + return B_TO_POSITIVE_ERROR(sReal_pthread_attr_setscope(attr, + contentionScope)); +) + + +WRAPPER_FUNCTION(int, pthread_create, + (pthread_t *thread, const pthread_attr_t *attr, + void *(*start_routine)(void*), void *arg), + return B_TO_POSITIVE_ERROR(sReal_pthread_create(thread, attr, start_routine, + arg)); +) + + +WRAPPER_FUNCTION(int, pthread_detach, (pthread_t thread), + return B_TO_POSITIVE_ERROR(sReal_pthread_detach(thread)); +) + + +WRAPPER_FUNCTION(int, pthread_join, (pthread_t thread, void **_value), + return B_TO_POSITIVE_ERROR(sReal_pthread_join(thread, _value)); +) + + +WRAPPER_FUNCTION(int, pthread_kill, (pthread_t thread, int sig), + return B_TO_POSITIVE_ERROR(sReal_pthread_kill(thread, sig)); +) + + +WRAPPER_FUNCTION(int, pthread_setconcurrency, (int newLevel), + return B_TO_POSITIVE_ERROR(sReal_pthread_setconcurrency(newLevel)); +) + + +WRAPPER_FUNCTION(int, pthread_cancel, (pthread_t thread), + return B_TO_POSITIVE_ERROR(sReal_pthread_cancel(thread)); +) + + +WRAPPER_FUNCTION(int, pthread_setcancelstate, + (int state, int *_oldState), + return B_TO_POSITIVE_ERROR(sReal_pthread_setcancelstate(state, _oldState)); +) + + +WRAPPER_FUNCTION(int, pthread_setcanceltype, (int type, int *_oldType), + return B_TO_POSITIVE_ERROR(sReal_pthread_setcanceltype(type, _oldType)); +) + + +WRAPPER_FUNCTION(int, pthread_key_create, + (pthread_key_t *key, void (*destructorFunc)(void*)), + return B_TO_POSITIVE_ERROR(sReal_pthread_key_create(key, destructorFunc)); +) + + +WRAPPER_FUNCTION(int, pthread_key_delete, (pthread_key_t key), + return B_TO_POSITIVE_ERROR(sReal_pthread_key_delete(key)); +) + + +WRAPPER_FUNCTION(int, pthread_setspecific, + (pthread_key_t key, const void *value), + return B_TO_POSITIVE_ERROR(sReal_pthread_setspecific(key, value)); +) diff --git a/src/libs/posix_error_mapper/pthread_condattr.cpp b/src/libs/posix_error_mapper/pthread_condattr.cpp new file mode 100644 index 0000000000..8e4c848810 --- /dev/null +++ b/src/libs/posix_error_mapper/pthread_condattr.cpp @@ -0,0 +1,34 @@ +/* + * Copyright 2009, Ingo Weinhold, ingo_weinhold@gmx.de. + * Distributed under the terms of the MIT License. + */ + +#include + +#include "posix_error_mapper.h" + + +WRAPPER_FUNCTION(int, pthread_condattr_destroy, + (pthread_condattr_t *condAttr), + return B_TO_POSITIVE_ERROR(sReal_pthread_condattr_destroy(condAttr)); +) + + +WRAPPER_FUNCTION(int, pthread_condattr_init, + (pthread_condattr_t *condAttr), + return B_TO_POSITIVE_ERROR(sReal_pthread_condattr_init(condAttr)); +) + + +WRAPPER_FUNCTION(int, pthread_condattr_getpshared, + (const pthread_condattr_t *condAttr, int *processShared), + return B_TO_POSITIVE_ERROR(sReal_pthread_condattr_getpshared(condAttr, + processShared)); +) + + +WRAPPER_FUNCTION(int, pthread_condattr_setpshared, + (pthread_condattr_t *condAttr, int processShared), + return B_TO_POSITIVE_ERROR(sReal_pthread_condattr_setpshared(condAttr, + processShared)); +) diff --git a/src/libs/posix_error_mapper/pthread_misc.cpp b/src/libs/posix_error_mapper/pthread_misc.cpp new file mode 100644 index 0000000000..d0b915dd5f --- /dev/null +++ b/src/libs/posix_error_mapper/pthread_misc.cpp @@ -0,0 +1,20 @@ +/* + * Copyright 2009, Ingo Weinhold, ingo_weinhold@gmx.de. + * Distributed under the terms of the MIT License. + */ + +#include + +#include "posix_error_mapper.h" + + +WRAPPER_FUNCTION(int, pthread_atfork, + (void (*prepare)(void), void (*parent)(void), void (*child)(void)), + return B_TO_POSITIVE_ERROR(sReal_pthread_atfork(prepare, parent, child)); +) + + +WRAPPER_FUNCTION(int, pthread_once, + (pthread_once_t *once_control, void (*init_routine)(void)), + return B_TO_POSITIVE_ERROR(sReal_pthread_once(once_control, init_routine)); +) diff --git a/src/libs/posix_error_mapper/pthread_mutex.cpp b/src/libs/posix_error_mapper/pthread_mutex.cpp new file mode 100644 index 0000000000..eb689f2f54 --- /dev/null +++ b/src/libs/posix_error_mapper/pthread_mutex.cpp @@ -0,0 +1,55 @@ +/* + * Copyright 2009, Ingo Weinhold, ingo_weinhold@gmx.de. + * Distributed under the terms of the MIT License. + */ + +#include + +#include "posix_error_mapper.h" + + +WRAPPER_FUNCTION(int, pthread_mutex_destroy, (pthread_mutex_t *mutex), + return B_TO_POSITIVE_ERROR(sReal_pthread_mutex_destroy(mutex)); +) + + +WRAPPER_FUNCTION(int, pthread_mutex_getprioceiling, + (pthread_mutex_t *mutex, int *_priorityCeiling), + return B_TO_POSITIVE_ERROR(sReal_pthread_mutex_getprioceiling(mutex, + _priorityCeiling)); +) + + +WRAPPER_FUNCTION(int, pthread_mutex_init, + (pthread_mutex_t *mutex, const pthread_mutexattr_t *attr), + return B_TO_POSITIVE_ERROR(sReal_pthread_mutex_init(mutex, attr)); +) + + +WRAPPER_FUNCTION(int, pthread_mutex_lock, (pthread_mutex_t *mutex), + return B_TO_POSITIVE_ERROR(sReal_pthread_mutex_lock(mutex)); +) + + +WRAPPER_FUNCTION(int, pthread_mutex_setprioceiling, + (pthread_mutex_t *mutex, int newPriorityCeiling, + int *_oldPriorityCeiling), + return B_TO_POSITIVE_ERROR(sReal_pthread_mutex_setprioceiling(mutex, + newPriorityCeiling, _oldPriorityCeiling)); +) + + +WRAPPER_FUNCTION(int, pthread_mutex_timedlock, + (pthread_mutex_t *mutex, const struct timespec *spec), + return B_TO_POSITIVE_ERROR(sReal_pthread_mutex_timedlock(mutex, spec)); +) + + +WRAPPER_FUNCTION(int, pthread_mutex_trylock, (pthread_mutex_t *mutex), + return B_TO_POSITIVE_ERROR(sReal_pthread_mutex_trylock(mutex)); +) + + +WRAPPER_FUNCTION(int, pthread_mutex_unlock, (pthread_mutex_t *mutex), + return B_TO_POSITIVE_ERROR(sReal_pthread_mutex_unlock(mutex)); +) diff --git a/src/libs/posix_error_mapper/pthread_mutexattr.cpp b/src/libs/posix_error_mapper/pthread_mutexattr.cpp new file mode 100644 index 0000000000..2d3d7e7d0a --- /dev/null +++ b/src/libs/posix_error_mapper/pthread_mutexattr.cpp @@ -0,0 +1,76 @@ +/* + * Copyright 2009, Ingo Weinhold, ingo_weinhold@gmx.de. + * Distributed under the terms of the MIT License. + */ + +#include + +#include "posix_error_mapper.h" + + +WRAPPER_FUNCTION(int, pthread_mutexattr_destroy, + (pthread_mutexattr_t *mutexAttr), + return B_TO_POSITIVE_ERROR(sReal_pthread_mutexattr_destroy(mutexAttr)); +) + + +WRAPPER_FUNCTION(int, pthread_mutexattr_getprioceiling, + (pthread_mutexattr_t *mutexAttr, int *_priorityCeiling), + return B_TO_POSITIVE_ERROR(sReal_pthread_mutexattr_getprioceiling(mutexAttr, + _priorityCeiling)); +) + + +WRAPPER_FUNCTION(int, pthread_mutexattr_getprotocol, + (pthread_mutexattr_t *mutexAttr, int *_protocol), + return B_TO_POSITIVE_ERROR(sReal_pthread_mutexattr_getprotocol(mutexAttr, + _protocol)); +) + + +WRAPPER_FUNCTION(int, pthread_mutexattr_getpshared, + (pthread_mutexattr_t *mutexAttr, int *_processShared), + return B_TO_POSITIVE_ERROR(sReal_pthread_mutexattr_getpshared(mutexAttr, + _processShared)); +) + + +WRAPPER_FUNCTION(int, pthread_mutexattr_gettype, + (pthread_mutexattr_t *mutexAttr, int *_type), + return B_TO_POSITIVE_ERROR(sReal_pthread_mutexattr_gettype(mutexAttr, + _type)); +) + + +WRAPPER_FUNCTION(int, pthread_mutexattr_init, + (pthread_mutexattr_t *mutexAttr), + return B_TO_POSITIVE_ERROR(sReal_pthread_mutexattr_init(mutexAttr)); +) + + +WRAPPER_FUNCTION(int, pthread_mutexattr_setprioceiling, + (pthread_mutexattr_t *mutexAttr, int priorityCeiling), + return B_TO_POSITIVE_ERROR(sReal_pthread_mutexattr_setprioceiling(mutexAttr, + priorityCeiling)); +) + + +WRAPPER_FUNCTION(int, pthread_mutexattr_setprotocol, + (pthread_mutexattr_t *mutexAttr, int protocol), + return B_TO_POSITIVE_ERROR(sReal_pthread_mutexattr_setprotocol(mutexAttr, + protocol)); +) + + +WRAPPER_FUNCTION(int, pthread_mutexattr_setpshared, + (pthread_mutexattr_t *mutexAttr, int processShared), + return B_TO_POSITIVE_ERROR(sReal_pthread_mutexattr_setpshared(mutexAttr, + processShared)); +) + + +WRAPPER_FUNCTION(int, pthread_mutexattr_settype, + (pthread_mutexattr_t *mutexAttr, int type), + return B_TO_POSITIVE_ERROR(sReal_pthread_mutexattr_settype(mutexAttr, + type)); +) diff --git a/src/libs/posix_error_mapper/pthread_rwlock.cpp b/src/libs/posix_error_mapper/pthread_rwlock.cpp new file mode 100644 index 0000000000..fc2127b54f --- /dev/null +++ b/src/libs/posix_error_mapper/pthread_rwlock.cpp @@ -0,0 +1,56 @@ +/* + * Copyright 2009, Ingo Weinhold, ingo_weinhold@gmx.de. + * Distributed under the terms of the MIT License. + */ + +#include + +#include "posix_error_mapper.h" + + +WRAPPER_FUNCTION(int, pthread_rwlock_init, + (pthread_rwlock_t *lock, const pthread_rwlockattr_t *attr), + return B_TO_POSITIVE_ERROR(sReal_pthread_rwlock_init(lock, attr)); +) + + +WRAPPER_FUNCTION(int, pthread_rwlock_destroy, (pthread_rwlock_t *lock), + return B_TO_POSITIVE_ERROR(sReal_pthread_rwlock_destroy(lock)); +) + + +WRAPPER_FUNCTION(int, pthread_rwlock_rdlock, (pthread_rwlock_t *lock), + return B_TO_POSITIVE_ERROR(sReal_pthread_rwlock_rdlock(lock)); +) + + +WRAPPER_FUNCTION(int, pthread_rwlock_tryrdlock, (pthread_rwlock_t *lock), + return B_TO_POSITIVE_ERROR(sReal_pthread_rwlock_tryrdlock(lock)); +) + + +WRAPPER_FUNCTION(int, pthread_rwlock_timedrdlock, + (pthread_rwlock_t *lock, const struct timespec *timeout), + return B_TO_POSITIVE_ERROR(sReal_pthread_rwlock_timedrdlock(lock, timeout)); +) + + +WRAPPER_FUNCTION(int, pthread_rwlock_wrlock, (pthread_rwlock_t *lock), + return B_TO_POSITIVE_ERROR(sReal_pthread_rwlock_wrlock(lock)); +) + + +WRAPPER_FUNCTION(int, pthread_rwlock_trywrlock, (pthread_rwlock_t *lock), + return B_TO_POSITIVE_ERROR(sReal_pthread_rwlock_trywrlock(lock)); +) + + +WRAPPER_FUNCTION(int, pthread_rwlock_timedwrlock, + (pthread_rwlock_t *lock, const struct timespec *timeout), + return B_TO_POSITIVE_ERROR(sReal_pthread_rwlock_timedwrlock(lock, timeout)); +) + + +WRAPPER_FUNCTION(int, pthread_rwlock_unlock, (pthread_rwlock_t *lock), + return B_TO_POSITIVE_ERROR(sReal_pthread_rwlock_unlock(lock)); +) diff --git a/src/libs/posix_error_mapper/pthread_rwlockattr.cpp b/src/libs/posix_error_mapper/pthread_rwlockattr.cpp new file mode 100644 index 0000000000..f8f06ea251 --- /dev/null +++ b/src/libs/posix_error_mapper/pthread_rwlockattr.cpp @@ -0,0 +1,34 @@ +/* + * Copyright 2009, Ingo Weinhold, ingo_weinhold@gmx.de. + * Distributed under the terms of the MIT License. + */ + +#include + +#include "posix_error_mapper.h" + + +WRAPPER_FUNCTION(int, pthread_rwlockattr_init, + (pthread_rwlockattr_t *attr), + return B_TO_POSITIVE_ERROR(sReal_pthread_rwlockattr_init(attr)); +) + + +WRAPPER_FUNCTION(int, pthread_rwlockattr_destroy, + (pthread_rwlockattr_t *attr), + return B_TO_POSITIVE_ERROR(sReal_pthread_rwlockattr_destroy(attr)); +) + + +WRAPPER_FUNCTION(int, pthread_rwlockattr_getpshared, + (const pthread_rwlockattr_t *attr, int *shared), + return B_TO_POSITIVE_ERROR(sReal_pthread_rwlockattr_getpshared(attr, + shared)); +) + + +WRAPPER_FUNCTION(int, pthread_rwlockattr_setpshared, + (pthread_rwlockattr_t *attr, int shared), + return B_TO_POSITIVE_ERROR(sReal_pthread_rwlockattr_setpshared(attr, + shared)); +) diff --git a/src/libs/posix_error_mapper/pthread_specific.cpp b/src/libs/posix_error_mapper/pthread_specific.cpp new file mode 100644 index 0000000000..c496260e65 --- /dev/null +++ b/src/libs/posix_error_mapper/pthread_specific.cpp @@ -0,0 +1,25 @@ +/* + * Copyright 2009, Ingo Weinhold, ingo_weinhold@gmx.de. + * Distributed under the terms of the MIT License. + */ + +#include + +#include "posix_error_mapper.h" + + +WRAPPER_FUNCTION(int, pthread_key_create, + (pthread_key_t *key, void (*destructorFunc)(void*)), + return B_TO_POSITIVE_ERROR(sReal_pthread_key_create(key, destructorFunc)); +) + + +WRAPPER_FUNCTION(int, pthread_key_delete, (pthread_key_t key), + return B_TO_POSITIVE_ERROR(sReal_pthread_key_delete(key)); +) + + +WRAPPER_FUNCTION(int, pthread_setspecific, + (pthread_key_t key, const void *value), + return B_TO_POSITIVE_ERROR(sReal_pthread_setspecific(key, value)); +) diff --git a/src/libs/posix_error_mapper/pthread_thread.cpp b/src/libs/posix_error_mapper/pthread_thread.cpp new file mode 100644 index 0000000000..f3deb38d35 --- /dev/null +++ b/src/libs/posix_error_mapper/pthread_thread.cpp @@ -0,0 +1,52 @@ +/* + * Copyright 2009, Ingo Weinhold, ingo_weinhold@gmx.de. + * Distributed under the terms of the MIT License. + */ + +#include + +#include "posix_error_mapper.h" + + +WRAPPER_FUNCTION(int, pthread_create, + (pthread_t *thread, const pthread_attr_t *attr, + void *(*start_routine)(void*), void *arg), + return B_TO_POSITIVE_ERROR(sReal_pthread_create(thread, attr, start_routine, + arg)); +) + + +WRAPPER_FUNCTION(int, pthread_detach, (pthread_t thread), + return B_TO_POSITIVE_ERROR(sReal_pthread_detach(thread)); +) + + +WRAPPER_FUNCTION(int, pthread_join, (pthread_t thread, void **_value), + return B_TO_POSITIVE_ERROR(sReal_pthread_join(thread, _value)); +) + + +WRAPPER_FUNCTION(int, pthread_kill, (pthread_t thread, int sig), + return B_TO_POSITIVE_ERROR(sReal_pthread_kill(thread, sig)); +) + + +WRAPPER_FUNCTION(int, pthread_setconcurrency, (int newLevel), + return B_TO_POSITIVE_ERROR(sReal_pthread_setconcurrency(newLevel)); +) + + +WRAPPER_FUNCTION(int, pthread_cancel, (pthread_t thread), + return B_TO_POSITIVE_ERROR(sReal_pthread_cancel(thread)); +) + + +WRAPPER_FUNCTION(int, pthread_setcancelstate, + (int state, int *_oldState), + return B_TO_POSITIVE_ERROR(sReal_pthread_setcancelstate(state, _oldState)); +) + + +WRAPPER_FUNCTION(int, pthread_setcanceltype, (int type, int *_oldType), + return B_TO_POSITIVE_ERROR(sReal_pthread_setcanceltype(type, _oldType)); +) diff --git a/src/system/libroot/posix/errno.c b/src/system/libroot/posix/errno.c index 3ab4e93168..059d183017 100644 --- a/src/system/libroot/posix/errno.c +++ b/src/system/libroot/posix/errno.c @@ -1,4 +1,4 @@ -/* +/* ** Copyright 2003-2005, Axel Dörfler, axeld@pinc-software.de. All rights reserved. ** Distributed under the terms of the MIT License. */ @@ -26,3 +26,21 @@ _errnop(void) extern int *(*__errno_location)(void) __attribute__ ((weak, alias("_errnop"))); #endif + +// #pragma mark - + + +int +_to_positive_error(int error) +{ + if (error < 0) + return error == B_NO_MEMORY ? B_POSIX_ENOMEM : -error; + return error; +} + + +int +_to_negative_error(int error) +{ + return error > 0 ? -error : error; +} diff --git a/src/system/libroot/posix/string/strerror.c b/src/system/libroot/posix/string/strerror.c index a5d3aabe20..7cd459d18f 100644 --- a/src/system/libroot/posix/string/strerror.c +++ b/src/system/libroot/posix/string/strerror.c @@ -44,6 +44,7 @@ error_description(int error) // General Errors case B_NO_ERROR: + case B_POSIX_ENOMEM: return "No error"; case B_ERROR: return "General system error";