From e33a23fbe8c2dba04fe05678c584d3efcb6c9951 Mon Sep 17 00:00:00 2001 From: Adhemerval Zanella Date: Thu, 30 Jun 2016 16:34:18 -0300 Subject: Add INTERNAL_SYSCALL_CALL This patch adds two new macros for internal and inline syscall to use within GLIBC: INTERNAL_SYSCALL_CALL and INLINE_SYSCALL_CALL. They are similar to the old INTERNAL_SYSCALL and INLINE_SYSCALL with the difference the new macros accept a variable argument call and do not require to pass the expected argument size. The advantage is it is possible to use variable argument macros like SYSCALL_LL{64} without the need to also handle the argument size. So for an ABI where SYSCALL_LL might split the argument in high and low parts, instead of: INTERNAL_SYSCALL_DECL (err); #if ... INTERNAL_SYSCALL (syscall, err, 2, SYSCALL_LL (len)); #else INTERNAL_SYSCALL (syscall, err, 1, SYSCALL_LL (len)); #endif It will be just: INTERNAL_SYSCALL_CALL (syscall, err, SYSCALL_LL (len)); The INLINE_SYSCALL_CALL follows the same semanthic regarding the argument and is similar to INLINE_SYSCALL regarding setting errno. Checked with a build for x86_64, i386, aach64, armhf, powerpc64le, powerpc32, and mips32. No code generation changed. * sysdeps/unix/sysdep.h (__INTERNAL_SYSCALL0): New macro. (__INTERNAL_SYSCALL1): Likewise. (__INTERNAL_SYSCALL2): Likewise. (__INTERNAL_SYSCALL3): Likewise. (__INTERNAL_SYSCALL4): Likewise. (__INTERNAL_SYSCALL5): Likewise. (__INTERNAL_SYSCALL6): Likewise. (__INTERNAL_SYSCALL7): Likewise. (__INTERNAL_SYSCALL_NARGS_X): Likewise. (__INTERNAL_SYSCALL_NARGS): Likewise. (__INTERNAL_SYSCALL_DISP): Likewise. (INTERNAL_SYSCALL_CALL): Likewise. (__SYSCALL0): Rename to __INLINE_SYSCALL0. (__SYSCALL1): Rename to __INLINE_SYSCALL1. (__SYSCALL2): Rename to __INLINE_SYSCALL2. (__SYSCALL3): Rename to __INLINE_SYSCALL3. (__SYSCALL4): Rename to __INLINE_SYSCALL4. (__SYSCALL5): Rename to __INLINE_SYSCALL5. (__SYSCALL6): Rename to __INLINE_SYSCALL6. (__SYSCALL7): Rename to __INLINE_SYSCALL7. (__SYSCALL_NARGS_X): Rename to __INLINE_SYSCALL_NARGS_X. (__SYSCALL_NARGS): Rename to __INLINE_SYSCALL_NARGS. (__SYSCALL_DISP): Rename to __INLINE_SYSCALL_DISP. (__SYSCALL_CALL): Rename to INLINE_SYSCALL_CALL. (SYSCALL_CANCEL): Replace __SYSCALL_CALL with INLINE_SYSCALL_CALL. --- sysdeps/unix/sysdep.h | 73 ++++++++++++++++++++++++++++++++++++++------------- 1 file changed, 55 insertions(+), 18 deletions(-) (limited to 'sysdeps/unix/sysdep.h') diff --git a/sysdeps/unix/sysdep.h b/sysdeps/unix/sysdep.h index 94a2ce0e37..38c2432002 100644 --- a/sysdeps/unix/sysdep.h +++ b/sysdeps/unix/sysdep.h @@ -24,42 +24,79 @@ #define SYSCALL__(name, args) PSEUDO (__##name, name, args) #define SYSCALL(name, args) PSEUDO (name, name, args) -#define __SYSCALL0(name) \ +#define __SYSCALL_CONCAT_X(a,b) a##b +#define __SYSCALL_CONCAT(a,b) __SYSCALL_CONCAT_X (a, b) + + +#define __INTERNAL_SYSCALL0(name, err) \ + INTERNAL_SYSCALL (name, err, 0) +#define __INTERNAL_SYSCALL1(name, err, a1) \ + INTERNAL_SYSCALL (name, err, 1, a1) +#define __INTERNAL_SYSCALL2(name, err, a1, a2) \ + INTERNAL_SYSCALL (name, err, 2, a1, a2) +#define __INTERNAL_SYSCALL3(name, err, a1, a2, a3) \ + INTERNAL_SYSCALL (name, err, 3, a1, a2, a3) +#define __INTERNAL_SYSCALL4(name, err, a1, a2, a3, a4) \ + INTERNAL_SYSCALL (name, err, 4, a1, a2, a3, a4) +#define __INTERNAL_SYSCALL5(name, err, a1, a2, a3, a4, a5) \ + INTERNAL_SYSCALL (name, err, 5, a1, a2, a3, a4, a5) +#define __INTERNAL_SYSCALL6(name, err, a1, a2, a3, a4, a5, a6) \ + INTERNAL_SYSCALL (name, err, 6, a1, a2, a3, a4, a5, a6) +#define __INTERNAL_SYSCALL7(name, err, a1, a2, a3, a4, a5, a6, a7) \ + INTERNAL_SYSCALL (name, err, 7, a1, a2, a3, a4, a5, a6, a7) + +#define __INTERNAL_SYSCALL_NARGS_X(a,b,c,d,e,f,g,h,n,o,...) o +#define __INTERNAL_SYSCALL_NARGS(...) \ + __INTERNAL_SYSCALL_NARGS_X (__VA_ARGS__,7,6,5,4,3,2,1,0,) +#define __INTERNAL_SYSCALL_DISP(b,...) \ + __SYSCALL_CONCAT (b,__INTERNAL_SYSCALL_NARGS(__VA_ARGS__))(__VA_ARGS__) + +/* Issue a syscall defined by syscall number plus any other argument required. + It is similar to INTERNAL_SYSCALL macro, but without the need to pass the + expected argument number as second parameter. */ +#define INTERNAL_SYSCALL_CALL(...) \ + __INTERNAL_SYSCALL_DISP (__INTERNAL_SYSCALL, __VA_ARGS__) + +#define __INLINE_SYSCALL0(name) \ INLINE_SYSCALL (name, 0) -#define __SYSCALL1(name, a1) \ +#define __INLINE_SYSCALL1(name, a1) \ INLINE_SYSCALL (name, 1, a1) -#define __SYSCALL2(name, a1, a2) \ +#define __INLINE_SYSCALL2(name, a1, a2) \ INLINE_SYSCALL (name, 2, a1, a2) -#define __SYSCALL3(name, a1, a2, a3) \ +#define __INLINE_SYSCALL3(name, a1, a2, a3) \ INLINE_SYSCALL (name, 3, a1, a2, a3) -#define __SYSCALL4(name, a1, a2, a3, a4) \ +#define __INLINE_SYSCALL4(name, a1, a2, a3, a4) \ INLINE_SYSCALL (name, 4, a1, a2, a3, a4) -#define __SYSCALL5(name, a1, a2, a3, a4, a5) \ +#define __INLINE_SYSCALL5(name, a1, a2, a3, a4, a5) \ INLINE_SYSCALL (name, 5, a1, a2, a3, a4, a5) -#define __SYSCALL6(name, a1, a2, a3, a4, a5, a6) \ +#define __INLINE_SYSCALL6(name, a1, a2, a3, a4, a5, a6) \ INLINE_SYSCALL (name, 6, a1, a2, a3, a4, a5, a6) -#define __SYSCALL7(name, a1, a2, a3, a4, a5, a6, a7) \ +#define __INLINE_SYSCALL7(name, a1, a2, a3, a4, a5, a6, a7) \ INLINE_SYSCALL (name, 7, a1, a2, a3, a4, a5, a6, a7) -#define __SYSCALL_NARGS_X(a,b,c,d,e,f,g,h,n,...) n -#define __SYSCALL_NARGS(...) \ - __SYSCALL_NARGS_X (__VA_ARGS__,7,6,5,4,3,2,1,0,) -#define __SYSCALL_CONCAT_X(a,b) a##b -#define __SYSCALL_CONCAT(a,b) __SYSCALL_CONCAT_X (a, b) -#define __SYSCALL_DISP(b,...) \ - __SYSCALL_CONCAT (b,__SYSCALL_NARGS(__VA_ARGS__))(__VA_ARGS__) +#define __INLINE_SYSCALL_NARGS_X(a,b,c,d,e,f,g,h,n,...) n +#define __INLINE_SYSCALL_NARGS(...) \ + __INLINE_SYSCALL_NARGS_X (__VA_ARGS__,7,6,5,4,3,2,1,0,) +#define __INLINE_SYSCALL_DISP(b,...) \ + __SYSCALL_CONCAT (b,__INLINE_SYSCALL_NARGS(__VA_ARGS__))(__VA_ARGS__) -#define __SYSCALL_CALL(...) __SYSCALL_DISP (__SYSCALL, __VA_ARGS__) +/* Issue a syscall defined by syscall number plus any other argument + required. Any error will be handled using arch defined macros and errno + will be set accordingly. + It is similar to INLINE_SYSCALL macro, but without the need to pass the + expected argument number as second parameter. */ +#define INLINE_SYSCALL_CALL(...) \ + __INLINE_SYSCALL_DISP (__INLINE_SYSCALL, __VA_ARGS__) #define SYSCALL_CANCEL(...) \ ({ \ long int sc_ret; \ if (SINGLE_THREAD_P) \ - sc_ret = __SYSCALL_CALL (__VA_ARGS__); \ + sc_ret = INLINE_SYSCALL_CALL (__VA_ARGS__); \ else \ { \ int sc_cancel_oldtype = LIBC_CANCEL_ASYNC (); \ - sc_ret = __SYSCALL_CALL (__VA_ARGS__); \ + sc_ret = INLINE_SYSCALL_CALL (__VA_ARGS__); \ LIBC_CANCEL_RESET (sc_cancel_oldtype); \ } \ sc_ret; \ -- cgit v1.2.3