Files
DroidDeck/tools/proot/bench/svc-check.c
T

454 lines
20 KiB
C

#if defined(__aarch64__)
static void interruption_hook(const long *);
#define FP_SVC_TEST_HOOK interruption_hook
#endif
#include "../fastpath/fastpath.c"
#include "checks.h"
#include <sys/wait.h>
#include <linux/futex.h>
#include <signal.h>
#include <setjmp.h>
#if defined(__aarch64__)
static void (*interrupt_path)(void);
static void interruption_hook(const long *r) {
(void)r;
if (interrupt_path) {
void (*hook)(void) = interrupt_path;
interrupt_path = NULL;
hook();
}
}
struct snapshot { long x[32]; unsigned char q[32][16]; unsigned long nzcv, fpcr, fpsr; };
extern uint32_t svc_check_site;
extern void svc_register_probe(struct snapshot *, const long *);
__asm__(
".text\n.p2align 4\n.type svc_register_probe,%function\nsvc_register_probe:\n"
"sub sp, sp, #1072\n"
"stp x19, x20, [sp]\nstp x21, x22, [sp, #16]\nstp x23, x24, [sp, #32]\n"
"stp x25, x26, [sp, #48]\nstp x27, x28, [sp, #64]\nstp x29, x30, [sp, #80]\n"
"stp q8, q9, [sp, #96]\nstp q10, q11, [sp, #128]\n"
"stp q12, q13, [sp, #160]\nstp q14, q15, [sp, #192]\n"
"stp x0, x1, [sp, #224]\n"
".irp n,1,2,3,4,5,6,7,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30\n"
"mov x\\n, #\\n\n.endr\n"
".irp n,0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31\n"
"movi v\\n\\().16b, #0x5a\n.endr\n"
"mov x0, #0xa0000000\nmsr nzcv, x0\n"
"ldr x0, [sp, #232]\nldr x8, [x0, #48]\n"
"ldp x4, x5, [x0, #32]\nldp x2, x3, [x0, #16]\nldp x0, x1, [x0]\n"
".global svc_check_site\nsvc_check_site:\nsvc #0\n"
".irp n,0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30\n"
"str x\\n, [sp, #(256 + \\n * 8)]\n.endr\n"
".irp n,0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31\n"
"str q\\n, [sp, #(512 + \\n * 16)]\n.endr\n"
"mrs x0, nzcv\nstr x0, [sp, #1024]\nmrs x0, fpcr\nstr x0, [sp, #1032]\n"
"mrs x0, fpsr\nstr x0, [sp, #1040]\n"
"ldr x0, [sp, #224]\nadd x1, sp, #256\nmov x2, #792\nbl memcpy\n"
"ldp q8, q9, [sp, #96]\nldp q10, q11, [sp, #128]\n"
"ldp q12, q13, [sp, #160]\nldp q14, q15, [sp, #192]\n"
"ldp x19, x20, [sp]\nldp x21, x22, [sp, #16]\nldp x23, x24, [sp, #32]\n"
"ldp x25, x26, [sp, #48]\nldp x27, x28, [sp, #64]\nldp x29, x30, [sp, #80]\n"
"add sp, sp, #1072\nret\n.size svc_register_probe, .-svc_register_probe\n"
);
static long probe(const long *args) {
struct snapshot out = {0};
unsigned long saved_fpcr, saved_fpsr;
__asm__ volatile("mrs %0, fpcr\nmrs %1, fpsr" : "=r"(saved_fpcr), "=r"(saved_fpsr));
unsigned long fpcr = saved_fpcr ^ (1UL << 22), fpsr = saved_fpsr | (1UL << 27);
__asm__ volatile("msr fpcr, %0\nmsr fpsr, %1" : : "r"(fpcr), "r"(fpsr));
errno = 123;
svc_register_probe(&out, args);
assert(errno == 123);
for (int i = 1; i <= 30; i++) {
long expected = i <= 5 ? args[i] : i == 8 ? args[6] : i;
if (out.x[i] != expected) { fprintf(stderr, "x%d: %lx != %lx\n", i, out.x[i], expected); abort(); }
}
for (int i = 0; i < 32; i++)
for (int j = 0; j < 16; j++) assert(out.q[i][j] == 0x5a);
assert(out.nzcv == 0xa0000000UL);
assert(out.fpcr == fpcr && out.fpsr == fpsr);
__asm__ volatile("msr fpcr, %0\nmsr fpsr, %1" : : "r"(saved_fpcr), "r"(saved_fpsr));
return out.x[0];
}
static void check(const long *args, long want) {
long got = probe(args);
if (got != want) { fprintf(stderr, "syscall %ld: got %ld, expected %ld\n", args[6], got, want); abort(); }
}
static long raw(long nr, long a, long b, long c, long d, long e, long f) {
long args[] = {a, b, c, d, e, f, nr};
return probe(args);
}
static void fault(long nr, long a, long b, long c, long d, long e, long f) {
long args[] = {a, b, c, d, e, f, 0, 0, nr};
long want = svc_original(args);
long call[] = {a, b, c, d, e, f, nr};
check(call, want);
}
static void readlink_boundaries(const char *path) {
char expected[PATH_MAX + 8], actual[PATH_MAX + 8];
long args[] = {AT_FDCWD, (long)path, (long)expected, PATH_MAX, 0, 0, 0, 0, SYS_readlinkat};
long length = svc_original(args);
assert(length > 0 && length < PATH_MAX - 2);
for (long size = length - 1; size <= length + 2; size++) {
memset(expected, 0x5a, sizeof expected); memset(actual, 0x5a, sizeof actual);
args[3] = size;
long want = svc_original(args);
long got = raw(SYS_readlinkat, AT_FDCWD, (long)path, (long)actual, size, 0, 0);
if (got != want || (want > 0 && memcmp(expected, actual, (size_t)want)))
fprintf(stderr, "readlink %s size %ld: relay %ld, proot %ld\n", path, size, got, want);
assert(got == want && (want <= 0 || !memcmp(expected, actual, (size_t)want)));
for (size_t i = (size_t)size; i < sizeof actual; i++) assert(actual[i] == 0x5a);
}
}
static void path_checks(void) {
char work[] = "/tmp/proot-expanded-check-XXXXXX";
assert(mkdtemp(work));
int cwd = open(".", O_RDONLY | O_DIRECTORY);
assert(cwd >= 0 && chdir(work) == 0);
assert(raw(SYS_mkdirat, AT_FDCWD, (long)"dir", 0700, 0, 0, 0) == 0);
long fd = raw(SYS_openat, AT_FDCWD, (long)"dir/file", O_CREAT | O_RDWR | O_EXCL, 0600, 0, 0);
assert(fd >= 0 && write((int)fd, "hello", 5) == 5);
struct stat st;
struct statx sx;
assert(raw(SYS_newfstatat, AT_FDCWD, (long)"dir/file", (long)&st, 0, 0, 0) == 0 && st.st_size == 5);
assert(raw(SYS_statx, AT_FDCWD, (long)"dir/file", 0, STATX_BASIC_STATS, (long)&sx, 0) == 0 && sx.stx_size == 5);
assert(raw(SYS_faccessat, AT_FDCWD, (long)"dir/file", R_OK, 0, 0, 0) == 0);
assert(raw(SYS_symlinkat, (long)"file", AT_FDCWD, (long)"dir/link", 0, 0, 0) == 0);
readlink_boundaries("dir/link");
readlink_boundaries("/proc/self/exe");
char text[PATH_MAX];
memset(text, '#', sizeof text);
assert(raw(SYS_readlinkat, AT_FDCWD, (long)"dir/link", (long)text, sizeof text, 0, 0) == 4);
assert(!memcmp(text, "file#", 5));
assert(raw(SYS_fchmodat, AT_FDCWD, (long)"dir/file", 0640, 0, 0, 0) == 0);
struct timespec times[] = {{1000, 0}, {2000, 0}};
assert(raw(SYS_truncate, (long)"dir/file", 11, 0, 0, 0, 0) == 0);
assert(raw(SYS_utimensat, AT_FDCWD, (long)"dir/file", (long)times, 0, 0, 0) == 0);
assert(raw(SYS_newfstatat, AT_FDCWD, (long)"dir/file", (long)&st, 0, 0, 0) == 0);
assert(st.st_size == 11 && (st.st_mode & 0777) == 0640 && st.st_mtime == 2000);
assert(raw(SYS_renameat, AT_FDCWD, (long)"dir/file", AT_FDCWD, (long)"dir/moved", 0, 0) == 0);
assert(raw(SYS_renameat2, AT_FDCWD, (long)"dir/moved", AT_FDCWD, (long)"dir/file", RENAME_NOREPLACE, 0) == 0);
struct statfs fs;
assert(raw(SYS_statfs, (long)"dir/file", (long)&fs, 0, 0, 0, 0) == 0);
long x = raw(SYS_getxattr, (long)"dir/file", (long)"user.proot-missing", (long)text, sizeof text, 0, 0);
assert(x == -ENODATA || x == -EOPNOTSUPP);
x = raw(SYS_lgetxattr, (long)"dir/link", (long)"user.proot-missing", (long)text, sizeof text, 0, 0);
assert(x == -ENODATA || x == -EOPNOTSUPP);
assert(raw(SYS_listxattr, (long)"dir/file", (long)text, sizeof text, 0, 0, 0) >= 0);
assert(raw(SYS_llistxattr, (long)"dir/link", (long)text, sizeof text, 0, 0, 0) >= 0);
int in = inotify_init1(IN_CLOEXEC);
assert(in >= 0 && raw(SYS_inotify_add_watch, in, (long)"dir", IN_CREATE, 0, 0, 0) >= 0);
close(in);
long n = raw(SYS_getcwd, (long)text, sizeof text, 0, 0, 0, 0);
assert(n == (long)strlen(work) + 1 && !strcmp(text, work));
size_t page = sysconf(_SC_PAGESIZE);
char *guard = mmap(NULL, page * 2, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
assert(guard != MAP_FAILED && mprotect(guard + page, page, PROT_NONE) == 0);
strcpy(guard + page - 2, ".");
assert(raw(SYS_newfstatat, AT_FDCWD, (long)(guard + page - 2), (long)&st, 0, 0, 0) == 0);
long bad = (long)(guard + page);
fault(SYS_openat, AT_FDCWD, bad, O_RDONLY, 0, 0, 0);
fault(SYS_newfstatat, AT_FDCWD, (long)"dir/file", bad, 0, 0, 0);
fault(SYS_statx, AT_FDCWD, (long)"dir/file", 0, STATX_BASIC_STATS, bad, 0);
fault(SYS_readlinkat, AT_FDCWD, (long)"dir/link", bad, 16, 0, 0);
fault(SYS_getcwd, bad, PATH_MAX, 0, 0, 0, 0);
fault(SYS_utimensat, AT_FDCWD, (long)"missing", bad, 0, 0, 0);
fault(SYS_inotify_add_watch, -1, (long)"missing", IN_CREATE, 0, 0, 0);
fault(SYS_renameat2, AT_FDCWD, (long)"dir/file", AT_FDCWD, (long)"dir/nope", 0x80000000, 0);
assert(munmap(guard, page * 2) == 0);
close((int)fd);
assert(raw(SYS_unlinkat, AT_FDCWD, (long)"dir/link", 0, 0, 0, 0) == 0);
assert(raw(SYS_unlinkat, AT_FDCWD, (long)"dir/file", 0, 0, 0, 0) == 0);
assert(raw(SYS_unlinkat, AT_FDCWD, (long)"dir", AT_REMOVEDIR, 0, 0, 0) == 0);
assert(fchdir(cwd) == 0 && close(cwd) == 0 && rmdir(work) == 0);
puts("PASS: path families, dirfds, flags, symlinks, protected pointers, page boundary");
}
static void robust_checks(void) {
if (!svc_android_api) return;
long original = 0;
size_t size = 0;
assert(raw(SYS_get_robust_list, 0, (long)&original, (long)&size, 0, 0, 0) == 0);
struct robust_list_head head = {0};
long set_result = raw(SYS_set_robust_list, (long)&head, sizeof head, 0, 0, 0, 0);
assert(set_result == 0 || set_result == -ENOSYS);
long raw_head = 0;
long direct[] = {0, (long)&raw_head, (long)&size, 0, 0, 0, 0, 0, SYS_get_robust_list};
assert(svc_original(direct) == 0 && raw_head == (long)&head);
long got = 0;
assert(raw(SYS_get_robust_list, gettid(), (long)&got, (long)&size, 0, 0, 0) == 0);
assert(got == (long)&head && size == sizeof head);
assert(raw(SYS_get_robust_list, 0, 1, (long)&size, 0, 0, 0) == -EFAULT);
assert(raw(SYS_set_robust_list, 0, sizeof head, 0, 0, 0, 0) == set_result);
long cleared = raw(SYS_get_robust_list, 0, (long)&got, (long)&size, 0, 0, 0);
assert(cleared == -ENOSYS || (cleared == 0 && got == 0));
direct[0] = original; direct[1] = sizeof head; direct[8] = SYS_set_robust_list;
assert(svc_original(direct) == set_result);
assert(raw(SYS_get_robust_list, 0, (long)&got, (long)&size, 0, 0, 0) == 0 && original == got);
assert(raw(SYS_faccessat2, AT_FDCWD, (long)"/usr/lib/libc.so.6", R_OK, 0, 0, 0) == -ENOSYS);
if (svc_android_api < 35) assert(raw(SYS_clone3, 0, 0, 0, 0, 0, 0) == -ENOSYS);
int api = svc_android_api;
svc_android_api = 35;
assert(!svc_supported(SYS_clone3));
svc_android_api = 0;
assert(!svc_supported(SYS_clone3) && !svc_supported(SYS_set_robust_list));
svc_android_api = api;
assert(!svc_supported(SYS_set_robust_list) && !svc_supported(SYS_get_robust_list));
puts("PASS: mixed relay/raw robust-list callers, errors, faccessat2, clone3 platform guard");
}
static void *thread_check(void *unused) {
(void)unused;
struct stat st;
if (svc_android_api) {
long head;
size_t size;
assert(raw(SYS_get_robust_list, 0, (long)&head, (long)&size, 0, 0, 0) == 0 && head && size == 3 * sizeof(long));
struct robust_list_head private = {0};
long result = raw(SYS_set_robust_list, (long)&private, sizeof private, 0, 0, 0, 0);
assert(result == 0 || result == -ENOSYS);
for (int i = 0; i < 10; i++) {
long got;
sched_yield();
assert(raw(SYS_get_robust_list, 0, (long)&got, (long)&size, 0, 0, 0) == 0 && got == (long)&private);
}
assert(raw(SYS_set_robust_list, head, sizeof private, 0, 0, 0, 0) == result);
}
const long args[] = {AT_FDCWD, (long)"/usr/lib/libc.so.6", (long)&st, 0, 0, 0, SYS_newfstatat};
for (int i = 0; i < 100; i++) check(args, 0);
return NULL;
}
static pthread_barrier_t barrier;
static void *thread_probe(void *unused) {
pthread_barrier_wait(&barrier);
thread_check(unused);
pthread_barrier_wait(&barrier);
return NULL;
}
static volatile sig_atomic_t signals_seen;
static void on_signal(int signal) {
(void)signal;
int saved = errno;
struct stat st;
assert(raw(SYS_newfstatat, AT_FDCWD, (long)"/usr/lib/libc.so.6", (long)&st, 0, 0, 0) == 0);
signals_seen++;
errno = saved;
}
static sigjmp_buf interrupted;
static void jump_signal(int signal) { (void)signal; siglongjmp(interrupted, 1); }
static void jump_path(void) { assert(raise(SIGUSR2) == 0); abort(); }
static void exit_path(void) { pthread_exit(PTHREAD_CANCELED); }
static void mark_cleanup(void *arg) { *(int *)arg = 1; }
struct unwind_check { int cleaned; int (*stat)(int, const char *, struct stat *, int); };
static void *unwind_worker(void *arg) {
struct unwind_check *test = arg;
struct stat st;
pthread_cleanup_push(mark_cleanup, &test->cleaned);
interrupt_path = exit_path;
test->stat(AT_FDCWD, "/usr/lib/libc.so.6", &st, 0);
pthread_cleanup_pop(1);
abort();
}
static void interruption_checks(void) {
void *libc = dlopen("libc.so.6", RTLD_NOW);
struct unwind_check test = {.stat = dlsym(libc, "fstatat")};
assert(test.stat);
struct sigaction old, action = {.sa_handler = jump_signal};
sigemptyset(&action.sa_mask);
assert(sigaction(SIGUSR2, &action, &old) == 0);
sigset_t deliver, old_mask;
sigemptyset(&deliver); sigaddset(&deliver, SIGUSR2);
assert(pthread_sigmask(SIG_UNBLOCK, &deliver, &old_mask) == 0);
if (!sigsetjmp(interrupted, 1)) {
struct stat st;
interrupt_path = jump_path;
test.stat(AT_FDCWD, "/usr/lib/libc.so.6", &st, 0);
abort();
}
assert(svc_busy);
struct stat st;
unsigned long before = svc_fast;
assert(test.stat(AT_FDCWD, "/usr/lib/libc.so.6", &st, 0) == 0);
assert(!svc_busy && svc_fast > before);
assert(sigaction(SIGUSR2, &old, NULL) == 0 && pthread_sigmask(SIG_SETMASK, &old_mask, NULL) == 0);
pthread_t thread;
void *result;
assert(pthread_create(&thread, NULL, unwind_worker, &test) == 0);
assert(pthread_join(thread, &result) == 0 && result == PTHREAD_CANCELED && test.cleaned);
assert(dlclose(libc) == 0);
puts("PASS: signal siglongjmp recovery, forced unwind through patched libc with caller cleanup");
}
static void *small_stack_worker(void *unused) {
size_t consume = (size_t)(uintptr_t)unused - 48 * 1024;
volatile char *padding = __builtin_alloca(consume);
padding[0] = padding[consume - 1] = 1;
struct stat st;
unsigned long before = svc_fast;
for (int i = 0; i < 20; i++)
assert(raw(SYS_newfstatat, AT_FDCWD, (long)"/usr/lib/libc.so.6", (long)&st, 0, 0, 0) == 0);
assert(svc_fast == before && !svc_busy);
return NULL;
}
static void small_stack_checks(void) {
pthread_attr_t attr;
pthread_t thread;
size_t size = PTHREAD_STACK_MIN;
if (size < 128 * 1024) size = 128 * 1024;
assert(pthread_attr_init(&attr) == 0 && pthread_attr_setstacksize(&attr, size) == 0);
assert(pthread_create(&thread, &attr, small_stack_worker, (void *)(uintptr_t)size) == 0);
assert(pthread_join(thread, NULL) == 0 && pthread_attr_destroy(&attr) == 0);
puts("PASS: limited remaining thread stack delegates path calls to PRoot");
}
struct signal_sender { pthread_t target; int done; };
static void *send_signals(void *arg) {
struct signal_sender *sender = arg;
const struct timespec delay = {0, 100000};
for (int i = 0; i < 100; i++) {
assert(pthread_kill(sender->target, SIGUSR1) == 0);
nanosleep(&delay, NULL);
}
__atomic_store_n(&sender->done, 1, __ATOMIC_RELEASE);
return NULL;
}
static void *cancel_worker(void *unused) {
(void)unused;
struct stat st;
for (;;) {
assert(raw(SYS_newfstatat, AT_FDCWD, (long)"/usr/lib/libc.so.6", (long)&st, 0, 0, 0) == 0);
pthread_testcancel();
}
}
struct cancel_open { const char *path; int (*open)(const char *, int, ...); int ready, cleaned; };
static void cancel_cleanup(void *arg) { ((struct cancel_open *)arg)->cleaned = 1; }
static void *cancel_fifo(void *arg) {
struct cancel_open *test = arg;
pthread_cleanup_push(cancel_cleanup, test);
__atomic_store_n(&test->ready, 1, __ATOMIC_RELEASE);
int fd = test->open(test->path, O_RDONLY);
if (fd >= 0) close(fd);
pthread_cleanup_pop(1);
return NULL;
}
static void signal_checks(void) {
stack_t old_stack, stack = {.ss_sp = malloc(SIGSTKSZ), .ss_size = SIGSTKSZ};
assert(stack.ss_sp && sigaltstack(&stack, &old_stack) == 0);
struct sigaction old, action = {.sa_handler = on_signal, .sa_flags = SA_ONSTACK};
sigemptyset(&action.sa_mask);
assert(sigaction(SIGUSR1, &action, &old) == 0);
sigset_t deliver, old_mask;
sigemptyset(&deliver);
sigaddset(&deliver, SIGUSR1);
assert(pthread_sigmask(SIG_UNBLOCK, &deliver, &old_mask) == 0);
struct signal_sender sender = {.target = pthread_self()};
pthread_t thread;
assert(pthread_create(&thread, NULL, send_signals, &sender) == 0);
struct stat st;
for (int i = 0; i < 2000 || !__atomic_load_n(&sender.done, __ATOMIC_ACQUIRE); i++)
assert(raw(SYS_newfstatat, AT_FDCWD, (long)"/usr/lib/libc.so.6", (long)&st, 0, 0, 0) == 0);
assert(pthread_join(thread, NULL) == 0 && signals_seen > 0);
assert(sigaction(SIGUSR1, &old, NULL) == 0 && sigaltstack(&old_stack, NULL) == 0);
assert(pthread_sigmask(SIG_SETMASK, &old_mask, NULL) == 0);
free(stack.ss_sp);
void *result;
assert(pthread_create(&thread, NULL, cancel_worker, NULL) == 0);
assert(pthread_cancel(thread) == 0 && pthread_join(thread, &result) == 0 && result == PTHREAD_CANCELED);
char fifo[] = "/tmp/proot-expanded-fifo-XXXXXX";
int fd = mkstemp(fifo);
assert(fd >= 0 && close(fd) == 0 && unlink(fifo) == 0 && mkfifo(fifo, 0600) == 0);
void *libc = dlopen("libc.so.6", RTLD_NOW);
struct cancel_open test = {.path = fifo, .open = dlsym(libc, "open")};
assert(test.open && pthread_create(&thread, NULL, cancel_fifo, &test) == 0);
while (!__atomic_load_n(&test.ready, __ATOMIC_ACQUIRE)) sched_yield();
struct timespec deadline = {0, 20000000};
nanosleep(&deadline, NULL);
assert(pthread_cancel(thread) == 0 && clock_gettime(CLOCK_REALTIME, &deadline) == 0);
deadline.tv_sec += 2;
assert(pthread_timedjoin_np(thread, &result, &deadline) == 0 && result == PTHREAD_CANCELED && test.cleaned);
assert(unlink(fifo) == 0 && dlclose(libc) == 0);
for (int i = 0; i < 32; i++) {
assert(pthread_create(&thread, NULL, thread_check, NULL) == 0);
assert(pthread_join(thread, NULL) == 0);
}
puts("PASS: signal reentry on alternate stack, deferred/FIFO cancellation with cleanup, thread churn");
}
int main(void) {
assert(fp_ready());
const char *mode = getenv("PROOT_FP_PATCH_SVC");
if (!svc_sites && mode && !strcmp(mode, "0")) {
assert(setenv("PROOT_FP_PATCH_SVC", "1", 1) == 0);
svc_patch_init();
}
printf("platform: android %d, patched %u sites\n", svc_android_api, svc_sites);
assert(svc_sites > 0);
assert(svc_single_thread());
size_t page = sysconf(_SC_PAGESIZE);
uint32_t *relay = svc_relay_page((uintptr_t)&svc_check_site, page), branch;
assert(relay && svc_emit(relay, &svc_check_site, &branch));
__builtin___clear_cache((char *)relay, (char *)relay + 40);
assert(mprotect(relay, page, PROT_READ | PROT_EXEC) == 0);
int mem = open("/proc/self/mem", O_RDWR | O_CLOEXEC);
assert(mem >= 0 && pwrite(mem, &branch, 4, (off_t)(uintptr_t)&svc_check_site) == 4);
close(mem);
__builtin___clear_cache((char *)&svc_check_site, (char *)(&svc_check_site + 1));
long args[] = {0, 1, 2, 3, 4, 5, SYS_getpid};
check(args, getpid());
struct stat st;
args[0] = AT_FDCWD; args[1] = (long)"/usr/lib/libc.so.6"; args[2] = (long)&st;
args[3] = 0; args[6] = SYS_newfstatat;
check(args, 0);
assert(st.st_size > 0);
args[1] = (long)"/usr/lib/proot-svc-check-does-not-exist";
check(args, -ENOENT);
args[1] = 0;
check(args, -EFAULT);
args[1] = (long)"/usr/lib/libc.so.6"; args[2] = 0;
check(args, -EFAULT);
args[1] = (long)"/proc/self/exe"; args[2] = (long)&st;
check(args, 0);
args[3] = 0x40000000;
check(args, -EINVAL);
path_checks();
robust_checks();
pthread_t threads[4];
assert(pthread_barrier_init(&barrier, NULL, 5) == 0);
for (int i = 0; i < 4; i++) assert(pthread_create(&threads[i], NULL, thread_probe, NULL) == 0);
pthread_barrier_wait(&barrier);
assert(!svc_single_thread());
pthread_barrier_wait(&barrier);
for (int i = 0; i < 4; i++) assert(pthread_join(threads[i], NULL) == 0);
assert(pthread_barrier_destroy(&barrier) == 0);
pid_t pid = fork();
assert(pid >= 0);
if (!pid) { thread_check(NULL); _exit(0); }
int status;
assert(waitpid(pid, &status, 0) == pid && WIFEXITED(status) && WEXITSTATUS(status) == 0);
signal_checks();
interruption_checks();
small_stack_checks();
puts("PASS: raw results, errno, x1-x30, q0-q31, NZCV, FPCR/FPSR, 4 threads, fork");
return 0;
}
#else
int main(void) { return 77; }
#endif