@@ -17,7 +17,7 @@
<https://www.gnu.org/licenses/>. */
#include <sysdep.h>
-#include <pthread-errnos.h>
+#include <errno.h>
#ifdef UP
@@ -35,7 +35,7 @@
# define READ_THREAD_POINTER() (__builtin_thread_pointer ())
#else
/* Note: rd must be $v1 to be ABI-conformant. */
-# if __mips_isa_rev >= 2
+# if defined (__mips_isa_rev) && __mips_isa_rev >= 2
# define READ_THREAD_POINTER() \
({ void *__result; \
asm volatile ("rdhwr\t%0, $29" : "=v" (__result)); \
@@ -15,7 +15,7 @@
License along with the GNU C Library; if not, see
<https://www.gnu.org/licenses/>. */
-#include <pthread-errnos.h>
+#include <errno.h>
.globl pthread_spin_trylock
.type pthread_spin_trylock,@function
@@ -16,7 +16,7 @@
<https://www.gnu.org/licenses/>. */
#include <sysdep.h>
-#include <pthread-errnos.h>
+#include <errno.h>
.text
ENTRY(pthread_spin_trylock)
@@ -16,7 +16,7 @@
<https://www.gnu.org/licenses/>. */
#include <sysdep.h>
-#include <pthread-errnos.h>
+#include <errno.h>
.text
ENTRY(pthread_spin_trylock)
@@ -16,8 +16,7 @@
<https://www.gnu.org/licenses/>. */
#include <sysdep.h>
-#define _ERRNO_H
-#include <bits/errno.h>
+#include <errno.h>
#if IS_IN (rtld)
# include <dl-sysdep.h> /* Defines RTLD_PRIVATE_ERRNO. */
@@ -17,8 +17,7 @@
<https://www.gnu.org/licenses/>. */
#include <sysdep.h>
-#define _ERRNO_H
-#include <bits/errno.h>
+#include <errno.h>
#include <sys/asm.h>
.set nomips16
@@ -16,8 +16,7 @@
<https://www.gnu.org/licenses/>. */
#include <sysdep.h>
-#define _ERRNO_H
-#include <bits/errno.h>
+#include <errno.h>
ENTRY(__syscall_error)
#if defined (EWOULDBLOCK_sys) && EWOULDBLOCK_sys != EAGAIN
@@ -170,21 +170,6 @@
# define SINGLE_THREAD_BY_GLOBAL 1
-/* Define a macro which expands into the inline wrapper code for a system
- call. */
-# undef INLINE_SYSCALL
-# define INLINE_SYSCALL(name, nr, args...) \
- ({ unsigned long _sys_result = INTERNAL_SYSCALL (name, , nr, args); \
- if (__builtin_expect (INTERNAL_SYSCALL_ERROR_P (_sys_result, ), 0))\
- { \
- __set_errno (INTERNAL_SYSCALL_ERRNO (_sys_result, )); \
- _sys_result = (unsigned long) -1; \
- } \
- (long) _sys_result; })
-
-# undef INTERNAL_SYSCALL_DECL
-# define INTERNAL_SYSCALL_DECL(err) do { } while (0)
-
# undef INTERNAL_SYSCALL_RAW
# define INTERNAL_SYSCALL_RAW(name, err, nr, args...) \
({ long _sys_result; \
@@ -205,13 +190,6 @@
# define INTERNAL_SYSCALL_AARCH64(name, err, nr, args...) \
INTERNAL_SYSCALL_RAW(__ARM_NR_##name, err, nr, args)
-# undef INTERNAL_SYSCALL_ERROR_P
-# define INTERNAL_SYSCALL_ERROR_P(val, err) \
- ((unsigned long) (val) >= (unsigned long) -4095)
-
-# undef INTERNAL_SYSCALL_ERRNO
-# define INTERNAL_SYSCALL_ERRNO(val, err) (-(val))
-
# define LOAD_ARGS_0() \
register long _x0 asm ("x0");
# define LOAD_ARGS_1(x0) \
@@ -21,8 +21,7 @@
break value (instead of the new, requested one). */
#include <sysdep.h>
-#define _ERRNO_H
-#include <bits/errno.h>
+#include <errno.h>
#ifdef PIC
.section .bss
@@ -169,42 +169,18 @@ __LABEL(name) \
#else /* !ASSEMBLER */
-/* In order to get __set_errno() definition in INLINE_SYSCALL. */
-#include <errno.h>
-
-#undef INLINE_SYSCALL
-#define INLINE_SYSCALL(name, nr, args...) \
-({ \
- INTERNAL_SYSCALL_DECL (_sc_err); \
- long int _sc_ret = INTERNAL_SYSCALL (name, sc_err, nr, args); \
- if (INTERNAL_SYSCALL_ERROR_P (_sc_ret, _sc_err)) \
- { \
- __set_errno (INTERNAL_SYSCALL_ERRNO (_sc_ret, _sc_err)); \
- _sc_ret = -1L; \
- } \
- _sc_ret; \
-})
-
#define INTERNAL_SYSCALL(name, err_out, nr, args...) \
internal_syscall##nr(__NR_##name, args)
#define INTERNAL_SYSCALL_NCS(name, err_out, nr, args...) \
internal_syscall##nr(name, args)
-#define INTERNAL_SYSCALL_DECL(err) do { } while (0)
-
/* The normal Alpha calling convention sign-extends 32-bit quantties
no matter what the "real" sign of the 32-bit type. We want to
preserve that when filling in values for the kernel. */
#define syscall_promote(arg) \
(sizeof (arg) == 4 ? (long)(int)(long)(arg) : (long)(arg))
-/* Make sure and "use" the variable that we're not returning,
- in order to suppress unused variable warnings. */
-#define INTERNAL_SYSCALL_ERROR_P(val, err) \
- ((unsigned long) (val) >= (unsigned long) -4095)
-#define INTERNAL_SYSCALL_ERRNO(val, err) (-(val))
-
#define internal_syscall_clobbers \
"$1", "$2", "$3", "$4", "$5", "$6", "$7", "$8", \
"$22", "$23", "$24", "$25", "$27", "$28", "memory"
@@ -29,11 +29,6 @@
#include <tls.h>
-/* In order to get __set_errno() definition in INLINE_SYSCALL. */
-#ifndef __ASSEMBLER__
-#include <errno.h>
-#endif
-
/* For Linux we can use the system call table in the header file
/usr/include/asm/unistd.h
of the kernel. But these symbols do not follow the SYS_* syntax
@@ -317,21 +312,6 @@ __local_syscall_error: \
#else /* not __ASSEMBLER__ */
-/* Define a macro which expands into the inline wrapper code for a system
- call. */
-#undef INLINE_SYSCALL
-#define INLINE_SYSCALL(name, nr, args...) \
- ({ unsigned int _sys_result = INTERNAL_SYSCALL (name, , nr, args); \
- if (__builtin_expect (INTERNAL_SYSCALL_ERROR_P (_sys_result, ), 0)) \
- { \
- __set_errno (INTERNAL_SYSCALL_ERRNO (_sys_result, )); \
- _sys_result = (unsigned int) -1; \
- } \
- (int) _sys_result; })
-
-#undef INTERNAL_SYSCALL_DECL
-#define INTERNAL_SYSCALL_DECL(err) do { } while (0)
-
#if defined(__thumb__)
/* We can not expose the use of r7 to the compiler. GCC (as
of 4.5) uses r7 as the hard frame pointer for Thumb - although
@@ -377,13 +357,6 @@ __local_syscall_error: \
#define INTERNAL_SYSCALL(name, err, nr, args...) \
INTERNAL_SYSCALL_RAW(SYS_ify(name), err, nr, args)
-#undef INTERNAL_SYSCALL_ERROR_P
-#define INTERNAL_SYSCALL_ERROR_P(val, err) \
- ((unsigned int) (val) >= 0xfffff001u)
-
-#undef INTERNAL_SYSCALL_ERRNO
-#define INTERNAL_SYSCALL_ERRNO(val, err) (-(val))
-
#define VDSO_NAME "LINUX_2.6"
#define VDSO_HASH 61765110
@@ -293,28 +293,6 @@ __local_syscall_error: \
#else /* not __ASSEMBLER__ */
-/* Define a macro which expands into the inline wrapper code for a system
- call. */
-# undef INLINE_SYSCALL
-# define INLINE_SYSCALL(name, nr, args...) \
- ({ unsigned int _sys_result = INTERNAL_SYSCALL (name, , nr, args); \
- if (__builtin_expect (INTERNAL_SYSCALL_ERROR_P (_sys_result,), 0)) \
- { \
- __set_errno (INTERNAL_SYSCALL_ERRNO (_sys_result, )); \
- _sys_result = (unsigned int) -1; \
- } \
- (int) _sys_result; })
-
-# undef INTERNAL_SYSCALL_DECL
-# define INTERNAL_SYSCALL_DECL(err) do { } while (0)
-
-# undef INTERNAL_SYSCALL_ERROR_P
-# define INTERNAL_SYSCALL_ERROR_P(val, err) \
- ((unsigned int) (val) >= 0xffffff01u)
-
-# undef INTERNAL_SYSCALL_ERRNO
-# define INTERNAL_SYSCALL_ERRNO(val, err) (-(val))
-
# undef INTERNAL_SYSCALL_RAW
# define INTERNAL_SYSCALL_RAW0(name, err, dummy...) \
({unsigned int __sys_result; \
@@ -360,36 +360,6 @@ L(pre_end): ASM_LINE_SEP \
#define CALL_CLOB_REGS "%r1", "%r2", CLOB_TREG \
"%r20", "%r29", "%r31"
-#undef INLINE_SYSCALL
-#define INLINE_SYSCALL(name, nr, args...) \
-({ \
- long __sys_res = INTERNAL_SYSCALL (name, , nr, args); \
- if (__glibc_unlikely (INTERNAL_SYSCALL_ERROR_P (__sys_res, ))) \
- { \
- __set_errno (INTERNAL_SYSCALL_ERRNO (__sys_res, )); \
- __sys_res = -1; \
- } \
- __sys_res; \
-})
-
-/* INTERNAL_SYSCALL_DECL - Allows us to setup some function static
- value to use within the context of the syscall
- INTERNAL_SYSCALL_ERROR_P - Returns 0 if it wasn't an error, 1 otherwise
- You are allowed to use the syscall result (val) and the DECL error
- variable to determine what went wrong.
- INTERLAL_SYSCALL_ERRNO - Munges the val/err pair into the error number.
- In our case we just flip the sign. */
-
-#undef INTERNAL_SYSCALL_DECL
-#define INTERNAL_SYSCALL_DECL(err)
-
-#undef INTERNAL_SYSCALL_ERROR_P
-#define INTERNAL_SYSCALL_ERROR_P(val, err) \
- ((val < 0) && (val > -4095))
-
-#undef INTERNAL_SYSCALL_ERRNO
-#define INTERNAL_SYSCALL_ERRNO(val, err) (-(val))
-
/* Similar to INLINE_SYSCALL but we don't set errno */
#undef INTERNAL_SYSCALL
#define INTERNAL_SYSCALL(name, err, nr, args...) \
@@ -67,6 +67,7 @@
/* We don't want the label for the error handle to be global when we define
it here. */
+#undef SYSCALL_ERROR_LABEL
#define SYSCALL_ERROR_LABEL __syscall_error
#undef PSEUDO
@@ -280,35 +281,6 @@ struct libc_do_syscall_args
};
#endif
-/* Define a macro which expands inline into the wrapper code for a system
- call. */
-#undef INLINE_SYSCALL
-#if IS_IN (libc)
-# define INLINE_SYSCALL(name, nr, args...) \
- ({ \
- unsigned int resultvar = INTERNAL_SYSCALL (name, , nr, args); \
- __glibc_unlikely (INTERNAL_SYSCALL_ERROR_P (resultvar, )) \
- ? __syscall_error (-INTERNAL_SYSCALL_ERRNO (resultvar, )) \
- : (int) resultvar; })
-#else
-# define INLINE_SYSCALL(name, nr, args...) \
- ({ \
- unsigned int resultvar = INTERNAL_SYSCALL (name, , nr, args); \
- if (__glibc_unlikely (INTERNAL_SYSCALL_ERROR_P (resultvar, ))) \
- { \
- __set_errno (INTERNAL_SYSCALL_ERRNO (resultvar, )); \
- resultvar = 0xffffffff; \
- } \
- (int) resultvar; })
-#endif
-
-/* Set error number and return -1. Return the internal function,
- __syscall_error, which sets errno from the negative error number
- and returns -1, to avoid PIC. */
-#undef INLINE_SYSCALL_ERROR_RETURN_VALUE
-#define INLINE_SYSCALL_ERROR_RETURN_VALUE(resultvar) \
- __syscall_error (-(resultvar))
-
# define VDSO_NAME "LINUX_2.6"
# define VDSO_HASH 61765110
@@ -490,16 +462,6 @@ struct libc_do_syscall_args
# endif /* GCC 5 */
#endif
-#undef INTERNAL_SYSCALL_DECL
-#define INTERNAL_SYSCALL_DECL(err) do { } while (0)
-
-#undef INTERNAL_SYSCALL_ERROR_P
-#define INTERNAL_SYSCALL_ERROR_P(val, err) \
- ((unsigned int) (val) >= 0xfffff001u)
-
-#undef INTERNAL_SYSCALL_ERRNO
-#define INTERNAL_SYSCALL_ERRNO(val, err) (-(val))
-
#define LOADARGS_0
#ifdef __PIC__
# if I386_USE_SYSENTER && defined PIC
@@ -231,29 +231,9 @@
#endif /* !IA64_USE_NEW_STUB */
-# undef INLINE_SYSCALL
-# define INLINE_SYSCALL(name, nr, args...) \
- ({ unsigned long _sys_result = INTERNAL_SYSCALL (name, , nr, args); \
- if (__builtin_expect (INTERNAL_SYSCALL_ERROR_P (_sys_result, ), 0))\
- { \
- __set_errno (INTERNAL_SYSCALL_ERRNO (_sys_result, )); \
- _sys_result = (unsigned long) -1; \
- } \
- (long) _sys_result; })
-
-# undef INTERNAL_SYSCALL_DECL
-# define INTERNAL_SYSCALL_DECL(err) do { } while (0)
-
#define INTERNAL_SYSCALL(name, err, nr, args...) \
INTERNAL_SYSCALL_NCS (__NR_##name, err, nr, ##args)
-#undef INTERNAL_SYSCALL_ERROR_P
-#define INTERNAL_SYSCALL_ERROR_P(val, err) \
- ((unsigned long) (val) >= (unsigned long) -4095)
-
-#undef INTERNAL_SYSCALL_ERRNO
-#define INTERNAL_SYSCALL_ERRNO(val, err) (-(val))
-
#define LOAD_ARGS_0()
#define LOAD_REGS_0
#define LOAD_ARGS_1(a1) \
@@ -221,21 +221,6 @@ SYSCALL_ERROR_LABEL: \
#else /* not __ASSEMBLER__ */
-/* Define a macro which expands into the inline wrapper code for a system
- call. */
-#undef INLINE_SYSCALL
-#define INLINE_SYSCALL(name, nr, args...) \
- ({ unsigned int _sys_result = INTERNAL_SYSCALL (name, , nr, args); \
- if (__builtin_expect (INTERNAL_SYSCALL_ERROR_P (_sys_result, ), 0))\
- { \
- __set_errno (INTERNAL_SYSCALL_ERRNO (_sys_result, )); \
- _sys_result = (unsigned int) -1; \
- } \
- (int) _sys_result; })
-
-#undef INTERNAL_SYSCALL_DECL
-#define INTERNAL_SYSCALL_DECL(err) do { } while (0)
-
/* Define a macro which expands inline into the wrapper code for a system
call. This use is for internal calls that do not need to handle errors
normally. It will never touch errno. This returns just what the kernel
@@ -260,13 +245,6 @@ SYSCALL_ERROR_LABEL: \
#define INTERNAL_SYSCALL(name, err, nr, args...) \
INTERNAL_SYSCALL_NCS (__NR_##name, err, nr, ##args)
-#undef INTERNAL_SYSCALL_ERROR_P
-#define INTERNAL_SYSCALL_ERROR_P(val, err) \
- ((unsigned int) (val) >= -4095U)
-
-#undef INTERNAL_SYSCALL_ERRNO
-#define INTERNAL_SYSCALL_ERRNO(val, err) (-(val))
-
#define LOAD_ARGS_0()
#define LOAD_REGS_0
#define ASM_ARGS_0
@@ -163,23 +163,6 @@ SYSCALL_ERROR_LABEL_DCL: \
#else /* not __ASSEMBLER__ */
-/* Define a macro which expands into the inline wrapper code for a system
- call. */
-# undef INLINE_SYSCALL
-# define INLINE_SYSCALL(name, nr, args...) \
-({ INTERNAL_SYSCALL_DECL(err); \
- unsigned long resultvar = INTERNAL_SYSCALL(name, err, nr, args); \
- if (INTERNAL_SYSCALL_ERROR_P (resultvar, err)) \
- { \
- __set_errno (INTERNAL_SYSCALL_ERRNO (resultvar, err)); \
- resultvar = (unsigned long) -1; \
- } \
- (long) resultvar; \
-})
-
-# undef INTERNAL_SYSCALL_DECL
-# define INTERNAL_SYSCALL_DECL(err) do { } while (0)
-
/* Define a macro which expands inline into the wrapper code for a system
call. This use is for internal calls that do not need to handle errors
normally. It will never touch errno. This returns just what the kernel
@@ -192,13 +175,6 @@ SYSCALL_ERROR_LABEL_DCL: \
# define INTERNAL_SYSCALL_NCS(name, err, nr, args...) \
inline_syscall##nr(name, args)
-# undef INTERNAL_SYSCALL_ERROR_P
-# define INTERNAL_SYSCALL_ERROR_P(val, err) \
- ((unsigned int) (val) >= -4095U)
-
-# undef INTERNAL_SYSCALL_ERRNO
-# define INTERNAL_SYSCALL_ERRNO(val, err) (-(val))
-
# define SYSCALL_CLOBBERS_6 "r11", "r4", "memory"
# define SYSCALL_CLOBBERS_5 "r10", SYSCALL_CLOBBERS_6
# define SYSCALL_CLOBBERS_4 "r9", SYSCALL_CLOBBERS_5
@@ -25,11 +25,6 @@
#include <tls.h>
-/* In order to get __set_errno() definition in INLINE_SYSCALL. */
-#ifndef __ASSEMBLER__
-#include <errno.h>
-#endif
-
/* For Linux we can use the system call table in the header file
/usr/include/asm/unistd.h
of the kernel. But these symbols do not follow the SYS_* syntax
@@ -47,29 +42,6 @@
#else /* ! __ASSEMBLER__ */
-/* Define a macro which expands into the inline wrapper code for a system
- call. */
-#undef INLINE_SYSCALL
-#define INLINE_SYSCALL(name, nr, args...) \
- ({ INTERNAL_SYSCALL_DECL (_sc_err); \
- long result_var = INTERNAL_SYSCALL (name, _sc_err, nr, args); \
- if ( INTERNAL_SYSCALL_ERROR_P (result_var, _sc_err) ) \
- { \
- __set_errno (INTERNAL_SYSCALL_ERRNO (result_var, _sc_err)); \
- result_var = -1L; \
- } \
- result_var; })
-
-#undef INTERNAL_SYSCALL_DECL
-#define INTERNAL_SYSCALL_DECL(err) do { } while (0)
-
-#undef INTERNAL_SYSCALL_ERROR_P
-#define INTERNAL_SYSCALL_ERROR_P(val, err) \
- ((unsigned long) (val) >= (unsigned long) -4095)
-
-#undef INTERNAL_SYSCALL_ERRNO
-#define INTERNAL_SYSCALL_ERRNO(val, err) (-(val))
-
/* Note that the original Linux syscall restart convention required the
instruction immediately preceding SYSCALL to initialize $v0 with the
syscall number. Then if a restart triggered, $v0 would have been
@@ -25,11 +25,6 @@
#include <tls.h>
-/* In order to get __set_errno() definition in INLINE_SYSCALL. */
-#ifndef __ASSEMBLER__
-#include <errno.h>
-#endif
-
/* For Linux we can use the system call table in the header file
/usr/include/asm/unistd.h
of the kernel. But these symbols do not follow the SYS_* syntax
@@ -55,29 +50,6 @@ typedef long long int __syscall_arg_t;
typedef long int __syscall_arg_t;
#endif
-/* Define a macro which expands into the inline wrapper code for a system
- call. */
-#undef INLINE_SYSCALL
-#define INLINE_SYSCALL(name, nr, args...) \
- ({ INTERNAL_SYSCALL_DECL (_sc_err); \
- long result_var = INTERNAL_SYSCALL (name, _sc_err, nr, args); \
- if ( INTERNAL_SYSCALL_ERROR_P (result_var, _sc_err) ) \
- { \
- __set_errno (INTERNAL_SYSCALL_ERRNO (result_var, _sc_err)); \
- result_var = -1L; \
- } \
- result_var; })
-
-#undef INTERNAL_SYSCALL_DECL
-#define INTERNAL_SYSCALL_DECL(err) do { } while (0)
-
-#undef INTERNAL_SYSCALL_ERROR_P
-#define INTERNAL_SYSCALL_ERROR_P(val, err) \
- ((unsigned long) (val) >= (unsigned long) -4095)
-
-#undef INTERNAL_SYSCALL_ERRNO
-#define INTERNAL_SYSCALL_ERRNO(val, err) (-(val))
-
/* Note that the original Linux syscall restart convention required the
instruction immediately preceding SYSCALL to initialize $v0 with the
syscall number. Then if a restart triggered, $v0 would have been
@@ -37,6 +37,7 @@
#ifdef __ASSEMBLER__
+#undef SYSCALL_ERROR_LABEL
#define SYSCALL_ERROR_LABEL __local_syscall_error
#undef PSEUDO
@@ -143,29 +144,6 @@
which lead in a non existent __send symbol in libc.so. */
# undef HAVE_INTERNAL_SEND_SYMBOL
-/* Define a macro which expands into the inline wrapper code for a system
- call. */
-#undef INLINE_SYSCALL
-#define INLINE_SYSCALL(name, nr, args...) \
- ({ INTERNAL_SYSCALL_DECL(err); \
- unsigned int result_var = INTERNAL_SYSCALL (name, err, nr, args); \
- if ( INTERNAL_SYSCALL_ERROR_P (result_var, err) ) \
- { \
- __set_errno (INTERNAL_SYSCALL_ERRNO (result_var, err)); \
- result_var = -1L; \
- } \
- (int) result_var; })
-
-#undef INTERNAL_SYSCALL_DECL
-#define INTERNAL_SYSCALL_DECL(err) do { } while (0)
-
-#undef INTERNAL_SYSCALL_ERROR_P
-#define INTERNAL_SYSCALL_ERROR_P(val, err) \
- ((unsigned long) (val) >= (unsigned long) -4095)
-
-#undef INTERNAL_SYSCALL_ERRNO
-#define INTERNAL_SYSCALL_ERRNO(val, err) (-(val))
-
#undef INTERNAL_SYSCALL_RAW
#define INTERNAL_SYSCALL_RAW(name, err, nr, args...) \
({ unsigned int _sys_result; \
@@ -67,26 +67,6 @@
#define INTERNAL_VSYSCALL_CALL(funcptr, err, nr, args...) \
INTERNAL_VSYSCALL_CALL_TYPE(funcptr, err, long int, nr, args)
-/* This version is for kernels that implement system calls that
- behave like function calls as far as register saving. */
-#undef INLINE_SYSCALL
-#define INLINE_SYSCALL(name, nr, args...) \
- ({ \
- INTERNAL_SYSCALL_DECL (sc_err); \
- long int sc_ret = INTERNAL_SYSCALL (name, sc_err, nr, args); \
- if (INTERNAL_SYSCALL_ERROR_P (sc_ret, sc_err)) \
- { \
- __set_errno (INTERNAL_SYSCALL_ERRNO (sc_ret, sc_err)); \
- sc_ret = -1L; \
- } \
- sc_ret; \
- })
-
-/* Define a macro which expands inline into the wrapper code for a system
- call. This use is for internal calls that do not need to handle errors
- normally. It will never touch errno. This returns just what the kernel
- gave back in the non-error (CR0.SO cleared) case, otherwise (CR0.SO set)
- the negation of the return value in the kernel gets reverted. */
#undef INTERNAL_SYSCALL
#define INTERNAL_SYSCALL_NCS(name, err, nr, args...) \
@@ -114,16 +94,6 @@
#define INTERNAL_SYSCALL(name, err, nr, args...) \
INTERNAL_SYSCALL_NCS (__NR_##name, err, nr, args)
-#undef INTERNAL_SYSCALL_DECL
-#define INTERNAL_SYSCALL_DECL(err) do { } while (0)
-
-#undef INTERNAL_SYSCALL_ERROR_P
-#define INTERNAL_SYSCALL_ERROR_P(val, err) \
- ((unsigned long) (val) >= (unsigned long) -4095)
-
-#undef INTERNAL_SYSCALL_ERRNO
-#define INTERNAL_SYSCALL_ERRNO(val, err) (-(val))
-
#if defined(__PPC64__) || defined(__powerpc64__)
# define SYSCALL_ARG_SIZE 8
#else
@@ -130,26 +130,6 @@
# define HAVE_GETTIMEOFDAY_VSYSCALL "__vdso_gettimeofday"
# define HAVE_GETCPU_VSYSCALL "__vdso_getcpu"
-/* Define a macro which expands into the inline wrapper code for a system
- call. */
-# undef INLINE_SYSCALL
-# define INLINE_SYSCALL(name, nr, args...) \
- ({ INTERNAL_SYSCALL_DECL (err); \
- long int __sys_result = INTERNAL_SYSCALL (name, err, nr, args); \
- if (__glibc_unlikely (INTERNAL_SYSCALL_ERROR_P (__sys_result, ))) \
- { \
- __set_errno (INTERNAL_SYSCALL_ERRNO (__sys_result, )); \
- __sys_result = (unsigned long) -1; \
- } \
- __sys_result; })
-
-# define INTERNAL_SYSCALL_DECL(err) do { } while (0)
-
-# define INTERNAL_SYSCALL_ERROR_P(val, err) \
- ((unsigned long int) (val) > -4096UL)
-
-# define INTERNAL_SYSCALL_ERRNO(val, err) (-val)
-
# define INTERNAL_SYSCALL(name, err, nr, args...) \
internal_syscall##nr (SYS_ify (name), err, args)
@@ -26,11 +26,6 @@
#include <dl-sysdep.h> /* For RTLD_PRIVATE_ERRNO. */
#include <tls.h>
-/* Define __set_errno() for INLINE_SYSCALL macro below. */
-#ifndef __ASSEMBLER__
-#include <errno.h>
-#endif
-
/* For Linux we can use the system call table in the header file
/usr/include/asm/unistd.h
of the kernel. But these symbols do not follow the SYS_* syntax
@@ -27,11 +27,6 @@
#include <dl-sysdep.h> /* For RTLD_PRIVATE_ERRNO. */
#include <tls.h>
-/* Define __set_errno() for INLINE_SYSCALL macro below. */
-#ifndef __ASSEMBLER__
-#include <errno.h>
-#endif
-
/* For Linux we can use the system call table in the header file
/usr/include/asm/unistd.h
of the kernel. But these symbols do not follow the SYS_* syntax
@@ -21,20 +21,6 @@
#undef SYS_ify
#define SYS_ify(syscall_name) __NR_##syscall_name
-#undef INLINE_SYSCALL
-#define INLINE_SYSCALL(name, nr, args...) \
- ({ \
- long _ret = INTERNAL_SYSCALL (name, , nr, args); \
- if (__glibc_unlikely (INTERNAL_SYSCALL_ERROR_P (_ret, ))) \
- { \
- __set_errno (INTERNAL_SYSCALL_ERRNO (_ret, )); \
- _ret = -1; \
- } \
- _ret; })
-
-#undef INTERNAL_SYSCALL_DECL
-#define INTERNAL_SYSCALL_DECL(err) do { } while (0)
-
#undef INTERNAL_SYSCALL_DIRECT
#define INTERNAL_SYSCALL_DIRECT(name, err, nr, args...) \
({ \
@@ -79,13 +65,6 @@
? INTERNAL_SYSCALL_DIRECT(name, nr, args) \
: INTERNAL_SYSCALL_SVC0(name, nr, args))
-#undef INTERNAL_SYSCALL_ERROR_P
-#define INTERNAL_SYSCALL_ERROR_P(val, err) \
- ((unsigned long) (val) >= -4095UL)
-
-#undef INTERNAL_SYSCALL_ERRNO
-#define INTERNAL_SYSCALL_ERRNO(val, err) (-(val))
-
#define DECLARGS_0()
#define DECLARGS_1(arg1) \
register unsigned long gpr2 __asm__ ("2") = (unsigned long)(arg1);
@@ -287,17 +287,6 @@
register long int r1 asm ("%r1") = (long int) (_arg6); \
register long int r2 asm ("%r2") = (long int) (_arg7)
-#undef INLINE_SYSCALL
-#define INLINE_SYSCALL(name, nr, args...) \
- ({ \
- unsigned int resultvar = INTERNAL_SYSCALL (name, , nr, args); \
- if (__builtin_expect (INTERNAL_SYSCALL_ERROR_P (resultvar, ), 0)) \
- { \
- __set_errno (INTERNAL_SYSCALL_ERRNO (resultvar, )); \
- resultvar = 0xffffffff; \
- } \
- (int) resultvar; })
-
#undef INTERNAL_SYSCALL
#define INTERNAL_SYSCALL(name, err, nr, args...) \
({ \
@@ -326,16 +315,6 @@
\
(int) resultvar; })
-#undef INTERNAL_SYSCALL_DECL
-#define INTERNAL_SYSCALL_DECL(err) do { } while (0)
-
-#undef INTERNAL_SYSCALL_ERROR_P
-#define INTERNAL_SYSCALL_ERROR_P(val, err) \
- ((unsigned int) (val) >= 0xfffff001u)
-
-#undef INTERNAL_SYSCALL_ERRNO
-#define INTERNAL_SYSCALL_ERRNO(val, err) (-(val))
-
#endif /* __ASSEMBLER__ */
/* Pointer mangling support. */
@@ -21,8 +21,7 @@
break value (instead of the new, requested one). */
#include <sysdep.h>
-#define _ERRNO_H
-#include <bits/errno.h>
+#include <errno.h>
#ifdef PIC
.section .bss
@@ -45,21 +45,6 @@
# endif
# define HAVE_GETTIMEOFDAY_VSYSCALL "__vdso_gettimeofday"
-#undef INLINE_SYSCALL
-#define INLINE_SYSCALL(name, nr, args...) \
-({ INTERNAL_SYSCALL_DECL(err); \
- unsigned long resultvar = INTERNAL_SYSCALL(name, err, nr, args);\
- if (INTERNAL_SYSCALL_ERROR_P (resultvar, err)) \
- { \
- __set_errno (INTERNAL_SYSCALL_ERRNO (resultvar, err)); \
- resultvar = (unsigned long) -1; \
- } \
- (long) resultvar; \
-})
-
-#undef INTERNAL_SYSCALL_DECL
-#define INTERNAL_SYSCALL_DECL(err) do { } while (0)
-
#undef INTERNAL_SYSCALL
#define INTERNAL_SYSCALL(name, err, nr, args...) \
internal_syscall##nr(__SYSCALL_STRING, err, __NR_##name, args)
@@ -68,13 +53,6 @@
#define INTERNAL_SYSCALL_NCS(name, err, nr, args...) \
internal_syscall##nr(__SYSCALL_STRING, err, name, args)
-#undef INTERNAL_SYSCALL_ERROR_P
-#define INTERNAL_SYSCALL_ERROR_P(val, err) \
- ((unsigned long) (val) >= (unsigned long) -4095)
-
-#undef INTERNAL_SYSCALL_ERRNO
-#define INTERNAL_SYSCALL_ERRNO(val, err) (-(val))
-
#define internal_syscall0(string,err,name,dummy...) \
({ \
register long __err __asm__("g1") = (name); \
@@ -15,8 +15,44 @@
License along with the GNU C Library; if not, see
<https://www.gnu.org/licenses/>. */
+#ifndef _SYSDEP_LINUX_H
+#define _SYSDEP_LINUX_H
+
#include <bits/wordsize.h>
#include <kernel-features.h>
+#include <errno.h>
+
+#ifndef __ASSEMBLER__
+
+#undef INTERNAL_SYSCALL_DECL
+#define INTERNAL_SYSCALL_DECL(err) do { } while (0)
+
+#undef INTERNAL_SYSCALL_ERROR_P
+#define INTERNAL_SYSCALL_ERROR_P(val, err) \
+ ((unsigned long) (val) > -4096UL)
+
+#ifndef SYSCALL_ERROR_LABEL
+# define SYSCALL_ERROR_LABEL(sc_err) \
+ ({ \
+ __set_errno (sc_err); \
+ -1L; \
+ })
+#endif
+
+/* This version is for kernels that implement system calls that
+ behave like function calls as far as register saving. */
+#undef INLINE_SYSCALL
+#define INLINE_SYSCALL(name, nr, args...) \
+ ({ \
+ INTERNAL_SYSCALL_DECL (sc_err); \
+ long int sc_ret = INTERNAL_SYSCALL (name, sc_err, nr, args); \
+ __glibc_unlikely (INTERNAL_SYSCALL_ERROR_P (sc_ret, sc_err)) \
+ ? SYSCALL_ERROR_LABEL (INTERNAL_SYSCALL_ERRNO (sc_ret, sc_err)) \
+ : sc_ret; \
+ })
+
+#undef INTERNAL_SYSCALL_ERRNO
+#define INTERNAL_SYSCALL_ERRNO(val, err) (-(val))
/* Set error number and return -1. A target may choose to return the
internal function, __syscall_error, which sets errno and returns -1.
@@ -66,3 +102,7 @@
/* Exports the __send symbol on send.c linux implementation (some ABI have
it missing due the usage of a old generic version without it). */
#define HAVE_INTERNAL_SEND_SYMBOL 1
+
+#endif /* __ASSEMBLER__ */
+
+#endif /* _SYSDEP_LINUX_H */
@@ -177,35 +177,6 @@
# define DOARGS_6 DOARGS_5
#else /* !__ASSEMBLER__ */
-/* Define a macro which expands inline into the wrapper code for a system
- call. */
-# undef INLINE_SYSCALL
-# define INLINE_SYSCALL(name, nr, args...) \
- ({ \
- unsigned long int resultvar = INTERNAL_SYSCALL (name, , nr, args); \
- if (__glibc_unlikely (INTERNAL_SYSCALL_ERROR_P (resultvar, ))) \
- { \
- __set_errno (INTERNAL_SYSCALL_ERRNO (resultvar, )); \
- resultvar = (unsigned long int) -1; \
- } \
- (long int) resultvar; })
-
-/* Define a macro with explicit types for arguments, which expands inline
- into the wrapper code for a system call. It should be used when size
- of any argument > size of long int. */
-# undef INLINE_SYSCALL_TYPES
-# define INLINE_SYSCALL_TYPES(name, nr, args...) \
- ({ \
- unsigned long int resultvar = INTERNAL_SYSCALL_TYPES (name, , nr, args); \
- if (__glibc_unlikely (INTERNAL_SYSCALL_ERROR_P (resultvar, ))) \
- { \
- __set_errno (INTERNAL_SYSCALL_ERRNO (resultvar, )); \
- resultvar = (unsigned long int) -1; \
- } \
- (long int) resultvar; })
-
-# undef INTERNAL_SYSCALL_DECL
-# define INTERNAL_SYSCALL_DECL(err) do { } while (0)
/* Registers clobbered by syscall. */
# define REGISTERS_CLOBBERED_BY_SYSCALL "cc", "r11", "cx"
@@ -353,12 +324,6 @@
(long int) resultvar; \
})
-# undef INTERNAL_SYSCALL_ERROR_P
-# define INTERNAL_SYSCALL_ERROR_P(val, err) \
- ((unsigned long int) (long int) (val) >= -4095L)
-
-# undef INTERNAL_SYSCALL_ERRNO
-# define INTERNAL_SYSCALL_ERRNO(val, err) (-(val))
# define VDSO_NAME "LINUX_2.6"
# define VDSO_HASH 61765110
@@ -16,8 +16,7 @@
<https://www.gnu.org/licenses/>. */
#include <sysdep.h>
-#define _ERRNO_H
-#include <bits/errno.h>
+#include <errno.h>
#include <tls.h>
#if IS_IN (rtld)
@@ -16,8 +16,8 @@
License along with the GNU C Library; if not, see
<https://www.gnu.org/licenses/>. */
-#include <pthread-errnos.h>
#include <sysdep.h>
+#include <errno.h>
#ifdef UP