Making syscalls on Linux without a stack

Question

On Linux i386, the int $0x80 syscall ABI makes it easy to perform syscalls without having a valid userspace stack. The vdso/vsyscall interface, on the other hand, requires access to a stack. How do other Linux ports fare in this regard, especially x86_64? Do they have ways to make syscalls without a stack? Is there a reference on the available syscall methods for each arch?

Answer 1

In general: no idea. Even on i386, if there is a 6th argument, it must be passed on the stack (e.g. for mmap).

For x86_64 specifically: put the syscall number in %rax (beware: the syscall numbers are allocated completely differently to the 32-bit ones), up to 6 arguments in %rdi, %rsi, %rdx, %r10, %r8 and %r9 (which is almost, but not quite, the same as the usual ABI for parameter passing in registers - note use of %r10 instead of %rcx), and use the syscall instruction. The result is returned in %rax, and %rcx and %r11 are clobbered.

x86_64 ABI information can be found at http://www.x86-64.org/documentation/abi.pdf; the Linux ABI is documented in the appendix. (And if looking around elsewhere for x86_64 ABI info, be aware that 64-bit Windows uses its own different ABI.)

---

I don't believe there is any requirement on the user stack frame for syscall to work properly. In the case of being interrupted by a signal, a sane stack is obviously required for the handler; but the following experiment, which uses an alternate signal stack and deliberately trashes %rsp around the syscall, works fine for me:

$ cat syscall_sig.c
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <signal.h>
#include <time.h>
#include <unistd.h>

#define __NR_nanosleep 35

static sig_atomic_t alrm = 0;

void handler(int sig)
{
    if (sig == SIGALRM)
        alrm = 1;
}

int main(void)
{
    stack_t ss;
    struct sigaction sa;
    struct timespec req, rem;
    long ret;

    ss.ss_flags = 0;
    ss.ss_size = SIGSTKSZ;
    ss.ss_sp = malloc(ss.ss_size);
    sigaltstack(&ss, NULL);

    memset(&sa, 0, sizeof(sa));
    sa.sa_handler = handler;
    sa.sa_flags = SA_ONSTACK;
    sigaction(SIGALRM, &sa, NULL);

    alarm(1);

    req.tv_sec = 5;
    req.tv_nsec = 0;
    asm("xorq $0x12345678, %%rsp ; syscall ; xorq $0x12345678, %%rsp"
        : "=a" (ret)
        : "0" (__NR_nanosleep), "D" (&req), "S" (&rem)
        : "rcx", "r11", "memory");

    printf("syscall return code %ld, alarm flag %d\n", ret, alrm);

    return 0;
}

$ gcc -Wall -o syscall_sig syscall_sig.c
$ ./syscall_sig
syscall return code -4, alarm flag 1
$