System Call Wrappers in Assembly

Topic Overview

syscall Is the Kernel Door

Userspace cannot read disks or map memory directly. On x86-64 Linux you load a number into rax, arguments into rdi/rsi/rdx/r10/r8/r9, and execute syscall. glibc's write wrapper adds cancellation points and error handling; your assembly calls the kernel raw. strace logs these crossings; seccomp filters them in Docker.

nasmCopy
Loading…

Errors return -errno in rax (negative values). Compare against zero after syscall.

For this exercise, you will wrap read, write, and exit as callable functions. This task asks you to preserve the AMD64 argument registers your caller sets, because botching the wrapper is how bare-metal demos write to the wrong fd silently.

Keep the relevant man page, ABI doc, or Rust reference chapter open while you work. When your output disagrees with the reference implementation on the same machine, the mismatch is usually an alignment rule, an off-by-one terminator, or a register slot you misread in GDB. Skim the official documentation for the tool or ABI named in the exercise; the prose changes, but register roles, syscall numbers, and ownership rules stay stable across releases.

Your Task

The syscall instruction is the whole user/kernel interface on x86-64 Linux: the number goes in rax, the arguments in rdi, rsi, rdx, r10, r8, r9 (r10, not rcx, because syscall itself overwrites rcx and r11), and the result comes back in rax, where -4095..-1 means -errno. Write the kernel side as a tiny dispatcher: each input line is the register state at a syscall instruction. Execute it against a small fake kernel, and print what strace would show.

Input

One syscall per line: REG=VALUE pairs in any order. REG is rax rdi rsi rdx r10 r8 r9 (or rcx, which the kernel ignores). A VALUE is an integer (decimal, 0x hex, or negative) or, only for write's rsi and open's rdi, a double-quoted string with \n \t \\ \" escapes. Unset registers are 0. rax is required.

The kernel

• fds 0, 1 and 2 are stdin (always at end of file), stdout and stderr (write-only).
• Files: /etc/hostname holds box\n, and /etc/motd holds hello, world\n.
• Open flags: access mode flags & 3 (0 O_RDONLY, 1 O_WRONLY, 2 O_RDWR; 3 is EINVAL), plus 64 O_CREAT (create an empty file), 512 O_TRUNC (with write access) and 1024 O_APPEND. A new fd is the lowest free one (up to 16 fds, and up to 8 files including the two above).
• Reads and writes move the fd's offset. O_APPEND writes go to the end of the file.

Errors, returned as -errno:

• EBADF (9): closed or invalid fd, reading a write-only fd, or writing a read-only one;
• EFAULT (14): write's count is negative or longer than the string, or open's path is not a string;
• ENOENT (2): missing file without O_CREAT;
• EINVAL (22): a negative count or offset, a bad whence, a seek outside 0..512, or access mode 3;
• EMFILE (24): out of fds or file slots;
• ENOSYS (38): an unknown number;
• lseek on fds 0-2 returns -1 ESPIPE (Illegal seek).

Output

cCopy
Loading…

• If a line sets rcx, print note: rcx is ignored (syscall overwrites rcx and r11); the 4th argument goes in r10 first.
• If the input ends without an exit, print +++ no exit call: the process would run off the end of its code +++.
• Always finish with stdout: "..." and stderr: "...": everything written to fds 1 and 2.
• Strings print with \n \t \\ \" escapes, and other non-printable bytes as \xNN.
• A malformed line prints error: bad line: LINE and is skipped.

Example

Input:

cCopy
Loading…

Output:

cCopy
Loading…

Requirements

1. Dispatch on rax and read the arguments in ABI order. The rcx trap is the classic hand-written-syscall bug.
2. Return errors as -errno, the way the kernel does, and render them the way strace does.

Hidden tests cover O_CREAT/O_APPEND/O_TRUNC files that are written and read back, lseek from the end, pread64 not moving the offset, EMFILE, stdin at EOF, exit_group with a negative status, lines after exit, and malformed lines.