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
This commit is contained in:
Ingo Weinhold
parent
4b0f97863f
commit
39d58e2f49
|
|
@ -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++ ;
|
||||
|
||||
|
|
|
|||
|
|
@ -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 */
|
||||
|
|
|
|||
|
|
@ -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 ;
|
||||
|
|
|
|||
|
|
@ -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
|
||||
;
|
||||
|
|
@ -0,0 +1,57 @@
|
|||
/*
|
||||
* Copyright 2009, Ingo Weinhold, ingo_weinhold@gmx.de.
|
||||
* Distributed under the terms of the MIT License.
|
||||
*/
|
||||
|
||||
#include <stdio.h>
|
||||
#include <string.h>
|
||||
|
||||
#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;
|
||||
)
|
||||
|
|
@ -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 <dlfcn.h>
|
||||
#include <errno.h>
|
||||
|
||||
#include <Errors.h>
|
||||
|
||||
|
||||
#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
|
||||
|
|
@ -0,0 +1,60 @@
|
|||
/*
|
||||
* Copyright 2009, Ingo Weinhold, ingo_weinhold@gmx.de.
|
||||
* Distributed under the terms of the MIT License.
|
||||
*/
|
||||
|
||||
#include <pthread.h>
|
||||
|
||||
#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));
|
||||
)
|
||||
|
|
@ -0,0 +1,267 @@
|
|||
/*
|
||||
* Copyright 2009, Ingo Weinhold, ingo_weinhold@gmx.de.
|
||||
* Distributed under the terms of the MIT License.
|
||||
*/
|
||||
|
||||
#include <pthread.h>
|
||||
|
||||
#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));
|
||||
)
|
||||
|
|
@ -0,0 +1,34 @@
|
|||
/*
|
||||
* Copyright 2009, Ingo Weinhold, ingo_weinhold@gmx.de.
|
||||
* Distributed under the terms of the MIT License.
|
||||
*/
|
||||
|
||||
#include <pthread.h>
|
||||
|
||||
#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));
|
||||
)
|
||||
|
|
@ -0,0 +1,20 @@
|
|||
/*
|
||||
* Copyright 2009, Ingo Weinhold, ingo_weinhold@gmx.de.
|
||||
* Distributed under the terms of the MIT License.
|
||||
*/
|
||||
|
||||
#include <pthread.h>
|
||||
|
||||
#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));
|
||||
)
|
||||
|
|
@ -0,0 +1,55 @@
|
|||
/*
|
||||
* Copyright 2009, Ingo Weinhold, ingo_weinhold@gmx.de.
|
||||
* Distributed under the terms of the MIT License.
|
||||
*/
|
||||
|
||||
#include <pthread.h>
|
||||
|
||||
#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));
|
||||
)
|
||||
|
|
@ -0,0 +1,76 @@
|
|||
/*
|
||||
* Copyright 2009, Ingo Weinhold, ingo_weinhold@gmx.de.
|
||||
* Distributed under the terms of the MIT License.
|
||||
*/
|
||||
|
||||
#include <pthread.h>
|
||||
|
||||
#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));
|
||||
)
|
||||
|
|
@ -0,0 +1,56 @@
|
|||
/*
|
||||
* Copyright 2009, Ingo Weinhold, ingo_weinhold@gmx.de.
|
||||
* Distributed under the terms of the MIT License.
|
||||
*/
|
||||
|
||||
#include <pthread.h>
|
||||
|
||||
#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));
|
||||
)
|
||||
|
|
@ -0,0 +1,34 @@
|
|||
/*
|
||||
* Copyright 2009, Ingo Weinhold, ingo_weinhold@gmx.de.
|
||||
* Distributed under the terms of the MIT License.
|
||||
*/
|
||||
|
||||
#include <pthread.h>
|
||||
|
||||
#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));
|
||||
)
|
||||
|
|
@ -0,0 +1,25 @@
|
|||
/*
|
||||
* Copyright 2009, Ingo Weinhold, ingo_weinhold@gmx.de.
|
||||
* Distributed under the terms of the MIT License.
|
||||
*/
|
||||
|
||||
#include <pthread.h>
|
||||
|
||||
#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));
|
||||
)
|
||||
|
|
@ -0,0 +1,52 @@
|
|||
/*
|
||||
* Copyright 2009, Ingo Weinhold, ingo_weinhold@gmx.de.
|
||||
* Distributed under the terms of the MIT License.
|
||||
*/
|
||||
|
||||
#include <pthread.h>
|
||||
|
||||
#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));
|
||||
)
|
||||
|
|
@ -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;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -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";
|
||||
|
|
|
|||
Loading…
Reference in New Issue