A bunch of compat work (mostly stubs but some real implementations, too.)

Another pass at getting bash-1.14.7 to build. Not that many symbols remain.

Kernel/Process.cpp

@@ -1035,6 +1035,23 @@ int Process::sys$close(int fd)
     return rc;
 }
 
+int Process::sys$access(const char* pathname, int mode)
+{
+    (void) mode;
+    VALIDATE_USER_READ(pathname, strlen(pathname));
+    ASSERT_NOT_REACHED();
+}
+
+int Process::sys$fstat(int fd, Unix::stat* statbuf)
+{
+    VALIDATE_USER_WRITE(statbuf, sizeof(Unix::stat));
+    auto* descriptor = file_descriptor(fd);
+    if (!descriptor)
+        return -EBADF;
+    descriptor->stat(statbuf);
+    return 0;
+}
+
 int Process::sys$lstat(const char* path, Unix::stat* statbuf)
 {
     VALIDATE_USER_WRITE(statbuf, sizeof(Unix::stat));
@@ -1139,6 +1156,36 @@ int Process::sys$open(const char* path, int options)
     return fd;
 }
 
+int Process::sys$pipe(int* pipefd)
+{
+    VALIDATE_USER_WRITE(pipefd, sizeof(int) * 2);
+    ASSERT_NOT_REACHED();
+}
+
+int Process::sys$killpg(int pgrp, int signum)
+{
+    if (signum < 1 || signum >= 32)
+        return -EINVAL;
+    (void) pgrp;
+    ASSERT_NOT_REACHED();
+}
+
+int Process::sys$setuid(uid_t)
+{
+    ASSERT_NOT_REACHED();
+}
+
+int Process::sys$setgid(gid_t)
+{
+    ASSERT_NOT_REACHED();
+}
+
+unsigned Process::sys$alarm(unsigned seconds)
+{
+    (void) seconds;
+    ASSERT_NOT_REACHED();
+}
+
 int Process::sys$uname(utsname* buf)
 {
     VALIDATE_USER_WRITE(buf, sizeof(utsname));
@@ -1472,7 +1519,7 @@ int Process::sys$dup2(int old_fd, int new_fd)
 Unix::sighandler_t Process::sys$signal(int signum, Unix::sighandler_t handler)
 {
     // FIXME: Fail with -EINVAL if attepmting to catch or ignore SIGKILL or SIGSTOP.
-    if (signum >= 32)
+    if (signum < 1 || signum >= 32)
         return (Unix::sighandler_t)-EINVAL;
     dbgprintf("sys$signal: %d => L%x\n", signum, handler);
     return nullptr;
@@ -1508,7 +1555,7 @@ int Process::sys$sigpending(Unix::sigset_t* set)
 int Process::sys$sigaction(int signum, const Unix::sigaction* act, Unix::sigaction* old_act)
 {
     // FIXME: Fail with -EINVAL if attepmting to change action for SIGKILL or SIGSTOP.
-    if (signum >= 32)
+    if (signum < 1 || signum >= 32)
         return -EINVAL;
     VALIDATE_USER_READ(act, sizeof(Unix::sigaction));
     InterruptDisabler disabler; // FIXME: This should use a narrower lock.

Kernel/Process.h

@@ -129,6 +129,7 @@ public:
     int sys$close(int fd);
     ssize_t sys$read(int fd, void* outbuf, size_t nread);
     ssize_t sys$write(int fd, const void*, size_t);
+    int sys$fstat(int fd, Unix::stat*);
     int sys$lstat(const char*, Unix::stat*);
     int sys$stat(const char*, Unix::stat*);
     int sys$lseek(int fd, off_t, int whence);
@@ -163,6 +164,12 @@ public:
     int sys$sigpending(Unix::sigset_t*);
     int sys$getgroups(int size, gid_t*);
     int sys$setgroups(size_t, const gid_t*);
+    int sys$pipe(int* pipefd);
+    int sys$killpg(int pgrp, int sig);
+    int sys$setgid(gid_t);
+    int sys$setuid(uid_t);
+    unsigned sys$alarm(unsigned seconds);
+    int sys$access(const char* pathname, int mode);
 
     static void initialize();
 

Kernel/Syscall.cpp

@@ -161,6 +161,18 @@ static DWORD handle(RegisterDump& regs, DWORD function, DWORD arg1, DWORD arg2,
         return 0;
     case Syscall::SC_sigprocmask:
         return current->sys$sigprocmask((int)arg1, (const Unix::sigset_t*)arg2, (Unix::sigset_t*)arg3);
+    case Syscall::SC_pipe:
+        return current->sys$pipe((int*)arg1);
+    case Syscall::SC_killpg:
+        return current->sys$killpg((int)arg1, (int)arg2);
+    case Syscall::SC_setuid:
+        return current->sys$setuid((uid_t)arg1);
+    case Syscall::SC_setgid:
+        return current->sys$setgid((gid_t)arg1);
+    case Syscall::SC_alarm:
+        return current->sys$alarm((unsigned)arg1);
+    case Syscall::SC_access:
+        return current->sys$access((const char*)arg1, (int)arg2);
     default:
         kprintf("<%u> int0x80: Unknown function %x requested {%x, %x, %x}\n", current->pid(), function, arg1, arg2, arg3);
         break;

Kernel/Syscall.h

@@ -56,6 +56,13 @@
     __ENUMERATE_SYSCALL(sigreturn) \
     __ENUMERATE_SYSCALL(sigprocmask) \
     __ENUMERATE_SYSCALL(sigpending) \
+    __ENUMERATE_SYSCALL(pipe) \
+    __ENUMERATE_SYSCALL(killpg) \
+    __ENUMERATE_SYSCALL(setuid) \
+    __ENUMERATE_SYSCALL(setgid) \
+    __ENUMERATE_SYSCALL(alarm) \
+    __ENUMERATE_SYSCALL(fstat) \
+    __ENUMERATE_SYSCALL(access) \
 
 
 #define DO_SYSCALL_A0(function) Syscall::invoke((dword)(function))