From patchwork Fri Aug 19 14:41:46 2016 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Adhemerval Zanella Netto X-Patchwork-Id: 14782 Received: (qmail 12384 invoked by alias); 19 Aug 2016 14:42:08 -0000 Mailing-List: contact libc-alpha-help@sourceware.org; run by ezmlm Precedence: bulk List-Id: List-Unsubscribe: List-Subscribe: List-Archive: List-Post: List-Help: , Sender: libc-alpha-owner@sourceware.org Delivered-To: mailing list libc-alpha@sourceware.org Received: (qmail 12352 invoked by uid 89); 19 Aug 2016 14:42:07 -0000 Authentication-Results: sourceware.org; auth=none X-Virus-Found: No X-Spam-SWARE-Status: No, score=-1.9 required=5.0 tests=BAYES_00, RCVD_IN_DNSWL_NONE, SPF_PASS autolearn=ham version=3.3.2 spammy=ab, a, b X-HELO: mail-yw0-f174.google.com X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20130820; h=x-gm-message-state:from:to:subject:date:message-id:in-reply-to :references; bh=MXjib9kfXNiD8RwoU6eaFlzvF303g1z8kUqI0RyWztI=; b=IFRcUDbXBBOJDfUCK5mfFbNiYjBdVtKi2EXzvPSBT82dy+afkraW6QMvO1d7NFubL+ z39bJjk44de4/ParJ9naH6LePvr5A0bsBvbDSRhHP7Q4cleO3uwdiSAWcnc5XTMyup9t SRs+vqYTNhVsKexDLX4Xs7Ay87zOIxp02N3gwOvXW9FpJVMM3W9O4MttCB3XvwvN4USK 0XR6wQM4m/jNY65wKPoMG61NsHCBSR/Bo/kJsLGvwY2UY/5FHD3dVNHTp0DE4g4rD/2Z uw4eW5hLaqi4Iq2ePIsHY1bqEJbhh6OzbdckZu2GAAy8QDTwPXEkc5goW/d3buqHkBOg 1ZMg== X-Gm-Message-State: AEkoousgKTEnWGq8ND3qzGjfYMWJHReBCOEpEC30zcE7KayouLouCrI3HD/DcFanVvx1jJR7 X-Received: by 10.129.108.194 with SMTP id h185mr6337077ywc.153.1471617716970; Fri, 19 Aug 2016 07:41:56 -0700 (PDT) From: Adhemerval Zanella To: libc-alpha@sourceware.org Subject: [PATCH 1/4] Add INTERNAL_SYSCALL_CALL Date: Fri, 19 Aug 2016 11:41:46 -0300 Message-Id: <1471617709-16267-2-git-send-email-adhemerval.zanella@linaro.org> In-Reply-To: <1471617709-16267-1-git-send-email-adhemerval.zanella@linaro.org> References: <1471617709-16267-1-git-send-email-adhemerval.zanella@linaro.org> 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 +#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; \