path: root/src
diff options
authorRich Felker <>2019-04-10 17:10:36 -0400
committerRich Felker <>2019-04-10 17:10:36 -0400
commit22e5bbd0deadcbd767864bd714e890b70e1fe1df (patch)
tree4482da4b24c0e08b29769dad08bf800207db1227 /src
parente97681d6f2c44bf5fa9ecdd30607cb63c780062e (diff)
overhaul i386 syscall mechanism not to depend on external asm source
this is the first part of a series of patches intended to make __syscall fully self-contained in the object file produced using syscall.h, which will make it possible for crt1 code to perform syscalls. the (confusingly named) i386 __vsyscall mechanism, which this commit removes, was introduced before the presence of a valid thread pointer was mandatory; back then the thread pointer was setup lazily only if threads were used. the intent was to be able to perform syscalls using the kernel's fast entry point in the VDSO, which can use the sysenter (Intel) or syscall (AMD) instruction instead of int $128, but without inlining an access to the __syscall global at the point of each syscall, which would incur a significant size cost from PIC setup everywhere. the mechanism also shuffled registers/calling convention around to avoid spills of call-saved registers, and to avoid allocating ebx or ebp via asm constraints, since there are plenty of broken-but-supported compiler versions which are incapable of allocating ebx with -fPIC or ebp with -fno-omit-frame-pointer. the new mechanism preserves the properties of avoiding spills and avoiding allocation of ebx/ebp in constraints, but does it inline, using some fairly simple register shuffling, and uses a field of the thread structure rather than global data for the vdso-provided syscall code address. for now, the external __syscall function is refactored not to use the old __vsyscall so it can be kept, but the intent is to remove it too.
Diffstat (limited to 'src')
7 files changed, 28 insertions, 71 deletions
diff --git a/src/env/__init_tls.c b/src/env/__init_tls.c
index f1874f2a..5f12500c 100644
--- a/src/env/__init_tls.c
+++ b/src/env/__init_tls.c
@@ -1,3 +1,4 @@
+#define SYSCALL_NO_TLS 1
#include <elf.h>
#include <limits.h>
#include <sys/mman.h>
@@ -21,6 +22,7 @@ int __init_tp(void *p)
td->tid = __syscall(SYS_set_tid_address, &__thread_list_lock);
td->locale = &libc.global_locale;
td->robust_list.head = &td->robust_list.head;
+ td->sysinfo = __sysinfo;
td->next = td->prev = td;
return 0;
diff --git a/src/env/__libc_start_main.c b/src/env/__libc_start_main.c
index 7c95f822..8fbe5262 100644
--- a/src/env/__libc_start_main.c
+++ b/src/env/__libc_start_main.c
@@ -28,7 +28,7 @@ void __init_libc(char **envp, char *pn)
libc.auxv = auxv = (void *)(envp+i+1);
for (i=0; auxv[i]; i+=2) if (auxv[i]<AUX_CNT) aux[auxv[i]] = auxv[i+1];
__hwcap = aux[AT_HWCAP];
- __sysinfo = aux[AT_SYSINFO];
+ if (aux[AT_SYSINFO]) __sysinfo = aux[AT_SYSINFO];
libc.page_size = aux[AT_PAGESZ];
if (!pn) pn = (void*)aux[AT_EXECFN];
diff --git a/src/internal/defsysinfo.c b/src/internal/defsysinfo.c
new file mode 100644
index 00000000..6d4117db
--- /dev/null
+++ b/src/internal/defsysinfo.c
@@ -0,0 +1,3 @@
+#include "libc.h"
+size_t __sysinfo;
diff --git a/src/internal/i386/defsysinfo.s b/src/internal/i386/defsysinfo.s
new file mode 100644
index 00000000..f1b5b0f2
--- /dev/null
+++ b/src/internal/i386/defsysinfo.s
@@ -0,0 +1,9 @@
+1: int $128
+ ret
+.align 4
+.hidden __sysinfo __sysinfo
+ .long 1b
diff --git a/src/internal/i386/syscall.s b/src/internal/i386/syscall.s
index 0ebf2218..004ddfef 100644
--- a/src/internal/i386/syscall.s
+++ b/src/internal/i386/syscall.s
@@ -1,78 +1,21 @@
-.hidden __sysinfo
-# The calling convention for __vsyscall has the syscall number
-# and 5 args arriving as: eax, edx, ecx, edi, esi, 4(%esp).
-# This ensures that the inline asm in the C code never has to touch
-# ebx or ebp (which are unavailable in PIC and frame-pointer-using
-# code, respectively), and optimizes for size/simplicity in the caller.
- __vsyscall
-.hidden __vsyscall
-.type __vsyscall,@function
- push %edi
- push %ebx
- mov %edx,%ebx
- mov %edi,%edx
- mov 12(%esp),%edi
- push %eax
- call 1f
-2: mov %ebx,%edx
- pop %ebx
- pop %ebx
- pop %edi
- ret
-1: mov (%esp),%eax
- add $[__sysinfo-2b],%eax
- mov (%eax),%eax
- test %eax,%eax
- jz 1f
- push %eax
- mov 8(%esp),%eax
- ret # tail call to kernel vsyscall entry
-1: mov 4(%esp),%eax
- int $128
- ret
-# The __vsyscall6 entry point is used only for 6-argument syscalls.
-# Instead of passing the 5th argument on the stack, a pointer to the
-# 5th and 6th arguments is passed. This is ugly, but there are no
-# register constraints the inline asm could use that would make it
-# possible to pass two arguments on the stack.
- __vsyscall6
-.hidden __vsyscall6
-.type __vsyscall6,@function
- push %ebp
- push %eax
- mov 12(%esp), %ebp
- mov (%ebp), %eax
- mov 4(%ebp), %ebp
- push %eax
- mov 4(%esp),%eax
- call __vsyscall
- pop %ebp
- pop %ebp
- pop %ebp
- ret
.global __syscall
.hidden __syscall
.type __syscall,@function
- lea 24(%esp),%eax
+ push %ebx
push %esi
push %edi
- push %eax
- mov 16(%esp),%eax
- mov 20(%esp),%edx
- mov 24(%esp),%ecx
- mov 28(%esp),%edi
- mov 32(%esp),%esi
- call __vsyscall6
- pop %edi
+ push %ebp
+ mov 20(%esp),%eax
+ mov 24(%esp),%ebx
+ mov 28(%esp),%ecx
+ mov 32(%esp),%edx
+ mov 36(%esp),%esi
+ mov 40(%esp),%edi
+ mov 44(%esp),%ebp
+ call *%gs:16
+ pop %ebp
pop %edi
pop %esi
+ pop %ebx
diff --git a/src/internal/libc.c b/src/internal/libc.c
index 2e10942d..cb051810 100644
--- a/src/internal/libc.c
+++ b/src/internal/libc.c
@@ -3,7 +3,6 @@
struct __libc __libc;
size_t __hwcap;
-size_t __sysinfo;
char *__progname=0, *__progname_full=0;
weak_alias(__progname, program_invocation_short_name);
diff --git a/src/thread/pthread_create.c b/src/thread/pthread_create.c
index 7d4dc2ed..ebf61ded 100644
--- a/src/thread/pthread_create.c
+++ b/src/thread/pthread_create.c
@@ -315,6 +315,7 @@ int __pthread_create(pthread_t *restrict res, const pthread_attr_t *restrict att
new->robust_list.head = &new->robust_list.head;
new->CANARY = self->CANARY;
+ new->sysinfo = self->sysinfo;
/* Setup argument structure for the new thread on its stack.
* It's safe to access from the caller only until the thread