[1/4] Add INTERNAL_SYSCALL_CALL
Commit Message
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.
* 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_CONCAT_X): Likewise.
(__INTERNAL_SYSCALL_CONCAT): Likewise.
(__INTERNAL_SYSCALL_DISP): Likewise.
(INTERNAL_SYSCALL_CALL): Likewise.
(__SYSCALL_CALL): Rename to INLINE_SYSCALL_CALL.
(SYSCALL_CANCEL): Replace __SYSCALL_CALL with INLINE_SYSCALL_CALL.
---
sysdeps/unix/sysdep.h | 42 +++++++++++++++++++++++++++++++++++++++---
2 files changed, 56 insertions(+), 3 deletions(-)
Comments
On Fri, Aug 19, 2016 at 11:41:46AM -0300, Adhemerval Zanella wrote:
> 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.
>
> * 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_CONCAT_X): Likewise.
> (__INTERNAL_SYSCALL_CONCAT): Likewise.
> (__INTERNAL_SYSCALL_DISP): Likewise.
> (INTERNAL_SYSCALL_CALL): Likewise.
> (__SYSCALL_CALL): Rename to INLINE_SYSCALL_CALL.
> (SYSCALL_CANCEL): Replace __SYSCALL_CALL with INLINE_SYSCALL_CALL.
> ---
> sysdeps/unix/sysdep.h | 42 +++++++++++++++++++++++++++++++++++++++---
> 2 files changed, 56 insertions(+), 3 deletions(-)
>
> diff --git a/sysdeps/unix/sysdep.h b/sysdeps/unix/sysdep.h
> index 94a2ce0..2253603 100644
> --- a/sysdeps/unix/sysdep.h
> +++ b/sysdeps/unix/sysdep.h
> @@ -24,6 +24,37 @@
> #define SYSCALL__(name, args) PSEUDO (__##name, name, args)
> #define SYSCALL(name, args) PSEUDO (name, name, args)
>
> +#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,...) n
Missed whitespaces after commas?
> +#define __INTERNAL_SYSCALL_NARGS(...) \
> + __INTERNAL_SYSCALL_NARGS_X (__VA_ARGS__,7,6,5,4,3,2,1,0,)
Same
> +#define __INTERNAL_SYSCALL_CONCAT_X(a,b) a##b
Same
> +#define __INTERNAL_SYSCALL_CONCAT(a,b) __SYSCALL_CONCAT_X (a, b)
> +#define __INTERNAL_SYSCALL_DISP(b,err,...) \
> + __INTERNAL_SYSCALL_CONCAT (b,__SYSCALL_NARGS(__VA_ARGS__))(err,__VA_ARGS__)
Missed whitespaces after commas and before opening braces?
> +
> +/* Issue a syscall defined by syscall number plus any other argument required.
> + It is similar to INLINE_SYSCALL macro, but without the need to pass the
Did you mean INTERNAL_SYSCALL macro?
> + expected argument number as second parameter. */
> +#define INTERNAL_SYSCALL_CALL(nr, err, ...) \
> + __INTERNAL_SYSCALL_DISP (__INTERNAL_SYSCALL, nr, err, __VA_ARGS__)
> +
> #define __SYSCALL0(name) \
> INLINE_SYSCALL (name, 0)
> #define __SYSCALL1(name, a1) \
> @@ -49,17 +80,22 @@
> #define __SYSCALL_DISP(b,...) \
> __SYSCALL_CONCAT (b,__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 se
> + 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(...) __SYSCALL_DISP (__SYSCALL, __VA_ARGS__)
Missed whitespaces after commas and before opening braces?
>
> #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; \
> --
> 2.7.4
Thanks for review, comments below.
On 22/08/2016 12:28, Yury Norov wrote:
>> ---
>> sysdeps/unix/sysdep.h | 42 +++++++++++++++++++++++++++++++++++++++---
>> 2 files changed, 56 insertions(+), 3 deletions(-)
>>
>> +
>> +#define __INTERNAL_SYSCALL_NARGS_X(a,b,c,d,e,f,g,h,n,...) n
>
> Missed whitespaces after commas?
>
Ack.
>> +#define __INTERNAL_SYSCALL_NARGS(...) \
>> + __INTERNAL_SYSCALL_NARGS_X (__VA_ARGS__,7,6,5,4,3,2,1,0,)
>
> Same
>
Ack.
>> +#define __INTERNAL_SYSCALL_CONCAT_X(a,b) a##b
>
> Same
>
Ack.
>> +#define __INTERNAL_SYSCALL_CONCAT(a,b) __SYSCALL_CONCAT_X (a, b)
>> +#define __INTERNAL_SYSCALL_DISP(b,err,...) \
>> + __INTERNAL_SYSCALL_CONCAT (b,__SYSCALL_NARGS(__VA_ARGS__))(err,__VA_ARGS__)
>
> Missed whitespaces after commas and before opening braces?
>
Ack.
>> +
>> +/* Issue a syscall defined by syscall number plus any other argument required.
>> + It is similar to INLINE_SYSCALL macro, but without the need to pass the
>
> Did you mean INTERNAL_SYSCALL macro?
>
Yes, I will fix it.
>> + expected argument number as second parameter. */
>> +#define INTERNAL_SYSCALL_CALL(nr, err, ...) \
>> + __INTERNAL_SYSCALL_DISP (__INTERNAL_SYSCALL, nr, err, __VA_ARGS__)
>> +
>> #define __SYSCALL0(name) \
>> INLINE_SYSCALL (name, 0)
>> #define __SYSCALL1(name, a1) \
>> @@ -49,17 +80,22 @@
>> #define __SYSCALL_DISP(b,...) \
>> __SYSCALL_CONCAT (b,__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 se
>> + 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(...) __SYSCALL_DISP (__SYSCALL, __VA_ARGS__)
>
> Missed whitespaces after commas and before opening braces?
For INLINE_SYSCALL_DEFINITION you mean? I do not think so, 'indent' also
shows no change for this specific snippet.
On Tue, Aug 23, 2016 at 04:15:55PM -0300, Adhemerval Zanella wrote:
> Thanks for review, comments below.
>
> On 22/08/2016 12:28, Yury Norov wrote:
> >> ---
> >> sysdeps/unix/sysdep.h | 42 +++++++++++++++++++++++++++++++++++++++---
> >> 2 files changed, 56 insertions(+), 3 deletions(-)
> >>
> >> +
> >> +#define __INTERNAL_SYSCALL_NARGS_X(a,b,c,d,e,f,g,h,n,...) n
> >
> > Missed whitespaces after commas?
> >
>
> Ack.
>
> >> +#define __INTERNAL_SYSCALL_NARGS(...) \
> >> + __INTERNAL_SYSCALL_NARGS_X (__VA_ARGS__,7,6,5,4,3,2,1,0,)
> >
> > Same
> >
>
> Ack.
>
> >> +#define __INTERNAL_SYSCALL_CONCAT_X(a,b) a##b
> >
> > Same
> >
>
> Ack.
>
> >> +#define __INTERNAL_SYSCALL_CONCAT(a,b) __SYSCALL_CONCAT_X (a, b)
> >> +#define __INTERNAL_SYSCALL_DISP(b,err,...) \
> >> + __INTERNAL_SYSCALL_CONCAT (b,__SYSCALL_NARGS(__VA_ARGS__))(err,__VA_ARGS__)
> >
> > Missed whitespaces after commas and before opening braces?
> >
>
> Ack.
>
> >> +
> >> +/* Issue a syscall defined by syscall number plus any other argument required.
> >> + It is similar to INLINE_SYSCALL macro, but without the need to pass the
> >
> > Did you mean INTERNAL_SYSCALL macro?
> >
>
> Yes, I will fix it.
>
> >> + expected argument number as second parameter. */
> >> +#define INTERNAL_SYSCALL_CALL(nr, err, ...) \
> >> + __INTERNAL_SYSCALL_DISP (__INTERNAL_SYSCALL, nr, err, __VA_ARGS__)
> >> +
> >> #define __SYSCALL0(name) \
> >> INLINE_SYSCALL (name, 0)
> >> #define __SYSCALL1(name, a1) \
> >> @@ -49,17 +80,22 @@
> >> #define __SYSCALL_DISP(b,...) \
> >> __SYSCALL_CONCAT (b,__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 se
> >> + 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(...) __SYSCALL_DISP (__SYSCALL, __VA_ARGS__)
> >
> > Missed whitespaces after commas and before opening braces?
>
> For INLINE_SYSCALL_DEFINITION you mean? I do not think so, 'indent' also
> shows no change for this specific snippet.
I missed. It was about __SYSCALL_DISP(), though you didn't touch it...
@@ -24,6 +24,37 @@
#define SYSCALL__(name, args) PSEUDO (__##name, name, args)
#define SYSCALL(name, args) PSEUDO (name, name, args)
+#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,...) n
+#define __INTERNAL_SYSCALL_NARGS(...) \
+ __INTERNAL_SYSCALL_NARGS_X (__VA_ARGS__,7,6,5,4,3,2,1,0,)
+#define __INTERNAL_SYSCALL_CONCAT_X(a,b) a##b
+#define __INTERNAL_SYSCALL_CONCAT(a,b) __SYSCALL_CONCAT_X (a, b)
+#define __INTERNAL_SYSCALL_DISP(b,err,...) \
+ __INTERNAL_SYSCALL_CONCAT (b,__SYSCALL_NARGS(__VA_ARGS__))(err,__VA_ARGS__)
+
+/* Issue a syscall defined by syscall number plus any other argument required.
+ It is similar to INLINE_SYSCALL macro, but without the need to pass the
+ expected argument number as second parameter. */
+#define INTERNAL_SYSCALL_CALL(nr, err, ...) \
+ __INTERNAL_SYSCALL_DISP (__INTERNAL_SYSCALL, nr, err, __VA_ARGS__)
+
#define __SYSCALL0(name) \
INLINE_SYSCALL (name, 0)
#define __SYSCALL1(name, a1) \
@@ -49,17 +80,22 @@
#define __SYSCALL_DISP(b,...) \
__SYSCALL_CONCAT (b,__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 se
+ 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(...) __SYSCALL_DISP (__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; \