0.3.0: converge relibc to upstream 0.6.0 + Red Bear patches

2026-07-06 19:13:08 +03:00
parent 1a0edd8eeb
commit 4ef7e57571
1466 changed files with 75236 additions and 13644 deletions
@@ -0,0 +1,27 @@
+#include <stdio.h>
+#include <sys/resource.h>
+
+int main(void) {
+    // Checks availability of constants specified in
+    // https://pubs.opengroup.org/onlinepubs/7908799/xsh/sysresource.h.html
+    printf("PRIO_PROCESS: %d\n", PRIO_PROCESS);
+    printf("PRIO_PGRP: %d\n", PRIO_PGRP);
+    printf("PRIO_USER: %d\n", PRIO_USER);
+
+    printf("RLIM_INFINITY: %lld\n", RLIM_INFINITY);
+    printf("RLIM_SAVED_MAX: %lld\n", RLIM_SAVED_MAX);
+    printf("RLIM_SAVED_CUR: %lld\n", RLIM_SAVED_CUR);
+
+    printf("RUSAGE_SELF: %lld\n", RUSAGE_SELF);
+    printf("RUSAGE_CHILDREN: %lld\n", RUSAGE_CHILDREN);
+
+    printf("RLIMIT_CORE: %d\n", RLIMIT_CORE);
+    printf("RLIMIT_CPU: %d\n", RLIMIT_CPU);
+    printf("RLIMIT_DATA: %d\n", RLIMIT_DATA);
+    printf("RLIMIT_FSIZE: %d\n", RLIMIT_FSIZE);
+    printf("RLIMIT_NOFILE: %d\n", RLIMIT_NOFILE);
+    printf("RLIMIT_STACK: %d\n", RLIMIT_STACK);
+    printf("RLIMIT_AS: %d\n", RLIMIT_AS);
+
+    return 0;
+}
@@ -0,0 +1,39 @@
+#include <errno.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <sys/resource.h>
+
+#include "test_helpers.h"
+
+void ptimeval(struct timeval* val) {
+    printf("{ tv_sec: %ld, tv_usec: %ld }\n", val->tv_sec, val->tv_usec);
+}
+
+int main(void) {
+    struct rusage r_usage;
+
+    int status = getrusage(RUSAGE_SELF, &r_usage);
+    ERROR_IF(getrusage, status, == -1);
+    UNEXP_IF(getrusage, status, != 0);
+
+    printf("ru_utime:");
+    ptimeval(&r_usage.ru_utime);
+
+    printf("ru_stime:");
+    ptimeval(&r_usage.ru_utime);
+
+    printf("ru_maxrss: %ld\n", r_usage.ru_maxrss);
+    printf("ru_ixrss: %ld\n", r_usage.ru_ixrss);
+    printf("ru_idrss: %ld\n", r_usage.ru_idrss);
+    printf("ru_isrss: %ld\n", r_usage.ru_isrss);
+    printf("ru_minflt: %ld\n", r_usage.ru_minflt);
+    printf("ru_majflt: %ld\n", r_usage.ru_majflt);
+    printf("ru_nswap: %ld\n", r_usage.ru_nswap);
+    printf("ru_inblock: %ld\n", r_usage.ru_inblock);
+    printf("ru_oublock: %ld\n", r_usage.ru_oublock);
+    printf("ru_msgsnd: %ld\n", r_usage.ru_msgsnd);
+    printf("ru_msgrcv: %ld\n", r_usage.ru_msgrcv);
+    printf("ru_nsignals: %ld\n", r_usage.ru_nsignals);
+    printf("ru_nvcsw: %ld\n", r_usage.ru_nvcsw);
+    printf("ru_nivcsw: %ld\n", r_usage.ru_nivcsw);
+}
@@ -0,0 +1,80 @@
+#include <assert.h>
+#include <errno.h>
+#include <limits.h>
+#include <stdio.h>
+#include <sys/resource.h>
+#include <unistd.h>
+
+int main(void) {
+    struct rlimit original;
+    struct rlimit current;
+    struct rlimit invalid;
+
+    errno = 0;
+    assert(getrlimit(RLIMIT_NOFILE, &original) == 0);
+
+    errno = 0;
+    assert(getrlimit(RLIMIT_NLIMITS, &current) == -1);
+    assert(errno == EINVAL);
+
+    errno = 0;
+    assert(getrlimit(RLIMIT_NOFILE, NULL) == -1);
+    assert(errno == EFAULT);
+
+    errno = 0;
+    assert(getrusage(RUSAGE_SELF, NULL) == -1);
+    assert(errno == EFAULT);
+
+    errno = 0;
+    assert(setrlimit(RLIMIT_NOFILE, NULL) == -1);
+    assert(errno == EFAULT);
+
+    invalid.rlim_cur = original.rlim_max;
+    invalid.rlim_max = original.rlim_cur;
+    errno = 0;
+    assert(setrlimit(RLIMIT_NOFILE, &invalid) == -1);
+    assert(errno == EINVAL);
+
+    if (original.rlim_max != RLIM_INFINITY) {
+        invalid.rlim_cur = original.rlim_max + 1;
+        invalid.rlim_max = original.rlim_max + 1;
+        errno = 0;
+        assert(setrlimit(RLIMIT_NOFILE, &invalid) == -1);
+        assert(errno == EPERM);
+    }
+
+    current.rlim_cur = original.rlim_cur > 16 ? original.rlim_cur - 16 : original.rlim_cur;
+    current.rlim_max = original.rlim_max;
+    errno = 0;
+    assert(setrlimit(RLIMIT_NOFILE, &current) == 0);
+
+    struct rlimit roundtrip;
+    errno = 0;
+    assert(getrlimit(RLIMIT_NOFILE, &roundtrip) == 0);
+    assert(roundtrip.rlim_cur == current.rlim_cur);
+    assert(roundtrip.rlim_max == current.rlim_max);
+
+    long open_max = sysconf(_SC_OPEN_MAX);
+    if (current.rlim_cur == RLIM_INFINITY) {
+        assert(open_max == -1);
+    } else if (current.rlim_cur > LONG_MAX) {
+        assert(open_max == LONG_MAX);
+    } else {
+        assert(open_max == (long)current.rlim_cur);
+    }
+
+    if (current.rlim_cur > INT_MAX) {
+        assert(getdtablesize() == INT_MAX);
+    } else {
+        assert(getdtablesize() == (int)current.rlim_cur);
+    }
+
+    errno = 0;
+    assert(setrlimit(RLIMIT_NOFILE, &original) == 0);
+    assert(getrlimit(RLIMIT_NOFILE, &roundtrip) == 0);
+    assert(roundtrip.rlim_cur == original.rlim_cur);
+    assert(roundtrip.rlim_max == original.rlim_max);
+
+    puts("rlimit roundtrip ok");
+    return 0;
+}