The current api from safe_syscall_base() is to return -errno, which is
the interface provided by *some* linux kernel abis. The wrapper macro,
safe_syscall(), detects error, stores into errno, and returns -1, to
match the api of the system syscall().
For those kernel abis that do not return -errno natively, this leads
to double syscall error detection. E.g. Linux ppc64, which sets the
SO flag for error.
Simplify the usage from C by moving the error detection into assembly.
Signed-off-by: Richard Henderson <richard.hender...@linaro.org>
---
linux-user/safe-syscall.h | 20 +++---
common-user/host/aarch64/safe-syscall.inc.S | 55 +++++++++-------
common-user/host/arm/safe-syscall.inc.S | 58 ++++++++++-------
common-user/host/i386/safe-syscall.inc.S | 51 +++++++++------
common-user/host/ppc64/safe-syscall.inc.S | 63 +++++++++++--------
common-user/host/riscv/safe-syscall.inc.S | 50 +++++++++------
common-user/host/s390x/safe-syscall.inc.S | 50 +++++++++------
common-user/host/x86_64/safe-syscall.inc.S | 70 ++++++++++++---------
8 files changed, 243 insertions(+), 174 deletions(-)
diff --git a/linux-user/safe-syscall.h b/linux-user/safe-syscall.h
index aaa9ffc0e2..ea0e8a8d24 100644
--- a/linux-user/safe-syscall.h
+++ b/linux-user/safe-syscall.h
@@ -125,23 +125,17 @@
* kinds of restartability.
*/
#ifdef HAVE_SAFE_SYSCALL
-/* The core part of this function is implemented in assembly */
-extern long safe_syscall_base(int *pending, long number, ...);
+
+/* The core part of this function is implemented in assembly. */
+extern long safe_syscall_base(int *pending, int *errnop, long number, ...);
+
/* These are defined by the safe-syscall.inc.S file */
extern char safe_syscall_start[];
extern char safe_syscall_end[];
-#define safe_syscall(...) \
- ({ \
- long ret_; \
- int *psp_ = &((TaskState *)thread_cpu->opaque)->signal_pending; \
- ret_ = safe_syscall_base(psp_, __VA_ARGS__); \
- if (is_error(ret_)) { \
- errno = -ret_; \
- ret_ = -1; \
- } \
- ret_; \
- })
+#define safe_syscall(...) \
+ safe_syscall_base(&((TaskState *)thread_cpu->opaque)->signal_pending, \
+ &errno, __VA_ARGS__)
#else
diff --git a/common-user/host/aarch64/safe-syscall.inc.S
b/common-user/host/aarch64/safe-syscall.inc.S
index bc1f5a9792..95c60d8609 100644
--- a/common-user/host/aarch64/safe-syscall.inc.S
+++ b/common-user/host/aarch64/safe-syscall.inc.S
@@ -17,22 +17,21 @@
.type safe_syscall_start, #function
.type safe_syscall_end, #function
- /* This is the entry point for making a system call. The calling
+ /*
+ * This is the entry point for making a system call. The calling
* convention here is that of a C varargs function with the
* first argument an 'int *' to the signal_pending flag, the
* second one the system call number (as a 'long'), and all further
* arguments being syscall arguments (also 'long').
- * We return a long which is the syscall's return value, which
- * may be negative-errno on failure. Conversion to the
- * -1-and-errno-set convention is done by the calling wrapper.
*/
safe_syscall_base:
.cfi_startproc
- /* The syscall calling convention isn't the same as the
- * C one:
+ /*
+ * The syscall calling convention isn't the same as the C one:
* we enter with x0 == *signal_pending
- * x1 == syscall number
- * x2 ... x7, (stack) == syscall arguments
+ * x1 == errno
+ * x2 == syscall number
+ * x3 ... x7, (stack) == syscall arguments
* and return the result in x0
* and the syscall instruction needs
* x8 == syscall number
@@ -40,17 +39,18 @@ safe_syscall_base:
* and returns the result in x0
* Shuffle everything around appropriately.
*/
- mov x9, x0 /* signal_pending pointer */
- mov x8, x1 /* syscall number */
- mov x0, x2 /* syscall arguments */
- mov x1, x3
- mov x2, x4
- mov x3, x5
- mov x4, x6
- mov x5, x7
- ldr x6, [sp]
+ mov x10, x0 /* signal_pending pointer */
+ mov x11, x1 /* errno pointer */
+ mov x8, x2 /* syscall number */
+ mov x0, x3 /* syscall arguments */
+ mov x1, x4
+ mov x2, x5
+ mov x3, x6
+ mov x4, x7
+ ldp x5, x6, [sp]
- /* This next sequence of code works in conjunction with the
+ /*
+ * This next sequence of code works in conjunction with the
* rewind_if_safe_syscall_function(). If a signal is taken
* and the interrupted PC is anywhere between 'safe_syscall_start'
* and 'safe_syscall_end' then we rewind it to 'safe_syscall_start'.
@@ -59,17 +59,26 @@ safe_syscall_base:
*/
safe_syscall_start:
/* if signal_pending is non-zero, don't do the call */
- ldr w10, [x9]
- cbnz w10, 0f
+ ldr w9, [x10]
+ cbnz w9, 2f
svc 0x0
safe_syscall_end:
+
/* code path for having successfully executed the syscall */
+ cmn x0, #4095
+ b.cs 1f
ret
-0:
- /* code path when we didn't execute the syscall */
- mov x0, #-TARGET_ERESTARTSYS
+ /* code path setting errno */
+0: neg w0, w0 /* create positive errno */
+1: str w0, [x11] /* store errno */
+ mov x0, #-1
ret
+
+ /* code path when we didn't execute the syscall */
+2: mov w0, #TARGET_ERESTARTSYS
+ b 1b
+
.cfi_endproc
.size safe_syscall_base, .-safe_syscall_base
diff --git a/common-user/host/arm/safe-syscall.inc.S
b/common-user/host/arm/safe-syscall.inc.S
index 88c4958504..17839c6486 100644
--- a/common-user/host/arm/safe-syscall.inc.S
+++ b/common-user/host/arm/safe-syscall.inc.S
@@ -22,33 +22,35 @@
.arm
.align 2
- /* This is the entry point for making a system call. The calling
+ /*
+ * This is the entry point for making a system call. The calling
* convention here is that of a C varargs function with the
* first argument an 'int *' to the signal_pending flag, the
* second one the system call number (as a 'long'), and all further
* arguments being syscall arguments (also 'long').
- * We return a long which is the syscall's return value, which
- * may be negative-errno on failure. Conversion to the
- * -1-and-errno-set convention is done by the calling wrapper.
*/
safe_syscall_base:
.fnstart
.cfi_startproc
mov r12, sp /* save entry stack */
- push { r4, r5, r6, r7, r8, lr }
- .save { r4, r5, r6, r7, r8, lr }
- .cfi_adjust_cfa_offset 24
+ push { r4, r5, r6, r7, r8, r9, r10, lr }
+ .save { r4, r5, r6, r7, r8, r9, r10, lr }
+ .cfi_adjust_cfa_offset 32
.cfi_rel_offset r4, 0
.cfi_rel_offset r5, 4
.cfi_rel_offset r6, 8
.cfi_rel_offset r7, 12
.cfi_rel_offset r8, 16
- .cfi_rel_offset lr, 20
+ .cfi_rel_offset r9, 20
+ .cfi_rel_offset r10, 24
+ .cfi_rel_offset lr, 28
- /* The syscall calling convention isn't the same as the C one:
- * we enter with r0 == *signal_pending
- * r1 == syscall number
- * r2, r3, [sp+0] ... [sp+12] == syscall arguments
+ /*
+ * The syscall calling convention isn't the same as the C one:
+ * we enter with r0 == &signal_pending
+ * r1 == &errno
+ * r2 == syscall number
+ * r3, [sp+0] ... [sp+16] == syscall arguments
* and return the result in r0
* and the syscall instruction needs
* r7 == syscall number
@@ -58,12 +60,13 @@ safe_syscall_base:
* Note the 16 bytes that we pushed to save registers.
*/
mov r8, r0 /* copy signal_pending */
- mov r7, r1 /* syscall number */
- mov r0, r2 /* syscall args */
- mov r1, r3
- ldm r12, { r2, r3, r4, r5, r6 }
+ mov r9, r1 /* copy errnop */
+ mov r7, r2 /* syscall number */
+ mov r0, r3 /* syscall args */
+ ldm r12, { r1, r2, r3, r4, r5, r6 }
- /* This next sequence of code works in conjunction with the
+ /*
+ * This next sequence of code works in conjunction with the
* rewind_if_safe_syscall_function(). If a signal is taken
* and the interrupted PC is anywhere between 'safe_syscall_start'
* and 'safe_syscall_end' then we rewind it to 'safe_syscall_start'.
@@ -74,16 +77,25 @@ safe_syscall_start:
/* if signal_pending is non-zero, don't do the call */
ldr r12, [r8] /* signal_pending */
tst r12, r12
- bne 1f
+ bne 2f
swi 0
safe_syscall_end:
- /* code path for having successfully executed the syscall */
- pop { r4, r5, r6, r7, r8, pc }
-1:
+ /* code path for having successfully executed the syscall */
+ cmp r0, #-4096
+ bhi 0f
+9: pop { r4, r5, r6, r7, r8, r9, r10, pc }
+
+ /* code path setting errno */
+0: neg r0, r0 /* create positive errno */
+1: str r0, [r9] /* store errno */
+ mov r0, #-1
+ b 9b
+
/* code path when we didn't execute the syscall */
- ldr r0, =-TARGET_ERESTARTSYS
- pop { r4, r5, r6, r7, r8, pc }
+2: ldr r0, =TARGET_ERESTARTSYS
+ b 1b
+
.fnend
.cfi_endproc
diff --git a/common-user/host/i386/safe-syscall.inc.S
b/common-user/host/i386/safe-syscall.inc.S
index 9e58fc6504..ad89521783 100644
--- a/common-user/host/i386/safe-syscall.inc.S
+++ b/common-user/host/i386/safe-syscall.inc.S
@@ -15,14 +15,12 @@
.global safe_syscall_end
.type safe_syscall_base, @function
- /* This is the entry point for making a system call. The calling
+ /*
+ * This is the entry point for making a system call. The calling
* convention here is that of a C varargs function with the
* first argument an 'int *' to the signal_pending flag, the
* second one the system call number (as a 'long'), and all further
* arguments being syscall arguments (also 'long').
- * We return a long which is the syscall's return value, which
- * may be negative-errno on failure. Conversion to the
- * -1-and-errno-set convention is done by the calling wrapper.
*/
safe_syscall_base:
.cfi_startproc
@@ -41,9 +39,10 @@ safe_syscall_base:
/* The syscall calling convention isn't the same as the C one:
* we enter with 0(%esp) == return address
- * 4(%esp) == *signal_pending
- * 8(%esp) == syscall number
- * 12(%esp) ... 32(%esp) == syscall arguments
+ * 4(%esp) == &signal_pending
+ * 8(%esp) == &errno
+ * 12(%esp) == syscall number
+ * 16(%esp) ... 36(%esp) == syscall arguments
* and return the result in eax
* and the syscall instruction needs
* eax == syscall number
@@ -52,14 +51,15 @@ safe_syscall_base:
* Shuffle everything around appropriately.
* Note the 16 bytes that we pushed to save registers.
*/
- mov 12+16(%esp), %ebx /* the syscall arguments */
- mov 16+16(%esp), %ecx
- mov 20+16(%esp), %edx
- mov 24+16(%esp), %esi
- mov 28+16(%esp), %edi
- mov 32+16(%esp), %ebp
+ mov 16+16(%esp), %ebx /* the syscall arguments */
+ mov 20+16(%esp), %ecx
+ mov 24+16(%esp), %edx
+ mov 28+16(%esp), %esi
+ mov 32+16(%esp), %edi
+ mov 36+16(%esp), %ebp
- /* This next sequence of code works in conjunction with the
+ /*
+ * This next sequence of code works in conjunction with the
* rewind_if_safe_syscall_function(). If a signal is taken
* and the interrupted PC is anywhere between 'safe_syscall_start'
* and 'safe_syscall_end' then we rewind it to 'safe_syscall_start'.
@@ -70,12 +70,16 @@ safe_syscall_start:
/* if signal_pending is non-zero, don't do the call */
mov 4+16(%esp), %eax /* signal_pending */
cmpl $0, (%eax)
- jnz 1f
+ jnz 2f
mov 8+16(%esp), %eax /* syscall number */
int $0x80
safe_syscall_end:
+
/* code path for having successfully executed the syscall */
- pop %ebx
+ cmp $-4095, %eax
+ jae 0f
+
+9: pop %ebx
.cfi_remember_state
.cfi_adjust_cfa_offset -4
.cfi_restore ebx
@@ -90,11 +94,18 @@ safe_syscall_end:
.cfi_restore ebp
ret
-1:
- /* code path when we didn't execute the syscall */
.cfi_restore_state
- mov $-TARGET_ERESTARTSYS, %eax
- jmp safe_syscall_end
+
+ /* code path setting errno */
+0: neg %eax /* create positive errno */
+1: mov 8+16(%esp), %ebx /* load errno pointer */
+ mov %eax, (%ebx) /* store errno */
+ mov $-1, %eax
+ jmp 9b
+
+ /* code path when we didn't execute the syscall */
+2: mov $TARGET_ERESTARTSYS, %eax
+ jmp 1b
.cfi_endproc
.size safe_syscall_base, .-safe_syscall_base
diff --git a/common-user/host/ppc64/safe-syscall.inc.S
b/common-user/host/ppc64/safe-syscall.inc.S
index 875133173b..e35408c5fb 100644
--- a/common-user/host/ppc64/safe-syscall.inc.S
+++ b/common-user/host/ppc64/safe-syscall.inc.S
@@ -17,14 +17,19 @@
.text
- /* This is the entry point for making a system call. The calling
+#if _CALL_ELF == 2
+#define PARAM_OFS 32
+#else
+#define PARAM_OFS 48
+#endif
+#define PARAM(X) PARAM_OFS + X*8
+
+ /*
+ * This is the entry point for making a system call. The calling
* convention here is that of a C varargs function with the
* first argument an 'int *' to the signal_pending flag, the
* second one the system call number (as a 'long'), and all further
* arguments being syscall arguments (also 'long').
- * We return a long which is the syscall's return value, which
- * may be negative-errno on failure. Conversion to the
- * -1-and-errno-set convention is done by the calling wrapper.
*/
#if _CALL_ELF == 2
safe_syscall_base:
@@ -39,9 +44,11 @@ safe_syscall_base:
.L.safe_syscall_base:
.cfi_startproc
#endif
- /* We enter with r3 == *signal_pending
- * r4 == syscall number
- * r5 ... r10 == syscall arguments
+ /*
+ * We enter with r3 == &signal_pending
+ * r4 == &errno
+ * r5 == syscall number
+ * r6 ... r10, (stack) == syscall arguments
* and return the result in r3
* and the syscall instruction needs
* r0 == syscall number
@@ -49,18 +56,18 @@ safe_syscall_base:
* and returns the result in r3
* Shuffle everything around appropriately.
*/
- std 14, 16(1) /* Preserve r14 in SP+16 */
- .cfi_offset 14, 16
- mr 14, 3 /* signal_pending */
- mr 0, 4 /* syscall number */
- mr 3, 5 /* syscall arguments */
- mr 4, 6
- mr 5, 7
- mr 6, 8
- mr 7, 9
- mr 8, 10
+ mr 11, 3 /* signal_pending pointer */
+ std 4, PARAM(1)(1) /* save errno pointer in param slot */
+ mr 0, 5 /* syscall number */
+ mr 3, 6 /* syscall arguments */
+ mr 4, 7
+ mr 5, 8
+ mr 6, 9
+ mr 7, 10
+ ld 8, PARAM(8)(1)
- /* This next sequence of code works in conjunction with the
+ /*
+ * This next sequence of code works in conjunction with the
* rewind_if_safe_syscall_function(). If a signal is taken
* and the interrupted PC is anywhere between 'safe_syscall_start'
* and 'safe_syscall_end' then we rewind it to 'safe_syscall_start'.
@@ -69,23 +76,25 @@ safe_syscall_base:
*/
safe_syscall_start:
/* if signal_pending is non-zero, don't do the call */
- lwz 12, 0(14)
+ lwz 12, 0(11)
cmpwi 0, 12, 0
bne- 0f
sc
safe_syscall_end:
- /* code path when we did execute the syscall */
- ld 14, 16(1) /* restore r14 to its original value */
- bnslr+
- /* syscall failed; return negative errno */
- neg 3, 3
+ /* code path for having successfully executed the syscall */
+ bnslr+ /* SO set for syscall error */
+
+ /* code path setting errno */
+1: ld 11, PARAM(1)(1) /* restore errno pointer */
+ stw 3, 0(11) /* store errno */
+ li 3, -1
blr
/* code path when we didn't execute the syscall */
-0: addi 3, 0, -TARGET_ERESTARTSYS
- ld 14, 16(1) /* restore r14 to its original value */
- blr
+0: li 3, TARGET_ERESTARTSYS
+ b 1b
+
.cfi_endproc
#if _CALL_ELF == 2
diff --git a/common-user/host/riscv/safe-syscall.inc.S
b/common-user/host/riscv/safe-syscall.inc.S
index 9ca3fbfd1e..eddede702b 100644
--- a/common-user/host/riscv/safe-syscall.inc.S
+++ b/common-user/host/riscv/safe-syscall.inc.S
@@ -23,17 +23,15 @@
* first argument an 'int *' to the signal_pending flag, the
* second one the system call number (as a 'long'), and all further
* arguments being syscall arguments (also 'long').
- * We return a long which is the syscall's return value, which
- * may be negative-errno on failure. Conversion to the
- * -1-and-errno-set convention is done by the calling wrapper.
*/
safe_syscall_base:
.cfi_startproc
/*
* The syscall calling convention is nearly the same as C:
- * we enter with a0 == *signal_pending
- * a1 == syscall number
- * a2 ... a7 == syscall arguments
+ * we enter with a0 == &signal_pending
+ * a1 == &errno
+ * a2 == syscall number
+ * a3 ... a7, [sp] == syscall arguments
* and return the result in a0
* and the syscall instruction needs
* a7 == syscall number
@@ -42,14 +40,19 @@ safe_syscall_base:
* Shuffle everything around appropriately.
*/
mv t0, a0 /* signal_pending pointer */
- mv t1, a1 /* syscall number */
- mv a0, a2 /* syscall arguments */
- mv a1, a3
- mv a2, a4
- mv a3, a5
- mv a4, a6
- mv a5, a7
- mv a7, t1
+ mv t1, a1 /* errno pointer */
+ mv t2, a2 /* syscall number */
+ mv a0, a3 /* syscall arguments */
+ mv a1, a4
+ mv a2, a5
+ mv a3, a6
+ mv a4, a7
+#if __riscv_xlen == 32
+ lw a5, 0(sp)
+#else
+ ld a5, 0(sp)
+#endif
+ mv a7, t2
/*
* This next sequence of code works in conjunction with the
@@ -61,17 +64,26 @@ safe_syscall_base:
*/
safe_syscall_start:
/* If signal_pending is non-zero, don't do the call */
- lw t1, 0(t0)
- bnez t1, 0f
+ lw t2, 0(t0)
+ bnez t2, 2f
scall
safe_syscall_end:
+
/* code path for having successfully executed the syscall */
+ li t2, -4096
+ bgtu a0, t2, 0f
ret
-0:
- /* code path when we didn't execute the syscall */
- li a0, -TARGET_ERESTARTSYS
+ /* code path setting errno */
+0: neg a0, a0 /* create positive errno */
+1: sw a0, 0(t1) /* store errno */
+ li a0, -1
ret
+
+ /* code path when we didn't execute the syscall */
+2: li a0, TARGET_ERESTARTSYS
+ j 1b
+
.cfi_endproc
.size safe_syscall_base, .-safe_syscall_base
diff --git a/common-user/host/s390x/safe-syscall.inc.S
b/common-user/host/s390x/safe-syscall.inc.S
index 414b44ad38..f2a3bccc13 100644
--- a/common-user/host/s390x/safe-syscall.inc.S
+++ b/common-user/host/s390x/safe-syscall.inc.S
@@ -15,14 +15,12 @@
.global safe_syscall_end
.type safe_syscall_base, @function
- /* This is the entry point for making a system call. The calling
+ /*
+ * This is the entry point for making a system call. The calling
* convention here is that of a C varargs function with the
* first argument an 'int *' to the signal_pending flag, the
* second one the system call number (as a 'long'), and all further
* arguments being syscall arguments (also 'long').
- * We return a long which is the syscall's return value, which
- * may be negative-errno on failure. Conversion to the
- * -1-and-errno-set convention is done by the calling wrapper.
*/
safe_syscall_base:
.cfi_startproc
@@ -44,11 +42,13 @@ safe_syscall_base:
stg %r1,0(%r15) /* store back chain */
stg %r0,8(%r15) /* store eos */
- /* The syscall calling convention isn't the same as the
+ /*
+ * The syscall calling convention isn't the same as the
* C one:
- * we enter with r2 == *signal_pending
- * r3 == syscall number
- * r4, r5, r6, (stack) == syscall arguments
+ * we enter with r2 == &signal_pending
+ * r3 == &errno
+ * r4 == syscall number
+ * r5, r6, (stack) == syscall arguments
* and return the result in r2
* and the syscall instruction needs
* r1 == syscall number
@@ -57,13 +57,14 @@ safe_syscall_base:
* Shuffle everything around appropriately.
*/
lgr %r8,%r2 /* signal_pending pointer */
- lgr %r1,%r3 /* syscall number */
- lgr %r2,%r4 /* syscall args */
- lgr %r3,%r5
- lgr %r4,%r6
- lmg %r5,%r7,320(%r15)
+ lgr %r9,%r3 /* errno pointer */
+ lgr %r1,%r4 /* syscall number */
+ lgr %r2,%r5 /* syscall args */
+ lgr %r3,%r6
+ lmg %r4,%r7,320(%r15)
- /* This next sequence of code works in conjunction with the
+ /*
+ * This next sequence of code works in conjunction with the
* rewind_if_safe_syscall_function(). If a signal is taken
* and the interrupted PC is anywhere between 'safe_syscall_start'
* and 'safe_syscall_end' then we rewind it to 'safe_syscall_start'.
@@ -73,18 +74,31 @@ safe_syscall_base:
safe_syscall_start:
/* if signal_pending is non-zero, don't do the call */
icm %r0,15,0(%r8)
- jne 2f
+ jne 1f
svc 0
safe_syscall_end:
-1: lg %r15,0(%r15) /* load back chain */
+ /* code path for having successfully executed the syscall */
+ lghi %r0, -4095 /* check for syscall error */
+ clgr %r2, %r0
+ jgnl 0f
+
+9: lg %r15,0(%r15) /* load back chain */
.cfi_remember_state
.cfi_adjust_cfa_offset -160
lmg %r6,%r15,48(%r15) /* load saved registers */
br %r14
.cfi_restore_state
-2: lghi %r2, -TARGET_ERESTARTSYS
- j 1b
+
+ /* code path when we didn't execute the syscall */
+1: lghi %r2, -TARGET_ERESTARTSYS
+
+ /* code path setting errno */
+0: lcr %r2, %r2 /* create positive errno */
+ st %r2, 0(%r9) /* store errno */
+ lghi %r2, -1
+ j 9b
+
.cfi_endproc
.size safe_syscall_base, .-safe_syscall_base
diff --git a/common-user/host/x86_64/safe-syscall.inc.S
b/common-user/host/x86_64/safe-syscall.inc.S
index f36992daa3..9a0c4c93b4 100644
--- a/common-user/host/x86_64/safe-syscall.inc.S
+++ b/common-user/host/x86_64/safe-syscall.inc.S
@@ -14,18 +14,17 @@
.global safe_syscall_end
.type safe_syscall_base, @function
- /* This is the entry point for making a system call. The calling
+ /*
+ * This is the entry point for making a system call. The calling
* convention here is that of a C varargs function with the
* first argument an 'int *' to the signal_pending flag, the
* second one the system call number (as a 'long'), and all further
* arguments being syscall arguments (also 'long').
- * We return a long which is the syscall's return value, which
- * may be negative-errno on failure. Conversion to the
- * -1-and-errno-set convention is done by the calling wrapper.
*/
safe_syscall_base:
.cfi_startproc
- /* This saves a frame pointer and aligns the stack for the syscall.
+ /*
+ * This saves a frame pointer and aligns the stack for the syscall.
* (It's unclear if the syscall ABI has the same stack alignment
* requirements as the userspace function call ABI, but better safe
than
* sorry. Appendix A2 of http://www.x86-64.org/documentation/abi.pdf
@@ -35,11 +34,12 @@ safe_syscall_base:
.cfi_adjust_cfa_offset 8
.cfi_rel_offset rbp, 0
- /* The syscall calling convention isn't the same as the
- * C one:
- * we enter with rdi == *signal_pending
- * rsi == syscall number
- * rdx, rcx, r8, r9, (stack), (stack) == syscall
arguments
+ /*
+ * The syscall calling convention isn't the same as the C one:
+ * we enter with rdi == &signal_pending
+ * rsi == &errno
+ * rdx == syscall number
+ * rcx, r8, r9, (stack...) == syscall arguments
* and return the result in rax
* and the syscall instruction needs
* rax == syscall number
@@ -48,17 +48,19 @@ safe_syscall_base:
* Shuffle everything around appropriately.
* Note that syscall will trash rcx and r11.
*/
- mov %rsi, %rax /* syscall number */
- mov %rdi, %rbp /* signal_pending pointer */
+ mov %rdi, %r11 /* signal_pending pointer */
+ mov %rsi, %rbp /* errno pointer */
+ mov %rdx, %rax /* syscall number */
/* and the syscall arguments */
- mov %rdx, %rdi
- mov %rcx, %rsi
- mov %r8, %rdx
- mov %r9, %r10
- mov 16(%rsp), %r8
- mov 24(%rsp), %r9
+ mov %rcx, %rdi
+ mov %r8, %rsi
+ mov %r9, %rdx
+ mov 16(%rsp), %r10
+ mov 24(%rsp), %r8
+ mov 32(%rsp), %r9
- /* This next sequence of code works in conjunction with the
+ /*
+ * This next sequence of code works in conjunction with the
* rewind_if_safe_syscall_function(). If a signal is taken
* and the interrupted PC is anywhere between 'safe_syscall_start'
* and 'safe_syscall_end' then we rewind it to 'safe_syscall_start'.
@@ -67,25 +69,31 @@ safe_syscall_base:
*/
safe_syscall_start:
/* if signal_pending is non-zero, don't do the call */
- cmpl $0, (%rbp)
- jnz 1f
+ cmpl $0, (%r11)
+ jnz 2f
syscall
safe_syscall_end:
+
/* code path for having successfully executed the syscall */
- pop %rbp
+ cmp $-4095, %rax
+ jae 0f
+
+9: pop %rbp
.cfi_remember_state
.cfi_def_cfa_offset 8
.cfi_restore rbp
ret
-
-1:
- /* code path when we didn't execute the syscall */
.cfi_restore_state
- mov $-TARGET_ERESTARTSYS, %rax
- pop %rbp
- .cfi_def_cfa_offset 8
- .cfi_restore rbp
- ret
- .cfi_endproc
+ /* code path setting errno */
+0: neg %eax /* create positive errno */
+1: mov %eax, (%rbp) /* store errno */
+ mov $-1, %rax
+ jmp 9b
+
+ /* code path when we didn't execute the syscall */
+2: mov $TARGET_ERESTARTSYS, %eax
+ jmp 1b
+
+ .cfi_endproc
.size safe_syscall_base, .-safe_syscall_base
--
2.25.1
