| Message ID | 1471617709-16267-2-git-send-email-adhemerval.zanella@linaro.org |
|---|---|
| State | New |
| Headers | show |
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...
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 +#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; \
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(-)