lks/minimalc
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Add waitpid and execve

Browse Source
This commit is contained in:
Lucas Schumacher
2026-01-17 15:19:52 -05:00
parent ea0ec6a818
commit 73ad441585
5 changed files with 249 additions and 153 deletions
Download Patch File Download Diff File Expand all files Collapse all files

44
arch/aarch64.c
View File

@@ -81,6 +81,50 @@ uint32_t fork(){
return (uint32_t)rtn; return (uint32_t)rtn;
} }
// SYS_EXECVE 221
int32_t execve(const char* filename, const char* argv[], const char* envp[]){
long int rtn;
asm volatile(
// Assembly Instructions
"mov x0, %0\n" // Set x0 to value of filename
"mov x1, %1\n" // Set x1 to value of argv
"mov x2, %2\n" // Set x2 to value of envp
"mov x8, #221\n" // Syscall number
"svc #0\n" // Make syscall
// Output operands
: "=r"(rtn)
// Input operands
: "r"(filename), "r" (argv), "r"(envp)
// Clobbered registers
: "x0", "x1", "x2", "x8", "memory"
);
return (int32_t)rtn;
}
uint32_t wait4(uint32_t pid, int* wstatus, int options, void* rusage) {
uint64_t rtn;
asm volatile (
// Assembly Instructions
"mov x8, #260\n" // Syscall number for 'listen' is 201 in AArch64
"mov x0, %1\n" // pid
"mov x1, %2\n" // wstatus
"mov x2, %3\n" // options
"mov x3, %4\n" // rusage
"svc #0\n" // Make the syscall
"mov %0, x0\n" // save return value
// Output operands
: "=r" (rtn)
// Input operand
: "r" ((uint64_t)pid), "r"(wstatus), "r"((int64_t)options), "r"(rusage)
// Clobbered registers
: "x0", "x1", "x8", "memory"
);
return (uint32_t)rtn;
}
uint32_t waitpid(uint32_t pid, int* wstatus, int options) {
return wait4(pid, wstatus, options, 0);
}
int32_t openat(int32_t fd, const char* filename, uint32_t flags, uint32_t mode) { int32_t openat(int32_t fd, const char* filename, uint32_t flags, uint32_t mode) {
long int rtn; long int rtn;
asm volatile ( asm volatile (

45
arch/mips.c
View File

@@ -1,5 +1,19 @@
#if defined(__mips__) #if defined(__mips__)
#include "../int.h" #include "../int.h"
#include "../sys.h"
/*
#ifndef _START_DEFINED
#define _START_DEFINED
extern int main(int c, char** v);
void __start() {
void* fp = __builtin_frame_address(0);
register int argc asm("a0") = *(uintptr_t*)(fp+32);
register char** argv asm("a1") = fp+36;
exit(main(argc, argv));
}
#endif */ /* ifndef _START_DEFINED */
#include "generic.h" #include "generic.h"
@@ -59,6 +73,37 @@ uint32_t fork(){
return (uint32_t)rtn; return (uint32_t)rtn;
} }
uint32_t waitpid(uint32_t pid, int* wstatus, int options) {
int child_pid = 0;
asm volatile (
"move $a0, %1\n"
"move $a1, %2\n"
"move $a2, %3\n"
"li $v0, 4007\n"
"syscall\n"
"move %0, $v0\n"
: "=r"(child_pid)
: "r"(pid), "r"(wstatus), "r"(options)
: "a0", "a1", "a2", "v0", "memory"
);
return child_pid;
}
int32_t execve(const char* filename, const char* argv[], const char* envp[]){
int rtn;
asm volatile (
"move $a0, %0\n"
"move $a1, %1\n"
"move $a2, %2\n"
"li $v0, 4011\n"
"syscall\n"
: "=r"(rtn)
: "r"(filename), "r"(argv), "r"(envp)
: "a0", "a1", "a2", "a3", "v0"
);
return (int32_t)rtn;
}
int32_t openat(int32_t fd, const char* filename, uint32_t flags, uint32_t mode) { int32_t openat(int32_t fd, const char* filename, uint32_t flags, uint32_t mode) {
int32_t file = 0; int32_t file = 0;
asm volatile ( asm volatile (

187
arch/x86_64.c
View File

@@ -22,254 +22,245 @@ void _start() {
#define SYS_EXIT 60 #define SYS_EXIT 60
void exit(int8_t status) { void exit(int8_t status) {
asm volatile( asm volatile("syscall" : : "a"(SYS_EXIT), "D"(status) :);
"syscall" for (;;)
: ;
: "a"(SYS_EXIT), "D"(status)
:
);
for(;;);
} }
#define SYS_WRITE 1 #define SYS_WRITE 1
intptr_t write(int32_t fd, const void *buf, intptr_t size) { intptr_t write(int32_t fd, const void *buf, intptr_t size) {
intptr_t n_written = 0; intptr_t n_written = 0;
asm volatile ( asm volatile("syscall\n"
"syscall\n"
"movq %0, %%rax\n" "movq %0, %%rax\n"
: "=r"(n_written) : "=r"(n_written)
: "a"(SYS_WRITE), "D"(fd), "S"(buf), "d"(size) // RDI, RSI, RDX are used in x86-64 for write args : "a"(SYS_WRITE), "D"(fd), "S"(buf),
: "rcx", "r11" "d"(size) // RDI, RSI, RDX are used in x86-64 for write args
); : "rcx", "r11");
return n_written; return n_written;
} }
#define SYS_READ 0 #define SYS_READ 0
intptr_t read(int32_t fd, const void *buf, intptr_t size) { intptr_t read(int32_t fd, const void *buf, intptr_t size) {
intptr_t n_read = 0; intptr_t n_read = 0;
asm volatile ( asm volatile("syscall\n"
"syscall\n"
"movq %0, %%rax\n" "movq %0, %%rax\n"
: "=r"(n_read) : "=r"(n_read)
: "a"(SYS_READ), "D"(fd), "S"(buf), "d"(size) // RDI, RSI, RDX are used in x86-64 for write args : "a"(SYS_READ), "D"(fd), "S"(buf),
: "rcx", "r11", "memory" "d"(size) // RDI, RSI, RDX are used in x86-64 for write args
); : "rcx", "r11", "memory");
return n_read; return n_read;
} }
#define SYS_FORK 57 #define SYS_FORK 57
uint32_t fork() { uint32_t fork() {
uint64_t rtn; uint64_t rtn;
asm volatile( asm volatile("syscall\n" // syscall
"syscall\n" // syscall
"movq %0, %%rax\n" // save return value "movq %0, %%rax\n" // save return value
: "=r"(rtn) : "=r"(rtn)
: "a"(SYS_FORK) : "a"(SYS_FORK)
: :);
);
return (uint32_t)rtn; return (uint32_t)rtn;
} }
#define SYS_EXECVE 59
int32_t execve(const char *filename, const char *argv[], const char *envp[]) {
int64_t rtn;
asm volatile("syscall\n"
: "=r"(rtn)
: "a"(SYS_EXECVE), "D"(filename), "S"(argv), "d"(envp)
: "rcx", "r11");
return (int32_t)rtn;
}
#define SYS_WAIT4 61
uint32_t wait4(uint32_t pid, int *wstatus, int options, void *rusage) {
uint32_t child_pid;
asm volatile("mov %5, %%r10\n"
"syscall\n"
: "=a"(child_pid)
: "a"(SYS_WAIT4), "D"(pid), "S"(wstatus), "d"(options),
"r"(rusage)
: "rcx", "r10", "r11", "memory");
return child_pid;
}
uint32_t waitpid(uint32_t pid, int *wstatus, int options) {
return wait4(pid, wstatus, options, 0);
}
#define SYS_OPENAT 257 #define SYS_OPENAT 257
int32_t openat(int32_t fd, const char* filename, uint32_t flags, uint32_t mode) { int32_t openat(int32_t fd, const char *filename, uint32_t flags,
uint32_t mode) {
int32_t file; int32_t file;
asm volatile( asm volatile(
"mov %5, %%r10\n" "mov %5, %%r10\n"
"syscall\n" "syscall\n"
: "=a"(file) : "=a"(file)
: "a"(SYS_OPENAT), "D"(fd), "S"(filename), "d"(flags), "r"((uint64_t)mode) // RDI, RSI, RDX are used in x86-64 for write args : "a"(SYS_OPENAT), "D"(fd), "S"(filename), "d"(flags),
: "rcx", "r10", "r11" "r"((uint64_t)mode) // RDI, RSI, RDX are used in x86-64 for write args
); : "rcx", "r10", "r11");
return file; return file;
} }
#define SYS_CLOSE 3 #define SYS_CLOSE 3
int close(unsigned int fd) { int close(unsigned int fd) {
int rtn; int rtn;
asm volatile( asm volatile("syscall" : "=a"(rtn) : "a"(SYS_CLOSE), "D"(fd) : "rcx", "r11");
"syscall"
: "=a"(rtn)
: "a"(SYS_CLOSE), "D"(fd)
: "rcx", "r11"
);
return rtn; return rtn;
} }
#define SYS_FSYNC 74 #define SYS_FSYNC 74
int fsync(unsigned int fd) { int fsync(unsigned int fd) {
int rtn; int rtn;
asm volatile( asm volatile("syscall" : "=a"(rtn) : "a"(SYS_FSYNC), "D"(fd) : "rcx", "r11");
"syscall"
: "=a"(rtn)
: "a"(SYS_FSYNC), "D"(fd)
: "rcx", "r11"
);
return rtn; return rtn;
} }
#define SYS_SOCKET 41 #define SYS_SOCKET 41
int socket(int domain, int type, int protocol) { int socket(int domain, int type, int protocol) {
int32_t fd; int32_t fd;
asm volatile ( asm volatile("syscall\n"
"syscall\n"
: "=a"(fd) : "=a"(fd)
: "a"(SYS_SOCKET), "D"(domain), "S"(type), "d"(protocol) : "a"(SYS_SOCKET), "D"(domain), "S"(type), "d"(protocol)
: "rcx", "r11" : "rcx", "r11");
);
return fd; return fd;
} }
#define SYS_SETSOCKOPT 54 #define SYS_SETSOCKOPT 54
int setsockopt(int fd, int level, int optname, const void* optval, socklen_t optlen) { int setsockopt(int fd, int level, int optname, const void *optval,
socklen_t optlen) {
int rtn; int rtn;
asm volatile( asm volatile("mov %5, %%r10\n"
"mov %5, %%r10\n"
"mov %6, %%r8\n" "mov %6, %%r8\n"
"syscall\n" "syscall\n"
: "=a"(rtn) : "=a"(rtn)
: "a"(SYS_SETSOCKOPT), "D"(fd), "S"(level), "d"(optname), "r"(optval), "r"((uint64_t)optlen) : "a"(SYS_SETSOCKOPT), "D"(fd), "S"(level), "d"(optname),
: "rcx", "r11" "r"(optval), "r"((uint64_t)optlen)
); : "rcx", "r11");
return rtn; return rtn;
} }
#define SYS_BIND 49 #define SYS_BIND 49
int bind(int fd, const void *sockaddr, socklen_t addrlen) { int bind(int fd, const void *sockaddr, socklen_t addrlen) {
int rtn; int rtn;
asm volatile( asm volatile("syscall\n"
"syscall\n"
: "=a"(rtn) : "=a"(rtn)
: "a"(SYS_BIND), "D"(fd), "S"(sockaddr), "d"(addrlen) : "a"(SYS_BIND), "D"(fd), "S"(sockaddr), "d"(addrlen)
: "rcx", "r11" : "rcx", "r11");
);
return rtn; return rtn;
} }
#define SYS_LISTEN 50 #define SYS_LISTEN 50
int listen(int fd, int backlog) { int listen(int fd, int backlog) {
int rtn; int rtn;
asm volatile( asm volatile("syscall\n"
"syscall\n"
: "=a"(rtn) : "=a"(rtn)
: "a"(SYS_LISTEN), "D"(fd), "S"(backlog) : "a"(SYS_LISTEN), "D"(fd), "S"(backlog)
: "rcx", "r11" : "rcx", "r11");
);
return rtn; return rtn;
} }
#define SYS_ACCEPT 43 #define SYS_ACCEPT 43
int accept(int fd, void *addr, socklen_t *addrlen) { int accept(int fd, void *addr, socklen_t *addrlen) {
int rtn; int rtn;
asm volatile( asm volatile("syscall\n"
"syscall\n"
: "=a"(rtn) : "=a"(rtn)
: "a"(SYS_ACCEPT), "D"(fd), "S"(addr), "d"(addrlen) : "a"(SYS_ACCEPT), "D"(fd), "S"(addr), "d"(addrlen)
: "rcx", "r11", "memory" : "rcx", "r11", "memory");
);
return rtn; return rtn;
} }
#define SYS_CONNECT 42 #define SYS_CONNECT 42
int connect(int fd, void *addr, socklen_t addrlen) { int connect(int fd, void *addr, socklen_t addrlen) {
int rtn; int rtn;
asm volatile( asm volatile("syscall\n"
"syscall\n"
: "=a"(rtn) : "=a"(rtn)
: "a"(SYS_CONNECT), "D"(fd), "S"(addr), "d"(addrlen) : "a"(SYS_CONNECT), "D"(fd), "S"(addr), "d"(addrlen)
: "rcx", "r11" : "rcx", "r11");
);
return rtn; return rtn;
} }
#define SYS_SENDTO 44 #define SYS_SENDTO 44
ssize_t sendto(int fd, const void* buf, size_t size, int flags, const void* sockaddr, socklen_t addrlen) { ssize_t sendto(int fd, const void *buf, size_t size, int flags,
const void *sockaddr, socklen_t addrlen) {
ssize_t nsent; ssize_t nsent;
asm volatile( asm volatile("mov %5, %%r10\n"
"mov %5, %%r10\n"
"mov %6, %%r8\n" "mov %6, %%r8\n"
"mov %7, %%r9\n" "mov %7, %%r9\n"
"syscall\n" "syscall\n"
: "=a"(nsent) : "=a"(nsent)
: "a"(SYS_SENDTO), "D"(fd), "S"(buf), "d"(size), "r"((int64_t)flags), "r"(sockaddr), "r"((uint64_t)addrlen) : "a"(SYS_SENDTO), "D"(fd), "S"(buf), "d"(size),
: "rcx", "r11" "r"((int64_t)flags), "r"(sockaddr), "r"((uint64_t)addrlen)
); : "rcx", "r11");
return nsent; return nsent;
} }
#define SYS_RECVFROM 45 #define SYS_RECVFROM 45
ssize_t recvfrom(int fd, const void* buf, size_t size, int flags, const void* sockaddr, socklen_t addrlen) { ssize_t recvfrom(int fd, const void *buf, size_t size, int flags,
const void *sockaddr, socklen_t addrlen) {
ssize_t nrecv; ssize_t nrecv;
asm volatile( asm volatile("mov %5, %%r10\n"
"mov %5, %%r10\n"
"mov %6, %%r8\n" "mov %6, %%r8\n"
"mov %7, %%r9\n" "mov %7, %%r9\n"
"syscall\n" "syscall\n"
: "=a"(nrecv) : "=a"(nrecv)
: "a"(SYS_RECVFROM), "D"(fd), "S"(buf), "d"(size), "r"((int64_t)flags), "r"(sockaddr), "r"((int64_t)addrlen) : "a"(SYS_RECVFROM), "D"(fd), "S"(buf), "d"(size),
: "rcx", "r11", "memory" "r"((int64_t)flags), "r"(sockaddr), "r"((int64_t)addrlen)
); : "rcx", "r11", "memory");
return nrecv; return nrecv;
} }
#define SYS_CLOCK_SETTIME 227 #define SYS_CLOCK_SETTIME 227
int clock_settime(clockid_t clockid, const struct timespec *tp) { int clock_settime(clockid_t clockid, const struct timespec *tp) {
int rtn; int rtn;
asm volatile( asm volatile("syscall\n"
"syscall\n"
: "=a"(rtn) : "=a"(rtn)
: "a"(SYS_CLOCK_SETTIME), "D"(clockid), "S"(tp) : "a"(SYS_CLOCK_SETTIME), "D"(clockid), "S"(tp)
: "rcx", "r11" : "rcx", "r11");
);
return rtn; return rtn;
} }
#define SYS_CLOCK_GETTIME 228 #define SYS_CLOCK_GETTIME 228
int clock_gettime(clockid_t clockid, struct timespec *tp) { int clock_gettime(clockid_t clockid, struct timespec *tp) {
int rtn; int rtn;
asm volatile( asm volatile("syscall\n"
"syscall\n"
: "=a"(rtn) : "=a"(rtn)
: "a"(SYS_CLOCK_GETTIME), "D"(clockid), "S"(tp) : "a"(SYS_CLOCK_GETTIME), "D"(clockid), "S"(tp)
: "rcx", "r11", "memory" : "rcx", "r11", "memory");
);
return rtn; return rtn;
} }
#define SYS_CLOCK_GETRES 229 #define SYS_CLOCK_GETRES 229
int clock_getres(clockid_t clockid, struct timespec *res) { int clock_getres(clockid_t clockid, struct timespec *res) {
int rtn; int rtn;
asm volatile( asm volatile("syscall\n"
"syscall\n"
: "=a"(rtn) : "=a"(rtn)
: "a"(SYS_CLOCK_GETRES), "D"(clockid), "S"(res) : "a"(SYS_CLOCK_GETRES), "D"(clockid), "S"(res)
: "rcx", "r11", "memory" : "rcx", "r11", "memory");
);
return rtn; return rtn;
} }
#define SYS_CLOCK_NANOSLEEP 230 #define SYS_CLOCK_NANOSLEEP 230
int clock_nanosleep(clockid_t clockid, int flags, const struct timespec *t, struct timespec* remain){ int clock_nanosleep(clockid_t clockid, int flags, const struct timespec *t,
struct timespec *remain) {
int rtn; int rtn;
asm volatile( asm volatile("mov %5, %%r10\n"
"mov %5, %%r10\n"
"syscall\n" "syscall\n"
: "=a"(rtn) : "=a"(rtn)
: "a"(SYS_CLOCK_NANOSLEEP), "D"(clockid), "S"(flags), "d"(t), "r"(remain) : "a"(SYS_CLOCK_NANOSLEEP), "D"(clockid), "S"(flags), "d"(t),
: "rcx", "r11", "memory" "r"(remain)
); : "rcx", "r11", "memory");
return rtn; return rtn;
} }
#define SYS_RT_SIGACTION 13 #define SYS_RT_SIGACTION 13
int rt_sigaction(int signum, const void *act, void *oldact, size_t sigset_len) { int rt_sigaction(int signum, const void *act, void *oldact, size_t sigset_len) {
int rtn; int rtn;
asm volatile( asm volatile("mov %5, %%r10\n"
"mov %5, %%r10\n"
"syscall\n" "syscall\n"
: "=a"(rtn) : "=a"(rtn)
: "a"(SYS_RT_SIGACTION), "D"(signum), "S"(act), "d"(oldact), "r"(sigset_len) : "a"(SYS_RT_SIGACTION), "D"(signum), "S"(act), "d"(oldact),
: "rcx", "r11", "memory" "r"(sigset_len)
); : "rcx", "r11", "memory");
return rtn; return rtn;
} }

22
buildtest.c
View File

@@ -34,10 +34,24 @@ int main(int argc, char* argv[]) {
uint64_t pid = fork(); uint64_t pid = fork();
// Print the pid in hex // Print the pid in hex
printhex(pid); printhex(pid);
// Child process
// Child process exits if (pid == 0) {
if(pid == 0) return 0; const char *progname = "/bin/sh";
//TODO: wait on child to remove zombie process const char *argv[4] = {
progname,
"-c",
"echo hi from sh",
0,
};
const char **envp = {0};
int32_t err = execve(progname, argv, envp);
// return with error code if execve fails
return err;
}
int status; // Note: this is not JUST the exit code of the child
waitpid(pid, &status, 0);
print("Child wstatus: ");
printhex((uint64_t)status);
// Test the read syscall // Test the read syscall
#define INPUT_BUFFER_LEN 4096 #define INPUT_BUFFER_LEN 4096

2
sys.h
View File

@@ -141,6 +141,8 @@ int clock_nanosleep(clockid_t clockid, int flags, const struct timespec *t, stru
#define nanosleep(t, remain) clock_nanosleep(CLOCK_MONOTONIC, 0, t, remain) #define nanosleep(t, remain) clock_nanosleep(CLOCK_MONOTONIC, 0, t, remain)
uint32_t fork(); uint32_t fork();
int32_t execve(const char* filename, const char* argv[], const char* envp[]);
uint32_t waitpid(uint32_t pid, int* wstatus, int options);
void *memset(void* s, int c, unsigned long n); void *memset(void* s, int c, unsigned long n);
int strlen(char* s); int strlen(char* s);