2175 lines
82 KiB
Plaintext
2175 lines
82 KiB
Plaintext
import drivers.serial.uart.serial as serial
|
||
import drivers.fs.fat32.fat32 as fat32
|
||
import drivers.fs.fat32.fat32_types as fat32_types
|
||
import sched.sched as sched
|
||
import sched.process as process
|
||
import viperlib
|
||
import string
|
||
import mm.mm as mm
|
||
import paging.paging as paging
|
||
import execrunner.elf as elf
|
||
import drivers.devfs.devfs as devfs
|
||
import platform.acpi.acpi as acpi
|
||
import platform.pch.timer as timer
|
||
import platform.pch.rtc as rtc
|
||
import intr.gdt as gdt
|
||
import drivers.core.cpu.cpu as cpu
|
||
import abi.linux as abi
|
||
import asm
|
||
|
||
|
||
# ----------------------------------------------------------------------------
|
||
# Syscall entry frame (set up by the compiler-provided syscall_entry):
|
||
# rbp+0x00 r15 +0x08 r14 +0x10 r13 +0x18 r12
|
||
# +0x20 r10 +0x28 r9 +0x30 r8 +0x38 rbp
|
||
# +0x40 rdi +0x48 rsi +0x50 rdx +0x58 rbx
|
||
# +0x60 r11(user flags) +0x68 rcx(user rip)
|
||
# +0x70 from-user flag +0x78 user rsp
|
||
# The handler itself never touches rbp, so a naked read is stable.
|
||
# ----------------------------------------------------------------------------
|
||
define FR_R15 = 0
|
||
define FR_R14 = 8
|
||
define FR_R13 = 16
|
||
define FR_R12 = 24
|
||
define FR_R10 = 32
|
||
define FR_R9 = 40
|
||
define FR_R8 = 48
|
||
define FR_RBP = 56
|
||
define FR_RDI = 64
|
||
define FR_RSI = 72
|
||
define FR_RDX = 80
|
||
define FR_RBX = 88
|
||
define FR_FLAGS = 96
|
||
define FR_RIP = 104
|
||
define FR_FROMU = 112
|
||
define FR_RSP = 120
|
||
|
||
# Entry trampoline state (naked syscall_handler stores the entry rbp here).
|
||
export _entry_frame: uint64 = 0
|
||
export _handler_ptr: rawptr = None
|
||
|
||
|
||
# ============================================================================
|
||
# 系统调用号表（由 Scripts/syscall_table.py 生成，禁止手改）。
|
||
# 生成源：Scripts/syscall_table.py；build.py 在编译前自动同步。
|
||
# ============================================================================
|
||
# BEGIN GENERATED SYSCALL TABLE
|
||
enum Syscall:
|
||
# ---- Linux 对齐段（号 = Linux x86-64 的号） ----
|
||
READ = 0 # read(fd, buf, count)
|
||
WRITE = 1 # write(fd, buf, count)
|
||
OPEN = 2 # open(path, flags) - Linux O_*
|
||
CLOSE = 3 # close(fd)
|
||
STAT = 4 # stat(path, fileinfo*) - legacy struct
|
||
FSTAT = 5 # fstat(fd, struct stat*)
|
||
POLL = 7 # poll(fds, nfds, timeout) - stub 0
|
||
SEEK = 8 # lseek(fd, offset, whence) -> new offset
|
||
MMAP = 9 # mmap(addr, len, prot, flags, fd, off)
|
||
MPROTECT = 10 # mprotect(addr, len, prot)
|
||
MUNMAP = 11 # munmap(addr, len)
|
||
BRK = 12 # brk(addr) -> new break
|
||
RT_SIGACTION = 13 # rt_sigaction() - bookkeeping
|
||
RT_SIGPROCMASK = 14 # rt_sigprocmask() - bookkeeping
|
||
RT_SIGRETURN = 15 # rt_sigreturn()
|
||
IOCTL = 16 # ioctl(fd, request, arg)
|
||
PREAD64 = 17 # pread64(fd, buf, count, offset)
|
||
PWRITE64 = 18 # pwrite64(fd, buf, count, offset)
|
||
READV = 19 # readv(fd, iov, iovcnt)
|
||
WRITEV = 20 # writev(fd, iov, iovcnt)
|
||
ACCESS = 21 # access(path, mode)
|
||
PIPE = 22 # pipe(int[2])
|
||
YIELD = 24 # sched_yield()
|
||
MREMAP = 25 # mremap(old, oldsz, newsz, flags, newaddr)
|
||
MADVISE = 28 # madvise(addr, len, advice)
|
||
DUP = 32 # dup(fd)
|
||
DUP2 = 33 # dup2(oldfd, newfd)
|
||
NANOSLEEP = 35 # nanosleep(req, rem)
|
||
GETPID = 39 # getpid()
|
||
CLONE = 56 # clone(flags, stack, ptid, ctid, tls)
|
||
FORK = 57 # fork() - copy address space
|
||
SPAWN = 59 # execve(path, argv, envp)
|
||
THREAD_EXIT = 60 # exit(): retire current thread
|
||
WAIT4 = 61 # wait4(pid, status, options, rusage)
|
||
KILL = 62 # kill(pid, sig) - bookkeeping
|
||
UNAME = 63 # uname(utsname*)
|
||
FCNTL = 72 # fcntl(fd, cmd, arg)
|
||
GETCWD = 79 # getcwd(buf, size)
|
||
CHDIR = 80 # chdir(path)
|
||
RENAME = 82 # rename(old, new)
|
||
MKDIR = 83 # mkdir(path)
|
||
RMDIR = 84 # rmdir(path)
|
||
REMOVE = 87 # unlink(path)
|
||
READLINK = 89 # readlink(path, buf, size) - no symlinks
|
||
GETUID = 102 # getuid()
|
||
GETGID = 104 # getgid()
|
||
GETEUID = 107 # geteuid()
|
||
GETEGID = 108 # getegid()
|
||
GETTIMEOFDAY = 96 # gettimeofday(tv, tz)
|
||
GETPPID = 110 # getppid()
|
||
ARCH_PRCTL = 158 # arch_prctl(code, addr)
|
||
REBOOT_LINUX = 169 # reboot(magic1, magic2, cmd, arg)
|
||
GETTID = 186 # gettid()
|
||
FUTEX = 202 # futex(uaddr, op, val, timeout)
|
||
GETDENTS64 = 217 # getdents64(fd, buf, count)
|
||
SET_TID_ADDRESS = 218 # set_tid_address(tidptr)
|
||
CLOCK_GETTIME = 228 # clock_gettime(clockid, timespec*)
|
||
CLOCK_GETRES = 229 # clock_getres(clockid, timespec*)
|
||
EXIT = 231 # exit_group(): terminate all threads
|
||
OPENAT = 257 # openat(dirfd, path, flags, mode)
|
||
NEWFSTATAT = 262 # newfstatat(dirfd, path, stat*, flags)
|
||
UNLINKAT = 263 # unlinkat(dirfd, path, flags)
|
||
READLINKAT = 267 # readlinkat(dirfd, path, buf, size)
|
||
FACCESSAT = 269 # faccessat(dirfd, path, mode, flags)
|
||
SET_ROBUST_LIST = 273 # set_robust_list(head, len)
|
||
DUP3 = 292 # dup3(oldfd, newfd, flags)
|
||
PIPE2 = 293 # pipe2(int[2], flags)
|
||
PRLIMIT64 = 302 # prlimit64(pid, resource, new, old)
|
||
GETRANDOM = 318 # getrandom(buf, len, flags)
|
||
STATX = 332 # statx(...) - -ENOSYS, glibc falls back
|
||
RSEQ = 334 # rseq(rseq, len, flags) - -ENOSYS
|
||
# ---- 临时私有段（0x1000+）：Linux 无对应，逐条迁出 ----
|
||
LOAD_SO = 0x1006 # TODO(userspace): dynamic library loading
|
||
SO_CALL1 = 0x1007 # TODO(userspace): dynamic library call
|
||
REBOOT = 0x1008 # TODO(linux): reboot(169)
|
||
SHUTDOWN = 0x1009 # TODO(linux): reboot(RB_POWER_OFF)
|
||
SPAWN_PROC = 0x100A # TODO(userspace): Terminal run helper
|
||
THREAD_CREATE_OLD = 0x100B # TODO(userspace): ViperOS thread_create
|
||
# END GENERATED SYSCALL TABLE
|
||
|
||
define IA32_EFER = 0xC0000080
|
||
define IA32_STAR = 0xC0000081
|
||
define IA32_LSTAR = 0xC0000082
|
||
define IA32_FMASK = 0xC0000084
|
||
|
||
# Reset via the 8042 controller; PCI reset and halt are fallbacks.
|
||
def power_reboot():
|
||
serial.puts("[power] reboot\n")
|
||
asm.cli()
|
||
for _ in range(1000):
|
||
if (asm.inb(0x64) & 0x02) == 0: break
|
||
asm.outb(0x64, 0xFE)
|
||
asm.outb(0xCF9, 0x02)
|
||
asm.io_wait()
|
||
asm.outb(0xCF9, 0x06)
|
||
while True:
|
||
asm.cli()
|
||
asm.hlt()
|
||
|
||
# ACPI S5 power-off.
|
||
def power_shutdown():
|
||
serial.puts("[power] shutdown\n")
|
||
asm.cli()
|
||
acpi.poweroff()
|
||
while True:
|
||
asm.cli()
|
||
asm.hlt()
|
||
|
||
def wrmsr(msr: uint32, val: uint64):
|
||
lo: uint32 = uint32(val & 0xFFFFFFFF)
|
||
hi: uint32 = uint32(val >> 32)
|
||
__asm__(f"""mov ecx, {asminp(msr, ASM_DESCR.REG_ANY)}
|
||
mov eax, {asminp(lo, ASM_DESCR.REG_ANY)}
|
||
mov edx, {asminp(hi, ASM_DESCR.REG_ANY)}
|
||
wrmsr""",
|
||
op=[ASM_DESCR.CLOBBER_RCX, ASM_DESCR.CLOBBER_RAX, ASM_DESCR.CLOBBER_RDX])
|
||
|
||
def rdmsr(msr: uint32) -> uint64:
|
||
lo: uint32
|
||
hi: uint32
|
||
# rdmsr 固定写 EDX:EAX；out 绑定 + CLOBBER_RAX/RDX 冲突会导致 lo/hi
|
||
# 分配到非 EAX/EDX 读到垃圾。显式 mov 到输出寄存器（与 asm.inb 修复同模式）。
|
||
__asm__(f"""mov ecx, {asminp(msr, ASM_DESCR.REG_ANY)}
|
||
rdmsr
|
||
mov {asmout(lo, ASM_DESCR.OUTPUT_REG)}, eax
|
||
mov {asmout(hi, ASM_DESCR.OUTPUT_REG)}, edx""",
|
||
out=[asmout(lo, ASM_DESCR.OUTPUT_REG), asmout(hi, ASM_DESCR.OUTPUT_REG)],
|
||
op=[ASM_DESCR.CLOBBER_RCX, ASM_DESCR.CLOBBER_RAX, ASM_DESCR.CLOBBER_RDX])
|
||
return uint64(lo) | (uint64(hi) << 32)
|
||
|
||
def _current_proc() -> process.Process*:
|
||
return process.ProcessManager.current()
|
||
|
||
def _fd_alloc(p: process.Process*) -> int:
|
||
for i in range(process.PROC_MAX_FDS):
|
||
if not p.fd_used[i]:
|
||
p.fd_used[i] = 1
|
||
p.fd_flags[i] = 0
|
||
p.fd_shared[i] = 0
|
||
return i
|
||
return -1
|
||
|
||
def _fd_free(p: process.Process*, fd: int):
|
||
if fd >= 0 and fd < process.PROC_MAX_FDS:
|
||
p.fd_used[fd] = None
|
||
p.fd_table[fd] = None
|
||
p.fd_kind[fd] = 0
|
||
p.fd_flags[fd] = 0
|
||
p.fd_shared[fd] = 0
|
||
|
||
# dup()/dup2() share the same underlying object; the last close wins.
|
||
def _fd_other_ref(p: process.Process*, fd: int) -> int:
|
||
fp: uint64 = uint64(p.fd_table[fd])
|
||
k: uint8 = p.fd_kind[fd]
|
||
for i in range(process.PROC_MAX_FDS):
|
||
if i == fd: continue
|
||
if not p.fd_used[i]: continue
|
||
if p.fd_kind[i] != k: continue
|
||
if uint64(p.fd_table[i]) == fp: return 1
|
||
return 0
|
||
|
||
def _dir_alloc(p: process.Process*) -> int:
|
||
for i in range(process.PROC_MAX_DIRS):
|
||
if not p.dir_used[i]:
|
||
p.dir_used[i] = 1
|
||
return i
|
||
return -1
|
||
|
||
def _dir_free(p: process.Process*, dd: int):
|
||
if dd >= 0 and dd < process.PROC_MAX_DIRS:
|
||
p.dir_used[dd] = None
|
||
p.dir_table[dd] = None
|
||
|
||
# ============================================================================
|
||
# Linux ABI helpers
|
||
# ============================================================================
|
||
|
||
# All handlers return int: non-negative on success, -errno on failure.
|
||
def _err(e: int) -> int:
|
||
return 0 - e
|
||
|
||
def _fr_errno(r: int) -> int:
|
||
"""Translate a FAT32 FRESULT into -errno (0 stays 0)."""
|
||
if r == 0: return 0
|
||
if r == int(fat32_types.FRESULT.FR_NO_FILE) or r == int(fat32_types.FRESULT.FR_NO_PATH):
|
||
return _err(abi.ENOENT)
|
||
if r == int(fat32_types.FRESULT.FR_INVALID_NAME):
|
||
return _err(abi.EINVAL)
|
||
if r == int(fat32_types.FRESULT.FR_DENIED):
|
||
return _err(abi.EACCES)
|
||
if r == int(fat32_types.FRESULT.FR_EXIST):
|
||
return _err(abi.EEXIST)
|
||
if r == int(fat32_types.FRESULT.FR_INVALID_OBJECT):
|
||
return _err(abi.EBADF)
|
||
if r == int(fat32_types.FRESULT.FR_WRITE_PROTECTED):
|
||
return _err(abi.EROFS)
|
||
if r == int(fat32_types.FRESULT.FR_NOT_ENOUGH_CORE):
|
||
return _err(abi.ENOMEM)
|
||
if r == int(fat32_types.FRESULT.FR_TOO_MANY_OPEN_FILES):
|
||
return _err(abi.EMFILE)
|
||
if r == int(fat32_types.FRESULT.FR_INVALID_PARAMETER):
|
||
return _err(abi.EINVAL)
|
||
if r == int(fat32_types.FRESULT.FR_TIMEOUT):
|
||
return _err(abi.EIO)
|
||
if r == int(fat32_types.FRESULT.FR_LOCKED):
|
||
return _err(abi.EBUSY)
|
||
return _err(abi.EIO)
|
||
|
||
def _open_mode(flags: uint32) -> uint8:
|
||
"""Linux O_* -> FatFs FA_* access/create mode."""
|
||
m: int = 0
|
||
acc: uint32 = flags & uint32(abi.O_ACCMODE)
|
||
if acc == uint32(abi.O_RDONLY):
|
||
m = int(fat32_types.FA_READ)
|
||
elif acc == uint32(abi.O_WRONLY):
|
||
m = int(fat32_types.FA_WRITE)
|
||
else:
|
||
m = int(fat32_types.FA_READ) | int(fat32_types.FA_WRITE)
|
||
if (flags & uint32(abi.O_EXCL)) != 0 and (flags & uint32(abi.O_CREAT)) != 0:
|
||
m = m | int(fat32_types.FA_CREATE_NEW)
|
||
elif (flags & uint32(abi.O_TRUNC)) != 0:
|
||
m = m | int(fat32_types.FA_CREATE_ALWAYS)
|
||
elif (flags & uint32(abi.O_CREAT)) != 0:
|
||
m = m | int(fat32_types.FA_OPEN_ALWAYS)
|
||
elif (flags & uint32(abi.O_APPEND)) != 0:
|
||
m = m | int(fat32_types.FA_OPEN_APPEND)
|
||
return uint8(m)
|
||
|
||
# Resolve `path` against `cwd` (dirfd == AT_FDCWD) or require an absolute path.
|
||
# Directory-relative lookups from a dir fd are added with openat (P1).
|
||
def _resolve_path(dirfd: int, path: const str, out: char*) -> int:
|
||
if path is None: return _err(abi.EFAULT)
|
||
n: int = 0
|
||
if path[0] == 47:
|
||
while path[n] != 0:
|
||
if n >= abi.PATH_MAX - 1: return _err(abi.ENAMETOOLONG)
|
||
out[n] = path[n]
|
||
n += 1
|
||
out[n] = 0
|
||
return 0
|
||
if dirfd != abi.AT_FDCWD:
|
||
return _err(abi.ENOTSUP)
|
||
p: process.Process* = _current_proc()
|
||
c: int = 0
|
||
while p.cwd[c] != 0:
|
||
if n >= abi.PATH_MAX - 1: return _err(abi.ENAMETOOLONG)
|
||
out[n] = p.cwd[c]
|
||
n += 1
|
||
c += 1
|
||
if n > 0 and out[n - 1] != 47:
|
||
out[n] = 47
|
||
n += 1
|
||
i: int = 0
|
||
while path[i] != 0:
|
||
if n >= abi.PATH_MAX - 1: return _err(abi.ENAMETOOLONG)
|
||
out[n] = path[i]
|
||
n += 1
|
||
i += 1
|
||
out[n] = 0
|
||
return 0
|
||
|
||
# Fill the common fields of a Linux struct stat. Times stay 0: FAT32 stores
|
||
# DOS timestamps, which are not converted yet (P1 with newfstatat).
|
||
def _fill_stat(st: abi.linux_stat*, size: uint64, mode: uint32, ino: uint64):
|
||
string.memset(rawptr(st), 0, uint64(abi.SIZEOF_LINUX_STAT))
|
||
st.st_ino = ino
|
||
st.st_nlink = 1
|
||
st.st_mode = mode
|
||
st.st_size = size
|
||
st.st_blksize = 512
|
||
st.st_blocks = (size + 511) / 512
|
||
|
||
# Software DRNG for getrandom(): no hardware entropy requirement, only used
|
||
# for stack canaries and similar non-cryptographic purposes (see docs).
|
||
_rng_state: uint64 = 0x9E3779B97F4A7C15
|
||
|
||
def _rng_next() -> uint64:
|
||
global _rng_state
|
||
# 64-bit LCG; the high bits are returned because low LCG bits are weak.
|
||
_rng_state = _rng_state * uint64(6364136223846793005) + uint64(1442695040888963407)
|
||
return _rng_state >> 16
|
||
|
||
def EXIT(code: int) -> int:
|
||
serial.puts("[syscall] exit called\n")
|
||
p: process.Process* = _current_proc()
|
||
p.exit_code = code
|
||
# S3e：不再在这里拆窗口 —— 窗口/输入已整体交给用户态图形壳 explorer（/dev/desk 共享区），
|
||
# 内核不再持有任何窗口语义。
|
||
# Linux exit_group：退役本进程的**所有**线程，绝不返回用户态。
|
||
# （THREAD_EXIT=60 只退当前线程。）
|
||
# 只 destroy 窗口不够：app 的 _start 在 process.exit(0) 之后还有 `return 0`，而内核是以
|
||
# rsp = USER_STACK_VTOP 进入 _start 的（elf.vp），一旦收尾 `ret` 就会去读 [VTOP]：
|
||
# #PF cr2=rsp=0x7fffffe00000，rip 在 _start 内，rbp=0，rax=退出码（实测现场）。
|
||
sched.Scheduler.exit_process(p.pid)
|
||
# 【硬保护】exit_process 不返回；这里仅作兜底。
|
||
while True:
|
||
sched.Scheduler._yield()
|
||
return 0
|
||
|
||
_loaded_so_base: rawptr = None
|
||
_loaded_so_path: [64]char
|
||
|
||
def LOAD_SO(path_ptr: str) -> uint64:
|
||
global _loaded_so_base
|
||
path: const str = path_ptr
|
||
serial.puts("[so] loading: ")
|
||
serial.puts(path)
|
||
serial.puts("\n")
|
||
base: rawptr = elf.load_so(path)
|
||
if base is not None:
|
||
_loaded_so_base = base
|
||
for i in range(63):
|
||
ch: char = path[i]
|
||
_loaded_so_path[i] = ch
|
||
if ch == 0: break
|
||
_loaded_so_path[63] = 0
|
||
return uint64(base)
|
||
return 0
|
||
|
||
def SO_CALL1(sym_name_ptr: str, arg1: rawptr) -> int:
|
||
if _loaded_so_base is None: return -1
|
||
sym_name: const str = sym_name_ptr
|
||
fn: rawptr = elf.get_so_symbol(_loaded_so_base, sym_name, &_loaded_so_path[0])
|
||
if fn is None:
|
||
serial.puts("[so] symbol not found\n")
|
||
return -2
|
||
__asm__(f"""mov rdi, {asminp(arg1, ASM_DESCR.REG_ANY)}
|
||
call {asminp(fn, ASM_DESCR.REG_ANY)}""",
|
||
op=[ASM_DESCR.CLOBBER_MEMORY, ASM_DESCR.CLOBBER_RAX,
|
||
ASM_DESCR.CLOBBER_RCX, ASM_DESCR.CLOBBER_RDX,
|
||
ASM_DESCR.CLOBBER_RDI, ASM_DESCR.CLOBBER_RSI,
|
||
ASM_DESCR.CLOBBER_R8, ASM_DESCR.CLOBBER_R9,
|
||
ASM_DESCR.CLOBBER_R10, ASM_DESCR.CLOBBER_R11])
|
||
serial.puts("[so] call returned\n")
|
||
return 0
|
||
|
||
def GETPID() -> uint64:
|
||
"""getpid()：当前进程 pid。/dev/desk 的事件按 pid 过滤，app 需要它。"""
|
||
return uint64(process.current())
|
||
|
||
def _is_dev_path(path: const str) -> int:
|
||
"""路径是否以 "/dev/" 开头（走 devfs 设备节点而不是 FAT32）。逐字符比较，不引 str 库。"""
|
||
if path[0] != 47: return 0 # '/'
|
||
if path[1] != 100: return 0 # 'd'
|
||
if path[2] != 101: return 0 # 'e'
|
||
if path[3] != 118: return 0 # 'v'
|
||
if path[4] != 47: return 0 # '/'
|
||
return 1
|
||
|
||
def OPEN(path_ptr: str, mode: uint32) -> int:
|
||
p: process.Process* = _current_proc()
|
||
path: const str = path_ptr
|
||
# /dev/* 走 devfs 设备节点（serial / 输入 / fb…），其余仍走 FAT32 文件系统。
|
||
# 判据用逐字符比较（不引 str 库函数）："/dev/" = 47 '/'、100 'd'、101 'e'、118 'v'、47 '/'。
|
||
if _is_dev_path(path):
|
||
dfd: int = devfs.devfs_open(path, int(mode))
|
||
if dfd < 0:
|
||
return _err(abi.ENOENT)
|
||
fd: int = _fd_alloc(p)
|
||
if fd < 0:
|
||
devfs.devfs_close(dfd)
|
||
return _err(abi.EMFILE)
|
||
# 存 devfs_fd+1：devfs fd 0 是合法值，直接用会与"空槽位"混淆
|
||
p.fd_table[fd] = rawptr(uint64(dfd + 1))
|
||
p.fd_kind[fd] = process.FD_KIND_DEVFS
|
||
p.fd_flags[fd] = mode
|
||
return fd
|
||
fat32.lock()
|
||
fp: rawptr = fat32.open(path, _open_mode(mode))
|
||
if not fp:
|
||
fat32.unlock()
|
||
return _err(abi.ENOENT)
|
||
fd: int = _fd_alloc(p)
|
||
if fd < 0:
|
||
fat32.close(fp)
|
||
fat32.unlock()
|
||
return _err(abi.EMFILE)
|
||
p.fd_table[fd] = fp
|
||
p.fd_kind[fd] = process.FD_KIND_FAT32
|
||
p.fd_flags[fd] = mode
|
||
fat32.unlock()
|
||
return fd
|
||
|
||
def CLOSE(fd: int) -> int:
|
||
p: process.Process* = _current_proc()
|
||
if fd < 0 or fd >= process.PROC_MAX_FDS:
|
||
return _err(abi.EBADF)
|
||
fp: rawptr = p.fd_table[fd]
|
||
if not fp:
|
||
return _err(abi.EBADF)
|
||
# Pipes carry their own reference counts: every inherited/dup'd end was
|
||
# counted, so always decrement (fork's shared flag must not skip this).
|
||
if p.fd_kind[fd] == process.FD_KIND_PIPE:
|
||
res_pipe: int = _pipe_close(fp)
|
||
_fd_free(p, fd)
|
||
return res_pipe
|
||
# fork() copies the fd table; shared entries must not close the
|
||
# underlying object (the parent still owns it).
|
||
if p.fd_shared[fd] != 0:
|
||
_fd_free(p, fd)
|
||
return 0
|
||
# dup()/dup2() aliases: only the last close releases the object.
|
||
if _fd_other_ref(p, fd) != 0:
|
||
_fd_free(p, fd)
|
||
return 0
|
||
if p.fd_kind[fd] == process.FD_KIND_DEVFS:
|
||
res_dev: int = devfs.devfs_close(int(uint64(fp)) - 1)
|
||
_fd_free(p, fd)
|
||
if res_dev < 0: return _err(abi.EIO)
|
||
return 0
|
||
if p.fd_kind[fd] == process.FD_KIND_DIR:
|
||
dd: int = int(uint64(fp)) - 1
|
||
if dd >= 0 and dd < process.PROC_MAX_DIRS:
|
||
fat32.lock()
|
||
fat32.closedir(&p.dir_pool[dd])
|
||
fat32.unlock()
|
||
_dir_free(p, dd)
|
||
_fd_free(p, fd)
|
||
return 0
|
||
fat32.lock()
|
||
res: int = int(fat32.close(fp))
|
||
fat32.unlock()
|
||
_fd_free(p, fd)
|
||
return _fr_errno(res)
|
||
|
||
def READ(fd: int, buf_ptr: rawptr, count: uint32) -> int:
|
||
p: process.Process* = _current_proc()
|
||
if fd < 0 or fd >= process.PROC_MAX_FDS:
|
||
return _err(abi.EBADF)
|
||
fp: rawptr = p.fd_table[fd]
|
||
if not fp:
|
||
return _err(abi.EBADF)
|
||
if p.fd_kind[fd] == process.FD_KIND_DIR:
|
||
return _err(abi.EISDIR)
|
||
if p.fd_kind[fd] == process.FD_KIND_PIPE:
|
||
return _pipe_read(fp, buf_ptr, count)
|
||
if p.fd_kind[fd] == process.FD_KIND_DEVFS:
|
||
r: int = devfs.devfs_read(int(uint64(fp)) - 1, buf_ptr, count)
|
||
if r < 0: return _err(abi.EIO)
|
||
return r
|
||
fat32.lock()
|
||
br: uint32 = fat32.read(fp, buf_ptr, count)
|
||
fat32.unlock()
|
||
return int(br)
|
||
|
||
def WRITE(fd: int, buf_ptr: rawptr, count: uint32) -> int:
|
||
p: process.Process* = _current_proc()
|
||
if fd < 0 or fd >= process.PROC_MAX_FDS:
|
||
return _err(abi.EBADF)
|
||
fp: rawptr = p.fd_table[fd]
|
||
if not fp:
|
||
return _err(abi.EBADF)
|
||
if p.fd_kind[fd] == process.FD_KIND_DIR:
|
||
return _err(abi.EISDIR)
|
||
if p.fd_kind[fd] == process.FD_KIND_PIPE:
|
||
return _pipe_write(fp, buf_ptr, count)
|
||
if p.fd_kind[fd] == process.FD_KIND_DEVFS:
|
||
r: int = devfs.devfs_write(int(uint64(fp)) - 1, buf_ptr, count)
|
||
if r < 0: return _err(abi.EIO)
|
||
return r
|
||
fat32.lock()
|
||
bw: uint32 = fat32.write(fp, buf_ptr, count)
|
||
fat32.unlock()
|
||
return int(bw)
|
||
|
||
def IOCTL(fd: int, request: uint32, arg: rawptr) -> int:
|
||
"""设备控制（Linux ioctl 的子集）：当前只有 devfs 设备支持，用于 /dev/fb0 查几何。"""
|
||
p: process.Process* = _current_proc()
|
||
if fd < 0 or fd >= process.PROC_MAX_FDS:
|
||
return _err(abi.EBADF)
|
||
if not p.fd_used[fd]:
|
||
return _err(abi.EBADF)
|
||
if p.fd_kind[fd] != process.FD_KIND_DEVFS:
|
||
return _err(abi.ENOTTY)
|
||
r: int = devfs.devfs_ioctl(int(uint64(p.fd_table[fd])) - 1, request, arg)
|
||
if r < 0: return _err(abi.EINVAL)
|
||
return r
|
||
|
||
def SEEK(fd: int, offset: uint64, whence: uint32) -> int:
|
||
"""lseek(fd, offset, whence) -> new offset, or -errno.
|
||
|
||
offset is 64-bit on the ABI side; FAT32 caps files at 4 GiB so anything
|
||
beyond that range is rejected with -EINVAL. Whence: 0=SET 1=CUR 2=END.
|
||
"""
|
||
p: process.Process* = _current_proc()
|
||
if fd < 0 or fd >= process.PROC_MAX_FDS:
|
||
return _err(abi.EBADF)
|
||
fp: rawptr = p.fd_table[fd]
|
||
if not fp:
|
||
return _err(abi.EBADF)
|
||
if p.fd_kind[fd] == process.FD_KIND_DIR:
|
||
return _err(abi.EINVAL)
|
||
if p.fd_kind[fd] == process.FD_KIND_PIPE:
|
||
return _err(abi.ESPIPE)
|
||
if p.fd_kind[fd] == process.FD_KIND_DEVFS:
|
||
return _err(abi.ESPIPE)
|
||
fat32.lock()
|
||
base: int = 0
|
||
if whence == uint32(abi.SEEK_CUR):
|
||
base = int(fat32.tell(fp))
|
||
elif whence == uint32(abi.SEEK_END):
|
||
base = int(fat32.size(fp))
|
||
elif whence != uint32(abi.SEEK_SET):
|
||
fat32.unlock()
|
||
return _err(abi.EINVAL)
|
||
tgt: int = base + int(offset)
|
||
if tgt < 0 or tgt > 0x7FFFFFFF:
|
||
fat32.unlock()
|
||
return _err(abi.EINVAL)
|
||
r: int = int(fat32.seek(fp, uint32(tgt)))
|
||
fat32.unlock()
|
||
if r != 0: return _fr_errno(r)
|
||
return tgt
|
||
|
||
def MKDIR(path_ptr: str) -> int:
|
||
path: const str = path_ptr
|
||
fat32.lock()
|
||
r: int = int(fat32.mkdir(path))
|
||
fat32.unlock()
|
||
return _fr_errno(r)
|
||
|
||
def REMOVE(path_ptr: str) -> int:
|
||
path: const str = path_ptr
|
||
fat32.lock()
|
||
r: int = int(fat32.remove(path))
|
||
fat32.unlock()
|
||
return _fr_errno(r)
|
||
|
||
# ---------------- P1: file system ABI ----------------
|
||
|
||
def _open_dir(path: const str) -> int:
|
||
p: process.Process* = _current_proc()
|
||
dd: int = _dir_alloc(p)
|
||
if dd < 0: return _err(abi.EMFILE)
|
||
dp: fat32_types.dirobj* = &p.dir_pool[dd]
|
||
fat32.lock()
|
||
res: int = int(fat32.opendir(path, dp))
|
||
fat32.unlock()
|
||
if res != 0:
|
||
_dir_free(p, dd)
|
||
return _fr_errno(res)
|
||
p.dir_table[dd] = rawptr(uint64(dp))
|
||
fd: int = _fd_alloc(p)
|
||
if fd < 0:
|
||
fat32.lock()
|
||
fat32.closedir(dp)
|
||
fat32.unlock()
|
||
_dir_free(p, dd)
|
||
return _err(abi.EMFILE)
|
||
p.fd_table[fd] = rawptr(uint64(dd + 1))
|
||
p.fd_kind[fd] = process.FD_KIND_DIR
|
||
return fd
|
||
|
||
def OPENAT(dirfd: int, path_ptr: str, flags: uint32, mode: uint32) -> int:
|
||
path: const str = path_ptr
|
||
buf: [256]char
|
||
r: int = _resolve_path(dirfd, path, &buf[0])
|
||
if r != 0: return r
|
||
if (flags & uint32(abi.O_DIRECTORY)) != 0:
|
||
return _open_dir(&buf[0])
|
||
return OPEN(&buf[0], flags)
|
||
|
||
def GETDENTS64(fd: int, buf_ptr: rawptr, count: uint64) -> int:
|
||
p: process.Process* = _current_proc()
|
||
if fd < 0 or fd >= process.PROC_MAX_FDS: return _err(abi.EBADF)
|
||
if not p.fd_used[fd]: return _err(abi.EBADF)
|
||
if p.fd_kind[fd] != process.FD_KIND_DIR: return _err(abi.ENOTDIR)
|
||
dd: int = int(uint64(p.fd_table[fd])) - 1
|
||
if dd < 0 or dd >= process.PROC_MAX_DIRS: return _err(abi.EBADF)
|
||
dp: fat32_types.dirobj* = &p.dir_pool[dd]
|
||
info: fat32_types.fileinfo
|
||
fat32.lock()
|
||
r: int = int(fat32.readdir(dp, &info))
|
||
fat32.unlock()
|
||
if r != 0:
|
||
if r == int(fat32_types.FRESULT.FR_NO_FILE): return 0
|
||
return _fr_errno(r)
|
||
name: str = &info.fname[0]
|
||
n: int = int(string.strlen(name))
|
||
reclen: int = (19 + n + 1 + 7) / 8 * 8
|
||
if uint64(reclen) > count: return _err(abi.EINVAL)
|
||
d: abi.linux_dirent64* = buf_ptr
|
||
d.d_ino = uint64(1)
|
||
d.d_off = uint64(0)
|
||
d.d_reclen = uint16(reclen)
|
||
if (int(info.attr) & 0x10) != 0:
|
||
d.d_type = uint8(abi.DT_DIR)
|
||
else:
|
||
d.d_type = uint8(abi.DT_REG)
|
||
dst: char* = char*(uint64(buf_ptr) + 19)
|
||
i: int = 0
|
||
while i < n:
|
||
dst[i] = name[i]
|
||
i += 1
|
||
dst[n] = 0
|
||
i = n + 1
|
||
while i < reclen - 19:
|
||
dst[i] = 0
|
||
i += 1
|
||
return reclen
|
||
|
||
def FSTAT(fd: int, st_ptr: rawptr) -> int:
|
||
p: process.Process* = _current_proc()
|
||
if fd < 0 or fd >= process.PROC_MAX_FDS: return _err(abi.EBADF)
|
||
if not p.fd_used[fd]: return _err(abi.EBADF)
|
||
if st_ptr is None: return _err(abi.EFAULT)
|
||
st: abi.linux_stat* = st_ptr
|
||
if p.fd_kind[fd] == process.FD_KIND_DEVFS:
|
||
_fill_stat(st, uint64(0), uint32(abi.MODE_CHAR), uint64(fd + 1))
|
||
elif p.fd_kind[fd] == process.FD_KIND_DIR:
|
||
_fill_stat(st, uint64(0), uint32(abi.MODE_DIR), uint64(fd + 1))
|
||
elif p.fd_kind[fd] == process.FD_KIND_PIPE:
|
||
_fill_stat(st, uint64(0), uint32(abi.MODE_FIFO), uint64(fd + 1))
|
||
else:
|
||
fp: rawptr = p.fd_table[fd]
|
||
size: uint64 = uint64(fat32.size(fp))
|
||
_fill_stat(st, size, uint32(abi.MODE_FILE), uint64(fd + 1))
|
||
return 0
|
||
|
||
def NEWFSTATAT(dirfd: int, path_ptr: str, st_ptr: rawptr, flags: uint32) -> int:
|
||
if st_ptr is None: return _err(abi.EFAULT)
|
||
path: const str = path_ptr
|
||
if path is None: return _err(abi.EFAULT)
|
||
if path[0] == 0:
|
||
if (flags & uint32(abi.AT_EMPTY_PATH)) != 0:
|
||
return FSTAT(dirfd, st_ptr)
|
||
return _err(abi.ENOENT)
|
||
st: abi.linux_stat* = st_ptr
|
||
buf: [256]char
|
||
r: int = _resolve_path(dirfd, path, &buf[0])
|
||
if r != 0: return r
|
||
if _is_dev_path(&buf[0]):
|
||
_fill_stat(st, uint64(0), uint32(abi.MODE_CHAR), uint64(1))
|
||
return 0
|
||
if buf[0] == 47 and buf[1] == 0:
|
||
_fill_stat(st, uint64(0), uint32(abi.MODE_DIR), uint64(1))
|
||
return 0
|
||
info: fat32_types.fileinfo
|
||
fat32.lock()
|
||
res: int = int(fat32.stat(&buf[0], &info))
|
||
fat32.unlock()
|
||
if res != 0: return _fr_errno(res)
|
||
if (int(info.attr) & 0x10) != 0:
|
||
_fill_stat(st, uint64(0), uint32(abi.MODE_DIR), uint64(1))
|
||
else:
|
||
_fill_stat(st, uint64(info.file_size), uint32(abi.MODE_FILE), uint64(1))
|
||
return 0
|
||
|
||
def DUP(fd: int) -> int:
|
||
p: process.Process* = _current_proc()
|
||
if fd < 0 or fd >= process.PROC_MAX_FDS: return _err(abi.EBADF)
|
||
if not p.fd_used[fd]: return _err(abi.EBADF)
|
||
nfd: int = _fd_alloc(p)
|
||
if nfd < 0: return _err(abi.EMFILE)
|
||
p.fd_table[nfd] = p.fd_table[fd]
|
||
p.fd_kind[nfd] = p.fd_kind[fd]
|
||
p.fd_flags[nfd] = p.fd_flags[fd]
|
||
p.fd_shared[nfd] = p.fd_shared[fd]
|
||
if p.fd_kind[nfd] == process.FD_KIND_PIPE:
|
||
_pipe_add_ref(p.fd_table[nfd])
|
||
return nfd
|
||
|
||
def DUP2(oldfd: int, newfd: int) -> int:
|
||
p: process.Process* = _current_proc()
|
||
if oldfd < 0 or oldfd >= process.PROC_MAX_FDS: return _err(abi.EBADF)
|
||
if not p.fd_used[oldfd]: return _err(abi.EBADF)
|
||
if newfd < 0 or newfd >= process.PROC_MAX_FDS: return _err(abi.EBADF)
|
||
if oldfd == newfd: return newfd
|
||
if p.fd_used[newfd]:
|
||
r: int = CLOSE(newfd)
|
||
if r != 0: return r
|
||
p.fd_used[newfd] = 1
|
||
p.fd_table[newfd] = p.fd_table[oldfd]
|
||
p.fd_kind[newfd] = p.fd_kind[oldfd]
|
||
p.fd_flags[newfd] = p.fd_flags[oldfd]
|
||
p.fd_shared[newfd] = p.fd_shared[oldfd]
|
||
if p.fd_kind[newfd] == process.FD_KIND_PIPE:
|
||
_pipe_add_ref(p.fd_table[newfd])
|
||
return newfd
|
||
|
||
def DUP3(oldfd: int, newfd: int, flags: uint32) -> int:
|
||
return DUP2(oldfd, newfd)
|
||
|
||
def FCNTL(fd: int, cmd: uint32, arg: uint64) -> int:
|
||
p: process.Process* = _current_proc()
|
||
if fd < 0 or fd >= process.PROC_MAX_FDS: return _err(abi.EBADF)
|
||
if not p.fd_used[fd]: return _err(abi.EBADF)
|
||
c: int = int(cmd)
|
||
if c == abi.F_DUPFD or c == abi.F_DUPFD_CLOEXEC:
|
||
return DUP(fd)
|
||
if c == abi.F_GETFD:
|
||
return 0
|
||
if c == abi.F_SETFD:
|
||
return 0
|
||
if c == abi.F_GETFL:
|
||
return int(p.fd_flags[fd])
|
||
if c == abi.F_SETFL:
|
||
p.fd_flags[fd] = uint32(arg)
|
||
return 0
|
||
return _err(abi.EINVAL)
|
||
|
||
def PREAD64(fd: int, buf_ptr: rawptr, count: uint32, offset: uint64) -> int:
|
||
p: process.Process* = _current_proc()
|
||
if fd < 0 or fd >= process.PROC_MAX_FDS: return _err(abi.EBADF)
|
||
if not p.fd_used[fd]: return _err(abi.EBADF)
|
||
if p.fd_kind[fd] != process.FD_KIND_FAT32: return _err(abi.ESPIPE)
|
||
cur: int = SEEK(fd, uint64(0), uint32(abi.SEEK_CUR))
|
||
if cur < 0: return cur
|
||
r: int = SEEK(fd, offset, uint32(abi.SEEK_SET))
|
||
if r < 0: return r
|
||
n: int = READ(fd, buf_ptr, count)
|
||
SEEK(fd, uint64(cur), uint32(abi.SEEK_SET))
|
||
return n
|
||
|
||
def PWRITE64(fd: int, buf_ptr: rawptr, count: uint32, offset: uint64) -> int:
|
||
p: process.Process* = _current_proc()
|
||
if fd < 0 or fd >= process.PROC_MAX_FDS: return _err(abi.EBADF)
|
||
if not p.fd_used[fd]: return _err(abi.EBADF)
|
||
if p.fd_kind[fd] != process.FD_KIND_FAT32: return _err(abi.ESPIPE)
|
||
cur: int = SEEK(fd, uint64(0), uint32(abi.SEEK_CUR))
|
||
if cur < 0: return cur
|
||
r: int = SEEK(fd, offset, uint32(abi.SEEK_SET))
|
||
if r < 0: return r
|
||
n: int = WRITE(fd, buf_ptr, count)
|
||
SEEK(fd, uint64(cur), uint32(abi.SEEK_SET))
|
||
return n
|
||
|
||
def RENAME(old_ptr: str, new_ptr: str) -> int:
|
||
oldp: const str = old_ptr
|
||
newp: const str = new_ptr
|
||
fat32.lock()
|
||
r: int = int(fat32.rename(oldp, newp))
|
||
fat32.unlock()
|
||
return _fr_errno(r)
|
||
|
||
def RMDIR(path_ptr: str) -> int:
|
||
path: const str = path_ptr
|
||
fat32.lock()
|
||
r: int = int(fat32.rmdir(path))
|
||
fat32.unlock()
|
||
return _fr_errno(r)
|
||
|
||
def UNLINKAT(dirfd: int, path_ptr: str, flags: uint32) -> int:
|
||
path: const str = path_ptr
|
||
buf: [256]char
|
||
r: int = _resolve_path(dirfd, path, &buf[0])
|
||
if r != 0: return r
|
||
if (flags & uint32(abi.AT_REMOVEDIR)) != 0:
|
||
return RMDIR(&buf[0])
|
||
return REMOVE(&buf[0])
|
||
|
||
def STAT(path_ptr: str, info_ptr: rawptr) -> int:
|
||
path: const str = path_ptr
|
||
info: fat32_types.fileinfo* = info_ptr
|
||
fat32.lock()
|
||
r: int = int(fat32.stat(path, info))
|
||
fat32.unlock()
|
||
return _fr_errno(r)
|
||
|
||
# Private launcher kept for Terminal's `run` command (a new child, caller stays alive).
|
||
def SPAWN_PROC(path_ptr: str, blocking: int) -> int:
|
||
path: const str = path_ptr
|
||
pid: int = elf.spawn_elf(path)
|
||
if pid < 0:
|
||
return _err(abi.ENOENT)
|
||
if blocking:
|
||
p: process.Process* = process.ProcessManager.get_process(pid)
|
||
if p:
|
||
while p.state != process.PROC_DONE:
|
||
sched.Scheduler.try_reschedule()
|
||
return pid
|
||
|
||
def WAIT4(pid: int, status_ptr: rawptr, options: uint32, rusage: rawptr) -> int:
|
||
cur: int = process.current()
|
||
while True:
|
||
found_child: int = 0
|
||
i: int = 0
|
||
while i < process.MAX_PROCESSES:
|
||
p: process.Process* = process.ProcessManager.get_process(i)
|
||
if p is not None:
|
||
matches: int = 0
|
||
if pid <= 0:
|
||
matches = 1 # any child (pid 0: same group, approximated)
|
||
elif p.pid == pid:
|
||
matches = 1
|
||
if matches != 0 and p.pid != cur and p.parent_pid == cur:
|
||
found_child = 1
|
||
if p.state == process.PROC_DONE:
|
||
if status_ptr is not None:
|
||
st: int* = int*(status_ptr)
|
||
st[0] = (p.exit_code & 0xFF) << 8
|
||
p.parent_pid = -1
|
||
return p.pid
|
||
i += 1
|
||
if found_child == 0:
|
||
return _err(abi.ECHILD)
|
||
if (options & uint32(1)) != 0: # WNOHANG
|
||
return 0
|
||
sched.Scheduler.yield_now()
|
||
|
||
# mmap bump allocator and brk base must not overlap (both live below the stack).
|
||
define USER_HEAP_BASE = 0x20000000
|
||
define USER_BRK_BASE = 0x40000000
|
||
define USER_VA_LIMIT = 0x7FFFFF000000
|
||
|
||
# fd = -1（Linux 匿名映射约定）
|
||
define MMAP_FD_ANON: uint64 = 0xFFFFFFFFFFFFFFFF
|
||
|
||
# ---- VMA bookkeeping -------------------------------------------------------
|
||
|
||
def _vma_find(p: process.Process*, addr: uint64) -> int:
|
||
for i in range(process.MAX_VMAS):
|
||
if p.vma_kind[i] == 0: continue
|
||
b: uint64 = p.vma_base[i]
|
||
if addr >= b and addr < b + p.vma_size[i]: return i
|
||
return -1
|
||
|
||
def _vma_overlap(p: process.Process*, start: uint64, size: uint64) -> int:
|
||
if size == 0: return 0
|
||
end: uint64 = start + size
|
||
for i in range(process.MAX_VMAS):
|
||
if p.vma_kind[i] == 0: continue
|
||
b: uint64 = p.vma_base[i]
|
||
e: uint64 = b + p.vma_size[i]
|
||
if start < e and b < end: return 1
|
||
return 0
|
||
|
||
def _vma_add(p: process.Process*, base: uint64, size: uint64, prot: uint32, kind: int, flags: uint32) -> int:
|
||
for i in range(process.MAX_VMAS):
|
||
if p.vma_kind[i] == 0:
|
||
p.vma_base[i] = base
|
||
p.vma_size[i] = size
|
||
p.vma_prot[i] = prot
|
||
p.vma_kind[i] = uint8(kind)
|
||
p.vma_flags[i] = flags
|
||
return 0
|
||
return _err(abi.ENOMEM)
|
||
|
||
def _vma_del(p: process.Process*, i: int):
|
||
p.vma_base[i] = 0
|
||
p.vma_size[i] = 0
|
||
p.vma_prot[i] = 0
|
||
p.vma_kind[i] = 0
|
||
p.vma_flags[i] = 0
|
||
|
||
def _unmap_pages(p: process.Process*, start: uint64, end: uint64, free_pages: int):
|
||
va: uint64 = start
|
||
while va < end:
|
||
if free_pages != 0:
|
||
phys: uint64 = paging.GetPagePhys(va)
|
||
if phys != 0:
|
||
mm.free_page(rawptr(phys))
|
||
paging.UnMapPage(va)
|
||
va = va + uint64(4096)
|
||
|
||
# Remove [addr, addr+length) from the VMA table, splitting partially covered
|
||
# areas, and release the backing frames of anon/file mappings.
|
||
def _vma_unmap_range(p: process.Process*, addr: uint64, length: uint64) -> int:
|
||
if length == 0: return 0
|
||
end: uint64 = addr + length
|
||
i: int = 0
|
||
while i < process.MAX_VMAS:
|
||
if p.vma_kind[i] != 0:
|
||
b: uint64 = p.vma_base[i]
|
||
e: uint64 = b + p.vma_size[i]
|
||
if b < end and addr < e:
|
||
s: uint64 = addr
|
||
if b > s: s = b
|
||
t: uint64 = end
|
||
if e < t: t = e
|
||
free_pages: int = 1
|
||
if p.vma_kind[i] == uint8(process.VMA_KIND_DEV): free_pages = 0
|
||
_unmap_pages(p, s, t, free_pages)
|
||
if s <= b and t >= e:
|
||
_vma_del(p, i)
|
||
elif s <= b:
|
||
p.vma_base[i] = t
|
||
p.vma_size[i] = e - t
|
||
elif t >= e:
|
||
p.vma_size[i] = s - b
|
||
else:
|
||
r: int = _vma_add(p, t, e - t, uint32(p.vma_prot[i]),
|
||
int(p.vma_kind[i]), uint32(p.vma_flags[i]))
|
||
if r != 0: return r
|
||
p.vma_size[i] = s - b
|
||
i += 1
|
||
return 0
|
||
|
||
def MMAP(addr: uint64, length: uint64, prot: uint64, flags: uint64, fd: uint64, offset: uint64) -> uint64:
|
||
"""mmap(addr, length, prot, flags, fd, offset) -> base, or MAP_FAILED (-1).
|
||
|
||
· MAP_ANONYMOUS: fresh zeroed pages;
|
||
· FAT32 fd: file contents copied into fresh pages (MAP_PRIVATE semantics);
|
||
· devfs fd: the device physical range is mapped directly (no frame owns it).
|
||
"""
|
||
p: process.Process* = _current_proc()
|
||
if length == 0: return abi.MAP_FAILED
|
||
aligned: uint64 = (length + uint64(0xFFF)) & ~uint64(0xFFF)
|
||
if aligned == 0: return abi.MAP_FAILED
|
||
fixed: int = 0
|
||
if (flags & uint64(abi.MAP_FIXED)) != 0: fixed = 1
|
||
base: uint64 = 0
|
||
if fixed != 0:
|
||
if (addr & uint64(0xFFF)) != 0: return abi.MAP_FAILED
|
||
base = addr
|
||
if base < uint64(0x10000) or base + aligned > uint64(USER_VA_LIMIT):
|
||
return abi.MAP_FAILED
|
||
if p.brk_end > p.brk_start and base < p.brk_end and p.brk_start < base + aligned:
|
||
return abi.MAP_FAILED
|
||
else:
|
||
if p.heap_start == 0: p.heap_start = USER_HEAP_BASE
|
||
base = p.heap_start + p.heap_size
|
||
while True:
|
||
brk_hit: int = 0
|
||
if p.brk_end > p.brk_start and base < p.brk_end and p.brk_start < base + aligned:
|
||
brk_hit = 1
|
||
if _vma_overlap(p, base, aligned) == 0 and brk_hit == 0: break
|
||
p.heap_size = p.heap_size + aligned
|
||
base = p.heap_start + p.heap_size
|
||
if base + aligned > uint64(USER_VA_LIMIT): return abi.MAP_FAILED
|
||
if base + aligned > uint64(USER_VA_LIMIT): return abi.MAP_FAILED
|
||
# classify the mapping source
|
||
kind: int = process.VMA_KIND_ANON
|
||
uncached: int = 0
|
||
dev_phys: uint64 = 0
|
||
dev_size: uint64 = 0
|
||
fp: rawptr = None
|
||
if (flags & uint64(abi.MAP_ANONYMOUS)) != 0:
|
||
kind = process.VMA_KIND_ANON
|
||
elif fd == MMAP_FD_ANON:
|
||
return abi.MAP_FAILED
|
||
else:
|
||
fdi: int = int(fd)
|
||
if fdi < 0 or fdi >= process.PROC_MAX_FDS: return abi.MAP_FAILED
|
||
if not p.fd_used[fdi]: return abi.MAP_FAILED
|
||
if p.fd_kind[fdi] == process.FD_KIND_DEVFS:
|
||
kind = process.VMA_KIND_DEV
|
||
if (offset & uint64(0xFFF)) != 0: return abi.MAP_FAILED
|
||
if devfs.devfs_get_mmap_info(int(uint64(p.fd_table[fdi])) - 1, &dev_phys, &dev_size) != 0:
|
||
return abi.MAP_FAILED
|
||
if devfs.devfs_mmap_uncached(int(uint64(p.fd_table[fdi])) - 1) != 0:
|
||
uncached = 1
|
||
if offset + aligned > dev_size: return abi.MAP_FAILED
|
||
elif p.fd_kind[fdi] == process.FD_KIND_FAT32:
|
||
kind = process.VMA_KIND_FILE
|
||
if (offset & uint64(0xFFF)) != 0: return abi.MAP_FAILED
|
||
if offset > uint64(0xFFFFFFFF): return abi.MAP_FAILED
|
||
fp = p.fd_table[fdi]
|
||
else:
|
||
return abi.MAP_FAILED
|
||
if fixed != 0:
|
||
ur: int = _vma_unmap_range(p, base, aligned)
|
||
if ur != 0: return abi.MAP_FAILED
|
||
pte: uint64 = paging.PTE_PRESENT | paging.PTE_USER
|
||
if (prot & uint64(abi.PROT_WRITE)) != 0:
|
||
pte = pte | paging.PTE_WRITABLE
|
||
if uncached != 0:
|
||
# MMIO (framebuffer). Use PAT write-combining when the CPU exposes it;
|
||
# otherwise leave the mapping write-back (fast sequential blits, and the
|
||
# compositor does not rely on UC for visibility). UC (PTE_PCD) made
|
||
# dragging noticeably slower on VMware.
|
||
if paging.has_pat_wc() != 0:
|
||
pte = pte | paging.PTE_PAT
|
||
# 这一段会连续调用 MapPage，而 MapPage 依赖**全局 paging.pml4**。若中途被
|
||
# 定时器抢占并切换进程，paging.pml4 会被 switch_pid 改成别的进程，后续页就
|
||
# 映射进错误的地址空间（本进程留下未映射空洞；用户写空洞时若命中 identity
|
||
# 大页就会直接改物理内存 → BAD blk / 画面花屏）。整个映射循环必须原子。
|
||
asm.cli()
|
||
va: uint64 = base
|
||
if kind == process.VMA_KIND_FILE:
|
||
fat32.lock()
|
||
oldpos: uint32 = fat32.tell(fp)
|
||
fat32.seek(fp, uint32(offset))
|
||
fat32.unlock()
|
||
done: uint64 = 0
|
||
while va < base + aligned:
|
||
fphys: rawptr = mm.alloc_page()
|
||
if fphys is None:
|
||
fat32.lock()
|
||
fat32.seek(fp, oldpos)
|
||
fat32.unlock()
|
||
_unmap_pages(p, base, va, 1)
|
||
asm.sti()
|
||
return abi.MAP_FAILED
|
||
string.memset(fphys, 0, 4096)
|
||
chunk: uint32 = 4096
|
||
if length - done < uint64(4096): chunk = uint32(length - done)
|
||
if chunk > 0:
|
||
fat32.lock()
|
||
got: int = fat32.read(fp, fphys, chunk)
|
||
fat32.unlock()
|
||
if got > 0:
|
||
done = done + uint64(got)
|
||
paging.MapPage(va, uint64(fphys), pte)
|
||
va = va + uint64(4096)
|
||
fat32.lock()
|
||
fat32.seek(fp, oldpos)
|
||
fat32.unlock()
|
||
else:
|
||
while va < base + aligned:
|
||
if kind == process.VMA_KIND_DEV:
|
||
paging.MapPage(va, dev_phys + offset + (va - base), pte)
|
||
else:
|
||
aphys: rawptr = mm.alloc_page()
|
||
if aphys is None:
|
||
_mf: [128]char
|
||
viperlib.snprintf(&_mf, 128, "[mmap] FAIL pid=%d va=0x%lx len=0x%lx\n",
|
||
p.pid, va, aligned)
|
||
serial.puts(&_mf)
|
||
_unmap_pages(p, base, va, 1)
|
||
asm.sti()
|
||
return abi.MAP_FAILED
|
||
string.memset(aphys, 0, 4096)
|
||
paging.MapPage(va, uint64(aphys), pte)
|
||
va = va + uint64(4096)
|
||
r: int = _vma_add(p, base, aligned, uint32(prot), kind, uint32(flags))
|
||
if r != 0:
|
||
if kind == process.VMA_KIND_DEV:
|
||
_unmap_pages(p, base, base + aligned, 0)
|
||
else:
|
||
_unmap_pages(p, base, base + aligned, 1)
|
||
asm.sti()
|
||
return abi.MAP_FAILED
|
||
if fixed == 0:
|
||
p.heap_size = p.heap_size + aligned
|
||
asm.sti()
|
||
return base
|
||
|
||
def MUNMAP(ptr: uint64, size: uint64) -> int:
|
||
if size == 0: return _err(abi.EINVAL)
|
||
start: uint64 = ptr & ~uint64(0xFFF)
|
||
end: uint64 = (ptr + size + uint64(0xFFF)) & ~uint64(0xFFF)
|
||
if end <= start: return _err(abi.EINVAL)
|
||
if start < uint64(0x10000) or end > uint64(USER_VA_LIMIT): return _err(abi.EINVAL)
|
||
asm.cli()
|
||
_mr: int = _vma_unmap_range(_current_proc(), start, end - start)
|
||
asm.sti()
|
||
return _mr
|
||
|
||
def MPROTECT(addr: uint64, length: uint64, prot: uint64) -> int:
|
||
p: process.Process* = _current_proc()
|
||
if length == 0: return 0
|
||
start: uint64 = addr & ~uint64(0xFFF)
|
||
end: uint64 = (addr + length + uint64(0xFFF)) & ~uint64(0xFFF)
|
||
if end <= start: return _err(abi.EINVAL)
|
||
if start < uint64(0x10000) or end > uint64(USER_VA_LIMIT): return _err(abi.EINVAL)
|
||
va: uint64 = start
|
||
while va < end:
|
||
# Kernel-loaded ELF segments are not in the VMA table; accept any
|
||
# present 4KB page so RELRO mprotect() on the main image still works.
|
||
if _vma_find(p, va) < 0 and paging.GetPagePhys(va) == 0:
|
||
return _err(abi.ENOMEM)
|
||
va = va + uint64(4096)
|
||
# Snapshot the VMAs that overlap: splitting below adds new entries.
|
||
idx: [64]int
|
||
n: int = 0
|
||
for i in range(process.MAX_VMAS):
|
||
if p.vma_kind[i] == 0: continue
|
||
b: uint64 = p.vma_base[i]
|
||
e: uint64 = b + p.vma_size[i]
|
||
if b < end and start < e:
|
||
idx[n] = i
|
||
n += 1
|
||
j: int = 0
|
||
while j < n:
|
||
i: int = idx[j]
|
||
b: uint64 = p.vma_base[i]
|
||
e: uint64 = b + p.vma_size[i]
|
||
s: uint64 = start
|
||
if b > s: s = b
|
||
t: uint64 = end
|
||
if e < t: t = e
|
||
old_prot: uint32 = uint32(p.vma_prot[i])
|
||
kind: int = int(p.vma_kind[i])
|
||
vflags: uint32 = uint32(p.vma_flags[i])
|
||
if s <= b and t >= e:
|
||
p.vma_prot[i] = uint32(prot)
|
||
elif s <= b:
|
||
r: int = _vma_add(p, t, e - t, old_prot, kind, vflags)
|
||
if r != 0: return r
|
||
p.vma_size[i] = t - b
|
||
p.vma_prot[i] = uint32(prot)
|
||
elif t >= e:
|
||
r = _vma_add(p, s, e - s, uint32(prot), kind, vflags)
|
||
if r != 0: return r
|
||
p.vma_size[i] = s - b
|
||
else:
|
||
r = _vma_add(p, s, t - s, uint32(prot), kind, vflags)
|
||
if r != 0: return r
|
||
r = _vma_add(p, t, e - t, old_prot, kind, vflags)
|
||
if r != 0: return r
|
||
p.vma_size[i] = s - b
|
||
j += 1
|
||
pte: uint64 = paging.PTE_PRESENT | paging.PTE_USER
|
||
if (prot & uint64(abi.PROT_WRITE)) != 0:
|
||
pte = pte | paging.PTE_WRITABLE
|
||
va = start
|
||
while va < end:
|
||
if paging.SetPageFlags(va, pte) == 0: return _err(abi.ENOMEM)
|
||
va = va + uint64(4096)
|
||
return 0
|
||
|
||
def BRK(addr: uint64) -> uint64:
|
||
p: process.Process* = _current_proc()
|
||
if p.brk_start == 0:
|
||
p.brk_start = USER_BRK_BASE
|
||
p.brk_end = USER_BRK_BASE
|
||
if addr == 0: return p.brk_end
|
||
if addr < p.brk_start or addr > uint64(USER_VA_LIMIT): return p.brk_end
|
||
old_map: uint64 = (p.brk_end + uint64(0xFFF)) & ~uint64(0xFFF)
|
||
new_map: uint64 = (addr + uint64(0xFFF)) & ~uint64(0xFFF)
|
||
if new_map > old_map:
|
||
asm.cli()
|
||
va: uint64 = old_map
|
||
while va < new_map:
|
||
if _vma_overlap(p, va, uint64(4096)) != 0:
|
||
_unmap_pages(p, old_map, va, 1)
|
||
asm.sti()
|
||
return p.brk_end
|
||
bphys: rawptr = mm.alloc_page()
|
||
if bphys is None:
|
||
_unmap_pages(p, old_map, va, 1)
|
||
asm.sti()
|
||
return p.brk_end
|
||
string.memset(bphys, 0, 4096)
|
||
paging.MapPage(va, uint64(bphys),
|
||
paging.PTE_PRESENT | paging.PTE_WRITABLE | paging.PTE_USER)
|
||
va = va + uint64(4096)
|
||
asm.sti()
|
||
elif new_map < old_map:
|
||
_unmap_pages(p, new_map, old_map, 1)
|
||
p.brk_end = addr
|
||
return p.brk_end
|
||
|
||
def MREMAP(old_addr: uint64, old_size: uint64, new_size: uint64, flags: uint64, new_addr: uint64) -> uint64:
|
||
p: process.Process* = _current_proc()
|
||
if old_size == 0 or new_size == 0: return abi.MAP_FAILED
|
||
if (old_addr & uint64(0xFFF)) != 0: return abi.MAP_FAILED
|
||
old_len: uint64 = (old_size + uint64(0xFFF)) & ~uint64(0xFFF)
|
||
new_len: uint64 = (new_size + uint64(0xFFF)) & ~uint64(0xFFF)
|
||
if old_addr < uint64(0x10000) or old_addr + old_len > uint64(USER_VA_LIMIT):
|
||
return abi.MAP_FAILED
|
||
if _vma_find(p, old_addr) < 0: return abi.MAP_FAILED
|
||
if new_len <= old_len:
|
||
if new_len < old_len:
|
||
_vma_unmap_range(p, old_addr + new_len, old_len - new_len)
|
||
return old_addr
|
||
if (flags & uint64(abi.MREMAP_MAYMOVE)) == 0:
|
||
return abi.MAP_FAILED
|
||
mflags: uint64 = uint64(abi.MAP_PRIVATE | abi.MAP_ANONYMOUS)
|
||
hint: uint64 = 0
|
||
if (flags & uint64(abi.MREMAP_FIXED)) != 0:
|
||
if new_addr < old_addr + old_len and old_addr < new_addr + new_len:
|
||
return abi.MAP_FAILED
|
||
mflags = mflags | uint64(abi.MAP_FIXED)
|
||
hint = new_addr
|
||
nv: uint64 = MMAP(hint, new_len, uint64(abi.PROT_READ | abi.PROT_WRITE),
|
||
mflags, MMAP_FD_ANON, 0)
|
||
if nv == abi.MAP_FAILED: return abi.MAP_FAILED
|
||
string.memcpy(rawptr(nv), rawptr(old_addr), old_len)
|
||
_vma_unmap_range(p, old_addr, old_len)
|
||
return nv
|
||
|
||
def MADVISE(addr: uint64, length: uint64, advice: uint32) -> int:
|
||
# No paging/swapping policy yet; accept the hint.
|
||
return 0
|
||
|
||
# ============================================================================
|
||
# P4/P5/P6: TLS, futex, time, signals, iovec, pipes, reboot
|
||
# ============================================================================
|
||
|
||
# ---- arch_prctl ----
|
||
def ARCH_PRCTL(code: int, addr: uint64) -> int:
|
||
if code == abi.ARCH_SET_FS:
|
||
sched.set_fs_base(addr)
|
||
return 0
|
||
if code == abi.ARCH_GET_FS:
|
||
if addr == 0: return _err(abi.EFAULT)
|
||
dst: uint64* = uint64*(addr)
|
||
dst[0] = sched.get_fs_base()
|
||
return 0
|
||
return _err(abi.ENOSYS)
|
||
|
||
# ---- futex: polling implementation (no sleep queue yet) ----
|
||
def FUTEX(uaddr: uint64, op: uint32, val: uint32, timeout: rawptr) -> int:
|
||
if uaddr == 0: return _err(abi.EFAULT)
|
||
cmd: int = int(op) & 0x7F
|
||
u: uint32* = uint32*(uaddr)
|
||
if cmd == 0 or cmd == 9:
|
||
if u[0] != val: return _err(abi.EAGAIN)
|
||
while u[0] == val:
|
||
sched.Scheduler.yield_now()
|
||
return 0
|
||
if cmd == 1 or cmd == 10:
|
||
return 0
|
||
return _err(abi.ENOSYS)
|
||
|
||
# ---- time ----
|
||
def _rtc_epoch() -> uint64:
|
||
y: int = int(rtc.rtc_get_year())
|
||
mo: int = int(rtc.rtc_get_month())
|
||
d: int = int(rtc.rtc_get_day())
|
||
h: int = int(rtc.rtc_get_hours())
|
||
mi: int = int(rtc.rtc_get_minutes())
|
||
s: int = int(rtc.rtc_get_seconds())
|
||
yy: int = y
|
||
if mo <= 2: yy = yy - 1
|
||
era: int = yy / 400
|
||
yoe: int = yy - era * 400
|
||
mp: int = (mo + 9) % 12
|
||
doy: int = (153 * mp + 2) / 5 + d - 1
|
||
doe: int = yoe * 365 + yoe / 4 - yoe / 100 + doy
|
||
days: int = era * 146097 + doe - 719468
|
||
return uint64(days * 86400 + h * 3600 + mi * 60 + s)
|
||
|
||
def CLOCK_GETTIME(clockid: int, ts_ptr: rawptr) -> int:
|
||
if ts_ptr is None: return _err(abi.EFAULT)
|
||
ts: abi.linux_timespec* = ts_ptr
|
||
if clockid == 0:
|
||
ts.tv_sec = _rtc_epoch()
|
||
ts.tv_nsec = uint64(0)
|
||
else:
|
||
t: uint64 = timer.timer_get_ticks()
|
||
ts.tv_sec = t / uint64(1000)
|
||
ts.tv_nsec = (t % uint64(1000)) * uint64(1000000)
|
||
return 0
|
||
|
||
def CLOCK_GETRES(clockid: int, ts_ptr: rawptr) -> int:
|
||
if ts_ptr is None: return _err(abi.EFAULT)
|
||
ts: abi.linux_timespec* = ts_ptr
|
||
ts.tv_sec = uint64(0)
|
||
ts.tv_nsec = uint64(1000000)
|
||
return 0
|
||
|
||
def GETTIMEOFDAY(tv_ptr: rawptr, tz_ptr: rawptr) -> int:
|
||
if tv_ptr is not None:
|
||
tv: uint64* = uint64*(tv_ptr)
|
||
tv[0] = _rtc_epoch()
|
||
tv[1] = uint64(0)
|
||
if tz_ptr is not None:
|
||
string.memset(tz_ptr, 0, 8)
|
||
return 0
|
||
|
||
def NANOSLEEP(req_ptr: rawptr, rem_ptr: rawptr) -> int:
|
||
if req_ptr is None: return _err(abi.EFAULT)
|
||
ts: abi.linux_timespec* = req_ptr
|
||
ms: uint64 = ts.tv_sec * uint64(1000) + ts.tv_nsec / uint64(1000000)
|
||
if ms > uint64(0x7FFFFFFF): ms = uint64(0x7FFFFFFF)
|
||
if ms > 0:
|
||
timer.timer_msleep(uint32(ms))
|
||
return 0
|
||
|
||
# ---- signals: registration + delivery on syscall return ----
|
||
define SIG_DFL = 0
|
||
define SIG_IGN = 1
|
||
define SA_NODEFER = 0x40000000
|
||
|
||
def RT_SIGACTION(sig: int, act_ptr: rawptr, old_ptr: rawptr, sigsetsize: uint32) -> int:
|
||
if sig < 1 or sig > 64: return _err(abi.EINVAL)
|
||
p: process.Process* = _current_proc()
|
||
if old_ptr is not None:
|
||
o: uint64* = uint64*(old_ptr)
|
||
o[0] = p.sig_handler[sig]
|
||
o[1] = p.sig_actflags[sig]
|
||
o[2] = p.sig_restorer[sig]
|
||
o[3] = uint64(0)
|
||
if act_ptr is not None:
|
||
a: uint64* = uint64*(act_ptr)
|
||
p.sig_handler[sig] = a[0]
|
||
p.sig_actflags[sig] = a[1]
|
||
p.sig_restorer[sig] = a[2]
|
||
return 0
|
||
|
||
def RT_SIGPROCMASK(how: int, set_ptr: rawptr, old_ptr: rawptr, sigsetsize: uint32) -> int:
|
||
p: process.Process* = _current_proc()
|
||
if old_ptr is not None:
|
||
o: uint64* = uint64*(old_ptr)
|
||
o[0] = p.sig_mask
|
||
if set_ptr is not None:
|
||
s: uint64* = uint64*(set_ptr)
|
||
m: uint64 = s[0]
|
||
if how == 0:
|
||
p.sig_mask = p.sig_mask | m
|
||
elif how == 1:
|
||
p.sig_mask = p.sig_mask & ~m
|
||
elif how == 2:
|
||
p.sig_mask = m
|
||
else:
|
||
return _err(abi.EINVAL)
|
||
return 0
|
||
|
||
def KILL(pid: int, sig: int) -> int:
|
||
if sig < 0 or sig > 64: return _err(abi.EINVAL)
|
||
if sig == 0: return 0
|
||
target: process.Process* = None
|
||
if pid == 0 or pid == process.current():
|
||
target = _current_proc()
|
||
elif pid > 0:
|
||
target = process.ProcessManager.get_process(pid)
|
||
if target is None: return _err(abi.ESRCH)
|
||
target.sig_pending = target.sig_pending | (uint64(1) << uint64(sig - 1))
|
||
return 0
|
||
|
||
def RT_SIGRETURN() -> int:
|
||
f: uint64* = uint64*(sched.get_syscall_frame())
|
||
sf: uint64 = f[15] - uint64(8)
|
||
w: uint64* = uint64*(sf)
|
||
i: int = 0
|
||
while i < 12:
|
||
f[i] = w[1 + i]
|
||
i += 1
|
||
f[13] = w[13]
|
||
f[12] = w[14]
|
||
f[15] = w[15]
|
||
p: process.Process* = _current_proc()
|
||
p.sig_mask = w[18]
|
||
return int(w[16])
|
||
|
||
# Deliver one pending signal by rewriting the syscall return frame.
|
||
# Returns 1 if a handler was entered (the syscall must return 0 in RAX).
|
||
def _deliver_signals(ret: uint64) -> int:
|
||
p: process.Process* = _current_proc()
|
||
avail: uint64 = p.sig_pending & ~p.sig_mask
|
||
# SIGKILL(9) / SIGSTOP(19) cannot be blocked
|
||
avail = avail | (p.sig_pending & (uint64(1) << uint64(8)))
|
||
avail = avail | (p.sig_pending & (uint64(1) << uint64(18)))
|
||
if avail == 0: return 0
|
||
sig: int = 1
|
||
while sig <= 64:
|
||
if (avail & (uint64(1) << uint64(sig - 1))) != 0: break
|
||
sig += 1
|
||
if sig > 64: return 0
|
||
bit: uint64 = uint64(1) << uint64(sig - 1)
|
||
p.sig_pending = p.sig_pending & ~bit
|
||
h: uint64 = p.sig_handler[sig]
|
||
if h == uint64(SIG_IGN):
|
||
return _deliver_signals(ret)
|
||
if h == uint64(SIG_DFL):
|
||
if sig == 1 or sig == 2 or sig == 3 or sig == 4 or sig == 5 or sig == 6 or sig == 7 or sig == 8 or sig == 9 or sig == 11 or sig == 13 or sig == 14 or sig == 15:
|
||
p.exit_code = 128 + sig
|
||
sched.Scheduler.exit_process(p.pid)
|
||
return _deliver_signals(ret)
|
||
rest: uint64 = p.sig_restorer[sig]
|
||
if rest == 0:
|
||
return _deliver_signals(ret)
|
||
f: uint64* = uint64*(sched.get_syscall_frame())
|
||
user_rsp: uint64 = f[15]
|
||
user_rip: uint64 = f[13]
|
||
user_flags: uint64 = f[12]
|
||
# The handler is entered with RSP == sf and [sf] == restorer, exactly like a
|
||
# normal call: rsp % 16 == 8 at function entry. rt_sigreturn then runs with
|
||
# rsp == sf + 8 and recovers sf as (user_rsp - 8).
|
||
sf: uint64 = ((user_rsp - uint64(320)) & ~uint64(0xF)) - uint64(8)
|
||
w: uint64* = uint64*(sf)
|
||
w[0] = rest
|
||
i: int = 0
|
||
while i < 12:
|
||
w[1 + i] = f[i]
|
||
i += 1
|
||
w[13] = user_rip
|
||
w[14] = user_flags
|
||
w[15] = user_rsp
|
||
w[16] = ret
|
||
w[17] = uint64(sig)
|
||
w[18] = p.sig_mask
|
||
si: uint64 = sf + uint64(152)
|
||
string.memset(rawptr(si), 0, 128)
|
||
si32: uint32* = uint32*(si)
|
||
si32[0] = uint32(sig) # si_signo
|
||
si32[1] = uint32(0) # si_errno
|
||
si32[2] = uint32(0) # si_code
|
||
# handler(sig, &siginfo, &ucontext)
|
||
f[8] = uint64(sig)
|
||
f[9] = si
|
||
f[10] = sf + uint64(8)
|
||
f[13] = h
|
||
# Enter the handler with [sf] = restorer (normal call-frame shape).
|
||
f[15] = sf
|
||
if (p.sig_actflags[sig] & uint64(SA_NODEFER)) == 0:
|
||
p.sig_mask = p.sig_mask | bit
|
||
return 1
|
||
|
||
# ---- iovec ----
|
||
define IOV_MAX = 1024
|
||
|
||
def READV(fd: int, iov_ptr: rawptr, iovcnt: int) -> int:
|
||
if iov_ptr is None or iovcnt < 0 or iovcnt > IOV_MAX: return _err(abi.EINVAL)
|
||
iov: abi.iovec* = iov_ptr
|
||
total: int = 0
|
||
i: int = 0
|
||
while i < iovcnt:
|
||
want: uint32 = 0xFFFFFFFF
|
||
if iov[i].len < uint64(0xFFFFFFFF): want = uint32(iov[i].len)
|
||
n: int = READ(fd, iov[i].base, want)
|
||
if n < 0:
|
||
if total > 0: return total
|
||
return n
|
||
total = total + n
|
||
if uint64(n) < iov[i].len: break
|
||
i += 1
|
||
return total
|
||
|
||
def WRITEV(fd: int, iov_ptr: rawptr, iovcnt: int) -> int:
|
||
if iov_ptr is None or iovcnt < 0 or iovcnt > IOV_MAX: return _err(abi.EINVAL)
|
||
iov: abi.iovec* = iov_ptr
|
||
total: int = 0
|
||
i: int = 0
|
||
while i < iovcnt:
|
||
want: uint32 = 0xFFFFFFFF
|
||
if iov[i].len < uint64(0xFFFFFFFF): want = uint32(iov[i].len)
|
||
n: int = WRITE(fd, iov[i].base, want)
|
||
if n < 0:
|
||
if total > 0: return total
|
||
return n
|
||
total = total + n
|
||
if uint64(n) < iov[i].len: break
|
||
i += 1
|
||
return total
|
||
|
||
def POLL(fds: rawptr, nfds: uint64, timeout: int) -> int:
|
||
return 0
|
||
|
||
# ---- pipes ----
|
||
define MAX_PIPES = 8
|
||
define PIPE_CAP = 4096
|
||
|
||
_pipe_buf: [MAX_PIPES]rawptr
|
||
_pipe_head: [MAX_PIPES]uint32
|
||
_pipe_tail: [MAX_PIPES]uint32
|
||
_pipe_cnt: [MAX_PIPES]uint32
|
||
_pipe_rd: [MAX_PIPES]int
|
||
_pipe_wr: [MAX_PIPES]int
|
||
_pipe_used: [MAX_PIPES]uint8
|
||
|
||
def _pipe_alloc() -> int:
|
||
for i in range(MAX_PIPES):
|
||
if _pipe_used[i] == 0:
|
||
b: rawptr = mm.malloc(uint64(PIPE_CAP))
|
||
if b is None: return -1
|
||
_pipe_buf[i] = b
|
||
_pipe_head[i] = 0
|
||
_pipe_tail[i] = 0
|
||
_pipe_cnt[i] = 0
|
||
_pipe_rd[i] = 0
|
||
_pipe_wr[i] = 0
|
||
_pipe_used[i] = 1
|
||
return i
|
||
return -1
|
||
|
||
def PIPE2(fds_ptr: rawptr, flags: uint32) -> int:
|
||
if fds_ptr is None: return _err(abi.EFAULT)
|
||
p: process.Process* = _current_proc()
|
||
id: int = _pipe_alloc()
|
||
if id < 0: return _err(abi.EMFILE)
|
||
rfd: int = _fd_alloc(p)
|
||
if rfd < 0:
|
||
mm.free(_pipe_buf[id])
|
||
_pipe_used[id] = 0
|
||
return _err(abi.EMFILE)
|
||
wfd: int = _fd_alloc(p)
|
||
if wfd < 0:
|
||
_fd_free(p, rfd)
|
||
mm.free(_pipe_buf[id])
|
||
_pipe_used[id] = 0
|
||
return _err(abi.EMFILE)
|
||
p.fd_table[rfd] = rawptr(uint64(id * 2 + 1))
|
||
p.fd_kind[rfd] = process.FD_KIND_PIPE
|
||
p.fd_flags[rfd] = flags
|
||
p.fd_table[wfd] = rawptr(uint64(id * 2 + 2))
|
||
p.fd_kind[wfd] = process.FD_KIND_PIPE
|
||
p.fd_flags[wfd] = flags
|
||
_pipe_rd[id] = 1
|
||
_pipe_wr[id] = 1
|
||
fds: int* = int*(fds_ptr)
|
||
fds[0] = rfd
|
||
fds[1] = wfd
|
||
return 0
|
||
|
||
def PIPE(fds_ptr: rawptr) -> int:
|
||
return PIPE2(fds_ptr, uint32(0))
|
||
|
||
def _pipe_read(fp: rawptr, buf_ptr: rawptr, count: uint32) -> int:
|
||
id: int = (int(uint64(fp)) - 1) / 2
|
||
if id < 0 or id >= MAX_PIPES or _pipe_used[id] == 0: return _err(abi.EBADF)
|
||
while _pipe_cnt[id] == 0:
|
||
if _pipe_wr[id] == 0: return 0
|
||
sched.Scheduler.yield_now()
|
||
n: uint32 = count
|
||
if _pipe_cnt[id] < n: n = _pipe_cnt[id]
|
||
dst: uint8* = uint8*(buf_ptr)
|
||
i: uint32 = 0
|
||
while i < n:
|
||
src: uint8* = uint8*(uint64(_pipe_buf[id]) + uint64(_pipe_head[id]))
|
||
dst[i] = src[0]
|
||
_pipe_head[id] = (_pipe_head[id] + uint32(1)) % uint32(PIPE_CAP)
|
||
i += 1
|
||
_pipe_cnt[id] = _pipe_cnt[id] - n
|
||
return int(n)
|
||
|
||
def _pipe_write(fp: rawptr, buf_ptr: rawptr, count: uint32) -> int:
|
||
id: int = (int(uint64(fp)) - 1) / 2
|
||
if id < 0 or id >= MAX_PIPES or _pipe_used[id] == 0: return _err(abi.EBADF)
|
||
if _pipe_rd[id] == 0: return _err(abi.EPIPE)
|
||
while _pipe_cnt[id] >= uint32(PIPE_CAP):
|
||
if _pipe_rd[id] == 0: return _err(abi.EPIPE)
|
||
sched.Scheduler.yield_now()
|
||
n: uint32 = count
|
||
room: uint32 = uint32(PIPE_CAP) - _pipe_cnt[id]
|
||
if room < n: n = room
|
||
src: uint8* = uint8*(buf_ptr)
|
||
i: uint32 = 0
|
||
while i < n:
|
||
dst: uint8* = uint8*(uint64(_pipe_buf[id]) + uint64(_pipe_tail[id]))
|
||
dst[0] = src[i]
|
||
_pipe_tail[id] = (_pipe_tail[id] + uint32(1)) % uint32(PIPE_CAP)
|
||
i += 1
|
||
_pipe_cnt[id] = _pipe_cnt[id] + n
|
||
return int(n)
|
||
|
||
# Count one more reference to a pipe end (dup/dup2/fork inherit).
|
||
def _pipe_add_ref(fp: rawptr):
|
||
v: int = int(uint64(fp)) - 1
|
||
id: int = v / 2
|
||
end: int = v % 2
|
||
if id < 0 or id >= MAX_PIPES: return
|
||
if end == 0: _pipe_rd[id] = _pipe_rd[id] + 1
|
||
else: _pipe_wr[id] = _pipe_wr[id] + 1
|
||
|
||
def _pipe_close(fp: rawptr) -> int:
|
||
v: int = int(uint64(fp)) - 1
|
||
id: int = v / 2
|
||
end: int = v % 2
|
||
if id < 0 or id >= MAX_PIPES: return _err(abi.EBADF)
|
||
if end == 0:
|
||
if _pipe_rd[id] > 0: _pipe_rd[id] = _pipe_rd[id] - 1
|
||
else:
|
||
if _pipe_wr[id] > 0: _pipe_wr[id] = _pipe_wr[id] - 1
|
||
if _pipe_rd[id] == 0 and _pipe_wr[id] == 0:
|
||
if _pipe_buf[id] is not None: mm.free(_pipe_buf[id])
|
||
_pipe_buf[id] = None
|
||
_pipe_used[id] = 0
|
||
return 0
|
||
|
||
# ---- Linux reboot(169) ----
|
||
define LINUX_REBOOT_MAGIC1 = 0xFEE1DEAD
|
||
define LINUX_REBOOT_MAGIC2 = 672274793
|
||
define LINUX_REBOOT_CMD_RESTART = 0x01234567
|
||
define LINUX_REBOOT_CMD_POWER_OFF = 0x4321FEDC
|
||
|
||
def REBOOT_LINUX(magic1: uint32, magic2: uint32, cmd: uint32, arg: rawptr) -> int:
|
||
if magic1 != uint32(LINUX_REBOOT_MAGIC1) or magic2 != uint32(LINUX_REBOOT_MAGIC2):
|
||
return _err(abi.EINVAL)
|
||
if cmd == uint32(LINUX_REBOOT_CMD_RESTART):
|
||
power_reboot()
|
||
return 0
|
||
if cmd == uint32(LINUX_REBOOT_CMD_POWER_OFF):
|
||
power_shutdown()
|
||
return 0
|
||
return _err(abi.EINVAL)
|
||
|
||
# ============================================================================
|
||
# Linux clone()/fork(): resume the child at the caller's post-syscall RIP
|
||
# ============================================================================
|
||
|
||
define CLONE_VM = 0x00000100
|
||
define CLONE_FS = 0x00000200
|
||
define CLONE_FILES = 0x00000400
|
||
define CLONE_SIGHAND = 0x00000800
|
||
define CLONE_THREAD = 0x00010000
|
||
define CLONE_SETTLS = 0x00080000
|
||
define CLONE_PARENT_SETTID = 0x00100000
|
||
define CLONE_CHILD_CLEARTID = 0x00200000
|
||
define CLONE_CHILD_SETTID = 0x01000000
|
||
|
||
class ForkCtx:
|
||
pid: int
|
||
rip: uint64
|
||
rsp: uint64
|
||
flags: uint64
|
||
fs: uint64
|
||
kern_stack: uint64
|
||
regs: [12]uint64
|
||
|
||
def _clone_context(flags: uint64, stack: uint64, tls: uint64) -> ForkCtx*:
|
||
fp: uint64 = sched.get_syscall_frame()
|
||
if fp == 0: return None
|
||
f: uint64* = uint64*(fp)
|
||
ctx: ForkCtx* = ForkCtx*(mm.malloc(uint64(ForkCtx.__sizeof__())))
|
||
if ctx is None: return None
|
||
string.memset(rawptr(ctx), 0, uint64(ForkCtx.__sizeof__()))
|
||
ctx.rip = f[13]
|
||
ctx.flags = f[12]
|
||
ctx.rsp = f[15]
|
||
if stack != 0: ctx.rsp = stack
|
||
ctx.fs = sched.get_fs_base()
|
||
if (flags & uint64(CLONE_SETTLS)) != 0 and tls != 0:
|
||
ctx.fs = tls
|
||
i: int = 0
|
||
while i < 12:
|
||
ctx.regs[i] = f[i]
|
||
i += 1
|
||
return ctx
|
||
|
||
def _fork_child_entry(arg: rawptr) -> int:
|
||
ctx: ForkCtx* = arg
|
||
asm.cli()
|
||
proc.switch_pid(ctx.pid)
|
||
ks: uint64 = ctx.kern_stack
|
||
gdt.set_tss_rsp0(ks)
|
||
cpu.set_kernel_rsp0(ks)
|
||
proc.set_resume(ctx.rip, ctx.rsp, ctx.flags, uint64(0), &ctx.regs[0])
|
||
mm.free(rawptr(ctx))
|
||
proc.drop_to_user_mode_ctx(ks)
|
||
return 0
|
||
|
||
def _clone_thread(flags: uint64, stack: uint64, ptid: uint64, ctid: uint64, tls: uint64) -> int:
|
||
cur: process.Process* = _current_proc()
|
||
ctx: ForkCtx* = _clone_context(flags, stack, tls)
|
||
if ctx is None: return _err(abi.EAGAIN)
|
||
ctx.pid = cur.pid
|
||
th: sched.Thread* = sched.Scheduler.create_thread(&_fork_child_entry, rawptr(ctx), cur.pid)
|
||
if th is None:
|
||
mm.free(rawptr(ctx))
|
||
return _err(abi.EAGAIN)
|
||
th.kern_stack = uint64(th.stack) + th.stack_size
|
||
ctx.kern_stack = th.kern_stack
|
||
if cur.addThread(th.tid) != 0:
|
||
th.state = sched.THREAD_DONE
|
||
mm.free(rawptr(ctx))
|
||
return _err(abi.EAGAIN)
|
||
sched.set_thread_fs_base(th.tid, ctx.fs)
|
||
if (flags & uint64(CLONE_PARENT_SETTID)) != 0 and ptid != 0:
|
||
pt: int* = int*(ptid)
|
||
pt[0] = th.tid
|
||
if (flags & uint64(CLONE_CHILD_SETTID)) != 0 and ctid != 0:
|
||
ct: int* = int*(ctid)
|
||
ct[0] = th.tid
|
||
if (flags & uint64(CLONE_CHILD_CLEARTID)) != 0 and ctid != 0:
|
||
sched.set_clear_child_tid(th.tid, ctid)
|
||
return th.tid
|
||
|
||
def _alloc_page4k() -> rawptr:
|
||
return mm.alloc_page()
|
||
|
||
# Fork/exec inherit the fd table as shared references: neither side may release
|
||
# an object the other still uses. Non-pipe objects have no cross-process
|
||
# refcount yet, so mark BOTH sides shared (they are leaked on close instead of
|
||
# being freed under a live user). Pipes do have counts and stay reclaimable.
|
||
def _copy_fds(dst: process.Process*, src: process.Process*):
|
||
i: int = 0
|
||
while i < process.PROC_MAX_FDS:
|
||
if src.fd_used[i]:
|
||
dst.fd_used[i] = 1
|
||
dst.fd_table[i] = src.fd_table[i]
|
||
dst.fd_kind[i] = src.fd_kind[i]
|
||
dst.fd_flags[i] = src.fd_flags[i]
|
||
if src.fd_kind[i] == process.FD_KIND_PIPE:
|
||
dst.fd_shared[i] = 0
|
||
_pipe_add_ref(src.fd_table[i])
|
||
else:
|
||
dst.fd_shared[i] = 1
|
||
src.fd_shared[i] = 1
|
||
i += 1
|
||
|
||
# Linux execve (placed after the pipe/fork helpers so it can inherit fds).
|
||
def EXECVE(path_ptr: str, argv: rawptr, envp: rawptr) -> int:
|
||
cur: process.Process* = _current_proc()
|
||
old_parent: int = cur.parent_pid
|
||
path: const str = path_ptr
|
||
pid: int = elf.spawn_elf(path, argv, envp)
|
||
if pid < 0:
|
||
return _err(abi.ENOENT)
|
||
np: process.Process* = process.ProcessManager.get_process(pid)
|
||
if np is not None:
|
||
np.parent_pid = old_parent
|
||
string.strcpy(&np.cwd[0], &cur.cwd[0])
|
||
np.sig_mask = cur.sig_mask
|
||
i: int = 0
|
||
while i < 65:
|
||
np.sig_handler[i] = 0
|
||
np.sig_actflags[i] = 0
|
||
np.sig_restorer[i] = 0
|
||
i += 1
|
||
np.sig_pending = 0
|
||
_copy_fds(np, cur)
|
||
cur.exit_code = 0
|
||
sched.Scheduler.exit_process(cur.pid)
|
||
return 0
|
||
|
||
def _fork_process(stack: uint64) -> int:
|
||
cur: process.Process* = _current_proc()
|
||
ctx: ForkCtx* = _clone_context(uint64(0), stack, uint64(0))
|
||
if ctx is None: return _err(abi.EAGAIN)
|
||
np: process.Process* = process.ProcessManager.create_process(&cur.name[0], None)
|
||
if np is None:
|
||
mm.free(rawptr(ctx))
|
||
return _err(abi.EAGAIN)
|
||
new_pml4: uint64 = paging.create_process_page_table()
|
||
if new_pml4 == 0:
|
||
mm.free(rawptr(ctx))
|
||
np.exit()
|
||
return _err(abi.ENOMEM)
|
||
if paging.CopyUserSpace(cur.pml4_root, new_pml4, rawptr(uint64(&_alloc_page4k))) != 0:
|
||
mm.free(rawptr(ctx))
|
||
np.exit()
|
||
return _err(abi.ENOMEM)
|
||
np.pml4_root = new_pml4
|
||
np.elf_base = cur.elf_base
|
||
np.heap_start = cur.heap_start
|
||
np.heap_size = cur.heap_size
|
||
np.brk_start = cur.brk_start
|
||
np.brk_end = cur.brk_end
|
||
np.entry = cur.entry
|
||
np.parent_pid = cur.pid
|
||
string.strcpy(&np.cwd[0], &cur.cwd[0])
|
||
i: int = 0
|
||
while i < process.MAX_VMAS:
|
||
np.vma_base[i] = cur.vma_base[i]
|
||
np.vma_size[i] = cur.vma_size[i]
|
||
np.vma_prot[i] = cur.vma_prot[i]
|
||
np.vma_kind[i] = cur.vma_kind[i]
|
||
np.vma_flags[i] = cur.vma_flags[i]
|
||
i += 1
|
||
i = 0
|
||
while i < 65:
|
||
np.sig_handler[i] = cur.sig_handler[i]
|
||
np.sig_actflags[i] = cur.sig_actflags[i]
|
||
np.sig_restorer[i] = cur.sig_restorer[i]
|
||
i += 1
|
||
np.sig_mask = cur.sig_mask
|
||
np.sig_pending = 0
|
||
# shared fd table (the child must not close the parent's objects)
|
||
_copy_fds(np, cur)
|
||
# create_process allocated a private 64KB stack; the child uses the copy.
|
||
if np.user_stack != 0:
|
||
mm.free(rawptr(np.user_stack - uint64(process.USER_STACK_SIZE)))
|
||
np.user_stack = 0
|
||
ctx.pid = np.pid
|
||
th: sched.Thread* = sched.Scheduler.create_thread(&_fork_child_entry, rawptr(ctx), np.pid)
|
||
if th is None:
|
||
mm.free(rawptr(ctx))
|
||
np.exit()
|
||
return _err(abi.EAGAIN)
|
||
th.kern_stack = np.kern_stack
|
||
ctx.kern_stack = np.kern_stack
|
||
np.addThread(th.tid)
|
||
sched.set_thread_fs_base(th.tid, ctx.fs)
|
||
return np.pid
|
||
|
||
def CLONE(flags: uint64, stack: uint64, ptid: uint64, ctid: uint64, tls: uint64) -> int:
|
||
if (flags & uint64(CLONE_VM)) != 0:
|
||
return _clone_thread(flags, stack, ptid, ctid, tls)
|
||
return _fork_process(stack)
|
||
|
||
def FORK() -> int:
|
||
return _fork_process(uint64(0))
|
||
|
||
# ============================================================================
|
||
# P0: identity / environment / random
|
||
# ============================================================================
|
||
|
||
def GETUID() -> uint64:
|
||
return uint64(0)
|
||
|
||
def GETEUID() -> uint64:
|
||
return uint64(0)
|
||
|
||
def GETGID() -> uint64:
|
||
return uint64(0)
|
||
|
||
def GETEGID() -> uint64:
|
||
return uint64(0)
|
||
|
||
def GETPPID() -> uint64:
|
||
return uint64(_current_proc().parent_pid)
|
||
|
||
def GETTID() -> uint64:
|
||
return uint64(sched.thread_current())
|
||
|
||
def SET_TID_ADDRESS(tid_ptr: rawptr) -> uint64:
|
||
# Single-address-space threads: the scheduler tid is the Linux tid.
|
||
tid: int = sched.thread_current()
|
||
if tid_ptr is not None:
|
||
sched.set_clear_child_tid(tid, uint64(tid_ptr))
|
||
return uint64(tid)
|
||
|
||
def SET_ROBUST_LIST(head: rawptr, len: uint64) -> int:
|
||
# Recorded nowhere yet; futex-based thread exit lands with P4.
|
||
return 0
|
||
|
||
def RSEQ(rseq_ptr: rawptr, len: uint32, flags: uint32) -> int:
|
||
# glibc disables rseq when this returns -ENOSYS.
|
||
return _err(abi.ENOSYS)
|
||
|
||
def UNAME(buf_ptr: rawptr) -> int:
|
||
if buf_ptr is None: return _err(abi.EFAULT)
|
||
u: abi.linux_utsname* = buf_ptr
|
||
string.memset(rawptr(u), 0, uint64(abi.SIZEOF_UTSNAME))
|
||
# Report "Linux" so scripts and build systems do not special-case us;
|
||
# the ViperOS identity stays in the version string.
|
||
string.strcpy(&u.sysname[0], "Linux")
|
||
string.strcpy(&u.nodename[0], "viperos")
|
||
string.strcpy(&u.release[0], "6.1.0-viperos")
|
||
string.strcpy(&u.version[0], "#1 SMP ViperOS")
|
||
string.strcpy(&u.machine[0], "x86_64")
|
||
string.strcpy(&u.domainname[0], "(none)")
|
||
return 0
|
||
|
||
def GETCWD(buf_ptr: rawptr, size: uint64) -> int:
|
||
if buf_ptr is None: return _err(abi.EFAULT)
|
||
p: process.Process* = _current_proc()
|
||
n: int = int(string.strlen(&p.cwd[0]))
|
||
if size < uint64(n + 1): return _err(abi.ERANGE)
|
||
dst: char* = char*(buf_ptr)
|
||
string.strcpy(dst, &p.cwd[0])
|
||
return n + 1
|
||
|
||
def CHDIR(path_ptr: str) -> int:
|
||
path: const str = path_ptr
|
||
buf: [256]char
|
||
r: int = _resolve_path(abi.AT_FDCWD, path, &buf[0])
|
||
if r != 0: return r
|
||
p: process.Process* = _current_proc()
|
||
if buf[0] == 47 and buf[1] == 0:
|
||
string.strcpy(&p.cwd[0], "/")
|
||
return 0
|
||
info: fat32_types.fileinfo
|
||
fat32.lock()
|
||
res: int = int(fat32.stat(&buf[0], &info))
|
||
fat32.unlock()
|
||
if res != 0: return _fr_errno(res)
|
||
if (int(info.attr) & 0x10) == 0:
|
||
return _err(abi.ENOTDIR)
|
||
string.strcpy(&p.cwd[0], &buf[0])
|
||
return 0
|
||
|
||
def FACCESSAT(dirfd: int, path_ptr: str, mode: uint32, flags: uint32) -> int:
|
||
path: const str = path_ptr
|
||
buf: [256]char
|
||
r: int = _resolve_path(dirfd, path, &buf[0])
|
||
if r != 0: return r
|
||
if buf[0] == 47 and buf[1] == 0: return 0
|
||
info: fat32_types.fileinfo
|
||
fat32.lock()
|
||
res: int = int(fat32.stat(&buf[0], &info))
|
||
fat32.unlock()
|
||
if res != 0: return _fr_errno(res)
|
||
return 0
|
||
|
||
def ACCESS(path_ptr: str, mode: uint32) -> int:
|
||
return FACCESSAT(abi.AT_FDCWD, path_ptr, mode, uint32(0))
|
||
|
||
def READLINKAT(dirfd: int, path_ptr: str, buf_ptr: rawptr, bufsiz: uint64) -> int:
|
||
path: const str = path_ptr
|
||
tmp: [256]char
|
||
r: int = _resolve_path(dirfd, path, &tmp[0])
|
||
if r != 0: return r
|
||
info: fat32_types.fileinfo
|
||
fat32.lock()
|
||
res: int = int(fat32.stat(&tmp[0], &info))
|
||
fat32.unlock()
|
||
if res != 0: return _fr_errno(res)
|
||
# FAT32 has no symbolic links; an existing name is simply not a link.
|
||
return _err(abi.EINVAL)
|
||
|
||
def READLINK(path_ptr: str, buf_ptr: rawptr, bufsiz: uint64) -> int:
|
||
return READLINKAT(abi.AT_FDCWD, path_ptr, buf_ptr, bufsiz)
|
||
|
||
def PRLIMIT64(pid: int, resource: uint32, new_ptr: rawptr, old_ptr: rawptr) -> int:
|
||
if pid != 0 and pid != process.current():
|
||
return _err(abi.ESRCH)
|
||
# Setting limits is accepted but not enforced yet.
|
||
if old_ptr is not None:
|
||
rl: abi.linux_rlimit* = old_ptr
|
||
cur: uint64 = abi.RLIM_INFINITY
|
||
mx: uint64 = abi.RLIM_INFINITY
|
||
if resource == uint32(abi.RLIMIT_STACK):
|
||
cur = uint64(process.USER_STACK_SIZE)
|
||
mx = uint64(process.USER_STACK_SIZE)
|
||
elif resource == uint32(abi.RLIMIT_NOFILE):
|
||
cur = uint64(process.PROC_MAX_FDS)
|
||
mx = uint64(process.PROC_MAX_FDS)
|
||
rl.cur = cur
|
||
rl.max = mx
|
||
return 0
|
||
|
||
def GETRANDOM(buf_ptr: rawptr, buflen: uint64, flags: uint32) -> int:
|
||
if buf_ptr is None: return _err(abi.EFAULT)
|
||
if buflen > uint64(0x7FFFFFFF): return _err(abi.EINVAL)
|
||
p: uint8* = uint8*(buf_ptr)
|
||
i: uint64 = 0
|
||
while i < buflen:
|
||
v: uint64 = _rng_next()
|
||
j: int = 0
|
||
while j < 8 and i < buflen:
|
||
p[i] = uint8(v & uint64(0xFF))
|
||
v = v >> 8
|
||
i += 1
|
||
j += 1
|
||
return int(buflen)
|
||
|
||
extern def syscall_entry()
|
||
|
||
def syscall_dispatch(num: uint64, arg1: uint64, arg2: uint64, arg3: uint64, arg4: uint64, arg5: uint64, arg6: uint64) -> uint64:
|
||
n: int = int(num)
|
||
if n == int(Syscall.EXIT):
|
||
return uint64(EXIT(int(arg1)))
|
||
elif n == int(Syscall.OPEN):
|
||
path_ptr: str = str(arg1)
|
||
return uint64(OPEN(path_ptr, uint32(arg2)))
|
||
elif n == int(Syscall.CLOSE):
|
||
return uint64(CLOSE(int(arg1)))
|
||
elif n == int(Syscall.READ):
|
||
buf_ptr: rawptr = rawptr(arg2)
|
||
return uint64(READ(int(arg1), buf_ptr, uint32(arg3)))
|
||
elif n == int(Syscall.WRITE):
|
||
buf_ptr: rawptr = rawptr(arg2)
|
||
return uint64(WRITE(int(arg1), buf_ptr, uint32(arg3)))
|
||
elif n == int(Syscall.IOCTL):
|
||
return uint64(IOCTL(int(arg1), uint32(arg2), rawptr(arg3)))
|
||
elif n == int(Syscall.SEEK):
|
||
return uint64(SEEK(int(arg1), arg2, uint32(arg3)))
|
||
elif n == int(Syscall.MKDIR):
|
||
path_ptr: str = str(arg1)
|
||
return uint64(MKDIR(path_ptr))
|
||
elif n == int(Syscall.REMOVE):
|
||
path_ptr: str = str(arg1)
|
||
return uint64(REMOVE(path_ptr))
|
||
elif n == int(Syscall.STAT):
|
||
path_ptr: str = str(arg1)
|
||
info_ptr: rawptr = rawptr(arg2)
|
||
return uint64(STAT(path_ptr, info_ptr))
|
||
elif n == int(Syscall.REBOOT):
|
||
power_reboot()
|
||
return uint64(0)
|
||
elif n == int(Syscall.SHUTDOWN):
|
||
power_shutdown()
|
||
return uint64(0)
|
||
elif n == int(Syscall.LOAD_SO):
|
||
path_ptr_so: rawptr = rawptr(arg1)
|
||
return LOAD_SO(path_ptr_so)
|
||
elif n == int(Syscall.SO_CALL1):
|
||
sym_ptr: rawptr = rawptr(arg1)
|
||
return uint64(SO_CALL1(sym_ptr, rawptr(arg2)))
|
||
elif n == int(Syscall.GETPID):
|
||
return GETPID()
|
||
elif n == int(Syscall.YIELD):
|
||
# sched_yield 是"主动放弃剩余时间片"，必须无条件切换；try_reschedule() 只在
|
||
# 时间片到期时才切，作为 syscall 会让等待外设的进程白等（见 Scheduler.yield_now 注释）。
|
||
sched.Scheduler.yield_now()
|
||
return 0
|
||
elif n == int(Syscall.SPAWN):
|
||
return uint64(EXECVE(str(arg1), rawptr(arg2), rawptr(arg3)))
|
||
elif n == int(Syscall.SPAWN_PROC):
|
||
path_ptr_sp2: rawptr = rawptr(arg1)
|
||
return uint64(SPAWN_PROC(path_ptr_sp2, int(arg2)))
|
||
elif n == int(Syscall.WAIT4):
|
||
return uint64(WAIT4(int(arg1), rawptr(arg2), uint32(arg3), rawptr(arg4)))
|
||
elif n == int(Syscall.MMAP):
|
||
return MMAP(arg1, arg2, arg3, arg4, arg5, arg6)
|
||
elif n == int(Syscall.MUNMAP):
|
||
return uint64(MUNMAP(arg1, arg2))
|
||
elif n == int(Syscall.MPROTECT):
|
||
return uint64(MPROTECT(arg1, arg2, arg3))
|
||
elif n == int(Syscall.BRK):
|
||
return BRK(arg1)
|
||
elif n == int(Syscall.MREMAP):
|
||
return MREMAP(arg1, arg2, arg3, arg4, arg5)
|
||
elif n == int(Syscall.MADVISE):
|
||
return uint64(MADVISE(arg1, arg2, uint32(arg3)))
|
||
elif n == int(Syscall.CLONE):
|
||
return uint64(CLONE(arg1, arg2, arg3, arg4, arg5))
|
||
elif n == int(Syscall.FORK):
|
||
return uint64(FORK())
|
||
elif n == int(Syscall.THREAD_CREATE_OLD):
|
||
func_ptr: rawptr = rawptr(arg1)
|
||
arg_ptr: rawptr = rawptr(arg2)
|
||
cur_pid: int = process.current()
|
||
# app 传进来的是**用户地址**：必须用 create_user_thread（独立用户栈 + 独立内核栈、
|
||
# 走 drop_to_user_mode 进 Ring 3），不能用 create_thread 在 Ring 0 直接 call。
|
||
th: sched.Thread* = sched.Scheduler.create_user_thread(cur_pid, func_ptr, arg_ptr)
|
||
if th is None: return uint64(_err(abi.EAGAIN))
|
||
p: process.Process* = process.ProcessManager.get_process(cur_pid)
|
||
if p:
|
||
p.addThread(th.tid)
|
||
return uint64(th.tid)
|
||
elif n == int(Syscall.THREAD_EXIT):
|
||
# 用户线程显式退出（回收用户栈等资源后让出，永不返回）。
|
||
sched.Scheduler.exit_current_thread()
|
||
return 0
|
||
elif n == int(Syscall.UNAME):
|
||
return uint64(UNAME(rawptr(arg1)))
|
||
elif n == int(Syscall.GETUID):
|
||
return GETUID()
|
||
elif n == int(Syscall.GETEUID):
|
||
return GETEUID()
|
||
elif n == int(Syscall.GETGID):
|
||
return GETGID()
|
||
elif n == int(Syscall.GETEGID):
|
||
return GETEGID()
|
||
elif n == int(Syscall.GETPPID):
|
||
return GETPPID()
|
||
elif n == int(Syscall.GETTID):
|
||
return GETTID()
|
||
elif n == int(Syscall.GETCWD):
|
||
return uint64(GETCWD(rawptr(arg1), arg2))
|
||
elif n == int(Syscall.CHDIR):
|
||
return uint64(CHDIR(str(arg1)))
|
||
elif n == int(Syscall.ACCESS):
|
||
return uint64(ACCESS(str(arg1), uint32(arg2)))
|
||
elif n == int(Syscall.FACCESSAT):
|
||
return uint64(FACCESSAT(int(arg1), str(arg2), uint32(arg3), uint32(arg4)))
|
||
elif n == int(Syscall.READLINK):
|
||
return uint64(READLINK(str(arg1), rawptr(arg2), arg3))
|
||
elif n == int(Syscall.READLINKAT):
|
||
return uint64(READLINKAT(int(arg1), str(arg2), rawptr(arg3), arg4))
|
||
elif n == int(Syscall.SET_TID_ADDRESS):
|
||
return SET_TID_ADDRESS(rawptr(arg1))
|
||
elif n == int(Syscall.SET_ROBUST_LIST):
|
||
return uint64(SET_ROBUST_LIST(rawptr(arg1), arg2))
|
||
elif n == int(Syscall.RSEQ):
|
||
return uint64(RSEQ(rawptr(arg1), uint32(arg2), uint32(arg3)))
|
||
elif n == int(Syscall.PRLIMIT64):
|
||
return uint64(PRLIMIT64(int(arg1), uint32(arg2), rawptr(arg3), rawptr(arg4)))
|
||
elif n == int(Syscall.GETRANDOM):
|
||
return uint64(GETRANDOM(rawptr(arg1), arg2, uint32(arg3)))
|
||
elif n == int(Syscall.FSTAT):
|
||
return uint64(FSTAT(int(arg1), rawptr(arg2)))
|
||
elif n == int(Syscall.NEWFSTATAT):
|
||
return uint64(NEWFSTATAT(int(arg1), str(arg2), rawptr(arg3), uint32(arg4)))
|
||
elif n == int(Syscall.OPENAT):
|
||
return uint64(OPENAT(int(arg1), str(arg2), uint32(arg3), uint32(arg4)))
|
||
elif n == int(Syscall.GETDENTS64):
|
||
return uint64(GETDENTS64(int(arg1), rawptr(arg2), arg3))
|
||
elif n == int(Syscall.DUP):
|
||
return uint64(DUP(int(arg1)))
|
||
elif n == int(Syscall.DUP2):
|
||
return uint64(DUP2(int(arg1), int(arg2)))
|
||
elif n == int(Syscall.DUP3):
|
||
return uint64(DUP3(int(arg1), int(arg2), uint32(arg3)))
|
||
elif n == int(Syscall.FCNTL):
|
||
return uint64(FCNTL(int(arg1), uint32(arg2), arg3))
|
||
elif n == int(Syscall.PREAD64):
|
||
return uint64(PREAD64(int(arg1), rawptr(arg2), uint32(arg3), arg4))
|
||
elif n == int(Syscall.PWRITE64):
|
||
return uint64(PWRITE64(int(arg1), rawptr(arg2), uint32(arg3), arg4))
|
||
elif n == int(Syscall.RENAME):
|
||
return uint64(RENAME(str(arg1), str(arg2)))
|
||
elif n == int(Syscall.RMDIR):
|
||
return uint64(RMDIR(str(arg1)))
|
||
elif n == int(Syscall.UNLINKAT):
|
||
return uint64(UNLINKAT(int(arg1), str(arg2), uint32(arg3)))
|
||
elif n == int(Syscall.ARCH_PRCTL):
|
||
return uint64(ARCH_PRCTL(int(arg1), arg2))
|
||
elif n == int(Syscall.FUTEX):
|
||
return uint64(FUTEX(arg1, uint32(arg2), uint32(arg3), rawptr(arg4)))
|
||
elif n == int(Syscall.CLOCK_GETTIME):
|
||
return uint64(CLOCK_GETTIME(int(arg1), rawptr(arg2)))
|
||
elif n == int(Syscall.CLOCK_GETRES):
|
||
return uint64(CLOCK_GETRES(int(arg1), rawptr(arg2)))
|
||
elif n == int(Syscall.GETTIMEOFDAY):
|
||
return uint64(GETTIMEOFDAY(rawptr(arg1), rawptr(arg2)))
|
||
elif n == int(Syscall.NANOSLEEP):
|
||
return uint64(NANOSLEEP(rawptr(arg1), rawptr(arg2)))
|
||
elif n == int(Syscall.RT_SIGACTION):
|
||
return uint64(RT_SIGACTION(int(arg1), rawptr(arg2), rawptr(arg3), uint32(arg4)))
|
||
elif n == int(Syscall.RT_SIGPROCMASK):
|
||
return uint64(RT_SIGPROCMASK(int(arg1), rawptr(arg2), rawptr(arg3), uint32(arg4)))
|
||
elif n == int(Syscall.RT_SIGRETURN):
|
||
return uint64(RT_SIGRETURN())
|
||
elif n == int(Syscall.KILL):
|
||
return uint64(KILL(int(arg1), int(arg2)))
|
||
elif n == int(Syscall.READV):
|
||
return uint64(READV(int(arg1), rawptr(arg2), int(arg3)))
|
||
elif n == int(Syscall.WRITEV):
|
||
return uint64(WRITEV(int(arg1), rawptr(arg2), int(arg3)))
|
||
elif n == int(Syscall.POLL):
|
||
return uint64(POLL(rawptr(arg1), arg2, int(arg3)))
|
||
elif n == int(Syscall.PIPE):
|
||
return uint64(PIPE(rawptr(arg1)))
|
||
elif n == int(Syscall.PIPE2):
|
||
return uint64(PIPE2(rawptr(arg1), uint32(arg2)))
|
||
elif n == int(Syscall.REBOOT_LINUX):
|
||
return uint64(REBOOT_LINUX(uint32(arg1), uint32(arg2), uint32(arg3), rawptr(arg4)))
|
||
# Unknown/unimplemented Linux numbers return -ENOSYS (never success).
|
||
return uint64(_err(abi.ENOSYS))
|
||
|
||
# Normal C entry: dispatch, then deliver at most one pending signal by
|
||
# rewriting the saved user context. Returning 0 makes the signal handler's
|
||
# entry RAX = 0; the original syscall result is saved in the frame.
|
||
def _syscall_invoke(num: uint64, arg1: uint64, arg2: uint64, arg3: uint64, arg4: uint64, arg5: uint64, arg6: uint64) -> uint64:
|
||
sched.set_syscall_frame(_entry_frame)
|
||
r: uint64 = syscall_dispatch(num, arg1, arg2, arg3, arg4, arg5, arg6)
|
||
if _deliver_signals(r) != 0:
|
||
return uint64(0)
|
||
return r
|
||
|
||
# The compiler-provided syscall_entry calls this symbol. Naked: save the
|
||
# entry frame pointer and tail-jump into _syscall_invoke (its ret returns to
|
||
# the entry's call site).
|
||
@__attribute__(naked)
|
||
export def syscall_handler(num: uint64, arg1: uint64, arg2: uint64, arg3: uint64, arg4: uint64, arg5: uint64, arg6: uint64) -> uint64:
|
||
__asm__("mov qword ptr [rip + _entry_frame], rbp\n jmp qword ptr [rip + _handler_ptr]")
|
||
return 0
|
||
|
||
def init():
|
||
global _handler_ptr
|
||
_handler_ptr = rawptr(uint64(&_syscall_invoke))
|
||
efer: uint64 = rdmsr(IA32_EFER)
|
||
efer = efer | 1
|
||
wrmsr(IA32_EFER, efer)
|
||
star_val: uint64 = (uint64(0x08) << 32) | (uint64(0x1B) << 48)
|
||
wrmsr(IA32_STAR, star_val)
|
||
wrmsr(IA32_LSTAR, uint64(syscall_entry))
|
||
wrmsr(IA32_FMASK, 0x200)
|
||
serial.puts("[syscall] MSR init done\n")
|