Re: [PATCH 1/4] Add INTERNAL_SYSCALL_CALL

[Yury Norov <ynorov at caviumnetworks dot com>]

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